Done and implemented compression. It doesn't segfaults at the moment

Samo Penic

2019-10-18 842378276ab4c4a8dabd02324bb24b8da39c4384

 src/io.c

@@ -17,421 +17,6 @@
#include <dirent.h>
#include <errno.h>
#include <snapshot.h>
/** DUMP STATE TO DISK DRIVE **/

ts_bool dump_state(ts_vesicle *vesicle, ts_uint iteration){

    /* save current state with wrong pointers. Will fix that later */
    ts_uint i,j,k;
    FILE *fh=fopen(command_line_args.dump_fullfilename,"wb");

    /* dump vesicle */
    fwrite(vesicle, sizeof(ts_vesicle)-sizeof(ts_double),1,fh);
    /* dump vertex list */
    fwrite(vesicle->vlist, sizeof(ts_vertex_list),1,fh);
    /* dump bond list */
    fwrite(vesicle->blist, sizeof(ts_bond_list),1,fh);
    /* dump triangle list */
    fwrite(vesicle->tlist, sizeof(ts_triangle_list),1,fh);
    /* dump cell list */
    fwrite(vesicle->clist, sizeof(ts_cell_list),1,fh);
    /* dump poly list */
    fwrite(vesicle->poly_list, sizeof(ts_poly_list),1,fh);
    /* dump filament list */
    fwrite(vesicle->filament_list, sizeof(ts_poly_list),1,fh);
    /* level 1 complete */

    /*dump vertices*/
    for(i=0;i<vesicle->vlist->n;i++){
        fwrite(vesicle->vlist->vtx[i],sizeof(ts_vertex),1,fh);
        /* dump pointer offsets for:
                    neigh
                    bond
                    tria
                    cell is ignored
        */
        for(j=0;j<vesicle->vlist->vtx[i]->neigh_no;j++){
            fwrite(&vesicle->vlist->vtx[i]->neigh[j]->idx,sizeof(ts_uint),1,fh); 
        }
        for(j=0;j<vesicle->vlist->vtx[i]->bond_no;j++){
            fwrite(&vesicle->vlist->vtx[i]->bond[j]->idx,sizeof(ts_uint),1,fh); 
        }
        for(j=0;j<vesicle->vlist->vtx[i]->tristar_no;j++){
            fwrite(&vesicle->vlist->vtx[i]->tristar[j]->idx,sizeof(ts_uint),1,fh); 
        }
    }

    /*dump bonds*/
    for(i=0;i<vesicle->blist->n;i++){
        fwrite(vesicle->blist->bond[i],sizeof(ts_bond),1,fh);
        /* dump pointer offsets for vtx1 and vtx2 */
        //off=(ts_ulong)(vesicle->blist->bond[i]->vtx1-vesicle->vlist->vtx[0]);
        fwrite(&vesicle->blist->bond[i]->vtx1->idx,sizeof(ts_uint),1,fh); 
        //off=(ts_ulong)(vesicle->blist->bond[i]->vtx2-vesicle->vlist->vtx[0]);
        fwrite(&vesicle->blist->bond[i]->vtx2->idx,sizeof(ts_uint),1,fh); 
    }

    /*dump triangles*/
    for(i=0;i<vesicle->tlist->n;i++){
        fwrite(vesicle->tlist->tria[i],sizeof(ts_triangle),1,fh);
        /* dump pointer offsets for vertex */
        fwrite(&vesicle->tlist->tria[i]->vertex[0]->idx,sizeof(ts_uint),1,fh); 
        fwrite(&vesicle->tlist->tria[i]->vertex[1]->idx,sizeof(ts_uint),1,fh); 
        fwrite(&vesicle->tlist->tria[i]->vertex[2]->idx,sizeof(ts_uint),1,fh); 
        /* dump pointer offsets for neigh */
        for(j=0;j<vesicle->tlist->tria[i]->neigh_no;j++){
            fwrite(&vesicle->tlist->tria[i]->neigh[j]->idx,sizeof(ts_uint),1,fh); 
        }
    }


    /*dump polymeres */
    for(i=0;i<vesicle->poly_list->n;i++){
        fwrite(vesicle->poly_list->poly[i],sizeof(ts_poly),1,fh);
        fwrite(vesicle->poly_list->poly[i]->vlist,sizeof(ts_vertex_list),1,fh);
        fwrite(vesicle->poly_list->poly[i]->blist,sizeof(ts_bond_list),1,fh);
    } 
     
    /* dump poly vertex(monomer) list*/
    for(i=0;i<vesicle->poly_list->n;i++){
        for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++){
            fwrite(vesicle->poly_list->poly[i]->vlist->vtx[j],sizeof(ts_vertex),1,fh);
            /* dump offset for neigh and bond */
            for(k=0;k<vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh_no;k++){
               // off=(ts_ulong)(vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh[k]-vesicle->poly_list->poly[i]->vlist->vtx[0]);
                fwrite(&vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh[k]->idx,sizeof(ts_uint),1,fh); 
            }
            for(k=0;k<vesicle->poly_list->poly[i]->vlist->vtx[j]->bond_no;k++){
                //off=(ts_ulong)(vesicle->poly_list->poly[i]->vlist->vtx[j]->bond[k]-vesicle->poly_list->poly[i]->blist->bond[0]);
                fwrite(&vesicle->poly_list->poly[i]->vlist->vtx[j]->bond[k]->idx,sizeof(ts_uint),1,fh); 
            }
        }
   // grafted vtx on vesicle data dump
      fwrite(&vesicle->poly_list->poly[i]->grafted_vtx->idx, sizeof(ts_uint),1,fh);
    }
    /* dump poly bonds between monomers list*/
    for(i=0;i<vesicle->poly_list->n;i++){
        for(j=0;j<vesicle->poly_list->poly[i]->blist->n;j++){
            fwrite(vesicle->poly_list->poly[i]->blist->bond[j],sizeof(ts_bond),1,fh);
            /* dump vtx1 and vtx2 offsets */
            //off=(ts_ulong)(vesicle->poly_list->poly[i]->blist->bond[j]->vtx1-vesicle->poly_list->poly[i]->vlist->vtx[0]);
            fwrite(&vesicle->poly_list->poly[i]->blist->bond[j]->vtx1->idx,sizeof(ts_uint),1,fh); 
//            off=(ts_ulong)(vesicle->poly_list->poly[i]->blist->bond[j]->vtx2-vesicle->poly_list->poly[i]->vlist->vtx[0]);
            fwrite(&vesicle->poly_list->poly[i]->blist->bond[j]->vtx2->idx,sizeof(ts_uint),1,fh); 
        }
    }


  /*dump filamentes grandes svinjas */
    for(i=0;i<vesicle->filament_list->n;i++){
        fwrite(vesicle->filament_list->poly[i],sizeof(ts_poly),1,fh);
        fwrite(vesicle->filament_list->poly[i]->vlist,sizeof(ts_vertex_list),1,fh);
        fwrite(vesicle->filament_list->poly[i]->blist,sizeof(ts_bond_list),1,fh);
    } 
     
    /* dump filamentes vertex(monomer) list*/
    for(i=0;i<vesicle->filament_list->n;i++){
        for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++){
            fwrite(vesicle->filament_list->poly[i]->vlist->vtx[j],sizeof(ts_vertex),1,fh);
            /* dump offset for neigh and bond */
            for(k=0;k<vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh_no;k++){
               // off=(ts_ulong)(vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh[k]-vesicle->poly_list->poly[i]->vlist->vtx[0]);
                fwrite(&vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh[k]->idx,sizeof(ts_uint),1,fh); 
            }
            for(k=0;k<vesicle->filament_list->poly[i]->vlist->vtx[j]->bond_no;k++){
                //off=(ts_ulong)(vesicle->poly_list->poly[i]->vlist->vtx[j]->bond[k]-vesicle->poly_list->poly[i]->blist->bond[0]);
                fwrite(&vesicle->filament_list->poly[i]->vlist->vtx[j]->bond[k]->idx,sizeof(ts_uint),1,fh); 
            }
        }
    }
    /* dump poly bonds between monomers list*/
    for(i=0;i<vesicle->filament_list->n;i++){
        for(j=0;j<vesicle->filament_list->poly[i]->blist->n;j++){
            fwrite(vesicle->filament_list->poly[i]->blist->bond[j],sizeof(ts_bond),1,fh);
            /* dump vtx1 and vtx2 offsets */
            //off=(ts_ulong)(vesicle->poly_list->poly[i]->blist->bond[j]->vtx1-vesicle->poly_list->poly[i]->vlist->vtx[0]);
            fwrite(&vesicle->filament_list->poly[i]->blist->bond[j]->vtx1->idx,sizeof(ts_uint),1,fh); 
//            off=(ts_ulong)(vesicle->poly_list->poly[i]->blist->bond[j]->vtx2-vesicle->poly_list->poly[i]->vlist->vtx[0]);
            fwrite(&vesicle->filament_list->poly[i]->blist->bond[j]->vtx2->idx,sizeof(ts_uint),1,fh); 
        }
    }



/* pointer offsets for fixing the restored pointers */
/* need pointers for 
    vlist->vtx
    blist->bond
    tlist->tria
    clist->cell
    poly_list->poly
    and for each poly:
        poly_list->poly->vtx
        poly_list->poly->bond
*/

//   fwrite(vesicle->clist, sizeof(ts_cell_list),1,  fh);
/* write tape information on vesicle */
//    fwrite(vesicle->tape,sizeof(ts_tape),1,fh);
   fwrite(&iteration, sizeof(ts_uint),1,fh);
    fclose(fh);
    return TS_SUCCESS;
}


/** RESTORE DUMP FROM DISK **/
ts_vesicle *restore_state(ts_uint *iteration){
    ts_uint i,j,k;
    FILE *fh=fopen(command_line_args.dump_fullfilename,"rb");

    struct stat sb;
    if (stat(command_line_args.dump_fullfilename, &sb) == -1) {
        //dump file does not exist.
        return NULL;
    }

    //check if it is regular file
    if((sb.st_mode & S_IFMT) != S_IFREG) {
        //dump file is not a regular file.
        ts_fprintf(stderr,"Dump file is not a regular file!\n");
        return NULL;
    }

    ts_uint retval;
   ts_uint idx;

/* we restore all the data from the dump */
    /* restore vesicle */
    ts_vesicle *vesicle=(ts_vesicle *)calloc(1,sizeof(ts_vesicle));
    retval=fread(vesicle, sizeof(ts_vesicle)-sizeof(ts_double),1,fh);
//   fprintf(stderr,"was here! %e\n",vesicle->dmax);

    /* restore vertex list */
    vesicle->vlist=(ts_vertex_list *)malloc(sizeof(ts_vertex_list));
    retval=fread(vesicle->vlist, sizeof(ts_vertex_list),1,fh);
    /* restore bond list */
    vesicle->blist=(ts_bond_list *)malloc(sizeof(ts_bond_list));
    retval=fread(vesicle->blist, sizeof(ts_bond_list),1,fh);
    /* restore triangle list */
    vesicle->tlist=(ts_triangle_list *)malloc(sizeof(ts_triangle_list));
    retval=fread(vesicle->tlist, sizeof(ts_triangle_list),1,fh);
    /* restore cell list */
    vesicle->clist=(ts_cell_list *)malloc(sizeof(ts_cell_list));
    retval=fread(vesicle->clist, sizeof(ts_cell_list),1,fh);
    /* restore poly list */
    vesicle->poly_list=(ts_poly_list *)calloc(1,sizeof(ts_poly_list));
    retval=fread(vesicle->poly_list, sizeof(ts_poly_list),1,fh);
    /* restore filament list */
    vesicle->filament_list=(ts_poly_list *)calloc(1,sizeof(ts_poly_list));
    retval=fread(vesicle->filament_list, sizeof(ts_poly_list),1,fh);
    /* level 1 complete */

/* prerequisity. Bonds must be malloced before vertexes are recreated */
  vesicle->blist->bond=(ts_bond **)calloc(vesicle->blist->n,sizeof(ts_bond *));
    for(i=0;i<vesicle->blist->n;i++){
        vesicle->blist->bond[i]=(ts_bond *)malloc(sizeof(ts_bond));
   }
/* prerequisity. Triangles must be malloced before vertexes are recreated */
  vesicle->tlist->tria=(ts_triangle **)calloc(vesicle->tlist->n,sizeof(ts_triangle *));
    for(i=0;i<vesicle->tlist->n;i++){
        vesicle->tlist->tria[i]=(ts_triangle *)malloc(sizeof(ts_triangle));
}
/* prerequisity. Vertices must be malloced before vertexes are recreated */
    vesicle->vlist->vtx=(ts_vertex **)calloc(vesicle->vlist->n,sizeof(ts_vertex *));
 for(i=0;i<vesicle->vlist->n;i++){
        vesicle->vlist->vtx[i]=(ts_vertex *)malloc(sizeof(ts_vertex));
 }
  /*restore vertices*/
    for(i=0;i<vesicle->vlist->n;i++){
        retval=fread(vesicle->vlist->vtx[i],sizeof(ts_vertex),1,fh);
        /*restore neigh, bond, tristar. Ignoring cell */
        vesicle->vlist->vtx[i]->neigh=(ts_vertex **)calloc(vesicle->vlist->vtx[i]->neigh_no, sizeof(ts_vertex *));
        for(j=0;j<vesicle->vlist->vtx[i]->neigh_no;j++){
            retval=fread(&idx,sizeof(ts_uint),1,fh);
            vesicle->vlist->vtx[i]->neigh[j]=vesicle->vlist->vtx[idx];
        }
        vesicle->vlist->vtx[i]->bond=(ts_bond **)calloc(vesicle->vlist->vtx[i]->bond_no, sizeof(ts_bond *));
        for(j=0;j<vesicle->vlist->vtx[i]->bond_no;j++){
            retval=fread(&idx,sizeof(ts_uint),1,fh);
/* pointer can be assigned only when list of bonds is fully initialized in memory. Thus bondlist popularization must be done before vertex can reference to it */
            vesicle->vlist->vtx[i]->bond[j]=vesicle->blist->bond[idx];    
        }

        vesicle->vlist->vtx[i]->tristar=(ts_triangle **)calloc(vesicle->vlist->vtx[i]->tristar_no, sizeof(ts_triangle *));
        for(j=0;j<vesicle->vlist->vtx[i]->tristar_no;j++){
            retval=fread(&idx,sizeof(ts_uint),1,fh);
/* same comment as above */
            vesicle->vlist->vtx[i]->tristar[j]=vesicle->tlist->tria[idx];
        }

    }

    /*restore bonds*/
   // vesicle->blist->bond=(ts_bond **)calloc(vesicle->blist->n,sizeof(ts_bond *)); // done before.
    for(i=0;i<vesicle->blist->n;i++){
     //   vesicle->blist->bond[i]=(ts_bond *)malloc(sizeof(ts_bond)); //done before.
        retval=fread(vesicle->blist->bond[i],sizeof(ts_bond),1,fh);
        /* restore vtx1 and vtx2 */
        retval=fread(&idx,sizeof(ts_uint),1,fh);
        vesicle->blist->bond[i]->vtx1=vesicle->vlist->vtx[idx];
        retval=fread(&idx,sizeof(ts_uint),1,fh);
        vesicle->blist->bond[i]->vtx2=vesicle->vlist->vtx[idx];
    }

    /*restore triangles*/
//    vesicle->tlist->tria=(ts_triangle **)calloc(vesicle->tlist->n,sizeof(ts_triangle *)); // done before
    for(i=0;i<vesicle->tlist->n;i++){
 //       vesicle->tlist->tria[i]=(ts_triangle *)malloc(sizeof(ts_triangle)); // done before
        retval=fread(vesicle->tlist->tria[i],sizeof(ts_triangle),1,fh);
        /* restore pointers for vertices */
        retval=fread(&idx,sizeof(ts_uint),1,fh);
        vesicle->tlist->tria[i]->vertex[0]=vesicle->vlist->vtx[idx];
        retval=fread(&idx,sizeof(ts_uint),1,fh);
        vesicle->tlist->tria[i]->vertex[1]=vesicle->vlist->vtx[idx];
        retval=fread(&idx,sizeof(ts_uint),1,fh);
        vesicle->tlist->tria[i]->vertex[2]=vesicle->vlist->vtx[idx];
        /* restore pointers for neigh */
    vesicle->tlist->tria[i]->neigh=(ts_triangle **)malloc(vesicle->tlist->tria[i]->neigh_no*sizeof(ts_triangle *));
        for(j=0;j<vesicle->tlist->tria[i]->neigh_no;j++){
            retval=fread(&idx,sizeof(ts_uint),1,fh);
            vesicle->tlist->tria[i]->neigh[j]=vesicle->tlist->tria[idx];
        }

    }
   
    /*restore cells */
/*TODO: do we need to recalculate cells here? */
/*    vesicle->clist->cell=(ts_cell **)malloc(vesicle->clist->cellno*sizeof(ts_cell *));
    for(i=0;i<vesicle->clist->cellno;i++){
        vesicle->clist->cell[i]=(ts_cell *)malloc(sizeof(ts_cell));
        retval=fread(vesicle->clist->cell[i],sizeof(ts_cell),1,fh);
    }
*/
    /*restore polymeres */
    vesicle->poly_list->poly = (ts_poly **)calloc(vesicle->poly_list->n,sizeof(ts_poly *));
    for(i=0;i<vesicle->poly_list->n;i++){
        vesicle->poly_list->poly[i]=(ts_poly *)calloc(1,sizeof(ts_poly));
        retval=fread(vesicle->poly_list->poly[i],sizeof(ts_poly),1,fh);
        vesicle->poly_list->poly[i]->vlist=(ts_vertex_list *)calloc(1,sizeof(ts_vertex_list));
        retval=fread(vesicle->poly_list->poly[i]->vlist,sizeof(ts_vertex_list),1,fh);
        vesicle->poly_list->poly[i]->blist=(ts_bond_list *)calloc(1,sizeof(ts_bond_list));
        retval=fread(vesicle->poly_list->poly[i]->blist,sizeof(ts_bond_list),1,fh);
   /* initialize adress space for pointers that will hold specific vertices (monomers) and bonds */
        vesicle->poly_list->poly[i]->vlist->vtx=(ts_vertex **)calloc(vesicle->poly_list->poly[i]->vlist->n,sizeof(ts_vertex *));
        vesicle->poly_list->poly[i]->blist->bond=(ts_bond **)calloc(vesicle->poly_list->poly[i]->blist->n,sizeof(ts_bond *));
    for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++){
            vesicle->poly_list->poly[i]->vlist->vtx[j]=(ts_vertex *)malloc(sizeof(ts_vertex));
   }
   for(j=0;j<vesicle->poly_list->poly[i]->blist->n;j++){
            vesicle->poly_list->poly[i]->blist->bond[j]=(ts_bond *)malloc(sizeof(ts_bond));
   }

    } 

     
    /* restore poly vertex(monomer) list*/
    for(i=0;i<vesicle->poly_list->n;i++){
        for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++){
            retval=fread(vesicle->poly_list->poly[i]->vlist->vtx[j],sizeof(ts_vertex),1,fh);
           	 
            /* restore neigh and bonds */
            vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh=(ts_vertex **)calloc(vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh_no, sizeof(ts_vertex *));
            for(k=0;k<vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh_no;k++){
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->poly_list->poly[i]->vlist->vtx[j]->neigh[k]=vesicle->poly_list->poly[i]->vlist->vtx[idx];
            }
            vesicle->poly_list->poly[i]->vlist->vtx[j]->bond=(ts_bond **)calloc(vesicle->poly_list->poly[i]->vlist->vtx[j]->bond_no, sizeof(ts_bond *));
            for(k=0;k<vesicle->poly_list->poly[i]->vlist->vtx[j]->bond_no;k++){
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->poly_list->poly[i]->vlist->vtx[j]->bond[k]=vesicle->poly_list->poly[i]->blist->bond[idx];
            }

        }
   /* restore grafted vtx on vesicle and grafted_poly */
                retval=fread(&idx,sizeof(ts_uint),1,fh);
      vesicle->vlist->vtx[idx]->grafted_poly=vesicle->poly_list->poly[i];
      vesicle->poly_list->poly[i]->grafted_vtx=vesicle->vlist->vtx[idx];	
    }

    /* restore poly bonds between monomers list*/
    for(i=0;i<vesicle->poly_list->n;i++){
        for(j=0;j<vesicle->poly_list->poly[i]->blist->n;j++){
       //     vesicle->poly_list->poly[i]->blist->bond[j]=(ts_bond *)malloc(sizeof(ts_bond));
            retval=fread(vesicle->poly_list->poly[i]->blist->bond[j],sizeof(ts_bond),1,fh);
            /* restore vtx1 and vtx2 */
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->poly_list->poly[i]->blist->bond[j]->vtx1=vesicle->poly_list->poly[i]->vlist->vtx[idx];
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->poly_list->poly[i]->blist->bond[j]->vtx2=vesicle->poly_list->poly[i]->vlist->vtx[idx];
        }
    }

    /*restore filaments */
    vesicle->filament_list->poly = (ts_poly **)calloc(vesicle->filament_list->n,sizeof(ts_poly *));
    for(i=0;i<vesicle->filament_list->n;i++){
        vesicle->filament_list->poly[i]=(ts_poly *)calloc(1,sizeof(ts_poly));
        retval=fread(vesicle->filament_list->poly[i],sizeof(ts_poly),1,fh);
        vesicle->filament_list->poly[i]->vlist=(ts_vertex_list *)calloc(1,sizeof(ts_vertex_list));
        retval=fread(vesicle->filament_list->poly[i]->vlist,sizeof(ts_vertex_list),1,fh);
        vesicle->filament_list->poly[i]->blist=(ts_bond_list *)calloc(1,sizeof(ts_bond_list));
        retval=fread(vesicle->filament_list->poly[i]->blist,sizeof(ts_bond_list),1,fh);
   /* initialize adress space for pointers that will hold specific vertices (monomers) and bonds */
        vesicle->filament_list->poly[i]->vlist->vtx=(ts_vertex **)calloc(vesicle->filament_list->poly[i]->vlist->n,sizeof(ts_vertex *));
        vesicle->filament_list->poly[i]->blist->bond=(ts_bond **)calloc(vesicle->filament_list->poly[i]->blist->n,sizeof(ts_bond *));
    for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++){
            vesicle->filament_list->poly[i]->vlist->vtx[j]=(ts_vertex *)malloc(sizeof(ts_vertex));
   }
   for(j=0;j<vesicle->filament_list->poly[i]->blist->n;j++){
            vesicle->filament_list->poly[i]->blist->bond[j]=(ts_bond *)malloc(sizeof(ts_bond));
   }

    } 

     
    /* restore poly vertex(monomer) list*/
    for(i=0;i<vesicle->filament_list->n;i++){
        for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++){
            retval=fread(vesicle->filament_list->poly[i]->vlist->vtx[j],sizeof(ts_vertex),1,fh);
           	 
            /* restore neigh and bonds */
            vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh=(ts_vertex **)calloc(vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh_no, sizeof(ts_vertex *));
            for(k=0;k<vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh_no;k++){
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->filament_list->poly[i]->vlist->vtx[j]->neigh[k]=vesicle->filament_list->poly[i]->vlist->vtx[idx];
            }
            vesicle->filament_list->poly[i]->vlist->vtx[j]->bond=(ts_bond **)calloc(vesicle->filament_list->poly[i]->vlist->vtx[j]->bond_no, sizeof(ts_bond *));
            for(k=0;k<vesicle->filament_list->poly[i]->vlist->vtx[j]->bond_no;k++){
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->filament_list->poly[i]->vlist->vtx[j]->bond[k]=vesicle->filament_list->poly[i]->blist->bond[idx];
            }

        }
    }

    /* restore poly bonds between monomers list*/
    for(i=0;i<vesicle->filament_list->n;i++){
        for(j=0;j<vesicle->filament_list->poly[i]->blist->n;j++){
       //     vesicle->poly_list->poly[i]->blist->bond[j]=(ts_bond *)malloc(sizeof(ts_bond));
            retval=fread(vesicle->filament_list->poly[i]->blist->bond[j],sizeof(ts_bond),1,fh);
            /* restore vtx1 and vtx2 */
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->filament_list->poly[i]->blist->bond[j]->vtx1=vesicle->filament_list->poly[i]->vlist->vtx[idx];
                retval=fread(&idx,sizeof(ts_uint),1,fh);
                vesicle->filament_list->poly[i]->blist->bond[j]->vtx2=vesicle->filament_list->poly[i]->vlist->vtx[idx];
        }
    }
    vesicle->tape=parsetape(command_line_args.tape_fullfilename);
// recreating space for cells // 
    vesicle->clist=init_cell_list(vesicle->tape->ncxmax, vesicle->tape->ncymax, vesicle->tape->nczmax, vesicle->tape->stepsize);
   vesicle->clist->max_occupancy=8;
//    vesicle->tape=(ts_tape *)malloc(sizeof(ts_tape));
//    retval=fread(vesicle->tape, sizeof(ts_tape),1,fh);
   retval=fread(iteration,sizeof(ts_uint),1,fh);
    if(retval); 
    fclose(fh);
    return vesicle;
}



ts_bool parse_args(int argc, char **argv){
@@ -626,205 +211,12 @@
   return TS_SUCCESS;
}



ts_bool print_vertex_list(ts_vertex_list *vlist){
   ts_uint i;
   printf("Number of vertices: %u\n",vlist->n);
   for(i=0;i<vlist->n;i++){
      printf("%u: %f %f %f\n",
vlist->vtx[i]->idx,vlist->vtx[i]->x, vlist->vtx[i]->y, vlist->vtx[i]->z);
   }
   return TS_SUCCESS;
}

ts_bool print_vertex_neighbours(ts_vertex_list *vlist){
   ts_uint i,j;
   ts_vertex **vtx=vlist->vtx;
   printf("Vertex id(neigh no): (neighvertex coord) (neighvertex coord) ...\n");
   for(i=0;i<vlist->n;i++){
      printf("%u(%u): ",vtx[i]->idx,vtx[i]->neigh_no);
      for(j=0;j<vtx[i]->neigh_no;j++){
         printf("(%f,%f,%f)",vtx[i]->neigh[j]->x,
vtx[i]->neigh[j]->y,vtx[i]->neigh[j]->z);
      }
      printf("\n");
   }

return TS_SUCCESS;
}

ts_bool write_vertex_fcompat_file(ts_vertex_list *vlist,ts_char *filename){
   ts_vertex **vtx=vlist->vtx;
   ts_uint i;
   FILE *fh;
	
   fh=fopen(filename, "w");
   if(fh==NULL){
      err("Cannot open file %s for writing");
      return TS_FAIL;
   }
   for(i=0;i<vlist->n;i++)
      fprintf(fh," %E\t%E\t%E\n",vtx[i]->x,vtx[i]->y, vtx[i]->z);

   fclose(fh);
return TS_SUCCESS;
}


ts_bool fprint_vertex_list(FILE *fh,ts_vertex_list *vlist){
    ts_uint i,j;
   for(i=0;i<vlist->n;i++){
      fprintf(fh," %.17E\t%.17E\t%.17E\t%u\n",vlist->vtx[i]->x,
         vlist->vtx[i]->y, vlist->vtx[i]->z,
            vlist->vtx[i]->neigh_no);
      for(j=0;j<vlist->vtx[i]->neigh_no;j++){
         fprintf(fh,"\t%u",(ts_uint)(vlist->vtx[i]->neigh[j]->idx));
        //-vlist->vtx+1));
      }
      fprintf(fh,"\n");
   }
    return TS_SUCCESS;
}

ts_bool fprint_tristar(FILE *fh, ts_vesicle *vesicle){
    ts_uint i,j;
   for(i=0;i<vesicle->vlist->n;i++){
      fprintf(fh,"\t%u",vesicle->vlist->vtx[i]->tristar_no);
      for(j=0;j<vesicle->vlist->vtx[i]->tristar_no;j++){
         fprintf(fh,"\t%u",(ts_uint)(vesicle->vlist->vtx[i]->tristar[j]->idx));//-vesicle->tlist->tria+1));
      }
      fprintf(fh,"\n");
   }
    return TS_SUCCESS;
}

ts_bool fprint_triangle_list(FILE *fh, ts_vesicle *vesicle){
        ts_triangle_list *tlist=vesicle->tlist;
      ts_uint i,j;
   for(i=0;i<tlist->n;i++){
        fprintf(fh,"\t%u",tlist->tria[i]->neigh_no);
       for(j=0;j<tlist->tria[i]->neigh_no;j++){
          fprintf(fh,"\t%u",(ts_uint)(tlist->tria[i]->neigh[j]->idx));//-tlist->tria+1)); 
        }
        fprintf(fh,"\n");
            for(j=0;j<3;j++){
          fprintf(fh,"\t%u",(ts_uint)(tlist->tria[i]->vertex[j]->idx));//-vesicle->vlist->vtx+1)); 
            }
        fprintf(fh,"\n");
      fprintf(fh,"%.17E\t%.17E\t%.17E\n",tlist->tria[i]->xnorm,
tlist->tria[i]->ynorm,tlist->tria[i]->znorm);
        fprintf(fh,"0.00000000000000000\n0.00000000000000000\n");
    }
    return TS_SUCCESS;
}

ts_bool fprint_vertex_data(FILE *fh,ts_vertex_list *vlist){
    ts_uint i,j;
    for(i=0;i<vlist->n;i++){
        fprintf(fh," %.17E\t%.17E\t%.17E\t%.17E\t%.17E\t%u\n",
        vlist->vtx[i]->xk,vlist->vtx[i]->c,vlist->vtx[i]->energy,
        vlist->vtx[i]->energy_h, vlist->vtx[i]->curvature, 0);
        for(j=0;j<vlist->vtx[i]->bond_no;j++){
            fprintf(fh," %.17E", vlist->vtx[i]->bond[j]->bond_length_dual);
        }
            fprintf(fh,"\n");
        for(j=0;j<vlist->vtx[i]->bond_no;j++){
            fprintf(fh," %.17E", vlist->vtx[i]->bond[j]->bond_length);
        }
            fprintf(fh,"\n");
    }
    return TS_SUCCESS;
}

ts_bool fprint_bonds(FILE *fh,ts_vesicle *vesicle){
    ts_uint i;
    for(i=0;i<vesicle->blist->n;i++){
        fprintf(fh,"\t%u\t%u\n",(ts_uint)(vesicle->blist->bond[i]->vtx1->idx),
//-vesicle->vlist->vtx+1),
        (ts_uint)(vesicle->blist->bond[i]->vtx2->idx));
    //-vesicle->vlist.vtx+1));
    }
    return TS_SUCCESS;
}


ts_bool write_dout_fcompat_file(ts_vesicle *vesicle, ts_char *filename){
   FILE *fh;
   fh=fopen(filename, "w");
    if(fh==NULL){
        err("Cannot open file %s for writing");
        return TS_FAIL;
    }
    fprintf(fh,"%.17E\n%.17E\n",vesicle->stepsize,vesicle->dmax);
    fprint_vertex_list(fh,vesicle->vlist);
    fprint_tristar(fh,vesicle);
    fprint_triangle_list(fh,vesicle);
    fprint_vertex_data(fh,vesicle->vlist);
    fprint_bonds(fh,vesicle);
   fclose(fh);	
   return TS_SUCCESS;
}

ts_bool read_tape_fcompat_file(ts_vesicle *vesicle, ts_char *filename){
   FILE *fh;
   char line[255];
   fh=fopen(filename, "r");
        if(fh==NULL){
                err("Cannot open file for reading... Nonexistant file?");
                return TS_FAIL;
        }
   ts_uint retval=1;
   while(retval!=EOF){
      retval=fscanf(fh,"%s",line);
		
      fprintf(stderr,"%s",line);
   }	
   fclose(fh);	
   return TS_SUCCESS;
}

ts_bool write_master_xml_file(ts_char *filename){
    FILE *fh;
   ts_char *i,*j;
    ts_uint tstep;
    ts_char *number;
        fh=fopen(filename, "w");
        if(fh==NULL){
                err("Cannot open file %s for writing");
                return TS_FAIL;
        }

   fprintf(fh,"<?xml version=\"1.0\"?>\n<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"LittleEndian\" compressor=\"vtkZLibDataCompressor\">\n<Collection>");
   DIR *dir = opendir(command_line_args.path);
   if(dir){
      struct dirent *ent;
        tstep=0;
      while((ent = readdir(dir)) != NULL)
      {
            i=rindex(ent->d_name,'.');
            if(i==NULL) continue;
            if(strcmp(i+1,"vtu")==0){
                    j=rindex(ent->d_name,'_');
                    if(j==NULL) continue;
                    number=strndup(j+1,j-i); 
                fprintf(fh,"<DataSet timestep=\"%u\" group=\"\" part=\"0\" file=\"%s\"/>\n",atoi(number),ent->d_name);
                tstep++;
                    free(number);
            }  
      }
   }
    free(dir);
   fprintf(fh,"</Collection>\n</VTKFile>\n");
   fclose(fh);
   return TS_SUCCESS;
}

ts_bool write_vertex_xml_file(ts_vesicle *vesicle, ts_uint timestepno, ts_cluster_list *cstlist){
   ts_vertex_list *vlist=vesicle->vlist;
   ts_bond_list *blist=vesicle->blist;
   ts_vertex **vtx=vlist->vtx;
    ts_uint i,j;
   //ts_double senergy=0.0;
       char filename[10000];
        char just_name[255];
   FILE *fh;
@@ -862,17 +254,28 @@
   xml_trisurf_data(fh,vesicle);
   fprintf(fh, " <UnstructuredGrid>\n");
    fprintf(fh, "<Piece NumberOfPoints=\"%u\" NumberOfCells=\"%u\">\n",vlist->n+monono*polyno+fonono*filno, blist->n+monono*polyno+filno*(fonono-1)+vesicle->tlist->n);
    fprintf(fh,"<PointData Scalars=\"vertices_idx\">\n<DataArray type=\"Int64\" Name=\"vertices_idx\" format=\"ascii\">");
    fprintf(fh,"<PointData Scalars=\"vertices_idx\">\n<DataArray type=\"Int64\" Name=\"vertices_idx\" format=\"binary\">");
   long *int_vector=(long *)malloc((vlist->n+monono*polyno+fonono*filno)*sizeof(long));
   ts_double *float_vector=(double *)malloc((vlist->n+monono*polyno+fonono*filno)*sizeof(double));
   ts_double *float_cell_vector=(double *)malloc((blist->n+monono*polyno+filno*(fonono-1)+vesicle->tlist->n)*sizeof(double));
   ts_double *coordinate_vector=(double *)malloc(3*(vlist->n+monono*polyno+fonono*filno)*sizeof(double));
// sizes are as expected 4 bytes for int and 1 byte for char
//   printf("size of ts_uint %ld, of int %ld, of char %ld",sizeof(ts_uint), sizeof(int), sizeof(char));
   int offset=0;
      for(i=0;i<vlist->n;i++){
      fprintf(fh,"%u ",vtx[i]->idx);
   //   fprintf(fh,"%u ",vtx[i]->idx);
      int_vector[i+offset]=vtx[i]->idx;
    }
   offset=offset+i;
   //polymeres
   if(poly){
      poly_idx=vlist->n;
      for(i=0;i<vesicle->poly_list->n;i++){
         for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++){
            fprintf(fh,"%u ", poly_idx);
            //fprintf(fh,"%u ", poly_idx);
            int_vector[j+offset]=poly_idx;
         }
         offset=offset+j;
      }
   }
   //filaments
@@ -881,27 +284,37 @@
      for(i=0;i<vesicle->filament_list->n;i++){
         for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++){
   //   fprintf(stderr,"was here\n");
            fprintf(fh,"%u ", poly_idx);
            //fprintf(fh,"%u ", poly_idx);
            int_vector[j+offset]=poly_idx;
         }
         offset=offset+j;
      }
   }
   printf("Offset in the end is %d, should be %d",offset,(vlist->n+monono*polyno+fonono*filno) );
   char *printout=ts_compress((char *)int_vector,offset*sizeof(long));
   fprintf(fh,"%s",printout);
   free(printout);

       fprintf(fh,"</DataArray>\n");
   if(cstlist!=NULL){
      fprintf(fh,"<DataArray type=\"Int64\" Name=\"vertices_in_cluster\" format=\"ascii\">");
      for(i=0;i<vlist->n;i++){
      fprintf(fh,"<DataArray type=\"Int64\" Name=\"vertices_in_cluster\" format=\"binary\">");
      offset=0;
      for(i=0;i<vlist->n;i++,offset++){
         if(vtx[i]->cluster!=NULL){
            fprintf(fh,"%u ",vtx[i]->cluster->nvtx);
//            fprintf(fh,"%u ",vtx[i]->cluster->nvtx);
            int_vector[offset]=vtx[i]->cluster->nvtx;
         } else {
            fprintf(fh,"-1 ");
//            fprintf(fh,"-1 ");
            int_vector[offset]=-1;
         }
          }
      //polymeres
      if(poly){
         poly_idx=vlist->n;
         for(i=0;i<vesicle->poly_list->n;i++){
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++){
               fprintf(fh,"-1 ");
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++, offset++){
               //fprintf(fh,"-1 ");
               int_vector[offset]=-1;
            }
         }
      }
@@ -909,12 +322,15 @@
      if(fil){
         poly_idx=vlist->n+monono*polyno;
         for(i=0;i<vesicle->filament_list->n;i++){
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++){
      //   fprintf(stderr,"was here\n");
               fprintf(fh,"-1 ");
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++, offset++){
   //               fprintf(fh,"-1 ");
               int_vector[offset]=-1;
            }
         }
      }
      char *printout=ts_compress((char *)int_vector,offset*sizeof(long));
      fprintf(fh,"%s",printout);
      free(printout);

      fprintf(fh,"</DataArray>\n");

@@ -922,16 +338,19 @@
   }

   //here comes additional data as needed. Currently only spontaneous curvature
   fprintf(fh,"<DataArray type=\"Float64\" Name=\"spontaneous_curvature\" format=\"ascii\">");
   for(i=0;i<vlist->n;i++){
      fprintf(fh,"%.17e ",vtx[i]->c);
   fprintf(fh,"<DataArray type=\"Float64\" Name=\"spontaneous_curvature\" format=\"binary\">");
   offset=0;
   for(i=0;i<vlist->n;i++, offset++){
//      fprintf(fh,"%.17e ",vtx[i]->c);
      float_vector[offset]=vtx[i]->c;
   }
      //polymeres
      if(poly){
         poly_idx=vlist->n;
         for(i=0;i<vesicle->poly_list->n;i++){
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++){
               fprintf(fh,"%.17e ", vesicle->poly_list->poly[i]->vlist->vtx[j]->c);
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++, offset++){
               //fprintf(fh,"%.17e ", vesicle->poly_list->poly[i]->vlist->vtx[j]->c);
               float_vector[offset]=vesicle->poly_list->poly[i]->vlist->vtx[j]->c;
            }
         }
      }
@@ -939,25 +358,34 @@
      if(fil){
         poly_idx=vlist->n+monono*polyno;
         for(i=0;i<vesicle->filament_list->n;i++){
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++){
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++,offset++){
      //   fprintf(stderr,"was here\n");
               fprintf(fh,"%.17e ",  vesicle->filament_list->poly[i]->vlist->vtx[j]->c);
               //fprintf(fh,"%.17e ",  vesicle->filament_list->poly[i]->vlist->vtx[j]->c);
               float_vector[offset]=vesicle->filament_list->poly[i]->vlist->vtx[j]->c;
            }
         }
      }
      printout=ts_compress((char *)float_vector,offset*sizeof(double));
      fprintf(fh,"%s",printout);
      free(printout);


    fprintf(fh,"</DataArray>\n");

   //here comes additional data. Energy!
   fprintf(fh,"<DataArray type=\"Float64\" Name=\"bending_energy\" format=\"ascii\">");
   for(i=0;i<vlist->n;i++){
      fprintf(fh,"%.17e ",vtx[i]->energy*vtx[i]->xk);
   fprintf(fh,"<DataArray type=\"Float64\" Name=\"bending_energy\" format=\"binary\">");
   offset=0;
   for(i=0;i<vlist->n;i++,offset++){
//      fprintf(fh,"%.17e ",vtx[i]->energy*vtx[i]->xk);
      float_vector[offset]=vtx[i]->energy*vtx[i]->xk;
   }
      //polymeres
      if(poly){
         poly_idx=vlist->n;
         for(i=0;i<vesicle->poly_list->n;i++){
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++){
               fprintf(fh,"%.17e ", vesicle->poly_list->poly[i]->vlist->vtx[j]->energy* vesicle->poly_list->poly[i]->k);
            for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,poly_idx++,offset++){
               //fprintf(fh,"%.17e ", vesicle->poly_list->poly[i]->vlist->vtx[j]->energy* vesicle->poly_list->poly[i]->k);
               float_vector[offset]=vesicle->poly_list->poly[i]->vlist->vtx[j]->energy* vesicle->poly_list->poly[i]->k;
            }
         }
      }
@@ -965,51 +393,108 @@
      if(fil){
         poly_idx=vlist->n+monono*polyno;
         for(i=0;i<vesicle->filament_list->n;i++){
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++){
            for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++,poly_idx++,offset++){
      //   fprintf(stderr,"was here\n");
               fprintf(fh,"%.17e ",  vesicle->filament_list->poly[i]->vlist->vtx[j]->energy*  vesicle->filament_list->poly[i]->k);
//               fprintf(fh,"%.17e ",  vesicle->filament_list->poly[i]->vlist->vtx[j]->energy*  vesicle->filament_list->poly[i]->k);
               float_vector[offset]=vesicle->filament_list->poly[i]->vlist->vtx[j]->energy*  vesicle->filament_list->poly[i]->k;
            }
         }
      }

   printout=ts_compress((char *)float_vector,offset*sizeof(double));
      fprintf(fh,"%s",printout);
      free(printout);

    fprintf(fh,"</DataArray>\n");


   
   fprintf(fh,"</PointData>\n<CellData>\n</CellData>\n<Points>\n<DataArray type=\"Float64\" Name=\"Koordinate tock\" NumberOfComponents=\"3\" format=\"ascii\">\n");
   for(i=0;i<vlist->n;i++){
      fprintf(fh,"%.17e %.17e %.17e\n",vtx[i]->x,vtx[i]->y, vtx[i]->z);
   fprintf(fh,"</PointData>\n<CellData>\n");

   if(vesicle->tape->stretchswitch==1){
      fprintf(fh,"<DataArray type=\"Float64\" Name=\"stretching_energy\" format=\"binary\">");
      offset=0;
      for(i=0;i<blist->n;i++,offset++){
         //fprintf(fh, "0.0 ");
         float_cell_vector[offset]=0.0;
      }
      for(i=0;i<monono*polyno+filno*(fonono-1);i++,offset++){
         float_cell_vector[offset]=0.0;
         //fprintf(fh,"0.0 ");
      }
      for(i=0;i<vesicle->tlist->n;i++,offset++){
         float_cell_vector[offset]=vesicle->tlist->tria[i]->energy;
         //fprintf(fh,"%.17e ",vesicle->tlist->tria[i]->energy);
      }

      printout=ts_compress((char *)float_cell_vector,offset*sizeof(double));
      fprintf(fh,"%s",printout);
      free(printout);

       fprintf(fh,"</DataArray>\n");
   }



   fprintf(fh,"</CellData>\n<Points>\n<DataArray type=\"Float64\" Name=\"Koordinate tock\" NumberOfComponents=\"3\" format=\"binary\">\n");
   offset=0;
   for(i=0;i<vlist->n;i++,offset+=3){
      //fprintf(fh,"%.17e %.17e %.17e\n",vtx[i]->x,vtx[i]->y, vtx[i]->z);
      coordinate_vector[offset]=vtx[i]->x;
      coordinate_vector[offset+1]=vtx[i]->y;
      coordinate_vector[offset+2]=vtx[i]->z;
   }
   //polymeres
   if(poly){
      for(i=0;i<vesicle->poly_list->n;i++){
         for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++){
            fprintf(fh,"%.17e %.17e %.17e\n", vesicle->poly_list->poly[i]->vlist->vtx[j]->x,vesicle->poly_list->poly[i]->vlist->vtx[j]->y, vesicle->poly_list->poly[i]->vlist->vtx[j]->z );
         for(j=0;j<vesicle->poly_list->poly[i]->vlist->n;j++,offset+=3){
            //fprintf(fh,"%.17e %.17e %.17e\n", vesicle->poly_list->poly[i]->vlist->vtx[j]->x,vesicle->poly_list->poly[i]->vlist->vtx[j]->y, vesicle->poly_list->poly[i]->vlist->vtx[j]->z );
      coordinate_vector[offset]=vesicle->poly_list->poly[i]->vlist->vtx[j]->x;
      coordinate_vector[offset+1]=vesicle->poly_list->poly[i]->vlist->vtx[j]->y;
      coordinate_vector[offset+2]=vesicle->poly_list->poly[i]->vlist->vtx[j]->z;
         }
      }
   }
   //filaments
   if(fil){
      for(i=0;i<vesicle->filament_list->n;i++){
      for(i=0;i<vesicle->filament_list->n;i++,offset+=3){
         for(j=0;j<vesicle->filament_list->poly[i]->vlist->n;j++){
            fprintf(fh,"%.17e %.17e %.17e\n", vesicle->filament_list->poly[i]->vlist->vtx[j]->x,vesicle->filament_list->poly[i]->vlist->vtx[j]->y, vesicle->filament_list->poly[i]->vlist->vtx[j]->z );
   //      fprintf(fh,"%.17e %.17e %.17e\n", vesicle->filament_list->poly[i]->vlist->vtx[j]->x,vesicle->filament_list->poly[i]->vlist->vtx[j]->y, vesicle->filament_list->poly[i]->vlist->vtx[j]->z );
      coordinate_vector[offset]=vesicle->filament_list->poly[i]->vlist->vtx[j]->x;
      coordinate_vector[offset+1]=vesicle->filament_list->poly[i]->vlist->vtx[j]->y;
      coordinate_vector[offset+2]=vesicle->filament_list->poly[i]->vlist->vtx[j]->z;
         }
      }
   }
   printout=ts_compress((char *)coordinate_vector,offset*sizeof(double));
      fprintf(fh,"%s",printout);
      free(printout);

    fprintf(fh,"</DataArray>\n</Points>\n<Cells>\n<DataArray type=\"Int64\" Name=\"connectivity\" format=\"ascii\">");
   for(i=0;i<blist->n;i++){
         fprintf(fh,"%u %u\n",blist->bond[i]->vtx1->idx,blist->bond[i]->vtx2->idx);


    fprintf(fh,"</DataArray>\n</Points>\n<Cells>\n<DataArray type=\"Int64\" Name=\"connectivity\" format=\"binary\">");
   free(int_vector);
   int_vector=(long *)malloc(((blist->n+monono*polyno+filno*(fonono-1))*2+vesicle->tlist->n*3)*sizeof(long));
   offset=0;
   for(i=0;i<blist->n;i++,offset+=2){
//         fprintf(fh,"%u %u\n",blist->bond[i]->vtx1->idx,blist->bond[i]->vtx2->idx);
         int_vector[offset]=blist->bond[i]->vtx1->idx;
         int_vector[offset+1]=blist->bond[i]->vtx2->idx;
   }
   //polymeres
   if(poly){
      poly_idx=vlist->n;
      for(i=0;i<vesicle->poly_list->n;i++){
         for(j=0;j<vesicle->poly_list->poly[i]->blist->n;j++){
//            fprintf(fh,"%u %u\n", vesicle->poly_list->poly[i]->blist->bond[j]->vtx1->idx,vesicle->poly_list->poly[i]->blist->bond[j]->vtx2->idx);
            fprintf(fh,"%u %u\n", vesicle->poly_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+i*monono,vesicle->poly_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+i*monono);
         for(j=0;j<vesicle->poly_list->poly[i]->blist->n;j++,offset+=2){
            //fprintf(fh,"%u %u\n", vesicle->poly_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+i*monono,vesicle->poly_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+i*monono);
            int_vector[offset]= vesicle->poly_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+i*monono;
            int_vector[offset+1]=vesicle->poly_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+i*monono;
				
         }
   //grafted bonds
      fprintf(fh,"%u %u\n", vesicle->poly_list->poly[i]->grafted_vtx->idx, vesicle->poly_list->poly[i]->vlist->vtx[0]->idx+vlist->n+i*monono);
      //fprintf(fh,"%u %u\n", vesicle->poly_list->poly[i]->grafted_vtx->idx, vesicle->poly_list->poly[i]->vlist->vtx[0]->idx+vlist->n+i*monono);
      int_vector[offset]=vesicle->poly_list->poly[i]->grafted_vtx->idx;
      int_vector[offset+1]=vesicle->poly_list->poly[i]->vlist->vtx[0]->idx+vlist->n+i*monono;
      offset+=2;
      }

   }
@@ -1018,82 +503,67 @@
   if(fil){
      poly_idx=vlist->n+monono*polyno;
      for(i=0;i<vesicle->filament_list->n;i++){
         for(j=0;j<vesicle->filament_list->poly[i]->blist->n;j++){
            fprintf(fh,"%u %u\n", vesicle->filament_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+monono*polyno+i*fonono,vesicle->filament_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+monono*polyno+i*fonono);
         for(j=0;j<vesicle->filament_list->poly[i]->blist->n;j++,offset+=2){
//            fprintf(fh,"%u %u\n", vesicle->filament_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+monono*polyno+i*fonono,vesicle->filament_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+monono*polyno+i*fonono);
            int_vector[offset]=vesicle->filament_list->poly[i]->blist->bond[j]->vtx1->idx+vlist->n+monono*polyno+i*fonono;
            int_vector[offset+1]=vesicle->filament_list->poly[i]->blist->bond[j]->vtx2->idx+vlist->n+monono*polyno+i*fonono;
//      fprintf(stderr,"was here\n");
         
         }
      }

   }
   for(i=0;i<vesicle->tlist->n;i++){
      fprintf(fh,"%u %u %u\n", vesicle->tlist->tria[i]->vertex[0]->idx, vesicle->tlist->tria[i]->vertex[1]->idx, vesicle->tlist->tria[i]->vertex[2]->idx);
   for(i=0;i<vesicle->tlist->n;i++,offset+=3){
//      fprintf(fh,"%u %u %u\n", vesicle->tlist->tria[i]->vertex[0]->idx, vesicle->tlist->tria[i]->vertex[1]->idx, vesicle->tlist->tria[i]->vertex[2]->idx);
      int_vector[offset]=vesicle->tlist->tria[i]->vertex[0]->idx;
      int_vector[offset+1]=vesicle->tlist->tria[i]->vertex[1]->idx;
      int_vector[offset+2]=vesicle->tlist->tria[i]->vertex[2]->idx;
		
   }
    fprintf(fh,"</DataArray>\n<DataArray type=\"Int64\" Name=\"offsets\" format=\"ascii\">");
    for (i=2;i<(blist->n+monono*polyno+(fonono-1)*filno)*2+1;i+=2){
    fprintf(fh,"%u ",i);
      printout=ts_compress((char *)int_vector,offset*sizeof(long));
      fprintf(fh,"%s",printout);
      free(printout);


    fprintf(fh,"</DataArray>\n<DataArray type=\"Int64\" Name=\"offsets\" format=\"binary\">");
    offset=0;
    for (i=2;i<(blist->n+monono*polyno+(fonono-1)*filno)*2+1;i+=2,offset++){
//    fprintf(fh,"%u ",i);
   int_vector[offset]=i;
    }
   for(j=i+1;j<i+3*(vesicle->tlist->n);j+=3){ //let's continue counting from where we left of
      fprintf(fh,"%u ", j);
   for(j=i+1;j<i+3*(vesicle->tlist->n);j+=3,offset++){ //let's continue counting from where we left of
//      fprintf(fh,"%u ", j);
   int_vector[offset]=j;
   }
    fprintf(fh,"\n");
    fprintf(fh,"</DataArray>\n<DataArray type=\"UInt8\" Name=\"types\" format=\"ascii\">\n");
     for (i=0;i<blist->n+monono*polyno+(fonono-1)*filno;i++){
        fprintf(fh,"3 ");
//    fprintf(fh,"\n");
   printout=ts_compress((char *)int_vector,offset*sizeof(long));
   fprintf(fh,"%s",printout);
   free(printout);
    fprintf(fh,"</DataArray>\n<DataArray type=\"UInt8\" Name=\"types\" format=\"binary\">\n");
   free(int_vector);
   free(float_vector);
   free(float_cell_vector);
   free(coordinate_vector);
   unsigned char *char_vector=(unsigned char *)malloc((blist->n+monono*polyno+filno*(fonono-1)+vesicle->tlist->n)*sizeof(char));
   offset=0;
     for (i=0;i<blist->n+monono*polyno+(fonono-1)*filno;i++,offset++){
        //fprintf(fh,"3 ");
   char_vector[offset]=3;
    }
   for(i=0;i<vesicle->tlist->n;i++){
      fprintf(fh,"5 ");
   for(i=0;i<vesicle->tlist->n;i++,offset++){
   //   fprintf(fh,"5 ");
      char_vector[offset]=5;
   }
   printout=ts_compress((char *)char_vector,offset*sizeof(char));
   fprintf(fh,"%s",printout);
   free(printout);
   free(char_vector);

    fprintf(fh,"</DataArray>\n</Cells>\n</Piece>\n</UnstructuredGrid>\n</VTKFile>\n");
    fclose(fh);
    return TS_SUCCESS;

}

ts_bool write_vertex_vtk_file(ts_vesicle *vesicle,ts_char *filename, ts_char *text){
   ts_vertex_list *vlist=vesicle->vlist;
   ts_bond_list *blist=vesicle->blist;
   ts_vertex **vtx=vlist->vtx;
   ts_uint i;
   FILE *fh;
	
   fh=fopen(filename, "w");
   if(fh==NULL){
      err("Cannot open file %s for writing");
      return TS_FAIL;
   }
   /* Here comes header of the file */
//    fprintf(stderr,"NSHELL=%u\n",nshell);
   fprintf(fh, "# vtk DataFile Version 2.0\n");
   /* TODO: Do a sanity check on text. Max 255 char, must not me \n terminated */ 
   fprintf(fh, "%s\n", text);
   fprintf(fh,"ASCII\n");
   fprintf(fh,"DATASET UNSTRUCTURED_GRID\n");
   fprintf(fh,"POINTS %u double\n", vlist->n);
   for(i=0;i<vlist->n;i++){
      fprintf(fh,"%e %e %e\n",vtx[i]->x,vtx[i]->y, vtx[i]->z);
   }
	
   fprintf(fh,"CELLS %u %u\n",blist->n,3*blist->n);
   for(i=0;i<blist->n;i++){
         fprintf(fh,"2 %u %u\n",blist->bond[i]->vtx1->idx,blist->bond[i]->vtx2->idx);
   }
   fprintf(fh,"CELL_TYPES %u\n",blist->n);
   for(i=0;i<blist->n;i++)
      fprintf(fh,"3\n");

   fprintf(fh,"POINT_DATA %u\n", vlist->n);
   fprintf(fh,"SCALARS scalars long 1\n");
   fprintf(fh,"LOOKUP_TABLE default\n");

   for(i=0;i<vlist->n;i++)
      fprintf(fh,"%u\n",vtx[i]->idx);

   fclose(fh);
   return TS_SUCCESS;
}



ts_bool write_pov_file(ts_vesicle *vesicle, char *filename){
   FILE *fh;
@@ -1152,6 +622,7 @@
        CFG_SIMPLE_INT("nmono", &tape->nmono),
   CFG_SIMPLE_INT("nfil",&tape->nfil),
   CFG_SIMPLE_INT("nfono",&tape->nfono),
   CFG_SIMPLE_INT("internal_poly",&tape->internal_poly),
   CFG_SIMPLE_INT("R_nucleus",&tape->R_nucleus),
   CFG_SIMPLE_FLOAT("R_nucleusX",&tape->R_nucleusX),
   CFG_SIMPLE_FLOAT("R_nucleusY",&tape->R_nucleusY),
@@ -1163,6 +634,8 @@
   CFG_SIMPLE_INT("constvolswitch",&tape->constvolswitch),
   CFG_SIMPLE_INT("constareaswitch",&tape->constareaswitch),
   CFG_SIMPLE_FLOAT("constvolprecision",&tape->constvolprecision),
   CFG_SIMPLE_INT("stretchswitch",&tape->stretchswitch),
   CFG_SIMPLE_FLOAT("xkA0",&tape->xkA0),	
   CFG_SIMPLE_FLOAT("pressure",&tape->pressure),
   CFG_SIMPLE_FLOAT("k_spring",&tape->kspring),
   CFG_SIMPLE_FLOAT("xi",&tape->xi),
@@ -1173,8 +646,8 @@
        CFG_SIMPLE_INT("iterations",&tape->iterations),
   CFG_SIMPLE_INT("mcsweeps",&tape->mcsweeps),
   CFG_SIMPLE_INT("inititer", &tape->inititer),
        CFG_SIMPLE_BOOL("quiet",&tape->quiet),
        CFG_SIMPLE_STR("multiprocessing",tape->multiprocessing),
            CFG_SIMPLE_BOOL("quiet",(cfg_bool_t *)&tape->quiet),
        CFG_SIMPLE_STR("multiprocessing",&tape->multiprocessing),
        CFG_SIMPLE_INT("smp_cores",&tape->brezveze0),
        CFG_SIMPLE_INT("cluster_nodes",&tape->brezveze1),
        CFG_SIMPLE_INT("distributed_processes",&tape->brezveze2),
@@ -1183,12 +656,23 @@
   CFG_SIMPLE_FLOAT("c0",&tape->c0),
   CFG_SIMPLE_FLOAT("w",&tape->w),
   CFG_SIMPLE_FLOAT("F",&tape->F),
/* Variables related to plane confinement */
   CFG_INT("plane_confinement_switch", 0, CFGF_NONE),
   CFG_FLOAT("plane_d", 15, CFGF_NONE),
   CFG_FLOAT("plane_F", 1000, CFGF_NONE),
/* Variables related to stretching */
//   CFG_FLOAT("stretchswitch", 0, CFGF_NONE),
//   CFG_FLOAT("xkA0",0,CFGF_NONE),
        CFG_END()
    };
    cfg_t *cfg;    
    ts_uint retval;
    cfg = cfg_init(opts, 0);
    retval=cfg_parse_buf(cfg, buffer);
   tape->plane_confinement_switch=cfg_getint(cfg,"plane_confinement_switch");
   tape->plane_d=cfg_getfloat(cfg,"plane_d");
   tape->plane_F=cfg_getfloat(cfg,"plane_F");

    if(retval==CFG_FILE_ERROR){
   fatal("No tape file.",100);
   }
@@ -1217,6 +701,8 @@
ts_bool getcmdline_tape(cfg_t *cfg, char *opts){

   char *commands, *backup, *saveptr, *saveopptr, *command, *operator[2];
   operator[0]=0;
   operator[1]=0;
   ts_uint i,j;
   commands=(char *)malloc(10000*sizeof(char));
    backup=commands; //since the pointer to commands will be lost, we acquire a pointer that will serve as backup.
@@ -1267,53 +753,5 @@
            break;

    }
    return TS_SUCCESS;
}



ts_bool read_geometry_file(char *fname, ts_vesicle *vesicle){
   FILE *fh;
    ts_uint i, nvtx,nedges,ntria;
    ts_uint vtxi1,vtxi2;
    float x,y,z;
    ts_vertex_list *vlist;
   fh=fopen(fname, "r");
        if(fh==NULL){
                err("Cannot open file for reading... Nonexistant file?");
                return TS_FAIL;
        }
   ts_uint retval;
   retval=fscanf(fh,"%u %u %u",&nvtx, &nedges, &ntria);
    vesicle->vlist=init_vertex_list(nvtx);
    vlist=vesicle->vlist;
    for(i=0;i<nvtx;i++){
   //     fscanf(fh,"%F %F %F",&vlist->vtx[i]->x,&vlist->vtx[i]->y,&vlist->vtx[i]->z);
       retval=fscanf(fh,"%F %F %F",&x,&y,&z);
        vlist->vtx[i]->x=x;
        vlist->vtx[i]->y=y;
        vlist->vtx[i]->z=z;
    }
    for(i=0;i<nedges;i++){
        retval=fscanf(fh,"%u %u",&vtxi1,&vtxi2);
        bond_add(vesicle->blist,vesicle->vlist->vtx[vtxi1-1],vesicle->vlist->vtx[vtxi2-1]);
    }
    //TODO: neighbours from bonds,
    //TODO: triangles from neigbours

//    Don't need to read triangles. Already have enough data
    /*
    for(i=0;i<ntria;i++){
        retval=fscanf(fh,"%u %u %u", &bi1, &bi2, &bi3);
        vtxi1=vesicle->blist->vertex1->idx;
        vtxi2=vesicle->blist->vertex1->idx;
        
    }
    */
   if(retval);
   fclose(fh);	



    return TS_SUCCESS;
}