00001 #include "gedge.h"
00002 #include "gnode.h"
00003 #include "gtopology.h"
00004 #include <math.h>
00005
00006 gedge::gedge (void)
00007 {
00008
00009 nn=0;
00010
00011 fn=-1;
00012
00013 ln=-1;
00014
00015 nm=0;
00016
00017 ndofnf=0;
00018
00019 ndofnl=0;
00020
00021
00022
00023 prev=-1;
00024
00025 next=-1;
00026
00027
00028 re=-1;
00029
00030 adjel=NULL;
00031
00032
00033 nlist = NULL;
00034
00035 cnfn = NULL;
00036
00037 cnln = NULL;
00038
00039
00040 l=0.0;
00041
00042 dv = NULL;
00043
00044 nv = NULL;
00045
00046
00047 threshold=1.0e-6;
00048 }
00049
00050
00051 gedge::~gedge (void)
00052 {
00053 delete [] adjel;
00054 delete [] nlist;
00055 delete [] cnfn;
00056 delete [] cnln;
00057 delete [] dv;
00058 delete [] nv;
00059 }
00060
00061
00062
00063
00064
00065
00066
00067
00068 void gedge::direction_vector (gnode *gnodes)
00069 {
00070 if (fn<0){
00071 print_err("first node on edge is not defined", __FILE__, __LINE__, __func__);
00072 }
00073 if (ln<0){
00074 print_err("last node on edge is not defined", __FILE__, __LINE__, __func__);
00075 }
00076
00077 dv = new double [3];
00078
00079 dv[0] = gnodes[ln].x - gnodes[fn].x;
00080 dv[1] = gnodes[ln].y - gnodes[fn].y;
00081 dv[2] = gnodes[ln].z - gnodes[fn].z;
00082
00083
00084 l = dv[0]*dv[0] + dv[1]*dv[1] + dv[2]*dv[2];
00085
00086 if (fabs(l)<threshold){
00087 print_err("zero length of the direction vector", __FILE__, __LINE__, __func__);
00088 }
00089
00090 l = sqrt(l);
00091
00092 dv[0]/=l;
00093 dv[1]/=l;
00094 dv[2]/=l;
00095 }
00096
00097
00098
00099
00100
00101
00102
00103
00104 void gedge::normal_vector (gnode *gnodes)
00105 {
00106 double norm;
00107
00108 if (dv==NULL){
00109 direction_vector (gnodes);
00110 }
00111
00112 nv = new double [3];
00113
00114 if (fabs(dv[2])<threshold){
00115
00116 nv[2]=0.0;
00117
00118 if (fabs(dv[0])<threshold){
00119 nv[0]=1.0;
00120 nv[1]=0.0;
00121 }
00122 else{
00123 nv[1]=1.0;
00124 nv[0]=0.0-dv[1]*nv[1]/dv[0];
00125 }
00126 }
00127 else{
00128 if (fabs(dv[1])<threshold){
00129 nv[1]=0.0;
00130
00131 if (fabs(dv[0])<threshold){
00132 nv[0]=1.0;
00133 nv[2]=0.0;
00134 }
00135 else{
00136 nv[2]=1.0;
00137 nv[0]=0.0-dv[2]*nv[2]/dv[0];
00138 }
00139 }
00140 else{
00141 nv[2]=0.0;
00142 nv[0]=1.0;
00143 nv[1]=0.0-dv[0]*nv[0]/dv[1];
00144 }
00145 }
00146
00147 norm = nv[0]*nv[0] + nv[1]*nv[1] + nv[2]*nv[2];
00148
00149 if (fabs(norm)<threshold){
00150 print_err("zero length of the normal vector", __FILE__, __LINE__, __func__);
00151 }
00152
00153 norm = sqrt(norm);
00154
00155 nv[0]/=norm;
00156 nv[1]/=norm;
00157 nv[2]/=norm;
00158 }
00159
00160
00161
00162
00163
00164
00165
00166
00167 void gedge::print (FILE *out)
00168 {
00169 long i;
00170
00171 fprintf (out,"\n");
00172 fprintf (out,"\n number of nodes %ld",nn);
00173 fprintf (out,"\n node multiplicity %ld",nm);
00174 fprintf (out,"\n number of previous edge %ld",prev);
00175 fprintf (out,"\n number of next edge %ld",next);
00176
00177 if (nlist!=NULL){
00178 fprintf (out,"\n egde nodes\n");
00179 for (i=0;i<nn;i++){
00180 fprintf (out," %ld",nlist[i]);
00181 }
00182 }
00183 if (dv!=NULL){
00184 fprintf (out,"\n direction vector");
00185 fprintf (out,"\n %lf %lf %lf",dv[0],dv[1],dv[2]);
00186 }
00187 if (nv!=NULL){
00188 fprintf (out,"\n normal vector");
00189 fprintf (out,"\n %lf %lf %lf",nv[0],nv[1],nv[2]);
00190 }
00191
00192 }
00193
00194
00195
00196
00197
00198
00199 void gedge::give_dirvect (double *v)
00200 {
00201 v[0]=dv[0];
00202 v[1]=dv[1];
00203 }
00204
00205
00206
00207
00208
00209
00210 void gedge::give_norvect (double *v)
00211 {
00212 v[0]=nv[0];
00213 v[1]=nv[1];
00214 }
00215
00216
00217
00218
00219
00220
00221 void gedge::check_normal (vector &x,vector &y,ivector &nod)
00222 {
00223 long i,nne;
00224 double ss,xc,yc,vx,vy,xf,yf;
00225
00226
00227 nne = x.n;
00228
00229
00230 xc=0.0; yc=0.0;
00231 for (i=0;i<nne;i++){
00232 xc+=x[i];
00233 yc+=y[i];
00234 }
00235 xc/=nne;
00236 yc/=nne;
00237
00238
00239 for (i=0;i<nne;i++){
00240 if (fn==nod[i]){
00241 xf=x[i];
00242 yf=y[i];
00243 break;
00244 }
00245 }
00246
00247
00248 vx=xf-xc;
00249 vy=yf-yc;
00250
00251
00252 ss = vx*nv[0] + vy*nv[1];
00253
00254 if (ss<0.0){
00255
00256
00257 nv[0]*=-1.0;
00258 nv[1]*=-1.0;
00259 nv[2]*=-1.0;
00260 }
00261
00262
00263 }
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273 void gedge::alloc_cn (long nccnfn,long nccnln)
00274 {
00275
00276 ndofnf=nccnfn;
00277
00278 ndofnl=nccnln;
00279
00280 if (cnfn!=NULL)
00281 delete [] cnfn;
00282 cnfn = new long [nccnfn];
00283 if (cnln!=NULL)
00284 delete [] cnln;
00285 cnln = new long [nccnln];
00286 }
00287
00288
00289
00290
00291
00292
00293
00294
00295 void gedge::give_first_node_numbers (long *fnn)
00296 {
00297 fnn[0]=nlist[0];
00298 fnn[1]=nlist[1];
00299 }
00300
00301
00302
00303
00304
00305
00306
00307
00308 void gedge::give_last_node_numbers (long *lnn)
00309 {
00310 lnn[0]=nlist[2];
00311 lnn[1]=nlist[3];
00312 }
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326 void gedge::give_mult_code_numbers (long fln,long *mcn)
00327 {
00328 long i;
00329
00330 if (fln==1){
00331 for (i=0;i<ndofnf;i++){
00332 mcn[i]=cnfn[i];
00333 }
00334 }
00335 if (fln==2){
00336 for (i=0;i<ndofnl;i++){
00337 mcn[i]=cnln[i];
00338 }
00339 }
00340 }