| commit | author | age | ||
| d7639a | 1 | #include<stdlib.h> |
| SP | 2 | #include<math.h> |
| 3 | #include<string.h> | |
| 4 | #include "general.h" | |
| 5 | #include "vertex.h" | |
| a10dd5 | 6 | #include "bond.h" |
| d7639a | 7 | #include<stdio.h> |
| SP | 8 | |
| 73f967 | 9 | ts_vertex_list *init_vertex_list(ts_uint N){ |
| d7639a | 10 | ts_int i; |
| a10dd5 | 11 | ts_vertex *tlist; |
| SP | 12 | ts_vertex_list *vlist=(ts_vertex_list *)malloc(sizeof(ts_vertex_list)); |
| 73f967 | 13 | |
| d7639a | 14 | if(N==0){ |
| SP | 15 | err("Initialized vertex list with zero elements. Pointer set to NULL"); |
| 73f967 | 16 | vlist->n=0; |
| SP | 17 | vlist->vtx=NULL; |
| 18 | return vlist; | |
| d7639a | 19 | } |
| 73f967 | 20 | |
| a10dd5 | 21 | vlist->vtx=(ts_vertex **)malloc(N*sizeof(ts_vertex *)); |
| SP | 22 | tlist=(ts_vertex *)malloc(N*sizeof(ts_vertex)); |
| 23 | if(vlist->vtx==NULL || tlist==NULL) | |
| 73f967 | 24 | fatal("Fatal error reserving memory space for vertex list! Could number of requsted vertices be too large?", 100); |
| a10dd5 | 25 | for(i=0;i<N;i++) { |
| SP | 26 | vlist->vtx[i]=&tlist[i]; |
| 27 | vlist->vtx[i]->data=init_vertex_data(); | |
| 28 | vlist->vtx[i]->idx=i; | |
| 29 | } | |
| 73f967 | 30 | vlist->n=N; |
| d7639a | 31 | return vlist; |
| SP | 32 | } |
| 33 | ||
| 737714 | 34 | ts_vertex_data *init_vertex_data(){ |
| SP | 35 | ts_vertex_data *data; |
| a10dd5 | 36 | data=(ts_vertex_data *)calloc(1,sizeof(ts_vertex_data)); |
| 737714 | 37 | if(data==NULL) |
| d7639a | 38 | fatal("Fatal error reserving memory space for ts_vertex! Memory full?", 100); |
| 737714 | 39 | return data; |
| d7639a | 40 | } |
| SP | 41 | |
| 42 | /* | |
| 43 | ts_bool vtx_set_global_values(ts_vertex **vlist, ts_vesicle *vesicle){ | |
| 44 | ts_double xk=vesicle->bending_rigidity; | |
| 45 | ts_uint i; | |
| 46 | for(i=0;i<vesicle->vlist.n;i++){ | |
| 47 | vlist[i]->xk=xk; | |
| 48 | } | |
| 49 | return TS_SUCCESS; | |
| 50 | } | |
| 51 | */ | |
| 52 | ||
| 53 | ||
| 54 | ||
| 737714 | 55 | ts_bool vtx_add_neighbour(ts_vertex *vtx, ts_vertex *nvtx){ |
| d7639a | 56 | ts_uint i; |
| SP | 57 | /* no neighbour can be null! */ |
| 58 | if(vtx==NULL || nvtx==NULL) return TS_FAIL; | |
| 59 | ||
| 60 | /*if it is already a neighbour don't add it to the list */ | |
| 737714 | 61 | for(i=0; i<vtx->data->neigh_no;i++){ |
| SP | 62 | if(vtx->data->neigh[i]==nvtx) return TS_FAIL; |
| d7639a | 63 | } |
| a10dd5 | 64 | ts_uint nn=++vtx->data->neigh_no; |
| 737714 | 65 | vtx->data->neigh=(ts_vertex **)realloc(vtx->data->neigh, nn*sizeof(ts_vertex *)); |
| a10dd5 | 66 | vtx->data->neigh[nn-1]=nvtx; |
| d7639a | 67 | |
| SP | 68 | /* pa se sosedu dodamo vertex */ |
| 69 | /*if it is already a neighbour don't add it to the list */ | |
| 737714 | 70 | for(i=0; i<nvtx->data->neigh_no;i++){ |
| SP | 71 | if(nvtx->data->neigh[i]==vtx) return TS_FAIL; |
| d7639a | 72 | } |
| a10dd5 | 73 | nn=++nvtx->data->neigh_no; |
| 737714 | 74 | nvtx->data->neigh=(ts_vertex **)realloc(nvtx->data->neigh, nn*sizeof(ts_vertex *)); |
| a10dd5 | 75 | nvtx->data->neigh[nn-1]=vtx; |
| d7639a | 76 | |
| SP | 77 | |
| 78 | return TS_SUCCESS; | |
| 79 | } | |
| a10dd5 | 80 | |
| 9802f1 | 81 | /* TODO: optimize this. test this. */ |
| SP | 82 | ts_bool vtx_remove_neighbour(ts_vertex *vtx, ts_vertex *nvtx){ |
| 83 | /* find a neighbour */ | |
| 84 | /* remove it from the list while shifting remaining neighbours up */ | |
| 85 | ts_uint i,j=0; | |
| 86 | for(i=0;i<vtx->data->neigh_no;i++){ | |
| 87 | if(vtx->data->neigh[i]!=nvtx){ | |
| 88 | vtx->data->neigh[j]=vtx->data->neigh[i]; | |
| 89 | j++; | |
| 90 | } | |
| 91 | } | |
| 92 | /* resize memory. potentionally time consuming */ | |
| 93 | vtx->data->neigh_no--; | |
| 94 | vtx->data->neigh=(ts_vertex **)realloc(vtx->data->neigh,vtx->data->neigh_no*sizeof(ts_vertex *)); | |
| 95 | if(vtx->data->neigh == NULL && vtx->data->neigh_no!=0) | |
| 96 | fatal("Reallocation of memory failed during removal of vertex neighbour in vtx_remove_neighbour",100); | |
| 97 | ||
| 98 | /* repeat for the neighbour */ | |
| 99 | /* find a neighbour */ | |
| 100 | /* remove it from the list while shifting remaining neighbours up */ | |
| 101 | for(i=0;i<nvtx->data->neigh_no;i++){ | |
| 102 | if(nvtx->data->neigh[i]!=vtx){ | |
| 103 | nvtx->data->neigh[j]=nvtx->data->neigh[i]; | |
| 104 | j++; | |
| 105 | } | |
| 106 | } | |
| 107 | /* resize memory. potentionally time consuming. */ | |
| 108 | nvtx->data->neigh_no--; | |
| 109 | nvtx->data->neigh=(ts_vertex **)realloc(nvtx->data->neigh,nvtx->data->neigh_no*sizeof(ts_vertex *)); | |
| 110 | if(nvtx->data->neigh == NULL && nvtx->data->neigh_no!=0) | |
| 111 | fatal("Reallocation of memory failed during removal of vertex neighbour in vtx_remove_neighbour",100); | |
| 112 | ||
| 113 | return TS_SUCCESS; | |
| 114 | } | |
| 115 | ||
| 116 | ||
| a10dd5 | 117 | ts_bool vtx_add_bond(ts_bond_list *blist,ts_vertex *vtx1,ts_vertex *vtx2){ |
| SP | 118 | ts_bond *bond; |
| 119 | bond=bond_add(blist,vtx1,vtx2); | |
| 120 | if(bond==NULL) return TS_FAIL; | |
| 121 | vtx1->data->bond_no++; | |
| 122 | vtx2->data->bond_no++; | |
| 123 | ||
| 124 | vtx1->data->bond=(ts_bond **)realloc(vtx1->data->bond, vtx1->data->bond_no*sizeof(ts_bond *)); | |
| 125 | vtx2->data->bond=(ts_bond **)realloc(vtx2->data->bond, vtx2->data->bond_no*sizeof(ts_bond *)); | |
| 126 | vtx1->data->bond[vtx1->data->bond_no-1]=bond; | |
| 127 | vtx2->data->bond[vtx2->data->bond_no-1]=bond; | |
| 128 | return TS_SUCCESS; | |
| 129 | } | |
| 130 | ||
| 131 | ts_bool vtx_add_cneighbour(ts_bond_list *blist, ts_vertex *vtx1, ts_vertex *vtx2){ | |
| 132 | ts_bool retval; | |
| 133 | retval=vtx_add_neighbour(vtx1,vtx2); | |
| 134 | if(retval==TS_SUCCESS) | |
| 135 | retval=vtx_add_bond(blist,vtx1,vtx2); | |
| 136 | return retval; | |
| 137 | } | |
| 138 | ||
| 9802f1 | 139 | /*TODO: write and optimize this urgently before use! */ |
| SP | 140 | ts_bool vtx_remove_cneighbour(ts_bond_list *blist, ts_vertex *vtx1, ts_vertex |
| 141 | *vtx2){ | |
| 142 | // ts_bool retval; | |
| 143 | /* remove the bond */ | |
| 144 | //retval=vtx_remove_bond(blist,vtx1,vtx2); | |
| 145 | /* remove the vertices */ | |
| 146 | return TS_SUCCESS; | |
| 147 | } | |
| a10dd5 | 148 | |
| d7639a | 149 | |
| SP | 150 | |
| 737714 | 151 | ts_bool vtx_data_free(ts_vertex_data *data){ |
| SP | 152 | if(data->neigh!=NULL) free(data->neigh); |
| 153 | if(data->tristar!=NULL) free(data->tristar); | |
| 154 | if(data->bond!=NULL) free(data->bond); | |
| 155 | if(data->cell!=NULL) free(data->cell); | |
| 156 | free(data); | |
| 157 | return TS_SUCCESS; | |
| 158 | } | |
| 159 | ||
| a10dd5 | 160 | /*not usable. can be deleted */ |
| 737714 | 161 | ts_bool vtx_free(ts_vertex *vtx){ |
| SP | 162 | vtx_data_free(vtx->data); |
| 163 | free(vtx); | |
| d7639a | 164 | return TS_SUCCESS; |
| SP | 165 | } |
| 166 | ||
| 73f967 | 167 | ts_bool vtx_list_free(ts_vertex_list *vlist){ |
| SP | 168 | int i; |
| 169 | for(i=0;i<vlist->n;i++){ | |
| a10dd5 | 170 | vtx_data_free(vlist->vtx[i]->data); |
| 73f967 | 171 | } |
| a10dd5 | 172 | free(*(vlist->vtx)); |
| 737714 | 173 | free(vlist->vtx); |
| 73f967 | 174 | free(vlist); |
| SP | 175 | return TS_SUCCESS; |
| 176 | } | |
| d7639a | 177 | |
| 73f967 | 178 | |
| SP | 179 | |
| 737714 | 180 | /* rewrite for additional structure in chain */ |
| SP | 181 | /*inline ts_double vtx_distance_sq(ts_vertex *vtx1, ts_vertex *vtx2){ |
| d7639a | 182 | ts_double dist; |
| SP | 183 | #ifdef TS_DOUBLE_DOUBLE |
| 184 | dist=pow((*vtx1)->x-(*vtx2)->x,2) + pow((*vtx1)->y-(*vtx2)->y,2) + pow((*vtx1)->z-(*vtx2)->z,2); | |
| 185 | #endif | |
| 186 | #ifdef TS_DOUBLE_LONGDOUBLE | |
| 187 | dist=powl((*vtx1)->x-(*vtx2)->x,2) + powl((*vtx1)->y-(*vtx2)->y,2) + powl((*vtx1)->z-(*vtx2)->z,2); | |
| 188 | #endif | |
| 189 | #ifdef TS_DOUBLE_FLOAT | |
| 190 | dist=powf((*vtx1)->x-(*vtx2)->x,2) + powf((*vtx1)->y-(*vtx2)->y,2) + powf((*vtx1)->z-(*vtx2)->z,2); | |
| 191 | #endif | |
| 192 | return(dist); | |
| 193 | } | |
| 737714 | 194 | */ |
