void LayoutContainer::SetHeight(const unsigned int& height) {
mHeight = height;
for (auto iter = mDivisions.begin(); iter != mDivisions.end(); ++iter) {
iter->CreateCells();
}
}
void LayoutContainer::SetWidth(const unsigned int& width) {
mWidth = width;
// make sure to update all divisions (cells will have new
// positions and dimensions)
for (auto iter = mDivisions.begin(); iter != mDivisions.end(); ++iter) {
iter->CreateCells();
}
}
ribi::trim::CellsCreator::CellsCreator(
const boost::shared_ptr<const Template> t,
const int n_cell_layers,
const boost::units::quantity<boost::units::si::length> layer_height,
const CreateVerticalFacesStrategy strategy,
const bool verbose,
const CellsCreatorFactory&
) : m_cells(
CreateCells(
t,
n_cell_layers + 1, //n_face_layers - 1 == n_cell_layers
layer_height,
strategy,
verbose
)
),
m_strategy(strategy)
{
#ifndef NDEBUG
Test();
assert(t);
assert(strategy == m_strategy);
#endif
}
ribi::trim::TriangleMeshBuilder::TriangleMeshBuilder(
const std::vector<boost::shared_ptr<Cell>>& cells,
const std::string& mesh_filename,
const std::function<ribi::foam::PatchFieldType(const std::string&)> boundary_to_patch_field_type_function
)
: m_cells(cells),
m_faces(SortByBoundary(ExtractFaces(cells))),
m_points(ExtractPoints(cells))
{
#ifndef NDEBUG
Test();
#endif
TRACE_FUNC();
PROFILE_FUNC();
for (const std::string& folder: GetAllFolders())
{
if (!ribi::fileio::IsFolder(folder))
{
ribi::fileio::CreateFolder(folder);
}
assert(ribi::fileio::IsFolder(folder));
}
//Remove cells with less than 8 faces or less than 8 faces with an owner
m_cells.erase(
std::remove_if(m_cells.begin(),m_cells.end(),
[](const boost::shared_ptr<Cell> cell)
{
const std::vector<boost::shared_ptr<Face>> faces { cell->GetFaces() };
assert(faces.size() == 8);
return std::count_if(faces.begin(),faces.end(),
[](const boost::shared_ptr<Face> face)
{
assert(face);
assert(face->GetOwner()); //Test: is this loop needed?
return face->GetOwner();
}
) < 8;
}
),
m_cells.end()
);
m_faces.erase(
std::remove_if(m_faces.begin(),m_faces.end(),
[](const boost::shared_ptr<const Face> face)
{
return !face->GetOwner();
}
),
m_faces.end()
);
//Remove cells with less than 8 faces or less than 8 faces with an owner
m_cells.erase(
std::remove_if(m_cells.begin(),m_cells.end(),
[](const boost::shared_ptr<Cell> cell)
{
const std::vector<boost::shared_ptr<Face>> faces { cell->GetFaces() };
assert(faces.size() == 8);
return std::count_if(faces.begin(),faces.end(),
[](const boost::shared_ptr<Face> face)
{
assert(face);
assert(face->GetOwner()); //Test: is this loop needed?
return face->GetOwner();
}
) < 8;
}
),
m_cells.end()
);
//Set all indices
{
const int n_cells = static_cast<int>(m_cells.size());
for (int i=0; i!=n_cells; ++i)
{
m_cells[i]->SetIndex(i);
}
const int n_faces = static_cast<int>(m_faces.size());
for (int i=0; i!=n_faces; ++i)
{
m_faces[i]->SetIndex(i);
}
const int n_points = static_cast<int>(m_points.size());
for (int i=0; i!=n_points; ++i)
{
m_points[i]->SetIndex(i);
}
}
//Check
#ifndef NDEBUG
{
const int cell_usecount = m_cells.empty() ? 0 : m_cells[0].use_count();
for (const auto& cell: m_cells)
{
assert(cell);
//TRACE(cell_usecount);
//TRACE(cell.use_count());
assert(cell.use_count() == cell_usecount && "Every Cell must have an equal use_count");
//All Cells must have existing indices
assert(cell->GetIndex() >= 0);
assert(cell->GetIndex() < static_cast<int>(m_cells.size()));
//const int face_usecount = cell->GetFaces().empty() ? 0 : cell->GetFaces()[0].use_count();
for (const auto& face: cell->GetFaces())
{
assert(face);
//TRACE(face_usecount);
//TRACE(face.use_count());
//assert(std::abs(face_usecount - face.use_count()) <= 1 && "Face are used once or twice");
//All Cells must exist of Faces with an existing index
assert(face->GetIndex() >= 0);
assert(face->GetIndex() < static_cast<int>(m_faces.size()));
//All Faces must have a Cell that owns them with an existing index
assert(face->GetOwner()->GetIndex() >= 0);
assert(face->GetOwner()->GetIndex() < static_cast<int>(m_cells.size()));
//All Faces must have either no Neighbout or a Neighbour with an existing index
assert(!face->GetNeighbour() || face->GetNeighbour()->GetIndex() >= 0);
assert(!face->GetNeighbour() || face->GetNeighbour()->GetIndex() < static_cast<int>(m_cells.size()));
for (const auto point: face->GetPoints())
{
assert(point);
//All Faces must exists of Points with an existing index
assert(point->GetIndex() >= 0);
assert(point->GetIndex() < static_cast<int>(m_points.size()));
}
}
}
}
#endif
const bool verbose = false;
if (verbose) std::cout << "Writing output...\n";
//Mesh
{
if (verbose) std::cout << "\tGenerating mesh (.ply)\n";
std::ofstream f(mesh_filename.c_str());
f << CreateHeader();
f << CreateNodes();
f << CreateFaces();
}
{
std::ofstream f(ribi::foam::Filenames().GetPoints().Get().c_str());
f << CreateOpenFoamHeader("vectorField","points","constant/polyMesh");
f << CreateOpenFoamNodes();
}
{
std::ofstream fp(ribi::foam::Filenames().GetFaces().Get().c_str());
fp << CreateOpenFoamHeader("faceList","faces","constant/polyMesh");
fp << CreateOpenFoamFaces();
}
{
const int n_cells = static_cast<int>(m_cells.size());
if (verbose) std::cout << "\tGenerating cells (" << n_cells << ")\n";
std::ofstream fo(ribi::foam::Filenames().GetOwner().Get().c_str());
std::ofstream fn(ribi::foam::Filenames().GetNeighbour().Get().c_str());
std::stringstream fs;
fs
<< "nPoints: " << m_points.size()
<< " nCells: " << m_cells.size()
<< " nFaces: " << m_faces.size()
;
fo << CreateOpenFoamHeader(
"labelList",
"owner",
"constant/polyMesh",
fs.str()
);
fn << CreateOpenFoamHeader(
"labelList",
"neighbour",
"constant/polyMesh",
fs.str()
);
const std::pair<std::string,std::string> p { CreateCells() };
const std::string& out_owner { p.first };
const std::string& out_neighbour { p.second};
fo << out_owner;
fn << out_neighbour;
}
{
std::ofstream f(ribi::foam::Filenames().GetBoundary().Get().c_str());
f << CreateBoundary(boundary_to_patch_field_type_function);
}
{
std::ofstream f(ribi::foam::Filenames().GetCase().Get().c_str());
//Need nothing to stream
}
{
//std::ofstream f(ribi::foam::Filenames().GetFvSchemes().Get().c_str());
//f << CreateOpenFoamFvSchemes();
}
{
//std::ofstream f(ribi::foam::Filenames().GetFvSolution().Get().c_str());
//f << CreateOpenFoamFvSolution();
}
{
std::ofstream f(ribi::foam::Filenames().GetVelocityField().Get().c_str());
f << CreateOpenFoamU();
}
{
//std::ofstream f(ribi::foam::Filenames().GetControlDict().Get().c_str());
//f << CreateOpenFoamControlDict();
}
PROFILER_UPDATE();
}
int main(int argc, char *argv[])
{
int i,j,k,l,inmethod,outmethod,info,errorstat;
int nogrids,nomeshes,nofile,dim,elementsredone=0;
int nodes3d,elements3d,showmem;
Real mergeeps;
char prefix[MAXFILESIZE];
struct GridType *grids;
struct CellType *cell[MAXCASES];
struct FemType data[MAXCASES];
struct BoundaryType *boundaries[MAXCASES];
struct ElmergridType eg;
showmem = TRUE;
printf("\nStarting program Elmergrid\n");
InitParameters(&eg);
grids = (struct GridType*)malloc((size_t) (MAXCASES)*sizeof(struct GridType));
InitGrid(grids);
info = TRUE;
if(argc <= 1) {
errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);
Instructions();
if(errorstat) Goodbye();
}
if(argc == 2) {
errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);
if(errorstat) Goodbye();
}
else if(argc < 4) {
Instructions();
Goodbye();
}
else {
errorstat = InlineParameters(&eg,argc,argv);
if(errorstat) Goodbye();
}
if(!eg.outmethod || !eg.inmethod) {
printf("Please define the input and output formats\n");
}
if(eg.inmethod != 1) {
if(eg.outmethod == 1 || eg.outmethod == 8 || eg.outmethod == 9 || eg.outmethod == 10) {
printf("input of type %d can't create output of type %d\n",
eg.inmethod,eg.outmethod);
errorstat++;
Goodbye();
}
}
#if 0
if(eg.inmethod != 8 && eg.outmethod == 5) {
printf("To write Easymesh format you need to read easymesh format!\n");
errorstat++;
}
#endif
if(eg.timeron) timer_activate(eg.infofile);
/**********************************/
printf("\nElmergrid loading data:\n");
printf( "-----------------------\n");
dim = eg.dim;
nofile = 0;
nomeshes = 0;
nogrids = 0;
inmethod = eg.inmethod;
outmethod = eg.outmethod;
read_another_file:
timer_show();
switch (inmethod) {
case 1:
if(LoadElmergrid(&grids,&nogrids,eg.filesin[nofile],eg.relh,info) == 1) {
if(dim == 3) ExampleGrid3D(&grids,&nogrids,info);
if(dim == 2) ExampleGrid2D(&grids,&nogrids,info);
if(dim == 1) ExampleGrid1D(&grids,&nogrids,info);
SaveElmergrid(grids,nogrids,eg.filesin[nofile],info);
printf("Because file %s didn't exist, it was created for you.\n",eg.filesin[nofile]);
Goodbye();
}
LoadCommands(eg.filesin[nofile],&eg,grids,2,info);
break;
case 2:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadElmerInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 3:
if(LoadSolutionElmer(&(data[nofile]),TRUE,eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 4:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
if(LoadAnsysInput(&(data[0]),boundaries[0],eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 5:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadAbaqusInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 6:
if(LoadAbaqusOutput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 7:
if(LoadFidapInput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(0 && !eg.usenames) data[nofile].boundarynamesexist = data[nofile].bodynamesexist = FALSE;
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
RenumberBoundaryTypes(&data[nofile],boundaries[nofile],TRUE,0,info);
nomeshes++;
break;
case 8:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadUniversalMesh(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 9:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadComsolMesh(&(data[nofile]),eg.filesin[nofile],info))
Goodbye();
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
nomeshes++;
break;
case 10:
if(LoadFieldviewInput(&(data[nofile]),eg.filesin[nofile],TRUE))
Goodbye();
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
nomeshes++;
break;
case 11:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadTriangleInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 12:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadMeditInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 13:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGidInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 14:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGmshInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 15:
if(info) printf("Partitioned solution is fused on-the-fly therefore no other operations may be performed.\n");
FuseSolutionElmerPartitioned(eg.filesin[nofile],eg.filesout[nofile],eg.decimals,eg.partjoin,
eg.saveinterval[0],eg.saveinterval[1],eg.saveinterval[2],info);
if(info) printf("Finishing with the fusion of partitioned Elmer solutions\n");
Goodbye();
break;
#if 0
case 16:
InitializeKnots(&(data[nofile]));
if( Easymesh(argc,argv,&data[nofile].noknots,
&data[nofile].noelements,&sides))
Goodbye();
data[nofile].dim = 2;
data[nofile].coordsystem = COORD_CART2;
data[nofile].maxnodes = 3;
AllocateKnots(&(data[nofile]));
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(EasymeshCopy(&(data[nofile]),boundaries[nofile]))
Goodbye();
nomeshes++;
break;
#endif
case 17:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadNastranInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
case 18:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if(LoadCGsimMesh(&(data[nofile]),eg.filesin[nofile],info))
Goodbye();
nomeshes++;
break;
case 19:
boundaries[nofile] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++) {
boundaries[nofile][i].created = FALSE;
boundaries[nofile][i].nosides = 0;
}
if (LoadGeoInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
Goodbye();
nomeshes++;
break;
default:
Instructions();
Goodbye();
}
nofile++;
if(nofile < eg.nofilesin) {
printf("\nElmergrid loading data from another file:\n");
goto read_another_file;
}
/***********************************/
redoelements:
printf("\nElmergrid creating and manipulating meshes:\n");
printf( "-------------------------------------------\n");
timer_show();
if(nogrids > nomeshes && outmethod != 1) {
nomeshes = nogrids;
for(k=0;k<nogrids;k++) {
CreateCells(&(grids[k]),&(cell[k]),info);
CreateKnots(&(grids[k]),cell[k],&(data[k]),0,0);
boundaries[k] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(j=0;j<MAXBOUNDARIES;j++) {
boundaries[k][j].created = FALSE;
boundaries[k][j].nosides = FALSE;
}
if(grids[k].noboundaries > 0) {
for(j=0;j<grids[k].noboundaries;j++) {
if(grids[k].boundsolid[j] < 4) {
CreateBoundary(cell[k],&(data[k]),&(boundaries[k][j]),
grids[k].boundext[j],grids[k].boundint[j],
1,grids[k].boundtype[j]);
}
else {
CreatePoints(cell[k],&(data[k]),&(boundaries[k][j]),
grids[k].boundext[j],grids[k].boundint[j],
grids[k].boundsolid[j],grids[k].boundtype[j]);
}
}
}
}
}
/* In some formats the dimension for curved 2D meshes seems to be set to 2.
This should fix the problem for all input types. */
if( data->dim < 3 ) {
data->dim = GetCoordinateDimension(data,info);
}
/* Make the discontinous boundary needed, for example, in poor thermal conduction */
for(k=0;k<nomeshes;k++) {
if(!eg.discont) {
for(j=0;j<grids[k].noboundaries;j++)
if(grids[k].boundsolid[j] == 2) {
eg.discontbounds[eg.discont] = grids[k].boundtype[j];
eg.discont++;
}
}
if(eg.discont) {
for(i=1;i<=eg.discont;i++)
SetDiscontinuousBoundary(&(data[k]),boundaries[k],eg.discontbounds[i-1],2,info);
}
}
/* Divide quadrilateral meshes into triangular meshes */
for(k=0;k<nomeshes;k++)
if(nogrids && (eg.triangles || grids[k].triangles == TRUE)) {
Real criticalangle;
criticalangle = MAX(eg.triangleangle , grids[k].triangleangle);
ElementsToTriangles(&data[k],boundaries[k],criticalangle,info);
}
/* Make a boundary layer with two different methods */
if(eg.layers > 0)
for(k=0;k<nomeshes;k++)
CreateBoundaryLayer(&data[k],boundaries[k],eg.layers,
eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
eg.layerparents, eg.layermove, eg.layereps, info);
else if(eg.layers < 0)
for(k=0;k<nomeshes;k++)
CreateBoundaryLayerDivide(&data[k],boundaries[k],abs(eg.layers),
eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
eg.layerparents, info);
/* Take up the infor on rotation */
for(k=0;k<nogrids;k++)
if( grids[k].rotatecurve ) {
eg.rotatecurve = TRUE;
eg.curvezet = grids[k].curvezet;
eg.curverad = grids[k].curverad;
eg.curveangle = grids[k].curveangle;
}
if(outmethod != 1 && dim != 2 && eg.dim != 2) {
j = MAX(nogrids,1);
for(k=0;k<j;k++) {
if(grids[k].dimension == 3 || grids[k].rotate) {
boundaries[j] = (struct BoundaryType*)
malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType));
for(i=0;i<MAXBOUNDARIES;i++)
boundaries[j][i].created = FALSE;
CreateKnotsExtruded(&(data[k]),boundaries[k],&(grids[k]),
&(data[j]),boundaries[j],info);
if(nogrids) {
elements3d = MAX(eg.elements3d, grids[k].wantedelems3d);
nodes3d = MAX(eg.nodes3d, grids[k].wantednodes3d);
if(elements3d) {
if( abs(data[j].noelements - elements3d) / (1.0*elements3d) > 0.01 && elementsredone < 5 ) {
grids[k].wantedelems *= pow(1.0*elements3d / data[j].noelements, (2.0/3.0));
elementsredone++;
}
else elementsredone = 0;
}
else if(nodes3d) {
if( abs(data[j].noknots - nodes3d) / (1.0*nodes3d) > 0.01 && elementsredone < 5 ) {
grids[k].wantedelems *= pow(1.0*nodes3d / data[j].noknots, (2.0/3.0));
elementsredone++;
}
else elementsredone = 0;
}
if(elementsredone) {
nomeshes = 0;
for(i=0;i < nogrids;i++) SetElementDivision(&(grids[i]),eg.relh,info);
DestroyKnots(&data[j]);
DestroyKnots(&data[k]);
free(cell[k]);
if(info) printf("Iteration %d of elements number targiting %d in 2D\n",
elementsredone,grids[k].wantedelems);
goto redoelements;
}
}
data[k] = data[j];
boundaries[k] = boundaries[j];
}
}
}
/* If the original mesh was given in polar coordinates make the transformation into cartesian ones */
for(k=0;k<nomeshes;k++) {
if(eg.polar || data[k].coordsystem == COORD_POLAR) {
if(!eg.polar) eg.polarradius = grids[k].polarradius;
PolarCoordinates(&data[k],eg.polarradius,info);
}
}
/* If the original mesh was given in cylindrical coordinates make the transformation into cartesian ones */
for(k=0;k<nomeshes;k++) {
if(eg.cylinder || data[k].coordsystem == COORD_CYL) {
CylinderCoordinates(&data[k],info);
}
}
if(1) for(k=0;k<nomeshes;k++)
RotateTranslateScale(&data[k],&eg,info);
/* Rotate may apply to 2d and 3d geometries as well */
for(k=0;k<nomeshes;k++)
if(eg.rotatecurve)
CylindricalCoordinateCurve(&data[k],eg.curvezet,eg.curverad,eg.curveangle);
/* Unite meshes if there are several of them */
if(eg.unitemeshes) {
for(k=1;k<nomeshes;k++)
UniteMeshes(&data[0],&data[k],boundaries[0],boundaries[k],info);
nomeshes = nogrids = 1;
}
if(eg.clone[0] || eg.clone[1] || eg.clone[2]) {
for(k=0;k<nomeshes;k++) {
CloneMeshes(&data[k],boundaries[k],eg.clone,eg.clonesize,FALSE,info);
mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,TRUE,TRUE);
}
}
if(eg.mirror[0] || eg.mirror[1] || eg.mirror[2]) {
for(k=0;k<nomeshes;k++) {
MirrorMeshes(&data[k],boundaries[k],eg.mirror,FALSE,eg.clonesize,eg.mirrorbc,info);
mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,FALSE,TRUE);
}
}
/* Naming convection for the case of several meshes */
if(nomeshes > 1) {
strcpy(prefix,eg.filesout[0]);
for(k=0;k<nomeshes;k++)
sprintf(eg.filesout[k],"%s%d",prefix,k+1);
}
for(k=0;k<nomeshes;k++) {
if(nogrids && grids[k].reduceordermatmax) {
eg.reduce = TRUE;
eg.reducemat1 = grids[k].reduceordermatmin;
eg.reducemat2 = grids[k].reduceordermatmax;
}
if(eg.reduce)
ReduceElementOrder(&data[k],eg.reducemat1,eg.reducemat2);
}
for(k=0;k<nomeshes;k++)
if(eg.increase) IncreaseElementOrder(&data[k],TRUE);
for(k=0;k<nomeshes;k++) {
if(eg.merge)
MergeElements(&data[k],boundaries[k],eg.order,eg.corder,eg.cmerge,FALSE,TRUE);
else if(eg.order == 3)
#if PARTMETIS
ReorderElementsMetis(&data[k],TRUE);
#else
printf("Cannot order nodes by Metis as it is not even compiled!\n");
#endif
else if(eg.order)
ReorderElements(&data[k],boundaries[k],eg.order,eg.corder,TRUE);
if(eg.isoparam)
IsoparametricElements(&data[k],boundaries[k],TRUE,info);
}
