From b5ba7b3c7142aa7a2d58d9554048e6317ebd3616 Mon Sep 17 00:00:00 2001 From: Samo Penic <samo.penic@gmail.com> Date: Sat, 30 Nov 2013 10:41:10 +0000 Subject: [PATCH] step in rewritting --- src/vertex.c | 275 +++++++++++++++++++++++++++++++++++++++++------------- 1 files changed, 209 insertions(+), 66 deletions(-) diff --git a/src/vertex.c b/src/vertex.c index 60123ab..653d8d2 100644 --- a/src/vertex.c +++ b/src/vertex.c @@ -3,110 +3,253 @@ #include<string.h> #include "general.h" #include "vertex.h" +#include "bond.h" #include<stdio.h> ts_vertex_list *init_vertex_list(ts_uint N){ ts_int i; - ts_vertex_list *vlist=(ts_vertex_list *)malloc(sizeof(ts_vertex_list *)); - + ts_vertex_list *vlist=(ts_vertex_list *)calloc(1,sizeof(ts_vertex_list)); + if(N==0){ - err("Initialized vertex list with zero elements. Pointer set to NULL"); - vlist->n=0; - vlist->vtx=NULL; + vlist->n=0; + vlist->vtx=(ts_vertex **)calloc(1,sizeof(ts_vertex *)); /*Allocate one memory space for vlist anyway */ return vlist; } - vlist->vtx=(ts_vertex **)malloc(N*sizeof(ts_vertex *)); + vlist->vtx=(ts_vertex **)calloc(N,sizeof(ts_vertex *)); if(vlist->vtx==NULL) fatal("Fatal error reserving memory space for vertex list! Could number of requsted vertices be too large?", 100); - for(i=0;i<N;i++) vlist->vtx[i]=init_vertex(i); + for(i=0;i<N;i++) { + vlist->vtx[i]=(ts_vertex *)calloc(1,sizeof(ts_vertex)); + vlist->vtx[i]->idx=i; + /* initialize Ylm for spherical hamonics DONE in sh.c */ + } vlist->n=N; return vlist; } -ts_vertex *init_vertex(ts_uint idx){ - ts_vertex *vtx; - vtx=(ts_vertex *)malloc(sizeof(ts_vertex)); - if(vtx==NULL) - fatal("Fatal error reserving memory space for ts_vertex! Memory full?", 100); - vtx->idx=idx; - return vtx; + +ts_bool vertex_list_add_vtx(ts_vertex_list *vlist, ts_vertex *vtx){ + +#ifdef DEBUG + if(vtx==NULL || vlist==NULL) return TS_FAIL; +#endif + if(vlist->list_size < vlist->n+1){ + vlist->vtx=(ts_vertex **)realloc(vlist->vtx, (vlist->list_size+TS_VLIST_CHUNK)*sizeof(ts_vertex*)); + if(vlist->vtx==NULL){ + fatal("Error in vertex_list_add. Could not reallocate memory space.",9999); + } + vlist->list_size+=TS_VLIST_CHUNK; + } + vlist->vtx[vlist->n]=vtx; + vlist->n++; + return TS_SUCCESS; } -/* -ts_bool vtx_set_global_values(ts_vertex **vlist, ts_vesicle *vesicle){ - ts_double xk=vesicle->bending_rigidity; - ts_uint i; - for(i=0;i<vesicle->vlist.n;i++){ - vlist[i]->xk=xk; - } - return TS_SUCCESS; + +/* Idea is to delete vertex by removing it from list. The emply place is then filled in by the last +vertex in the list. List can then be resized by one -- unless resize is required when max list size - +real list size > predefined value */ +ts_bool vertex_list_remove_vtx(ts_vertex_list *vlist, ts_vertex *vtx){ +#ifdef DEBUG + if(vtx==NULL || vlist==NULL) return TS_FAIL; +#endif + ts_uint i; + for(i=0; i<vlist->n;i++){ + if(vlist->vtx[i]==vtx){ + vlist->vtx[i]=vlist->vtx[vlist->n-1]; + vlist->n--; + if(vlist->list_size-vlist->n > TS_VLIST_CHUNK){ + vlist->vtx=(ts_vertex **)realloc(vlist->vtx, (vlist->list_size-TS_VLIST_CHUNK)*sizeof(ts_vertex*)); + if(vlist->vtx==NULL){ + fatal("Error in vertex_list_add. Could not reallocate memory space.",9999); + } + vlist->list_size-=TS_VLIST_CHUNK; + } + return TS_SUCCESS; + } + } + return TS_FAIL; } -*/ -ts_bool vtx_add_neighbour(ts_vertex **vtx, ts_vertex **nvtx){ - ts_uint i; - /* no neighbour can be null! */ - if(vtx==NULL || nvtx==NULL) return TS_FAIL; - - /*if it is already a neighbour don't add it to the list */ - for(i=0; i<(*vtx)->neigh_no;i++){ - if((*vtx)->neigh[i]==nvtx) return TS_FAIL; - } - ts_uint nn=(*vtx)->neigh_no++; - (*vtx)->neigh=(ts_vertex ***)realloc((*vtx)->neigh, nn*sizeof(ts_vertex **)); - (*vtx)->neigh[nn]=nvtx; +ts_bool vtx_add_bond(ts_bond_list *blist,ts_vertex *vtx1,ts_vertex *vtx2){ + ts_bond *bond; + bond=bond_add(blist,vtx1,vtx2); + if(bond==NULL) return TS_FAIL; + vtx1->bond_no++; + vtx2->bond_no++; + // vtx2->data->bond_no++; - /* pa se sosedu dodamo vertex */ - /*if it is already a neighbour don't add it to the list */ - for(i=0; i<(*nvtx)->neigh_no;i++){ - if((*nvtx)->neigh[i]==vtx) return TS_FAIL; - } - nn=(*nvtx)->neigh_no++; - (*nvtx)->neigh=(ts_vertex ***)realloc((*nvtx)->neigh, nn*sizeof(ts_vertex **)); - (*nvtx)->neigh[nn]=vtx; - - -/* Ustvari bond in doloci dolzino */ - + vtx1->bond=(ts_bond **)realloc(vtx1->bond, vtx1->bond_no*sizeof(ts_bond *)); + vtx2->bond=(ts_bond **)realloc(vtx2->bond, vtx2->bond_no*sizeof(ts_bond *)); + // vtx2->data->bond=(ts_bond **)realloc(vtx2->data->bond, vtx2->data->bond_no*sizeof(ts_bond *)); + vtx1->bond[vtx1->bond_no-1]=bond; + vtx2->bond[vtx2->bond_no-1]=bond; + // vtx2->ata->bond[vtx2->data->bond_no-1]=bond; return TS_SUCCESS; } -ts_bool vtx_free(ts_vertex **vtx){ - if((*vtx)->neigh!=NULL) free((*vtx)->neigh); - if((*vtx)->tristar!=NULL) free((*vtx)->tristar); - if((*vtx)->bond!=NULL) free((*vtx)->bond); - if((*vtx)->cell!=NULL) free((*vtx)->cell); - free(*vtx); +ts_bool vtx_add_neighbour(ts_vertex *vtx1, ts_vertex *vtx2){ + vertex_list_add_vtx(vtx1->neigh, vtx2); + vertex_list_add_vtx(vtx2->neigh, vtx1); + return TS_SUCCESS; +} + +ts_bool vtx_add_cneighbour(ts_bond_list *blist, ts_vertex *vtx1, ts_vertex *vtx2){ + ts_bool retval; + retval=vertex_list_add_vtx(vtx1->neigh, vtx2); + retval=vertex_list_add_vtx(vtx2->neigh, vtx1); + if(retval==TS_SUCCESS) + retval=vtx_add_bond(blist,vtx1,vtx2); + + return retval; +} + +/*TODO: write and optimize this urgently before use! */ +ts_bool vtx_remove_cneighbour(ts_bond_list *blist, ts_vertex *vtx1, ts_vertex +*vtx2){ +// ts_bool retval; +/* remove the bond */ +//retval=vtx_remove_bond(blist,vtx1,vtx2); +/* remove the vertices */ + return TS_SUCCESS; +} + + +ts_bool vtx_free(ts_vertex *vtx){ + if(vtx->neigh!=NULL) free(vtx->neigh); + if(vtx->tristar!=NULL) free(vtx->tristar); + if(vtx->bond!=NULL) free(vtx->bond); + free(vtx); return TS_SUCCESS; } ts_bool vtx_list_free(ts_vertex_list *vlist){ int i; for(i=0;i<vlist->n;i++){ - vtx_free(VTX(vlist,i)); + if(vlist->vtx[i]!=NULL) vtx_free(vlist->vtx[i]); } + //free(*(vlist->vtx)); + free(vlist->vtx); free(vlist); + return TS_SUCCESS; +} + +inline ts_double vtx_distance_sq(ts_vertex *vtx1, ts_vertex *vtx2){ + ts_double dist; +#ifdef TS_DOUBLE_DOUBLE + dist=pow(vtx1->x-vtx2->x,2) + pow(vtx1->y-vtx2->y,2) + pow(vtx1->z-vtx2->z,2); +#endif +#ifdef TS_DOUBLE_LONGDOUBLE + dist=powl(vtx1->x-vtx2->x,2) + powl(vtx1->y-vtx2->y,2) + powl(vtx1->z-vtx2->z,2); +#endif +#ifdef TS_DOUBLE_FLOAT + dist=powf(vtx1->x-vtx2->x,2) + powf(vtx1->y-vtx2->y,2) + powf(vtx1->z-vtx2->z,2); +#endif + return(dist); +} + + + +ts_bool vtx_set_global_values(ts_vesicle *vesicle){ + ts_double xk=vesicle->bending_rigidity; + ts_uint i; + for(i=0;i<vesicle->vlist->n;i++){ + vesicle->vlist->vtx[i]->xk=xk; + } + return TS_SUCCESS; +} + +inline ts_double vtx_direct(ts_vertex *vtx1, ts_vertex *vtx2, ts_vertex *vtx3){ + ts_double dX2=vtx2->x-vtx1->x; + ts_double dY2=vtx2->y-vtx1->y; + ts_double dZ2=vtx2->z-vtx1->z; + ts_double dX3=vtx3->x-vtx1->x; + ts_double dY3=vtx3->y-vtx1->y; + ts_double dZ3=vtx3->z-vtx1->z; + ts_double direct=vtx1->x*(dY2*dZ3 -dZ2*dY3)+ + vtx1->y*(dZ2*dX3-dX2*dZ3)+ + vtx1->z*(dX2*dY3-dY2*dX3); + return(direct); +} + + +inline ts_bool vertex_add_tristar(ts_vertex *vtx, ts_triangle *tristarmem){ + vtx->tristar_no++; + vtx->tristar=(ts_triangle **)realloc(vtx->tristar,vtx->tristar_no*sizeof(ts_triangle *)); + if(vtx->tristar==NULL){ + fatal("Reallocation of memory while adding tristar failed.",3); + } + vtx->tristar[vtx->tristar_no-1]=tristarmem; + return TS_SUCCESS; +} + + + +/* vtx remove tristar is required in bondflip. */ +/* TODO: Check whether it is important to keep the numbering of tristar + * elements in some order or not! */ +inline ts_bool vtx_remove_tristar(ts_vertex *vtx, ts_triangle *tristar){ + ts_uint i,j=0; + for(i=0;i<vtx->tristar_no;i++){ + if(vtx->tristar[i]!=tristar){ + vtx->tristar[j]=vtx->tristar[i]; + j++; + } + } + vtx->tristar_no--; + vtx->tristar=realloc(vtx->tristar,vtx->tristar_no*sizeof(ts_triangle *)); + if(vtx->neigh == NULL){ + fatal("Reallocation of memory failed during insertion of vertex neighbour in vertex_add_neighbour",3); + } return TS_SUCCESS; } +/* ****************************************************************** */ +/* ***** New vertex copy operations. Inherently they are slow. ***** */ +/* ****************************************************************** */ -inline ts_double vtx_distance_sq(ts_vertex **vtx1, ts_vertex **vtx2){ - ts_double dist; -#ifdef TS_DOUBLE_DOUBLE - dist=pow((*vtx1)->x-(*vtx2)->x,2) + pow((*vtx1)->y-(*vtx2)->y,2) + pow((*vtx1)->z-(*vtx2)->z,2); -#endif -#ifdef TS_DOUBLE_LONGDOUBLE - dist=powl((*vtx1)->x-(*vtx2)->x,2) + powl((*vtx1)->y-(*vtx2)->y,2) + powl((*vtx1)->z-(*vtx2)->z,2); -#endif -#ifdef TS_DOUBLE_FLOAT - dist=powf((*vtx1)->x-(*vtx2)->x,2) + powf((*vtx1)->y-(*vtx2)->y,2) + powf((*vtx1)->z-(*vtx2)->z,2); -#endif - return(dist); +ts_bool vtx_copy(ts_vertex *cvtx, ts_vertex *ovtx){ + memcpy((void *)cvtx,(void *)ovtx,sizeof(ts_vertex)); + cvtx->neigh=NULL; + cvtx->tristar_no=0; + cvtx->bond_no=0; + cvtx->tristar=NULL; + cvtx->bond=NULL; + cvtx->cell=NULL; + return TS_SUCCESS; } +ts_bool vtx_duplicate(ts_vertex *cvtx, ts_vertex *ovtx){ + memcpy((void *)cvtx,(void *)ovtx,sizeof(ts_vertex)); + return TS_SUCCESS; +} + +//TODO: needs to be done +ts_vertex **vtx_neigh_copy(ts_vertex_list *vlist,ts_vertex *ovtx){ + return NULL; +} + + + +ts_vertex_list *vertex_list_copy(ts_vertex_list *ovlist){ + ts_uint i; + ts_vertex_list *vlist=(ts_vertex_list *)malloc(sizeof(ts_vertex_list)); + vlist=memcpy((void *)vlist, (void *)ovlist, sizeof(ts_vertex_list)); + ts_vertex **vtx=(ts_vertex **)malloc(vlist->n*sizeof(ts_vertex *)); + vlist->vtx=vtx; + if(vlist->vtx==NULL) + fatal("Fatal error reserving memory space for vertex list! Could number of requsted vertices be too large?", 100); + for(i=0;i<vlist->n;i++) { + vlist->vtx[i]=(ts_vertex *)calloc(1,sizeof(ts_vertex)); + vlist->vtx[i]->idx=i; + vtx_copy(vlist->vtx[i],ovlist->vtx[i]); + } + + return vlist; +} -- Gitblit v1.9.3