5 OutPut(
"Example: import3Dmesh.h" << endl);
8 void GridBoundCondition(
double x,
double y,
double z, BoundCond &cond)
13 void SolidBoundCondition(
double x,
double y,
double z, BoundCond &cond)
18 void FluidBoundCondition(
double x,
double y,
double z, BoundCond &cond)
23 void Exact(
double x,
double y,
double z,
double *values)
33 void InitialCondition(
double x,
double y,
double z,
double *values)
40 void BoundCondition(
double x,
double y,
double z, BoundCond &cond)
53 if(x< 240 && y<-72. && z>191)
61 void BoundValue(
double x,
double y,
double z,
double &value)
66 void BilinearCoeffs(
int n_points,
double *X,
double *Y,
double *Z,
double **parameters,
double **coeffs)
74 double rhsfact, alpha, char_L, beam_r, DimlessBeam_r;
75 double xp=0., yp=0., zp=0., SourceCoord, Sourceradius;
80 xp=2.922130000000000e+02;
81 zp=1.583800000000000e+02;
94 Region_ID = coeffs[0][1];
95 DimlessBeam_r = beam_r/char_L;
118 for(i=0;i<n_points;i++)
140 Sourceradius = sqrt( (x-xp)*(x-xp) + (z-zp)*(z-zp));
147 Sourceradius = sqrt( (x-xp)*(x-xp) + (z-zp)*(z-zp));
154 if(Sourceradius<=DimlessBeam_r)
156 coeff[5] = rhsfact*exp(alpha*SourceCoord*char_L);
169 void ReadAdditionalNModes(
char *NODE, tetgenio &InAddPts)
171 int i, N_Vertices, index, N_Atribude, BDMarker;
173 std::ifstream dat(NODE);
177 cerr <<
"cannot open '" << NODE <<
"' for input" << endl;
181 dat.getline (line, 99);
182 dat >> N_Vertices >> N_Atribude >> BDMarker;
183 dat.getline (line, 99);
185 InAddPts.numberofpoints = N_Vertices;
186 InAddPts.pointlist =
new double[3*N_Vertices];
189 for(i=0;i<N_Vertices; i++)
191 dat.getline (line, 99);
192 dat >> index >> InAddPts.pointlist[3*i] >> InAddPts.pointlist[3*i+1] >> InAddPts.pointlist[3*i+2];
193 cout<< i <<
" vert X: " <<InAddPts.pointlist[3*i] <<
" vert Y: " <<InAddPts.pointlist[3*i+1] <<
" vert Z: " <<InAddPts.pointlist[3*i+2] <<endl;
200 void ReadMeditMeshWithCells(
char *SMESH, tetgenio &In)
202 int i, j, k, dimension, N_FVert, N_Faces, N_Vertices, N_CVert, N_Cells;
203 int BDComp_Min=10000000;
210 tetgenio::polygon *P;
212 std::ifstream dat(SMESH);
216 cerr <<
"cannot open '" << SMESH <<
"' for input" << endl;
225 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
227 dat.getline (line, 99);
232 dat.getline (line, 99);
237 cerr <<
"dimension: " << dimension << endl;
246 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
248 dat.getline (line, 99);
253 dat.getline (line, 99);
256 In.numberofpoints = N_Vertices;
257 In.pointlist =
new double[3*N_Vertices];
260 for(i=0;i<N_Vertices; i++)
262 dat.getline (line, 99);
263 dat >> x >> In.pointlist[3*i+1] >> In.pointlist[3*i+2];
265 In.pointlist[3*i] = x - 3.606596999999999830777142;
268 if(i==1062 || i==916 || i==341 || i==914 || i==162 || i==1063 || i==1061)
269 cout<< i <<
" vert X: " <<In.pointlist[3*i] <<
" vert Y: " <<In.pointlist[3*i+1] <<
" vert Z: " <<In.pointlist[3*i+2] <<endl;
278 if ( (!strcmp(line,
"Triangles")) || (!strcmp(line,
"triangles")) || (!strcmp(line,
"TRIANGLES")) )
281 dat.getline (line, 99);
285 else if ( (!strcmp(line,
"Quadrilaterals")) || (!strcmp(line,
"quadrilaterals")) || (!strcmp(line,
"QUADRILATERALS")) )
288 dat.getline (line, 99);
294 dat.getline (line, 99);
297 In.numberoffacets = N_Faces;
298 In.facetlist =
new tetgenio::facet[In.numberoffacets];
299 In.facetmarkerlist =
new int[In.numberoffacets];
301 for(i=0;i<N_Faces; i++)
303 dat.getline (line, 99);
305 F = &In.facetlist[i];
307 F->numberofpolygons = 1;
308 F->polygonlist =
new tetgenio::polygon[F->numberofpolygons];
309 F->numberofholes = 0;
311 P = &F->polygonlist[0];
313 P->numberofvertices = N_FVert;
314 P->vertexlist =
new int[P->numberofvertices];
316 for(j=0;j<N_FVert;j++)
319 P->vertexlist[j] = k-1;
322 dat >> In.facetmarkerlist[i];
324 if(BDComp_Min > In.facetmarkerlist[i])
325 BDComp_Min=In.facetmarkerlist[i];
332 for(i=0;i<N_Faces; i++)
333 In.facetmarkerlist[i] -= BDComp_Min;
341 if ( (!strcmp(line,
"Tetrahedron")) || (!strcmp(line,
"tetrahedron")) || (!strcmp(line,
"TETRAHEDRON")) )
344 dat.getline (line, 99);
349 dat.getline (line, 99);
352 In.numberoftetrahedra = N_Cells;
353 In.numberofcorners = N_CVert;
354 In.numberoftetrahedronattributes = 1;
355 In.tetrahedronlist =
new int[N_Cells * 4];
356 In.tetrahedronattributelist =
new REAL[N_Cells];
357 In.tetrahedronvolumelist =
new REAL[N_Cells];
359 for(i=0; i<N_Cells; i++)
361 dat.getline (line, 99);
362 plist = &(In.tetrahedronlist[i * 4]);
364 for(j=0;j<N_CVert;j++)
371 dat >> In.tetrahedronattributelist[i];
384 void ReadMeditMesh(
char *SMESH, tetgenio &In)
386 int i, j, k, dimension, N_FVert, N_Faces, N_Vertices;
387 int BDComp_Min=10000000;
391 tetgenio::polygon *P;
393 std::ifstream dat(SMESH);
397 cerr <<
"cannot open '" << SMESH <<
"' for input" << endl;
406 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
408 dat.getline (line, 99);
413 dat.getline (line, 99);
418 cerr <<
"dimension: " << dimension << endl;
427 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
429 dat.getline (line, 99);
434 dat.getline (line, 99);
437 In.numberofpoints = N_Vertices;
438 In.pointlist =
new double[3*N_Vertices];
441 for(i=0;i<N_Vertices; i++)
443 dat.getline (line, 99);
444 dat >> In.pointlist[3*i] >> In.pointlist[3*i+1] >> In.pointlist[3*i+2];
454 if ( (!strcmp(line,
"Triangles")) || (!strcmp(line,
"triangles")) || (!strcmp(line,
"TRIANGLES")) )
457 dat.getline (line, 99);
461 else if ( (!strcmp(line,
"Quadrilaterals")) || (!strcmp(line,
"quadrilaterals")) || (!strcmp(line,
"QUADRILATERALS")) )
464 dat.getline (line, 99);
470 dat.getline (line, 99);
473 In.numberoffacets = N_Faces;
474 In.facetlist =
new tetgenio::facet[In.numberoffacets];
475 In.facetmarkerlist =
new int[In.numberoffacets];
477 for(i=0;i<N_Faces; i++)
479 dat.getline (line, 99);
481 F = &In.facetlist[i];
483 F->numberofpolygons = 1;
484 F->polygonlist =
new tetgenio::polygon[F->numberofpolygons];
485 F->numberofholes = 0;
487 P = &F->polygonlist[0];
489 P->numberofvertices = N_FVert;
490 P->vertexlist =
new int[P->numberofvertices];
492 for(j=0;j<N_FVert;j++)
495 P->vertexlist[j] = k-1;
498 dat >> In.facetmarkerlist[i];
500 if(BDComp_Min > In.facetmarkerlist[i])
501 BDComp_Min=In.facetmarkerlist[i];
508 for(i=0;i<N_Faces; i++)
509 In.facetmarkerlist[i] -= BDComp_Min;
518 void DeleteDomain(
TDomain *&Domain)
520 int i, j, k, N_Cells, N_RootCells;
521 int CurrVertex, N_Faces, N_Vertices, ID;
522 TBaseCell **CellTree, **SurfCellTree, *cell;
531 VertexDel =
new TVertex*[8*N_RootCells];
534 for(i=0;i<N_Cells;i++)
539 for(j=0;j<N_Faces;j++)
543 VertexDel[CurrVertex++] = cell->
GetVertex(j);
548 for(k=0;k<CurrVertex;k++)
555 VertexDel[CurrVertex++] = cell->
GetVertex(j);
560 for(k=0;k<CurrVertex;k++)
561 if(VertexDel[k]==cell->
GetVertex((j+1)%N_Vertices))
567 VertexDel[CurrVertex++] = cell->
GetVertex((j+1)%N_Vertices);
571 for(k=0;k<CurrVertex;k++)
572 if(VertexDel[k]==cell->
GetVertex((j+2)%N_Vertices))
578 VertexDel[CurrVertex++] = cell->
GetVertex((j+2)%N_Vertices);
583 for(k=0;k<CurrVertex;k++)
584 if(VertexDel[k]==cell->
GetVertex((j+4)%N_Vertices))
590 VertexDel[CurrVertex++] = cell->
GetVertex((j+4)%N_Vertices);
596 for(i=0;i<CurrVertex;i++)
599 OutPut(CurrVertex<<
" vertices were deleted"<<endl);
602 for(i=0;i<N_RootCells;i++)
605 OutPut(N_RootCells<<
" cells were deleted"<<endl);
608 void getboundarytag(
int a,
int b,
int c,
int NBdfaces,
int *Bdfaces,
int &CompID)
610 int i,a1,b1,c1,marker;
611 for(i=0;i<NBdfaces;i++)
616 marker = Bdfaces[4*i+3];
617 if((a==a1||a==b1||a==c1)&&(b==a1||b==b1||b==c1)&&(c==a1||c==b1||c==c1))
625 void TetrameshCreate(
TDomain *&Domain)
627 int i, j, k, l, dimension, N_Vertices, NBdfaces, *Bdfaces, BoundaryMarker;
628 int N_Faces, N_RootCells;
629 int v1, v2, v3, v4, CellMarker, RefLevel=0, *Tetrahedrals, *PointNeighb, maxEpV, *Tetrahedrals_loc;
630 int a, b, c, Neib[2], Neighb_tmp, CurrNeib, len1, len2, len3, CurrComp=0, N_Points ;
631 int N_Cells, MaxLen, jj, CompID=0;
632 const int *EdgeVertex, *TmpFV, *TmpLen;
633 double X, Y, Z, DispX, DispY, DispZ;
634 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
635 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
636 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
637 char *MESH, line[100];
646 std::ifstream dat(MESH);
650 cerr <<
"cannot open '" << MESH <<
"' for input" << endl;
657 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
659 dat.getline (line, 99);
663 dat.getline (line, 99);
668 cerr <<
"dimension: " << dimension << endl;
675 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
677 dat.getline (line, 99);
681 dat.getline (line, 99);
683 cout <<
"N_Vertices "<<N_Vertices<<endl;
684 NewVertices =
new TVertex*[N_Vertices];
686 for(i=0;i<N_Vertices; i++)
688 dat.getline (line, 99);
690 NewVertices[i] =
new TVertex(X, Y, Z);
691 if (X > Xmax) Xmax = X;
692 if (X < Xmin) Xmin = X;
693 if (Y > Ymax) Ymax = Y;
694 if (Y < Ymin) Ymin = Y;
695 if (Z > Zmax) Zmax = Z;
696 if (Z < Zmin) Zmin = Z;
702 BoundX = Xmax - Xmin;
703 BoundY = Ymax - Ymin;
704 BoundZ = Zmax - Zmin;
706 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
711 if ( (!strcmp(line,
"Triangles")) || (!strcmp(line,
"triangles")) || (!strcmp(line,
"TRIANGLES")) )
713 dat.getline (line, 99);
718 dat.getline (line, 99);
720 cout<<
"number of boundary faces "<<NBdfaces<<endl;
721 Bdfaces =
new int[4*NBdfaces];
723 for(i=0;i<NBdfaces;i++)
725 dat.getline (line, 99);
726 dat >> v1 >> v2 >> v3 >> BoundaryMarker;
728 Bdfaces[4*i + 1] = v2;
729 Bdfaces[4*i + 2] = v3;
730 Bdfaces[4*i + 3] = BoundaryMarker;
739 if ( (!strcmp(line,
"Tetrahedra")) || (!strcmp(line,
"tetrahedra")) || (!strcmp(line,
"TETRAHEDRA")) )
741 dat.getline (line, 99);
746 dat.getline (line, 99);
749 cout <<
"number of root cells "<<N_RootCells <<endl;
751 Tetrahedrals =
new int[4*N_RootCells];
753 for (i=0;i<N_RootCells;i++)
755 dat.getline (line, 99);
756 dat >> v1 >> v2 >> v3 >> v4 >> CellMarker;
757 Tetrahedrals[4*i ] = v1-1;
758 Tetrahedrals[4*i + 1] = v2-1;
759 Tetrahedrals[4*i + 2] = v3-1;
760 Tetrahedrals[4*i + 3] = v4-1;
765 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
766 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
767 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
768 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
770 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
783 PointNeighb =
new int[N_Vertices];
784 memset(PointNeighb, 0, N_Vertices*SizeOfInt);
786 for (i=0;i<4*N_RootCells;i++)
787 PointNeighb[Tetrahedrals[i]]++;
790 for (i=0;i<N_Vertices;i++)
791 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
792 delete [] PointNeighb;
793 cout<<
"maximum edges per vertex "<< maxEpV<<endl;
794 PointNeighb =
new int[++maxEpV * N_Vertices];
795 memset(PointNeighb, 0, maxEpV*N_Vertices*SizeOfInt);
801 for(i=0;i<4*N_RootCells;i++)
803 j = Tetrahedrals[i]*maxEpV;
805 PointNeighb[j + PointNeighb[j]] = i / 4;
811 for(i=0;i<N_Cells;i++)
820 Tetrahedrals_loc = Tetrahedrals+4*i;
821 for(jj=0;jj<N_Faces;jj++)
824 N_Points = TmpLen[jj];
827 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
830 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
831 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
832 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
836 len1 = PointNeighb[a*maxEpV];
837 len2 = PointNeighb[b*maxEpV];
838 len3 = PointNeighb[c*maxEpV];
840 for (j=1;j<=len1;j++)
842 Neighb_tmp = PointNeighb[a*maxEpV + j];
843 for (k=1;k<=len2;k++)
845 if(Neighb_tmp == PointNeighb[b*maxEpV + k])
848 if(Neighb_tmp == PointNeighb[c*maxEpV + l])
850 Neib[CurrNeib++] = Neighb_tmp;
855 if (CurrNeib == 2)
break;
859 getboundarytag(a,b,c, NBdfaces, Bdfaces, CompID);
868 cout <<
"chek 11.5 "<< i<<endl;
869 cerr<<
"Error: could not set parameter values"<<endl;
870 OutPut(NewVertices[a]<<endl);
871 OutPut(NewVertices[b]<<endl);
872 OutPut(NewVertices[c]<<endl);
880 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
881 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
886 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
889 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
892 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
893 l = l*100 + k*10 + j;
897 case 210:
case 21:
case 102:
898 case 120:
case 12:
case 201:
901 case 310:
case 31:
case 103:
902 case 130:
case 13:
case 301:
905 case 321:
case 132:
case 213:
906 case 231:
case 123:
case 312:
909 case 230:
case 23:
case 302:
910 case 320:
case 32:
case 203:
915 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
918 CellTree[Neib[0]]->
SetJoint(j, Joint);
925 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
929 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
933 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
935 l = l*100 + k*10 + j;
938 case 210:
case 21:
case 102:
939 case 120:
case 12:
case 201:
942 case 310:
case 31:
case 103:
943 case 130:
case 13:
case 301:
946 case 321:
case 132:
case 213:
947 case 231:
case 123:
case 312:
950 case 230:
case 23:
case 302:
951 case 320:
case 32:
case 203:
956 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
959 CellTree[Neib[1]]->
SetJoint(j, Joint);
962 if (Joint->
GetType() == InterfaceJoint3D || Joint->
GetType() == IsoInterfaceJoint3D)
968 if (Joint->
GetType() == JointEqN)
972 delete [] PointNeighb;
973 cout<<
"tetrameshcreatesuccessful " <<
"\n";
976 void TetrameshGen(
TDomain *&Domain)
981 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
982 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
983 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
984 int *Tetrahedrals, *PointNeighb, dimension;
985 int *Facelist, *Facemarkerlist;
987 double *Coordinates, N_x, N_y, N_z;
989 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
990 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
991 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
997 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
1006 char *SMESH, line[100];
1013 MPI_Comm_rank(Comm, &rank);
1014 MPI_Comm_size(Comm, &size);
1027 std::ostringstream opts;
1030 opts.seekp(std::ios::beg);
1050 ReadMeditMesh(SMESH, In);
1057 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
1072 VertexDel =
new TVertex*[8*N_RootCells];
1075 for(i=0;i<N_Cells;i++)
1080 for(j=0;j<N_Faces;j++)
1084 VertexDel[CurrVertex++] = cell->
GetVertex(j);
1089 for(k=0;k<CurrVertex;k++)
1096 VertexDel[CurrVertex++] = cell->
GetVertex(j);
1101 for(k=0;k<CurrVertex;k++)
1102 if(VertexDel[k]==cell->
GetVertex((j+1)%N_Vertices))
1108 VertexDel[CurrVertex++] = cell->
GetVertex((j+1)%N_Vertices);
1112 for(k=0;k<CurrVertex;k++)
1113 if(VertexDel[k]==cell->
GetVertex((j+2)%N_Vertices))
1119 VertexDel[CurrVertex++] = cell->
GetVertex((j+2)%N_Vertices);
1124 for(k=0;k<CurrVertex;k++)
1125 if(VertexDel[k]==cell->
GetVertex((j+4)%N_Vertices))
1131 VertexDel[CurrVertex++] = cell->
GetVertex((j+4)%N_Vertices);
1137 for(i=0;i<CurrVertex;i++)
1138 delete VertexDel[i];
1139 delete [] VertexDel;
1140 OutPut(CurrVertex<<
" vertices were deleted"<<endl);
1144 for(i=0;i<N_RootCells;i++)
1147 OutPut(N_RootCells<<
" cells were deleted"<<endl);
1154 N_RootCells = Out.numberoftetrahedra;
1155 N_G = Out.numberofpoints;
1158 Coordinates = Out.pointlist;
1159 Tetrahedrals = Out.tetrahedronlist;
1165 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
1166 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1171 Coordinates =
new double [3*N_G];
1172 Tetrahedrals =
new int[4*N_RootCells];
1175 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
1176 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
1180 NewVertices =
new TVertex*[N_G];
1184 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
1187 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
1188 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
1189 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
1190 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
1191 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
1192 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
1198 BoundX = Xmax - Xmin;
1199 BoundY = Ymax - Ymin;
1200 BoundZ = Zmax - Zmin;
1202 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
1213 for (i=0;i<N_RootCells;i++)
1217 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
1218 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
1219 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
1220 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
1223 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
1237 PointNeighb =
new int[N_G];
1241 cout<<
"numberofpoints "<<N_G<<endl;
1242 memset(PointNeighb, 0, N_G *SizeOfInt);
1244 for (i=0;i<4*N_RootCells;i++)
1245 PointNeighb[Tetrahedrals[i]]++;
1248 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
1249 delete [] PointNeighb;
1254 cout<<
"maxEpV "<< maxEpV<<endl;
1256 PointNeighb =
new int[++maxEpV * N_G];
1258 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
1265 for(i=0;i<4*N_RootCells;i++)
1267 j = Tetrahedrals[i]*maxEpV;
1270 PointNeighb[j + PointNeighb[j]] = i / 4;
1286 N_G = Out.numberoftrifaces;
1287 Facelist = Out.trifacelist;
1288 Facemarkerlist = Out.trifacemarkerlist;
1292 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1296 Facelist =
new int [3*N_G];
1297 Facemarkerlist =
new int[N_G];
1301 MPI_Bcast(Facelist, 3*N_G, MPI_INT, 0, Comm);
1302 MPI_Bcast(Facemarkerlist, N_G, MPI_INT, 0, Comm);
1306 cout<<
"numberoftrifaces "<<N_G<<endl;
1311 b = Facelist[3*i+1];
1312 c = Facelist[3*i+2];
1320 len1 = PointNeighb[a*maxEpV];
1321 len2 = PointNeighb[b*maxEpV];
1322 len3 = PointNeighb[c*maxEpV];
1325 for (j=1;j<=len1;j++)
1327 Neighb_tmp = PointNeighb[a*maxEpV + j];
1328 for (k=1;k<=len2;k++)
1330 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
1332 for (l=1;l<=len3;l++)
1333 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
1335 Neib[CurrNeib++] = Neighb_tmp;
1340 if (CurrNeib == 2)
break;
1344 if (Facemarkerlist[i])
1347 CurrComp = Facemarkerlist[i] - 1;
1358 NewVertices[a]->
GetY(), T[1], S[1]) ||
1360 NewVertices[b]->
GetY(), T[2], S[2]) ||
1362 NewVertices[c]->
GetY(), T[3], S[3]) )
1364 cerr<<
"Error: could not set parameter values"<<endl;
1365 OutPut(NewVertices[a]<<endl);
1366 OutPut(NewVertices[b]<<endl);
1367 OutPut(NewVertices[c]<<endl);
1375 CellTree[Neib[0]], CellTree[Neib[1]] );
1378 CellTree[Neib[0]], CellTree[Neib[1]] );
1392 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
1394 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
1401 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
1405 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
1409 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
1411 l = l*100 + k*10 + j;
1415 case 210:
case 21:
case 102:
1416 case 120:
case 12:
case 201:
1419 case 310:
case 31:
case 103:
1420 case 130:
case 13:
case 301:
1423 case 321:
case 132:
case 213:
1424 case 231:
case 123:
case 312:
1427 case 230:
case 23:
case 302:
1428 case 320:
case 32:
case 203:
1433 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1436 CellTree[Neib[0]]->
SetJoint(j, Joint);
1442 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
1446 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
1450 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
1452 l = l*100 + k*10 + j;
1458 case 210:
case 21:
case 102:
1459 case 120:
case 12:
case 201:
1462 case 310:
case 31:
case 103:
1463 case 130:
case 13:
case 301:
1466 case 321:
case 132:
case 213:
1467 case 231:
case 123:
case 312:
1470 case 230:
case 23:
case 302:
1471 case 320:
case 32:
case 203:
1476 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1479 CellTree[Neib[1]]->
SetJoint(j, Joint);
1482 if (Joint->
GetType() == InterfaceJoint3D ||
1483 Joint->
GetType() == IsoInterfaceJoint3D)
1489 if (Joint->
GetType() == JointEqN)
1503 delete [] Tetrahedrals ;
1504 delete [] Coordinates;
1506 delete [] Facemarkerlist;
1509 delete [] PointNeighb;
1513 void TetraGen(
TDomain *&Domain)
1518 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
1519 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
1520 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
1521 int *Tetrahedrals, *PointNeighb, dimension;
1522 int jj, N_Points, MaxLen, *Tetrahedrals_loc;
1523 const int *EdgeVertex, *TmpFV, *TmpLen;
1525 double *Coordinates, N_x, N_y, N_z;
1527 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
1528 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
1529 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
1535 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
1545 char *SMESH, line[100];
1551 MPI_Comm_rank(Comm, &rank);
1552 MPI_Comm_size(Comm, &size);
1562 std::ostringstream opts;
1565 opts.seekp(std::ios::beg);
1585 ReadMeditMesh(SMESH, In);
1592 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
1601 DeleteDomain(Domain);
1607 N_RootCells = Out.numberoftetrahedra;
1608 N_G = Out.numberofpoints;
1610 Coordinates = Out.pointlist;
1611 Tetrahedrals = Out.tetrahedronlist;
1615 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
1616 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1619 Coordinates =
new double [3*N_G];
1620 Tetrahedrals =
new int[4*N_RootCells];
1622 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
1623 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
1627 NewVertices =
new TVertex*[N_G];
1631 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
1633 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
1634 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
1635 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
1636 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
1637 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
1638 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
1645 BoundX = Xmax - Xmin;
1646 BoundY = Ymax - Ymin;
1647 BoundZ = Zmax - Zmin;
1649 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
1659 for (i=0;i<N_RootCells;i++)
1663 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
1664 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
1665 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
1666 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
1668 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
1679 PointNeighb =
new int[N_G];
1683 cout<<
"numberofpoints "<<N_G<<endl;
1684 memset(PointNeighb, 0, N_G *SizeOfInt);
1686 for (i=0;i<4*N_RootCells;i++)
1687 PointNeighb[Tetrahedrals[i]]++;
1690 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
1691 delete [] PointNeighb;
1696 cout<<
"maxEpV "<< maxEpV<<endl;
1697 PointNeighb =
new int[++maxEpV * N_G];
1698 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
1704 for(i=0;i<4*N_RootCells;i++)
1706 j = Tetrahedrals[i]*maxEpV;
1709 PointNeighb[j + PointNeighb[j]] = i / 4;
1715 for (i=0;i<N_Cells;i++)
1721 Tetrahedrals_loc = Tetrahedrals+4*i;
1723 for(jj=0;jj<N_Faces;jj++)
1727 N_Points = TmpLen[jj];
1731 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
1736 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
1737 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
1738 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
1744 len1 = PointNeighb[a*maxEpV];
1745 len2 = PointNeighb[b*maxEpV];
1746 len3 = PointNeighb[c*maxEpV];
1749 for (j=1;j<=len1;j++)
1751 Neighb_tmp = PointNeighb[a*maxEpV + j];
1752 for (k=1;k<=len2;k++)
1754 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
1756 for (l=1;l<=len3;l++)
1757 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
1759 Neib[CurrNeib++] = Neighb_tmp;
1764 if (CurrNeib == 2)
break;
1775 NewVertices[a]->
GetY(), T[1], S[1]) ||
1777 NewVertices[b]->
GetY(), T[2], S[2]) ||
1779 NewVertices[c]->
GetY(), T[3], S[3]) )
1781 cerr<<
"Error: could not set parameter values"<<endl;
1782 OutPut(NewVertices[a]<<endl);
1783 OutPut(NewVertices[b]<<endl);
1784 OutPut(NewVertices[c]<<endl);
1792 CellTree[Neib[0]], CellTree[Neib[1]] );
1795 CellTree[Neib[0]], CellTree[Neib[1]] );
1809 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
1811 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
1817 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
1821 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
1825 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
1827 l = l*100 + k*10 + j;
1833 case 210:
case 21:
case 102:
1834 case 120:
case 12:
case 201:
1837 case 310:
case 31:
case 103:
1838 case 130:
case 13:
case 301:
1841 case 321:
case 132:
case 213:
1842 case 231:
case 123:
case 312:
1845 case 230:
case 23:
case 302:
1846 case 320:
case 32:
case 203:
1851 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1854 CellTree[Neib[0]]->
SetJoint(j, Joint);
1860 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
1864 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
1868 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
1870 l = l*100 + k*10 + j;
1874 case 210:
case 21:
case 102:
1875 case 120:
case 12:
case 201:
1878 case 310:
case 31:
case 103:
1879 case 130:
case 13:
case 301:
1882 case 321:
case 132:
case 213:
1883 case 231:
case 123:
case 312:
1886 case 230:
case 23:
case 302:
1887 case 320:
case 32:
case 203:
1892 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1895 CellTree[Neib[1]]->
SetJoint(j, Joint);
1898 if (Joint->
GetType() == InterfaceJoint3D ||
1899 Joint->
GetType() == IsoInterfaceJoint3D)
1905 if (Joint->
GetType() == JointEqN)
1913 cout<<
"numberoftrifaces after "<<N_G<<endl;
1925 delete [] Tetrahedrals ;
1926 delete [] Coordinates;
1931 delete [] PointNeighb;
1942 void TetraGenWithInputCells(
TDomain *&Domain)
1947 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
1948 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
1949 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
1950 int *Tetrahedrals, *PointNeighb, dimension;
1951 int jj, N_Points, MaxLen, *Tetrahedrals_loc;
1952 const int *EdgeVertex, *TmpFV, *TmpLen;
1953 double *TetRegionlist;
1955 double *Coordinates, N_x, N_y, N_z;
1957 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
1958 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
1959 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
1961 tetgenio In, Out, InAddPts;
1965 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
1975 char *SMESH, *NODE, line[100];
1982 MPI_Comm_rank(Comm, &rank);
1983 MPI_Comm_size(Comm, &size);
1993 std::ostringstream opts;
1996 opts.seekp(std::ios::beg);
2025 ReadMeditMeshWithCells(SMESH, In);
2037 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
2047 DeleteDomain(Domain);
2053 N_RootCells = Out.numberoftetrahedra;
2054 N_G = Out.numberofpoints;
2056 Coordinates = Out.pointlist;
2057 Tetrahedrals = Out.tetrahedronlist;
2058 TetRegionlist = Out.tetrahedronattributelist;
2062 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
2063 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
2067 Coordinates =
new double [3*N_G];
2068 Tetrahedrals =
new int[4*N_RootCells];
2069 TetRegionlist =
new double [N_RootCells];
2072 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
2073 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
2074 MPI_Bcast(TetRegionlist, N_RootCells, MPI_DOUBLE, 0, Comm);
2078 NewVertices =
new TVertex*[N_G];
2082 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
2085 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
2086 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
2087 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
2088 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
2089 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
2090 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
2097 BoundX = Xmax - Xmin;
2098 BoundY = Ymax - Ymin;
2099 BoundZ = Zmax - Zmin;
2100 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
2110 for (i=0;i<N_RootCells;i++)
2113 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
2114 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
2115 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
2116 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
2118 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
2132 PointNeighb =
new int[N_G];
2136 cout<<
"numberofpoints "<<N_G<<endl;
2137 memset(PointNeighb, 0, N_G *SizeOfInt);
2139 for (i=0;i<4*N_RootCells;i++)
2140 PointNeighb[Tetrahedrals[i]]++;
2143 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
2144 delete [] PointNeighb;
2149 cout<<
"maxEpV "<< maxEpV<<endl;
2151 PointNeighb =
new int[++maxEpV * N_G];
2153 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
2159 for(i=0;i<4*N_RootCells;i++)
2161 j = Tetrahedrals[i]*maxEpV;
2164 PointNeighb[j + PointNeighb[j]] = i / 4;
2171 for (i=0;i<N_Cells;i++)
2177 Tetrahedrals_loc = Tetrahedrals+4*i;
2179 for(jj=0;jj<N_Faces;jj++)
2183 N_Points = TmpLen[jj];
2187 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
2192 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
2193 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
2194 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
2202 len1 = PointNeighb[a*maxEpV];
2203 len2 = PointNeighb[b*maxEpV];
2204 len3 = PointNeighb[c*maxEpV];
2207 for (j=1;j<=len1;j++)
2209 Neighb_tmp = PointNeighb[a*maxEpV + j];
2210 for (k=1;k<=len2;k++)
2212 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
2214 for (l=1;l<=len3;l++)
2215 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
2217 Neib[CurrNeib++] = Neighb_tmp;
2222 if (CurrNeib == 2)
break;
2233 NewVertices[a]->
GetY(), T[1], S[1]) ||
2235 NewVertices[b]->
GetY(), T[2], S[2]) ||
2237 NewVertices[c]->
GetY(), T[3], S[3]) )
2239 cerr<<
"Error: could not set parameter values"<<endl;
2240 OutPut(NewVertices[a]<<endl);
2241 OutPut(NewVertices[b]<<endl);
2242 OutPut(NewVertices[c]<<endl);
2250 CellTree[Neib[0]], CellTree[Neib[1]] );
2253 CellTree[Neib[0]], CellTree[Neib[1]] );
2267 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
2269 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
2275 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
2279 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
2283 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
2285 l = l*100 + k*10 + j;
2290 case 210:
case 21:
case 102:
2291 case 120:
case 12:
case 201:
2294 case 310:
case 31:
case 103:
2295 case 130:
case 13:
case 301:
2298 case 321:
case 132:
case 213:
2299 case 231:
case 123:
case 312:
2302 case 230:
case 23:
case 302:
2303 case 320:
case 32:
case 203:
2308 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2311 CellTree[Neib[0]]->
SetJoint(j, Joint);
2317 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
2321 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
2325 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
2327 l = l*100 + k*10 + j;
2333 case 210:
case 21:
case 102:
2334 case 120:
case 12:
case 201:
2337 case 310:
case 31:
case 103:
2338 case 130:
case 13:
case 301:
2341 case 321:
case 132:
case 213:
2342 case 231:
case 123:
case 312:
2345 case 230:
case 23:
case 302:
2346 case 320:
case 32:
case 203:
2351 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2354 CellTree[Neib[1]]->
SetJoint(j, Joint);
2357 if (Joint->
GetType() == InterfaceJoint3D ||
2358 Joint->
GetType() == IsoInterfaceJoint3D)
2364 if (Joint->
GetType() == JointEqN)
2372 cout<<
"numberoftrifaces after "<<N_G<<endl;
2383 delete [] Tetrahedrals ;
2384 delete [] Coordinates;
2385 delete [] TetRegionlist;
2389 delete [] PointNeighb;
void SetMapType()
Definition: Joint.C:107
void GetTreeInfo(TBaseCell **&celltree, int &N_rootcells)
get tree of cells
Definition: Domain.h:176
virtual int GetTSofXYZ(double X, double Y, double Z, double &T, double &S)=0
JointType GetType()
Definition: Joint.h:75
TBaseCell * GetCell(int i) const
return Cell with index i in Cells-array
Definition: Collection.h:50
int GetN_Faces()
return the number of faces of the cell
Definition: BaseCell.h:190
TBoundComp2D * GetBdComp(int i)
Definition: BoundPart.h:49
int SetJoint(int J_i, TJoint *J)
set the pointer to face J_i to J
Definition: BaseCell.h:168
double P0
Definition: Database.h:533
int GetFaceVertex(const int *&TmpFV, const int *&TmpLen, int &MaxLen)
Definition: ShapeDesc.h:124
contains the boundary description, the virtual cell tree and macro grid
Definition: Domain.h:36
void SetClipBoard(int value)
set value in ClipBoard
Definition: BaseCell.h:263
int SetParam(TDomain *domain)
Definition: Iterator.C:17
static TIterator ** IteratorDB
Definition: Database.h:1131
Definition: IsoBoundFace.h:18
TShapeDesc * GetShapeDesc() const
return shape descriptor of refinement descriptor
Definition: BaseCell.h:134
store cells in an array, used by cell iterators
Definition: Collection.h:18
virtual TVertex * GetVertex(int Vert_i)=0
return the pointer to vertex with number i
represent a unit of the macro grid
Definition: MacroCell.h:15
Definition: JointEqN.h:20
int GetN_Cells() const
return number of cells
Definition: Collection.h:46
Definition: ShapeDesc.h:29
TJoint * GetJoint(int J_i)
return the pointer to face with number i
Definition: BaseCell.h:175
MPI_Comm Comm
Definition: Database.h:978
TBoundPart * GetBdPart(int i)
get i-th boundary part
Definition: Domain.h:172
Definition: BoundComp3D.h:17
double GetY() const
Definition: Vertex.h:99
int GetN_Vertices()
return the number of vertices of the cell
Definition: BaseCell.h:179
Definition: BoundPart.h:21
void SetTreeInfo(TBaseCell **celltree, int N_rootcells)
set tree of cells
Definition: Domain.h:183
bool IsFreeBoundary() const
Definition: BoundComp.h:57
TCollection * GetCollection(Iterators it, int level)
produce a collection with all cells returned by iterator it
Definition: Domain.C:1982
Definition: IsoInterfaceJoint3D.h:19
information for finite element data structure
Definition: BaseCell.h:25
static TRefDesc ** RefDescDB
Definition: Database.h:1125
void SetRegionID(int val)
set region number to this cell
Definition: BaseCell.h:347
Definition: BoundFace.h:18
double GetZ() const
Definition: Vertex.h:103
double GetX() const
Definition: Vertex.h:96
virtual int SetVertex(int Vert_i, TVertex *Vert)=0
set the pointer of vertex Vert_i to Vert
represent geometric information of the cell
Definition: GridCell.h:15
void SetAsLayerCell(int val)
set as LayerCell cell
Definition: BaseCell.h:355
Definition: BdSphere.h:18
static TParamDB * ParamDB
Definition: Database.h:1134
Definition: InterfaceJoint3D.h:18