10 OutPut(
"Example: cancer_exp_3d.h" << endl);
17 void Exact(
double x,
double y,
double z,
double *values)
23 void V_Exact(
double x,
double y,
double z,
double *values)
28 void W_Exact(
double x,
double y,
double z,
double *values)
34 void InitialCondition(
double x,
double y,
double z,
double *values)
47 temp = ((x)*(x)+(y)*(y)+(z)*(z));
52 { values[0] = exp(-temp/0.01);}
63 void V_InitialCondition(
double x,
double y,
double z,
double *values)
76 temp = ((x)*(x)+(y)*(y)+(z)*(z));
81 { values[0] = 1- 0.5 * exp(-temp/0.01);}
93 void W_InitialCondition(
double x,
double y,
double z,
double *values)
106 temp = ((x)*(x)+(y)*(y)+(z)*(z));
111 { values[0] = 0.5 * exp(-temp/0.01);}
123 void BoundCondition(
double x,
double y,
double z, BoundCond &cond)
128 void V_BoundCondition(
double x,
double y,
double z, BoundCond &cond)
134 void W_BoundCondition(
double x,
double y,
double z, BoundCond &cond)
140 void BoundValue(
double x,
double y,
double z,
double &value)
145 void V_BoundValue(
double x,
double y,
double z,
double &value)
150 void W_BoundValue(
double x,
double y,
double z,
double &value)
157 void BilinearCoeffs(
int n_points,
double *X,
double *Y,
double *Z,
158 double **parameters,
double **coeffs)
163 double x, y, z, c, a[3], b[3], s[3], h;
170 for(i=0;i<n_points;i++)
198 void V_BilinearCoeffs(
int n_points,
double *X,
double *Y,
double *Z,
199 double **parameters,
double **coeffs)
204 double x, y, z, c, a[3], b[3], s[3], h;
210 for(i=0;i<n_points;i++)
236 void W_BilinearCoeffs(
int n_points,
double *X,
double *Y,
double *Z,
237 double **parameters,
double **coeffs)
242 double x, y, z, c, a[3], b[3], s[3], h;
250 for(i=0;i<n_points;i++)
275 void ReadAdditionalNModes(
char *NODE, tetgenio &InAddPts)
277 int i, N_Vertices, index, N_Atribude, BDMarker;
279 std::ifstream dat(NODE);
283 cerr <<
"cannot open '" << NODE <<
"' for input" << endl;
287 dat.getline (line, 99);
288 dat >> N_Vertices >> N_Atribude >> BDMarker;
289 dat.getline (line, 99);
291 InAddPts.numberofpoints = N_Vertices;
292 InAddPts.pointlist =
new double[3*N_Vertices];
295 for(i=0;i<N_Vertices; i++)
297 dat.getline (line, 99);
298 dat >> index >> InAddPts.pointlist[3*i] >> InAddPts.pointlist[3*i+1] >> InAddPts.pointlist[3*i+2];
299 cout<< i <<
" vert X: " <<InAddPts.pointlist[3*i] <<
" vert Y: " <<InAddPts.pointlist[3*i+1] <<
" vert Z: " <<InAddPts.pointlist[3*i+2] <<endl;
313 void ReadMeditMeshWithCells(
char *SMESH, tetgenio &In)
315 int i, j, k, dimension, N_FVert, N_Faces, N_Vertices, N_CVert, N_Cells;
316 int BDComp_Min=10000000;
323 tetgenio::polygon *P;
325 std::ifstream dat(SMESH);
329 cerr <<
"cannot open '" << SMESH <<
"' for input" << endl;
338 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
340 dat.getline (line, 99);
345 dat.getline (line, 99);
350 cerr <<
"dimension: " << dimension << endl;
359 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
361 dat.getline (line, 99);
366 dat.getline (line, 99);
369 In.numberofpoints = N_Vertices;
370 In.pointlist =
new double[3*N_Vertices];
373 for(i=0;i<N_Vertices; i++)
375 dat.getline (line, 99);
376 dat >> x >> In.pointlist[3*i+1] >> In.pointlist[3*i+2];
378 In.pointlist[3*i] = x - 3.606596999999999830777142;
381 if(i==1062 || i==916 || i==341 || i==914 || i==162 || i==1063 || i==1061)
382 cout<< i <<
" vert X: " <<In.pointlist[3*i] <<
" vert Y: " <<In.pointlist[3*i+1] <<
" vert Z: " <<In.pointlist[3*i+2] <<endl;
391 if ( (!strcmp(line,
"Triangles")) || (!strcmp(line,
"triangles")) || (!strcmp(line,
"TRIANGLES")) )
394 dat.getline (line, 99);
398 else if ( (!strcmp(line,
"Quadrilaterals")) || (!strcmp(line,
"quadrilaterals")) || (!strcmp(line,
"QUADRILATERALS")) )
401 dat.getline (line, 99);
407 dat.getline (line, 99);
410 In.numberoffacets = N_Faces;
411 In.facetlist =
new tetgenio::facet[In.numberoffacets];
412 In.facetmarkerlist =
new int[In.numberoffacets];
414 for(i=0;i<N_Faces; i++)
416 dat.getline (line, 99);
418 F = &In.facetlist[i];
420 F->numberofpolygons = 1;
421 F->polygonlist =
new tetgenio::polygon[F->numberofpolygons];
422 F->numberofholes = 0;
424 P = &F->polygonlist[0];
426 P->numberofvertices = N_FVert;
427 P->vertexlist =
new int[P->numberofvertices];
429 for(j=0;j<N_FVert;j++)
432 P->vertexlist[j] = k-1;
435 dat >> In.facetmarkerlist[i];
437 if(BDComp_Min > In.facetmarkerlist[i])
438 BDComp_Min=In.facetmarkerlist[i];
445 for(i=0;i<N_Faces; i++)
446 In.facetmarkerlist[i] -= BDComp_Min;
454 if ( (!strcmp(line,
"Tetrahedron")) || (!strcmp(line,
"tetrahedron")) || (!strcmp(line,
"TETRAHEDRON")) )
457 dat.getline (line, 99);
462 dat.getline (line, 99);
465 In.numberoftetrahedra = N_Cells;
466 In.numberofcorners = N_CVert;
467 In.numberoftetrahedronattributes = 1;
468 In.tetrahedronlist =
new int[N_Cells * 4];
469 In.tetrahedronattributelist =
new REAL[N_Cells];
470 In.tetrahedronvolumelist =
new REAL[N_Cells];
472 for(i=0; i<N_Cells; i++)
474 dat.getline (line, 99);
475 plist = &(In.tetrahedronlist[i * 4]);
477 for(j=0;j<N_CVert;j++)
484 dat >> In.tetrahedronattributelist[i];
498 void ReadMeditMesh(
char *SMESH, tetgenio &In)
500 int i, j, k, dimension, N_FVert, N_Faces, N_Vertices;
501 int BDComp_Min=10000000;
505 tetgenio::polygon *P;
507 std::ifstream dat(SMESH);
511 cerr <<
"cannot open '" << SMESH <<
"' for input" << endl;
520 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
522 dat.getline (line, 99);
527 dat.getline (line, 99);
532 cerr <<
"dimension: " << dimension << endl;
541 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
543 dat.getline (line, 99);
548 dat.getline (line, 99);
551 In.numberofpoints = N_Vertices;
552 In.pointlist =
new double[3*N_Vertices];
555 for(i=0;i<N_Vertices; i++)
557 dat.getline (line, 99);
558 dat >> In.pointlist[3*i] >> In.pointlist[3*i+1] >> In.pointlist[3*i+2];
568 if ( (!strcmp(line,
"Triangles")) || (!strcmp(line,
"triangles")) || (!strcmp(line,
"TRIANGLES")) )
571 dat.getline (line, 99);
575 else if ( (!strcmp(line,
"Quadrilaterals")) || (!strcmp(line,
"quadrilaterals")) || (!strcmp(line,
"QUADRILATERALS")) )
578 dat.getline (line, 99);
584 dat.getline (line, 99);
587 In.numberoffacets = N_Faces;
588 In.facetlist =
new tetgenio::facet[In.numberoffacets];
589 In.facetmarkerlist =
new int[In.numberoffacets];
591 for(i=0;i<N_Faces; i++)
593 dat.getline (line, 99);
595 F = &In.facetlist[i];
597 F->numberofpolygons = 1;
598 F->polygonlist =
new tetgenio::polygon[F->numberofpolygons];
599 F->numberofholes = 0;
601 P = &F->polygonlist[0];
603 P->numberofvertices = N_FVert;
604 P->vertexlist =
new int[P->numberofvertices];
606 for(j=0;j<N_FVert;j++)
609 P->vertexlist[j] = k-1;
612 dat >> In.facetmarkerlist[i];
614 if(BDComp_Min > In.facetmarkerlist[i])
615 BDComp_Min=In.facetmarkerlist[i];
622 for(i=0;i<N_Faces; i++)
623 In.facetmarkerlist[i] -= BDComp_Min;
633 void DeleteDomain(
TDomain *&Domain)
635 int i, j, k, N_Cells, N_RootCells;
636 int CurrVertex, N_Faces, N_Vertices, ID;
638 TBaseCell **CellTree, **SurfCellTree, *cell;
651 VertexDel =
new TVertex*[8*N_RootCells];
654 for(i=0;i<N_Cells;i++)
659 for(j=0;j<N_Faces;j++)
663 VertexDel[CurrVertex++] = cell->
GetVertex(j);
668 for(k=0;k<CurrVertex;k++)
675 VertexDel[CurrVertex++] = cell->
GetVertex(j);
680 for(k=0;k<CurrVertex;k++)
681 if(VertexDel[k]==cell->
GetVertex((j+1)%N_Vertices))
687 VertexDel[CurrVertex++] = cell->
GetVertex((j+1)%N_Vertices);
691 for(k=0;k<CurrVertex;k++)
692 if(VertexDel[k]==cell->
GetVertex((j+2)%N_Vertices))
698 VertexDel[CurrVertex++] = cell->
GetVertex((j+2)%N_Vertices);
703 for(k=0;k<CurrVertex;k++)
704 if(VertexDel[k]==cell->
GetVertex((j+4)%N_Vertices))
710 VertexDel[CurrVertex++] = cell->
GetVertex((j+4)%N_Vertices);
716 for(i=0;i<CurrVertex;i++)
719 OutPut(CurrVertex<<
" vertices were deleted"<<endl);
723 for(i=0;i<N_RootCells;i++)
726 OutPut(N_RootCells<<
" cells were deleted"<<endl);
736 void TetrameshCreate(
TDomain *&Domain)
738 int i, j, k, l, dimension, N_Vertices;
739 int N_FVert, N_Faces, *Facemarkerlist, *Facelist, N_RootCells;
740 int v1, v2, v3, v4, CellMarker, RefLevel=0, *Tetrahedrals, *PointNeighb, maxEpV, *Tetrahedrals_loc;
741 int a, b, c, Neib[2], Neighb_tmp, CurrNeib, len1, len2, len3, CurrComp, N_Points ;
742 int N_Cells, MaxLen, jj, N_SourcePts;
743 const int *EdgeVertex, *TmpFV, *TmpLen;
745 double X, Y, Z, DispX, DispY, DispZ;
746 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
747 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
748 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
750 char *MESH, line[100];
764 MPI_Comm_rank(Comm, &rank);
765 MPI_Comm_size(Comm, &size);
770 DeleteDomain(Domain);
774 std::ifstream dat(MESH);
778 cerr <<
"cannot open '" << MESH <<
"' for input" << endl;
788 if ( (!strcmp(line,
"Dimension")) || (!strcmp(line,
"dimension")) || (!strcmp(line,
"DIMENSION")))
790 dat.getline (line, 99);
795 dat.getline (line, 99);
800 cerr <<
"dimension: " << dimension << endl;
809 if ( (!strcmp(line,
"Vertices")) || (!strcmp(line,
"vertices")) || (!strcmp(line,
"VERTICES")) )
811 dat.getline (line, 99);
816 dat.getline (line, 99);
820 NewVertices =
new TVertex*[N_Vertices];
823 for(i=0;i<N_Vertices; i++)
825 dat.getline (line, 99);
833 DispY = -1.8733333333333333;
843 DispY = 69.66666666666666;
852 NewVertices[i] =
new TVertex( (X - DispX), (Y - DispY), (Z- DispZ));
860 if (X > Xmax) Xmax = X;
861 if (X < Xmin) Xmin = X;
862 if (Y > Ymax) Ymax = Y;
863 if (Y < Ymin) Ymin = Y;
864 if (Z > Zmax) Zmax = Z;
865 if (Z < Zmin) Zmin = Z;
877 BoundX = Xmax - Xmin;
878 BoundY = Ymax - Ymin;
879 BoundZ = Zmax - Zmin;
882 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
896 if ( (!strcmp(line,
"Tetrahedron")) || (!strcmp(line,
"tetrahedron")) || (!strcmp(line,
"TETRAHEDRON")) )
898 dat.getline (line, 99);
903 dat.getline (line, 99);
908 Tetrahedrals =
new int[4*N_RootCells];
910 for (i=0;i<N_RootCells;i++)
912 dat.getline (line, 99);
913 dat >> v1 >> v2 >> v3 >> v4 >> CellMarker;
914 Tetrahedrals[4*i ] = v1 -1;
915 Tetrahedrals[4*i + 1] = v2 -1;
916 Tetrahedrals[4*i + 2] = v3 -1;
917 Tetrahedrals[4*i + 3] = v4 -1;
924 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
925 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
926 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
927 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
930 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
946 PointNeighb =
new int[N_Vertices];
950 cout<<
"Numberofpoints "<<N_Vertices<<endl;
951 memset(PointNeighb, 0, N_Vertices*SizeOfInt);
953 for (i=0;i<4*N_RootCells;i++)
954 PointNeighb[Tetrahedrals[i]]++;
957 for (i=0;i<N_Vertices;i++)
958 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
959 delete [] PointNeighb;
964 cout<<
"maxEpV "<< maxEpV<<endl;
966 PointNeighb =
new int[++maxEpV * N_Vertices];
968 memset(PointNeighb, 0, maxEpV*N_Vertices*SizeOfInt);
974 for(i=0;i<4*N_RootCells;i++)
976 j = Tetrahedrals[i]*maxEpV;
979 PointNeighb[j + PointNeighb[j]] = i / 4;
987 for(i=0;i<N_Cells;i++)
993 Tetrahedrals_loc = Tetrahedrals+4*i;
996 for(jj=0;jj<N_Faces;jj++)
999 N_Points = TmpLen[jj];
1003 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
1008 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
1009 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
1010 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
1018 len1 = PointNeighb[a*maxEpV];
1019 len2 = PointNeighb[b*maxEpV];
1020 len3 = PointNeighb[c*maxEpV];
1023 for (j=1;j<=len1;j++)
1025 Neighb_tmp = PointNeighb[a*maxEpV + j];
1026 for (k=1;k<=len2;k++)
1028 if(Neighb_tmp == PointNeighb[b*maxEpV + k])
1030 for(l=1;l<=len3;l++)
1031 if(Neighb_tmp == PointNeighb[c*maxEpV + l])
1033 Neib[CurrNeib++] = Neighb_tmp;
1038 if (CurrNeib == 2)
break;
1048 NewVertices[a]->
GetY(), T[1], S[1]) ||
1050 NewVertices[b]->
GetY(), T[2], S[2]) ||
1052 NewVertices[c]->
GetY(), T[3], S[3]) )
1054 cerr<<
"Error: could not set parameter values"<<endl;
1055 OutPut(NewVertices[a]<<endl);
1056 OutPut(NewVertices[b]<<endl);
1057 OutPut(NewVertices[c]<<endl);
1082 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
1084 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
1090 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
1094 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
1098 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
1100 l = l*100 + k*10 + j;
1106 case 210:
case 21:
case 102:
1107 case 120:
case 12:
case 201:
1110 case 310:
case 31:
case 103:
1111 case 130:
case 13:
case 301:
1114 case 321:
case 132:
case 213:
1115 case 231:
case 123:
case 312:
1118 case 230:
case 23:
case 302:
1119 case 320:
case 32:
case 203:
1124 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1128 CellTree[Neib[0]]->
SetJoint(j, Joint);
1135 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
1139 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
1143 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
1145 l = l*100 + k*10 + j;
1151 case 210:
case 21:
case 102:
1152 case 120:
case 12:
case 201:
1155 case 310:
case 31:
case 103:
1156 case 130:
case 13:
case 301:
1159 case 321:
case 132:
case 213:
1160 case 231:
case 123:
case 312:
1163 case 230:
case 23:
case 302:
1164 case 320:
case 32:
case 203:
1169 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1172 CellTree[Neib[1]]->
SetJoint(j, Joint);
1176 if (Joint->
GetType() == InterfaceJoint3D ||
1177 Joint->
GetType() == IsoInterfaceJoint3D)
1183 if (Joint->
GetType() == JointEqN)
1189 delete [] PointNeighb;
1202 void TetrameshGen(
TDomain *&Domain)
1207 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
1208 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
1209 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
1210 int *Tetrahedrals, *PointNeighb, dimension;
1211 int *Facelist, *Facemarkerlist;
1213 double *Coordinates, N_x, N_y, N_z;
1215 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
1216 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
1217 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
1223 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
1232 char *SMESH, line[100];
1239 MPI_Comm_rank(Comm, &rank);
1240 MPI_Comm_size(Comm, &size);
1255 std::ostringstream opts;
1258 opts.seekp(std::ios::beg);
1279 ReadMeditMesh(SMESH, In);
1287 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
1302 VertexDel =
new TVertex*[8*N_RootCells];
1305 for(i=0;i<N_Cells;i++)
1310 for(j=0;j<N_Faces;j++)
1314 VertexDel[CurrVertex++] = cell->
GetVertex(j);
1319 for(k=0;k<CurrVertex;k++)
1326 VertexDel[CurrVertex++] = cell->
GetVertex(j);
1331 for(k=0;k<CurrVertex;k++)
1332 if(VertexDel[k]==cell->
GetVertex((j+1)%N_Vertices))
1338 VertexDel[CurrVertex++] = cell->
GetVertex((j+1)%N_Vertices);
1342 for(k=0;k<CurrVertex;k++)
1343 if(VertexDel[k]==cell->
GetVertex((j+2)%N_Vertices))
1349 VertexDel[CurrVertex++] = cell->
GetVertex((j+2)%N_Vertices);
1354 for(k=0;k<CurrVertex;k++)
1355 if(VertexDel[k]==cell->
GetVertex((j+4)%N_Vertices))
1361 VertexDel[CurrVertex++] = cell->
GetVertex((j+4)%N_Vertices);
1367 for(i=0;i<CurrVertex;i++)
1368 delete VertexDel[i];
1369 delete [] VertexDel;
1370 OutPut(CurrVertex<<
" vertices were deleted"<<endl);
1374 for(i=0;i<N_RootCells;i++)
1377 OutPut(N_RootCells<<
" cells were deleted"<<endl);
1384 N_RootCells = Out.numberoftetrahedra;
1385 N_G = Out.numberofpoints;
1388 Coordinates = Out.pointlist;
1389 Tetrahedrals = Out.tetrahedronlist;
1395 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
1396 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1401 Coordinates =
new double [3*N_G];
1402 Tetrahedrals =
new int[4*N_RootCells];
1405 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
1406 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
1410 NewVertices =
new TVertex*[N_G];
1414 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
1417 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
1418 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
1419 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
1420 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
1421 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
1422 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
1429 BoundX = Xmax - Xmin;
1430 BoundY = Ymax - Ymin;
1431 BoundZ = Zmax - Zmin;
1434 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
1445 for (i=0;i<N_RootCells;i++)
1450 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
1451 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
1452 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
1453 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
1456 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
1471 PointNeighb =
new int[N_G];
1475 cout<<
"numberofpoints "<<N_G<<endl;
1476 memset(PointNeighb, 0, N_G *SizeOfInt);
1478 for (i=0;i<4*N_RootCells;i++)
1479 PointNeighb[Tetrahedrals[i]]++;
1482 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
1483 delete [] PointNeighb;
1488 cout<<
"maxEpV "<< maxEpV<<endl;
1490 PointNeighb =
new int[++maxEpV * N_G];
1492 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
1499 for(i=0;i<4*N_RootCells;i++)
1501 j = Tetrahedrals[i]*maxEpV;
1504 PointNeighb[j + PointNeighb[j]] = i / 4;
1522 N_G = Out.numberoftrifaces;
1523 Facelist = Out.trifacelist;
1524 Facemarkerlist = Out.trifacemarkerlist;
1528 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1532 Facelist =
new int [3*N_G];
1533 Facemarkerlist =
new int[N_G];
1537 MPI_Bcast(Facelist, 3*N_G, MPI_INT, 0, Comm);
1538 MPI_Bcast(Facemarkerlist, N_G, MPI_INT, 0, Comm);
1542 cout<<
"numberoftrifaces "<<N_G<<endl;
1547 b = Facelist[3*i+1];
1548 c = Facelist[3*i+2];
1556 len1 = PointNeighb[a*maxEpV];
1557 len2 = PointNeighb[b*maxEpV];
1558 len3 = PointNeighb[c*maxEpV];
1561 for (j=1;j<=len1;j++)
1563 Neighb_tmp = PointNeighb[a*maxEpV + j];
1564 for (k=1;k<=len2;k++)
1566 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
1568 for (l=1;l<=len3;l++)
1569 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
1571 Neib[CurrNeib++] = Neighb_tmp;
1576 if (CurrNeib == 2)
break;
1580 if (Facemarkerlist[i])
1583 CurrComp = Facemarkerlist[i] - 1;
1594 NewVertices[a]->
GetY(), T[1], S[1]) ||
1596 NewVertices[b]->
GetY(), T[2], S[2]) ||
1598 NewVertices[c]->
GetY(), T[3], S[3]) )
1600 cerr<<
"Error: could not set parameter values"<<endl;
1601 OutPut(NewVertices[a]<<endl);
1602 OutPut(NewVertices[b]<<endl);
1603 OutPut(NewVertices[c]<<endl);
1611 CellTree[Neib[0]], CellTree[Neib[1]] );
1614 CellTree[Neib[0]], CellTree[Neib[1]] );
1628 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
1630 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
1637 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
1641 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
1645 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
1647 l = l*100 + k*10 + j;
1653 case 210:
case 21:
case 102:
1654 case 120:
case 12:
case 201:
1657 case 310:
case 31:
case 103:
1658 case 130:
case 13:
case 301:
1661 case 321:
case 132:
case 213:
1662 case 231:
case 123:
case 312:
1665 case 230:
case 23:
case 302:
1666 case 320:
case 32:
case 203:
1671 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1674 CellTree[Neib[0]]->
SetJoint(j, Joint);
1680 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
1684 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
1688 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
1690 l = l*100 + k*10 + j;
1696 case 210:
case 21:
case 102:
1697 case 120:
case 12:
case 201:
1700 case 310:
case 31:
case 103:
1701 case 130:
case 13:
case 301:
1704 case 321:
case 132:
case 213:
1705 case 231:
case 123:
case 312:
1708 case 230:
case 23:
case 302:
1709 case 320:
case 32:
case 203:
1714 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
1717 CellTree[Neib[1]]->
SetJoint(j, Joint);
1720 if (Joint->
GetType() == InterfaceJoint3D ||
1721 Joint->
GetType() == IsoInterfaceJoint3D)
1727 if (Joint->
GetType() == JointEqN)
1746 delete [] Tetrahedrals ;
1747 delete [] Coordinates;
1749 delete [] Facemarkerlist;
1753 delete [] PointNeighb;
1767 void TetraGen(
TDomain *&Domain)
1772 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
1773 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
1774 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
1775 int *Tetrahedrals, *PointNeighb, dimension;
1776 int jj, N_Points, MaxLen, *Tetrahedrals_loc;
1777 const int *EdgeVertex, *TmpFV, *TmpLen;
1779 double *Coordinates, N_x, N_y, N_z;
1781 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
1782 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
1783 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
1789 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
1799 char *SMESH, line[100];
1806 MPI_Comm_rank(Comm, &rank);
1807 MPI_Comm_size(Comm, &size);
1820 std::ostringstream opts;
1823 opts.seekp(std::ios::beg);
1844 ReadMeditMesh(SMESH, In);
1852 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
1861 DeleteDomain(Domain);
1868 N_RootCells = Out.numberoftetrahedra;
1869 N_G = Out.numberofpoints;
1872 Coordinates = Out.pointlist;
1873 Tetrahedrals = Out.tetrahedronlist;
1877 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
1878 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
1883 Coordinates =
new double [3*N_G];
1884 Tetrahedrals =
new int[4*N_RootCells];
1887 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
1888 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
1892 NewVertices =
new TVertex*[N_G];
1896 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
1899 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
1900 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
1901 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
1902 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
1903 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
1904 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
1911 BoundX = Xmax - Xmin;
1912 BoundY = Ymax - Ymin;
1913 BoundZ = Zmax - Zmin;
1916 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
1927 for (i=0;i<N_RootCells;i++)
1932 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
1933 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
1934 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
1935 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
1938 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
1953 PointNeighb =
new int[N_G];
1957 cout<<
"numberofpoints "<<N_G<<endl;
1958 memset(PointNeighb, 0, N_G *SizeOfInt);
1960 for (i=0;i<4*N_RootCells;i++)
1961 PointNeighb[Tetrahedrals[i]]++;
1964 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
1965 delete [] PointNeighb;
1970 cout<<
"maxEpV "<< maxEpV<<endl;
1972 PointNeighb =
new int[++maxEpV * N_G];
1974 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
1981 for(i=0;i<4*N_RootCells;i++)
1983 j = Tetrahedrals[i]*maxEpV;
1986 PointNeighb[j + PointNeighb[j]] = i / 4;
1994 for (i=0;i<N_Cells;i++)
2000 Tetrahedrals_loc = Tetrahedrals+4*i;
2002 for(jj=0;jj<N_Faces;jj++)
2006 N_Points = TmpLen[jj];
2010 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
2016 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
2017 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
2018 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
2026 len1 = PointNeighb[a*maxEpV];
2027 len2 = PointNeighb[b*maxEpV];
2028 len3 = PointNeighb[c*maxEpV];
2031 for (j=1;j<=len1;j++)
2033 Neighb_tmp = PointNeighb[a*maxEpV + j];
2034 for (k=1;k<=len2;k++)
2036 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
2038 for (l=1;l<=len3;l++)
2039 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
2041 Neib[CurrNeib++] = Neighb_tmp;
2046 if (CurrNeib == 2)
break;
2061 NewVertices[a]->
GetY(), T[1], S[1]) ||
2063 NewVertices[b]->
GetY(), T[2], S[2]) ||
2065 NewVertices[c]->
GetY(), T[3], S[3]) )
2067 cerr<<
"Error: could not set parameter values"<<endl;
2068 OutPut(NewVertices[a]<<endl);
2069 OutPut(NewVertices[b]<<endl);
2070 OutPut(NewVertices[c]<<endl);
2078 CellTree[Neib[0]], CellTree[Neib[1]] );
2081 CellTree[Neib[0]], CellTree[Neib[1]] );
2095 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
2097 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
2103 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
2107 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
2111 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
2113 l = l*100 + k*10 + j;
2119 case 210:
case 21:
case 102:
2120 case 120:
case 12:
case 201:
2123 case 310:
case 31:
case 103:
2124 case 130:
case 13:
case 301:
2127 case 321:
case 132:
case 213:
2128 case 231:
case 123:
case 312:
2131 case 230:
case 23:
case 302:
2132 case 320:
case 32:
case 203:
2137 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2140 CellTree[Neib[0]]->
SetJoint(j, Joint);
2146 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
2150 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
2154 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
2156 l = l*100 + k*10 + j;
2162 case 210:
case 21:
case 102:
2163 case 120:
case 12:
case 201:
2166 case 310:
case 31:
case 103:
2167 case 130:
case 13:
case 301:
2170 case 321:
case 132:
case 213:
2171 case 231:
case 123:
case 312:
2174 case 230:
case 23:
case 302:
2175 case 320:
case 32:
case 203:
2180 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2183 CellTree[Neib[1]]->
SetJoint(j, Joint);
2186 if (Joint->
GetType() == InterfaceJoint3D ||
2187 Joint->
GetType() == IsoInterfaceJoint3D)
2193 if (Joint->
GetType() == JointEqN)
2202 cout<<
"numberoftrifaces after "<<N_G<<endl;
2218 delete [] Tetrahedrals ;
2219 delete [] Coordinates;
2225 delete [] PointNeighb;
2239 void TetraGenWithInputCells(
TDomain *&Domain)
2244 int i, j, k, l, N_Coord, *N_FVerts, N_Faces, *Facets;
2245 int N, N_RootCells, N_Cells, CurrVertex, N_Vertices, ID, N_G, RefLevel=0;
2246 int CurrNeib, len1, len2, len3, maxEpV = 0, a, b, c, Neib[2], Neighb_tmp, CurrComp;
2247 int *Tetrahedrals, *PointNeighb, dimension;
2248 int jj, N_Points, MaxLen, *Tetrahedrals_loc;
2249 const int *EdgeVertex, *TmpFV, *TmpLen;
2250 double *TetRegionlist;
2252 double *Coordinates, N_x, N_y, N_z;
2254 double Xmin = 1e10, Xmax = -1e10, Ymin = 1e10, Ymax = -1e10;
2255 double Zmin = 1e10, Zmax = -1e10, T[4]={0,0,0,0}, S[4]={0,0,0,0};
2256 double StartX, StartY, StartZ, BoundX, BoundY, BoundZ;
2258 tetgenio In, Out, InAddPts;
2262 TVertex **VertexDel, **NewVertices, **NewSurfVertices;
2272 char *SMESH, line[100];
2280 MPI_Comm_rank(Comm, &rank);
2281 MPI_Comm_size(Comm, &size);
2294 std::ostringstream opts;
2297 opts.seekp(std::ios::beg);
2326 ReadMeditMeshWithCells(SMESH, In);
2341 tetrahedralize((
char*)opts.str().c_str(), &In, &Out);
2351 DeleteDomain(Domain);
2358 N_RootCells = Out.numberoftetrahedra;
2359 N_G = Out.numberofpoints;
2362 Coordinates = Out.pointlist;
2363 Tetrahedrals = Out.tetrahedronlist;
2365 TetRegionlist = Out.tetrahedronattributelist;
2369 MPI_Bcast(&N_RootCells, 1, MPI_INT, 0, Comm);
2370 MPI_Bcast(&N_G, 1, MPI_INT, 0, Comm);
2375 Coordinates =
new double [3*N_G];
2376 Tetrahedrals =
new int[4*N_RootCells];
2377 TetRegionlist =
new double [N_RootCells];
2380 MPI_Bcast(Coordinates, 3*N_G, MPI_DOUBLE, 0, Comm);
2381 MPI_Bcast(Tetrahedrals, 4*N_RootCells, MPI_INT, 0, Comm);
2382 MPI_Bcast(TetRegionlist, N_RootCells, MPI_DOUBLE, 0, Comm);
2386 NewVertices =
new TVertex*[N_G];
2390 NewVertices[i] =
new TVertex(Coordinates[3*i], Coordinates[3*i+1], Coordinates[3*i+2]);
2393 if (Coordinates[3*i] > Xmax) Xmax = Coordinates[3*i];
2394 if (Coordinates[3*i] < Xmin) Xmin = Coordinates[3*i];
2395 if (Coordinates[3*i+1] > Ymax) Ymax = Coordinates[3*i+1];
2396 if (Coordinates[3*i+1] < Ymin) Ymin = Coordinates[3*i+1];
2397 if (Coordinates[3*i+2] > Zmax) Zmax = Coordinates[3*i+2];
2398 if (Coordinates[3*i+2] < Zmin) Zmin = Coordinates[3*i+2];
2405 BoundX = Xmax - Xmin;
2406 BoundY = Ymax - Ymin;
2407 BoundZ = Zmax - Zmin;
2410 Domain->SetBoundBox(StartX, StartY, StartZ, BoundX, BoundY, BoundZ);
2421 for (i=0;i<N_RootCells;i++)
2426 CellTree[i]->
SetVertex(0, NewVertices[Tetrahedrals[4*i ]]);
2427 CellTree[i]->
SetVertex(1, NewVertices[Tetrahedrals[4*i + 1]]);
2428 CellTree[i]->
SetVertex(2, NewVertices[Tetrahedrals[4*i + 2]]);
2429 CellTree[i]->
SetVertex(3, NewVertices[Tetrahedrals[4*i + 3]]);
2432 ((
TMacroCell *) CellTree[i])->SetSubGridID(0);
2450 PointNeighb =
new int[N_G];
2454 cout<<
"numberofpoints "<<N_G<<endl;
2455 memset(PointNeighb, 0, N_G *SizeOfInt);
2457 for (i=0;i<4*N_RootCells;i++)
2458 PointNeighb[Tetrahedrals[i]]++;
2461 if (PointNeighb[i] > maxEpV) maxEpV = PointNeighb[i];
2462 delete [] PointNeighb;
2467 cout<<
"maxEpV "<< maxEpV<<endl;
2469 PointNeighb =
new int[++maxEpV * N_G];
2471 memset(PointNeighb, 0, maxEpV*N_G*SizeOfInt);
2478 for(i=0;i<4*N_RootCells;i++)
2480 j = Tetrahedrals[i]*maxEpV;
2483 PointNeighb[j + PointNeighb[j]] = i / 4;
2491 for (i=0;i<N_Cells;i++)
2497 Tetrahedrals_loc = Tetrahedrals+4*i;
2499 for(jj=0;jj<N_Faces;jj++)
2503 N_Points = TmpLen[jj];
2507 cerr <<
"Only Tria faces are allowed!!! N_FVert: " << N_Points << endl;
2513 a = Tetrahedrals_loc[TmpFV[jj*MaxLen]];
2514 b = Tetrahedrals_loc[TmpFV[jj*MaxLen + 1]];
2515 c = Tetrahedrals_loc[TmpFV[jj*MaxLen + 2]];
2523 len1 = PointNeighb[a*maxEpV];
2524 len2 = PointNeighb[b*maxEpV];
2525 len3 = PointNeighb[c*maxEpV];
2528 for (j=1;j<=len1;j++)
2530 Neighb_tmp = PointNeighb[a*maxEpV + j];
2531 for (k=1;k<=len2;k++)
2533 if (Neighb_tmp == PointNeighb[b*maxEpV + k])
2535 for (l=1;l<=len3;l++)
2536 if (Neighb_tmp == PointNeighb[c*maxEpV + l])
2538 Neib[CurrNeib++] = Neighb_tmp;
2543 if (CurrNeib == 2)
break;
2558 NewVertices[a]->
GetY(), T[1], S[1]) ||
2560 NewVertices[b]->
GetY(), T[2], S[2]) ||
2562 NewVertices[c]->
GetY(), T[3], S[3]) )
2564 cerr<<
"Error: could not set parameter values"<<endl;
2565 OutPut(NewVertices[a]<<endl);
2566 OutPut(NewVertices[b]<<endl);
2567 OutPut(NewVertices[c]<<endl);
2575 CellTree[Neib[0]], CellTree[Neib[1]] );
2578 CellTree[Neib[0]], CellTree[Neib[1]] );
2592 cerr <<
"Error !!!!!!!! not enough neighbours!" << endl;
2594 Joint =
new TJointEqN(CellTree[Neib[0]], CellTree[Neib[1]]);
2600 if (Tetrahedrals[4*Neib[0]+j] == a)
break;
2604 if (Tetrahedrals[4*Neib[0]+k] == b)
break;
2608 if (Tetrahedrals[4*Neib[0]+l] == c)
break;
2610 l = l*100 + k*10 + j;
2616 case 210:
case 21:
case 102:
2617 case 120:
case 12:
case 201:
2620 case 310:
case 31:
case 103:
2621 case 130:
case 13:
case 301:
2624 case 321:
case 132:
case 213:
2625 case 231:
case 123:
case 312:
2628 case 230:
case 23:
case 302:
2629 case 320:
case 32:
case 203:
2634 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2637 CellTree[Neib[0]]->
SetJoint(j, Joint);
2643 if (Tetrahedrals[4*Neib[1]+j] == a)
break;
2647 if (Tetrahedrals[4*Neib[1]+k] == b)
break;
2651 if (Tetrahedrals[4*Neib[1]+l] == c)
break;
2653 l = l*100 + k*10 + j;
2659 case 210:
case 21:
case 102:
2660 case 120:
case 12:
case 201:
2663 case 310:
case 31:
case 103:
2664 case 130:
case 13:
case 301:
2667 case 321:
case 132:
case 213:
2668 case 231:
case 123:
case 312:
2671 case 230:
case 23:
case 302:
2672 case 320:
case 32:
case 203:
2677 Error(
"Unable to set the face !!!!!!!!!!!!" << endl);
2680 CellTree[Neib[1]]->
SetJoint(j, Joint);
2683 if (Joint->
GetType() == InterfaceJoint3D ||
2684 Joint->
GetType() == IsoInterfaceJoint3D)
2690 if (Joint->
GetType() == JointEqN)
2699 cout<<
"numberoftrifaces after "<<N_G<<endl;
2715 delete [] Tetrahedrals ;
2716 delete [] Coordinates;
2717 delete [] TetRegionlist;
2722 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
int GetFaceVertex(const int *&TmpFV, const int *&TmpLen, int &MaxLen)
Definition: ShapeDesc.h:124
static TTimeDB * TimeDB
Definition: Database.h:1137
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
double RE_NR
Definition: Database.h:313
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 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