int Doc::Save( FileOutputStream *output )
{
ArrayPtrVoid params;
params.push_back( output );
Functor save( &Object::Save );
Functor saveEnd( &Object::SaveEnd );
this->Process( &save, params, &saveEnd );
return true;
}
int Object::Save( FileOutputStream *output )
{
ArrayPtrVoid params;
params.push_back( output );
Functor save( &Object::Save );
// Special case where we want to process all objects
save.m_visibleOnly = false;
Functor saveEnd( &Object::SaveEnd );
this->Process( &save, params, &saveEnd );
return true;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
int iter = 0;
//const char* _frame = "fixed";
const char* _frame = "moving";
string physGroup = "\"wallInflowZeroU\"";
//string physGroup = "\"wallNoSlip\"";
double betaGrad = 1.0;
Solver *solverP = new PetscSolver(KSPCG,PCICC);
Solver *solverV = new PetscSolver(KSPCG,PCICC);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
// rising-pbc
//string meshFile = "airWaterSugarPBC-wallLeftRight.msh";
/*
const char *binFolder = "/work/gcpoliveira/post-processing/3d/rising-pbc/bin/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/rising-pbc/msh/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/rising-pbc/dat/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/rising-pbc/vtk/";
*/
// rising-beta
/*
const char *binFolder = "/work/gcpoliveira/post-processing/3d/rising-beta/bin/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/rising-beta/msh/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/rising-beta/dat/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/rising-beta/vtk/";
*/
// cell-2D
string meshFile = "unit-cell-s-2D-3d.msh";
// 1
/*
const char *binFolder = "/work/gcpoliveira/post-processing/3d/cell-1/bin/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/cell-1/dat/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/cell-1/msh/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/cell-1/vtk/";
*/
// 2
/*
const char *binFolder = "/work/gcpoliveira/post-processing/3d/cell-2/bin/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/cell-2/dat/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/cell-2/msh/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/cell-2/vtk/";
*/
// 3
const char *binFolder = "/work/gcpoliveira/post-processing/3d/cell-3/bin/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/cell-3/dat/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/cell-3/msh/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/cell-3/vtk/";
string meshDir = (string) getenv("MESH3D_DIR");
if( strcmp( _frame,"moving") == 0 )
meshDir += "/rising/movingFrame/" + meshFile;
else
meshDir += "/rising/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
cout << endl;
cout << "--------------> RE-STARTING..." << endl;
cout << endl;
//string mshBase = "/work/gcpoliveira/post-processing/3d/cell-1/msh/newMesh-";
//string mshBase = "/work/gcpoliveira/post-processing/3d/cell-2/msh/newMesh-";
string mshBase = "/work/gcpoliveira/post-processing/3d/cell-3/msh/newMesh-";
//string mshBase = "/work/gcpoliveira/post-processing/3d/rising-pbc/msh/newMesh-";
//string mshBase = "/work/gcpoliveira/post-processing/3d/rising-beta/msh/newMesh-";
// load surface mesh
string aux = *(argv+1);
string file = mshBase + *(argv+1) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
//string vtkBase = "/work/gcpoliveira/post-processing/3d/cell-1/vtk/sim-";
//string vtkBase = "/work/gcpoliveira/post-processing/3d/cell-2/vtk/sim-";
string vtkBase = "/work/gcpoliveira/post-processing/3d/cell-3/vtk/sim-";
//string vtkBase = "/work/gcpoliveira/post-processing/3d/rising-pbc/vtk/sim-";
//string vtkBase = "/work/gcpoliveira/post-processing/3d/rising-beta/vtk/sim-";
// load 3D mesh
file = vtkBase + *(argv+1) + (string) ".vtk";
const char *vtkFile = file.c_str();
m1.readVTK(vtkFile);
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.readVTKHeaviside(vtkFile);
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC();
Periodic3D pbc(m1);
pbc.MountPeriodicVectorsNew("print");
Simulator3D s1(pbc,m1);
s1.setBetaPressureLiquid(betaGrad);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
//const char *dirBase = "/work/gcpoliveira/post-processing/3d/cell-1/";
//const char *dirBase = "/work/gcpoliveira/post-processing/3d/cell-2/";
const char *dirBase = "/work/gcpoliveira/post-processing/3d/cell-3/";
//const char *dirBase = "/work/gcpoliveira/post-processing/3d/rising-pbc/";
//const char *dirBase = "/work/gcpoliveira/post-processing/3d/rising-beta/";
iter = s1.loadSolution(dirBase,"sim",atoi(*(argv+1)));
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
//h1.initThreeBubbles();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
double vinst=0;
double vref=0;
double xref=0;
double xinit=0;
double dx=0;
if( strcmp( _frame,"moving") == 0 )
{
// moving
vref = s1.getURef();
xref = s1.getXRef();
s1.setCentroidVelPos();
xinit = s1.getCentroidPosXAverage();
}
int nIter = 30000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
// moving
if( strcmp( _frame,"moving") == 0 )
{
// moving frame
dx = s1.getCentroidPosXAverage() - xinit;
vinst = s1.getCentroidVelXAverage() + dx/s1.getDt();
vref += vinst;
xref += vref*s1.getDt();
cout << "vref: " << vref << " xref: " << xref << endl;
cout << "dx: " << dx << endl;
s1.setUSol(vinst);
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC(vref);
pbc.MountPeriodicVectorsNew("print");
s1.setURef(vref);
s1.setXRef(xref);
}
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.stepALEPBC();
//s1.stepALE();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
s1.setGravity("-X");
s1.setBetaFlowLiq("+X");
s1.setRHS();
s1.setCopyDirectionPBC("RL");
s1.setInterfaceGeo();
//s1.setInterfaceLevelSet();
s1.unCoupledPBCNew();
//s1.unCoupledBetaPBC(); // rising-beta
if ( i%5 == 0 )
{
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
save.saveBubbleShapeFactors(datFolder,"shapeFactors",iter);
}
s1.saveOldData();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
s1.timeStep();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
//h2.initRisingBubble();
h2.initThreeBubbles();
h2.assemble();
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
m1.insert3dMeshPointsByDiffusion(6.0);
m1.remove3dMeshPointsByDiffusion(0.5);
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("curvature");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("curvature");
//m1.removePointsByLength();
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
if( strcmp( _frame,"moving") == 0 )
{
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC(vref);
pbc.MountPeriodicVectorsNew("print");
}
else
{
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC();
pbc.MountPeriodicVectorsNew("noPrint");
}
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
//double bubbleDiam = 3.0E-3; // sqrt(Ar) = 535.83 ; Eo = 1.2091
//double bubbleDiam = 4.0E-3; // sqrt(Ar) = 824.96 ; Eo = 2.1495
double bubbleDiam = 5.2E-3; // sqrt(Ar) = 12228.0 ; Eo = 3.6327
double mu_in = 18.21E-6;
double mu_out = 958.08E-6;
double rho_in = 1.205;
double rho_out = 998.0;
double gravity = 9.8;
double sigma = 0.0728;
double betaGrad = 1.0; // 0.9625
double Re = sqrt( CalcArchimedesBuoyancy(gravity,bubbleDiam,rho_out,mu_out ) );
double We = CalcEotvos(gravity,bubbleDiam,rho_out,sigma);
double Fr = 1.0;
/*
// Rabello's thesis: sugar-syrup 1
double Re = 33.0413;
double Sc = 1.0;
double Fr = 1.0;
double We = 115.662;
double mu_in = 1.78E-5;
double mu_out = 0.5396;
double rho_in = 1.225;
double rho_out = 1350.0;
*/
int iter = 0;
double alpha = 1.0;
double cfl = 0.5;
double c1 = 0.0; // lagrangian
double c2 = 0.1; // smooth vel
double c3 = 10.0; // smooth coord (fujiwara)
double d1 = 1.0; // surface tangent velocity u_n=u-u_t
double d2 = 0.1; // surface smooth cord (fujiwara)
//const char* _frame = "fixed";
const char* _frame = "moving";
string physGroup = "\"wallInflowZeroU\"";
Solver *solverP = new PetscSolver(KSPGMRES,PCILU);
Solver *solverV = new PetscSolver(KSPCG,PCICC);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
/*
string meshFile = "rising-moving-x.msh";
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/rising-pbc-moving/bin/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/rising-pbc-moving/msh/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/rising-pbc-moving/dat/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/rising-pbc-moving/";
*/
// cell-2D
string meshFile = "unit-cell-s-2D-3d.msh";
// 1
/*
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1/bin/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1/dat/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1/msh/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1/vtk/";
*/
// 2
/*
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-2/bin/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-2/dat/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-2/msh/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-2/vtk/";
*/
// 3
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-3/bin/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-3/dat/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-3/msh/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-2D-nb1-3/vtk/";
/*
// cell-D
string meshFile = "unit-cell-s-D-3d.msh";
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-D-nb1/bin/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-D-nb1/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-D-nb1/dat/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-D-nb1/msh/";
*/
/*
// cell-0.5D
string meshFile = "unit-cell-s-0.5D-3d.msh";
const char *binFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-0.5D-nb1/bin/";
const char *vtkFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-0.5D-nb1/";
const char *datFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-0.5D-nb1/dat/";
const char *mshFolder = "/home/gcpoliveira/post-processing/vtk/3d/unit-cell-s-0.5D-nb1/msh/";
*/
string meshDir = (string) getenv("MESH3D_DIR");
if( strcmp( _frame,"moving") == 0 )
meshDir += "/rising/movingFrame/" + meshFile;
else
meshDir += "/rising/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
cout << endl;
cout << "--------------> STARTING FROM 0" << endl;
cout << endl;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC();
Periodic3D pbc(m1);
pbc.MountPeriodicVectorsNew("print");
Simulator3D s1(pbc,m1);
s1.setRe(Re);
s1.setWe(We);
s1.setFr(Fr);
s1.setC1(c1);
s1.setC2(c2);
s1.setC3(c3);
s1.setD1(d1);
s1.setD2(d2);
s1.setAlpha(alpha);
s1.setMu(mu_in,mu_out);
s1.setRho(rho_in,rho_out);
s1.setCfl(cfl);
s1.init();
s1.setBetaPressureLiquid(betaGrad);
s1.setDtALETwoPhase();
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
//h1.initThreeBubbles();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
double vinst=0;
double vref=0;
double xref=0;
double xinit=0;
double dx=0;
if( strcmp( _frame,"moving") == 0 )
{
// moving
vref = s1.getURef();
xref = s1.getXRef();
s1.setCentroidVelPos();
xinit = s1.getCentroidPosXAverage();
}
int nIter = 30000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
// moving
if( strcmp( _frame,"moving") == 0 )
{
// moving frame
dx = s1.getCentroidPosXAverage() - xinit;
vinst = s1.getCentroidVelXAverage() + dx/s1.getDt();
vref += vinst;
xref += vref*s1.getDt();
cout << "vref: " << vref << " xref: " << xref << endl;
cout << "dx: " << dx << endl;
s1.setUSol(vinst);
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC(vref);
pbc.MountPeriodicVectorsNew("print");
s1.setURef(vref);
s1.setXRef(xref);
}
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.stepALEPBC();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
s1.setGravity("-X");
s1.setBetaFlowLiq("+X");
s1.setRHS();
s1.setCopyDirectionPBC("RL");
s1.setInterfaceGeo();
//s1.setInterfaceLevelSet();
s1.unCoupledPBCNew();
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
save.saveBubbleShapeFactors(datFolder,"shapeFactors",iter);
s1.saveOldData();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
s1.timeStep();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
h2.initRisingBubble();
//h2.initThreeBubbles();
h2.assemble();
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
m1.insert3dMeshPointsByDiffusion(6.0);
m1.remove3dMeshPointsByDiffusion(1.0);
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("curvature");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("curvature");
//m1.removePointsByLength();
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
if( strcmp( _frame,"moving") == 0 )
{
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC(vref);
pbc.MountPeriodicVectorsNew("print");
}
else
{
m1.setGenericBCPBCNew(physGroup);
m1.setGenericBC();
pbc.MountPeriodicVectorsNew("noPrint");
}
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
bool ContextPrivate::save( const QString &pFileName, const QList<QUuid> *pNodeList ) const
{
QFileInfo FileInfo( pFileName );
QString TmpFileName = FileInfo.absoluteFilePath().append( ".out" );
if( true )
{
QSettings CFG( TmpFileName, QSettings::IniFormat );
if( !CFG.isWritable() )
{
return( false );
}
CFG.clear();
emit saveStart( CFG );
CFG.beginGroup( "fugio" );
CFG.setValue( "version", int( 2 ) );
CFG.setValue( "duration", double( duration() ) );
CFG.endGroup();
//-------------------------------------------------------------------------
CFG.beginGroup( "meta" );
for( auto it = mMetaInfoMap.begin() ; it != mMetaInfoMap.end() ; it++ )
{
const QString K = mMetaNameMap.value( it.key() );
const QString V = it.value();
if( !K.isEmpty() && !V.isEmpty() )
{
CFG.setValue( K, V );
}
}
CFG.endGroup();
//-------------------------------------------------------------------------
CFG.beginGroup( "nodes" );
for( QSharedPointer<fugio::NodeInterface> N : mNodeHash.values() )
{
if( !pNodeList || pNodeList->contains( N->uuid() ) )
{
CFG.setValue( fugio::utils::uuid2string( N->uuid() ), fugio::utils::uuid2string( N->controlUuid() ) );
}
}
CFG.endGroup();
//-------------------------------------------------------------------------
CFG.beginGroup( "connections" );
for( QSharedPointer<fugio::NodeInterface> N : mNodeHash.values() )
{
if( !pNodeList || pNodeList->contains( N->uuid() ) )
{
for( QSharedPointer<fugio::PinInterface> P : N->enumInputPins() )
{
if( !P->isConnected() )
{
continue;
}
QSharedPointer<fugio::PinInterface> ConPin = P->connectedPin();
if( !ConPin || !ConPin->node() )
{
continue;
}
if( !pNodeList || pNodeList->contains( ConPin->node()->uuid() ) )
{
CFG.setValue( fugio::utils::uuid2string( P->globalId() ), fugio::utils::uuid2string( ConPin->globalId() ) );
}
}
}
}
CFG.endGroup();
//-------------------------------------------------------------------------
for( QSharedPointer<fugio::NodeInterface> N : mNodeHash.values() )
{
if( !pNodeList || pNodeList->contains( N->uuid() ) )
{
CFG.beginGroup( fugio::utils::uuid2string( N->uuid() ) );
N->saveSettings( CFG, false );
CFG.endGroup();
for( QSharedPointer<fugio::PinInterface> P : N->enumPins() )
{
CFG.beginGroup( fugio::utils::uuid2string( P->globalId() ) );
P->saveSettings( CFG );
CFG.endGroup();
}
}
}
//-------------------------------------------------------------------------
CFG.beginGroup( "assets" );
for( auto it : mAssetMap.toStdMap() )
{
QFileInfo FI( CFG.fileName() );
QDir FD( FI.absolutePath() );
QString AP = FD.absoluteFilePath( it.second );
qDebug() << AP;
CFG.setValue( fugio::utils::uuid2string( it.first ), AP );
}
CFG.endGroup();
//-------------------------------------------------------------------------
emit saving( CFG );
emit saveEnd( CFG );
}
QString TmpOld;
if( FileInfo.exists() )
{
TmpOld = FileInfo.dir().absoluteFilePath( FileInfo.completeBaseName() ).append( ".old" );
if( !QFile::rename( pFileName, TmpOld ) )
{
qWarning() << "Couldn't rename output file";
return( false );
}
}
if( true )
{
QFile SrcDat( TmpFileName );
QFile DstDat( pFileName );
if( !SrcDat.open( QFile::ReadOnly ) )
{
qWarning() << "Couldn't open temporary file";
return( false );
}
if( !DstDat.open( QFile::WriteOnly ) )
{
qWarning() << "Couldn't open output file";
return( false );
}
QStringList HdrLst;
HdrLst << QString( ";-----------------------------------------------------------------" );
HdrLst << QString( "; Created with Fugio %1" ).arg( QCoreApplication::applicationVersion() );
for( auto it = mMetaInfoMap.begin() ; it != mMetaInfoMap.end() ; it++ )
{
const QString K = mMetaNameMap.value( it.key() );
const QString V = it.value();
if( !K.isEmpty() && !V.isEmpty() )
{
HdrLst << QString( "; %1: %2" ).arg( K ).arg( V );
}
}
HdrLst << QString( ";-----------------------------------------------------------------" );
HdrLst << QString( "" );
HdrLst << QString( "" );
QByteArray TmpDat;
TmpDat = HdrLst.join( "\n" ).toLatin1();
while( !TmpDat.isEmpty() )
{
if( DstDat.write( TmpDat ) != TmpDat.size() )
{
qWarning() << "Couldn't write output data";
return( false );
}
TmpDat = SrcDat.read( 1024 );
}
SrcDat.close();
DstDat.close();
}
if( !QFile::remove( TmpFileName ) )
{
qWarning() << "Couldn't remove temporary file";
}
if( !TmpOld.isEmpty() && !QFile::remove( TmpOld ) )
{
qWarning() << "Couldn't remove old file";
}
return( true );
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
int iter = 1;
real Re = 91;
real We = 0.23;
real c1 = 0.0; // lagrangian
real c2 = 1.0; // smooth vel
real c3 = 10.0; // smooth coord (fujiwara)
real d1 = 1.0; // surface tangent velocity u_n=u-u_t
real d2 = 0.1; // surface smooth cord (fujiwara)
real alpha = 1.0;
real mu_in = 1.78E-5;
real mu_out = 1.0E-3;
real rho_in = 1.25;
real rho_out = 1000;
real cfl = 0.5;
string meshFile = "annular.msh";
//string meshFile = "annularSquare.msh";
//Solver *solverP = new PetscSolver(KSPGMRES,PCILU);
Solver *solverP = new PetscSolver(KSPGMRES,PCJACOBI);
Solver *solverV = new PetscSolver(KSPCG,PCJACOBI);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
const char *binFolder = "./bin/";
const char *vtkFolder = "./vtk/";
const char *mshFolder = "./msh/";
const char *datFolder = "./dat/";
string meshDir = (string) getenv("DATA_DIR");
meshDir += "/gmsh/3d/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.setWallInterfaceBC();
m1.mesh2Dto3D();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setRe(Re);
s1.setWe(We);
s1.setC1(c1);
s1.setC2(c2);
s1.setC3(c3);
s1.setD1(d1);
s1.setD2(d2);
s1.setAlpha(alpha);
s1.setMu(mu_in,mu_out);
s1.setRho(rho_in,rho_out);
s1.setCfl(cfl);
s1.initAnnular();
s1.setDtALETwoPhase();
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
int nIter = 3000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< i << endl << endl;
cout << resetColor();
//s1.stepLagrangian();
s1.stepALE();
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
s1.setRHS();
s1.setGravity("+Z");
//s1.setInterface();
s1.setInterfaceGeo();
s1.unCoupled();
save.saveMSH(mshFolder,"newMesh",i);
save.saveVTK(vtkFolder,"sim",i);
save.saveVTKSurface(vtkFolder,"sim",i);
save.saveSol(binFolder,"sim",i);
save.saveBubbleInfo(datFolder);
save.chordalPressure(datFolder,"chordalPressure",i);
s1.saveOldData();
s1.timeStep();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< i << endl << endl;;
cout << resetColor();
iter++;
}
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
//m1.insert3dMeshPointsByDiffusion();
m1.remove3dMeshPointsByDiffusion();
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("curvature");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("curvature");
//m1.removePointsByLength();
//m1.flipTriangleEdges();
//m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setGenericBC();
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
int iter = 0;
double velVCrossflow = 0.0; // i.e. V_crossflow = velVCrossflow x V_jet
double velWCrossflow = velVCrossflow;
//const char* _frame = "fixed";
const char* _frame = "moving";
string _physGroup = "\"wallInflowVTransverse\"";
double betaGrad = 0.0;
Solver *solverP = new PetscSolver(KSPCG,PCILU);
Solver *solverV = new PCGSolver();
Solver *solverC = new PCGSolver();
string meshFile = "crossflow-3d-Lp1.5-b0.09.msh";
const char* name = "ms";
const char *binFolder = "null";
const char *datFolder = "null";
const char *mshFolder = "null";
const char *vtkFolder = "null";
if( strcmp( name,"wl") == 0 )
{
binFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/bin/";
datFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/dat/";
mshFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/msh/";
vtkFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/vtk/";
}
else
{
binFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/bin/";
datFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/dat/";
mshFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/msh/";
vtkFolder = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/vtk/";
}
string meshDir = (string) getenv("MESH3D_DIR");
if( strcmp( _frame,"moving") == 0 )
meshDir += "/rising/movingFrame/" + meshFile;
else
meshDir += "/rising/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
cout << endl;
cout << "--------------> RE-STARTING..." << endl;
cout << endl;
string mshBase = "null";
if( strcmp( name,"wl") == 0 )
mshBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/msh/newMesh-";
else
mshBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/msh/newMesh-";
// load surface mesh
string aux = *(argv+1);
string file = mshBase + *(argv+1) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
string vtkBase = "null";
if( strcmp( name,"wl") == 0 )
vtkBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/vtk/sim-";
else
vtkBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/vtk/sim-";
// load 3D mesh
file = vtkBase + *(argv+1) + (string) ".vtk";
const char *vtkFile = file.c_str();
m1.readVTK(vtkFile);
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.readVTKHeaviside(vtkFile);
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setCrossflowVVelocity(velVCrossflow);
m1.setCrossflowWVelocity(velWCrossflow);
m1.setGenericBCPBCNew(_physGroup);
m1.setGenericBC();
Periodic3D pbc(m1);
//pbc.MountPeriodicVectorsNew("noPrint");
pbc.MountPeriodicVectors("noPrint");
Simulator3D s1(pbc,m1);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
const char *dirBase = "null";
if( strcmp( name,"wl") == 0 )
dirBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-1.0-longmire-Lp5/";
else
dirBase = "/work/gcpoliveira/post-processing/3d/crossflow-lambda-0.0-meister-Lp1.5-b0.09/";
iter = s1.loadSolution(dirBase,"sim",atoi(*(argv+1)));
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTKSurface(vtkFolder,"geometry");
save.saveVTKPBC(vtkFolder,"initial",0,betaGrad);
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
double uinst=0;
double vinst=0;
double winst=0;
double uref=0;
double vref=0;
double wref=0;
double xref=0;
double yref=0;
double zref=0;
double xinit=0;
double yinit=0;
double zinit=0;
double dx=0;
double dy=0;
double dz=0;
if( strcmp( _frame,"moving") == 0 )
{
// moving
uref = s1.getURef();
xref = s1.getXRef();
vref = s1.getVRef();
yref = s1.getYRef();
wref = s1.getWRef();
zref = s1.getZRef();
s1.setCentroidVelPos();
xinit = s1.getCentroidPosXAverage(); // initial x centroid
yinit = s1.getCentroidPosYAverage(); // initial y centroid
zinit = s1.getCentroidPosZAverage(); // initial z centroid
}
int nIter = 50000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl;
cout << resetColor();
if( strcmp( _frame,"moving") == 0 )
{
// moving frame
dx = s1.getCentroidPosXAverage() - xinit; // mov. frame x displacement
dy = s1.getCentroidPosYAverage() - yinit; // mov. frame y displacement
dz = s1.getCentroidPosZAverage() - zinit; // mov. frame z displacement
uinst = s1.getCentroidVelXAverage() + dx/s1.getDt(); // uc + correction
vinst = s1.getCentroidVelYAverage() + dy/s1.getDt(); // vc + correction
winst = s1.getCentroidVelZAverage() + dz/s1.getDt(); // wc + correction
uref += uinst; // sums to recover inertial vel
vref += vinst;
wref += winst;
xref += uref*s1.getDt();
yref += vref*s1.getDt();
zref += wref*s1.getDt();
cout << "uref: " << uref << " xref: " << xref << endl;
cout << "vref: " << vref << " yref: " << yref << endl;
cout << "wref: " << wref << " zref: " << zref << endl;
cout << "uinst: " << uinst << " vinst: " << vinst << " winst: " << winst << endl;
cout << "dx: " << dx << endl;
cout << "dy: " << dy << endl;
cout << "dz: " << dz << endl;
s1.setUSol(uinst); // subtraction for inertial frame: u - u_MFR
s1.setVSol(vinst); // subtraction for inertial frame: v - v_MFR
s1.setWSol(winst); // subtraction for inertial frame: w - w_MFR
m1.setCrossflowVVelocity(velVCrossflow); // set of crossflow velocity for BC
m1.setCrossflowWVelocity(velWCrossflow); // set of crossflow velocity for BC
m1.setGenericBCPBCNew(_physGroup);
m1.setGenericBC(uref,vref,wref); // crossflow condition
//pbc.MountPeriodicVectorsNew("print");
pbc.MountPeriodicVectors("print");
s1.setURef(uref); // sets to recover the inertial physics; ease prints in InOut
s1.setVRef(vref);
s1.setWRef(wref);
s1.setXRef(xref);
s1.setYRef(yref);
s1.setZRef(zref);
}
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.stepALEPBC();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
//s1.setGravity("-Z");
//s1.setBetaFlowLiq("+X");
s1.setRHS();
s1.setCopyDirectionPBC("RL");
s1.setInterfaceGeo();
//s1.unCoupledPBCNew();
s1.unCoupledPBC();
if ( i%15 == 0 )
{
save.saveVTKPBC(vtkFolder,"sim",iter,betaGrad);
save.saveVTKSurfacePBC(vtkFolder,"sim",iter,betaGrad);
save.saveMSH(mshFolder,"newMesh",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
save.bubbleWallDistance(datFolder,"dist",iter);
save.saveBubbleShapeFactors(datFolder,"shapeFactors",iter);
}
s1.saveOldData();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl;
cout << resetColor();
s1.timeStep();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
h2.initRisingBubble();
h2.assemble();
h2.setk(0.2);
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
h2.saveVTK(vtkFolder,"edge",iter-1);
//h2.saveChordalEdge(datFolder,"edge",iter-1);
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D mesh operations
m1.insert3dMeshPointsByDiffusion(6.5);
m1.remove3dMeshPointsByDiffusion(1.5);
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface mesh operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("curvature");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("curvature");
//m1.removePointsByLength();
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
if( strcmp( _frame,"moving") == 0 )
{
m1.setCrossflowVVelocity(velVCrossflow);
m1.setCrossflowWVelocity(velWCrossflow);
m1.setGenericBCPBCNew(_physGroup);
m1.setGenericBC(uref,vref,wref);
//pbc.MountPeriodicVectorsNew("noPrint");
pbc.MountPeriodicVectors("noPrint");
}
else
{
m1.setCrossflowVVelocity(velVCrossflow);
m1.setCrossflowWVelocity(velWCrossflow);
m1.setGenericBCPBCNew(_physGroup);
m1.setGenericBC();
//pbc.MountPeriodicVectorsNew("noPrint");
pbc.MountPeriodicVectors("noPrint");
}
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
if ( i%15 == 0 )
{
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
/* This test case applies a prescribed vortex field in a unit cube to
* test the re-meshing techinique of the surface mesh.
*
* OBS.: - comment stepSL() on Simulator3D::stepALE
* - switch to tetrahedralize( (char*) "QYYAp",&in,&out ) on
* Model3D::mesh3DPoints
*
* Since the field is prescribed, there is no need of calculating the
* convection in a Euleurian way (stepSL) and the insertion of nodes on
* the 3D mesh.
*
* */
PetscInitializeNoArguments();
int iter = 1;
double d1 = 0.0; // surface tangent velocity u_n=u-u_t
double d2 = 0.0; // surface smooth cord (fujiwara)
double dt = 0.02;
double T = 3.0;
double time = 0;
string meshFile = "sphere.msh";
const char *vtkFolder = "./vtk/";
const char *mshFolder = "./msh/";
const char *datFolder = "./dat/";
string meshDir = (string) getenv("DATA_DIR");
meshDir += "/gmsh/3d/sphere/vortex/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D("QYYAp");
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
s1(m1);
s1.setDt(dt);
s1.setD1(d1);
s1.setD2(d2);
// initial conditions
s1.stepImposedPeriodicField("3d",T,s1.getTime()); // X,Y and Z --> Sol(n+1)
int nReMesh = 1;
while( time < T )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
time = s1.getTime();
// time step: n+1/4
Simulator3D s20(m1,s1);
double stepTime = dt/4.0;
s20.stepImposedPeriodicField("3d",T,time+stepTime,stepTime); // SolOld(n) --> Sol(n+1/2)
s20.saveOldData(); // Sol(n+1/2) --> SolOld(n+1/2)
// time step: n+1/2
Simulator3D s30(m1,s20);
stepTime = dt/2.0;
s30.stepImposedPeriodicField("3d",T,time+stepTime,stepTime); // SolOld(n) --> Sol(n+1/2)
s30.saveOldData(); // Sol(n+1/2) --> SolOld(n+1/2)
s30.stepALE(); // SolOld(n+1/2) --> ALE(n+1/2)
// time step: n using ALE(n+1/2)
s1.setUALE(s30.getUALE());
s1.setVALE(s30.getVALE());
s1.setWALE(s30.getWALE());
s1.movePoints();
m1.setNormalAndKappa();
double field = cos(3.14159265358*time/T);
cout << endl;
cout << " | T: " << T << endl;
cout << " | dt: " << dt << endl;
cout << " | time: " << time << endl;
cout << " | iter: " << iter << endl;
cout << " | field: " << field << endl;
cout << endl;
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
s1.saveOldData(); // Sol(n+1) --> SolOld(n)
s1.timeStep();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
iter++;
}
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.initMeshParameters();
// surface operations
//m1.smoothPointsByCurvature();
m1.insertPointsByLength("flat");
m1.contractEdgesByLength("flat");
if( time > 1.9 )
m1.contractEdgesByLength("flat",0.65);
if( time > 2.2 )
m1.contractEdgesByLength2("flat",0.7);
if( time > 2.3 )
m1.contractEdgesByLength2("flat",0.8);
if( time > 2.8 )
m1.contractEdgesByLength2("flat",1.2);
//m1.removePointsByLength();
m1.flipTriangleEdges();
//m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
m1.setInterfaceBC();
m1.setMiniElement();
m1.restoreMappingArrays();
m1.setSurfaceVolume();
m1.setSurfaceArea();
m1.triMeshStats();
// computing velocity field X^(n+1),time+1 at new nodes too!
Simulator3D s2(m1,s1);
s2.stepImposedPeriodicField("3d",T,time); // X,Y and Z --> Sol(n+1)
s2.saveOldData();
s1 = s2;
s1.setCentroidVelPos();
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
// bogdan's thesis 2010 (Bhaga and Weber, JFM 1980)
int iter = 1;
double Re = 100;
double We = 115.662;
double Sc = 1;
double Fr = 1.0;
double alpha = 1.0;
double rho_in = 1.225;
double rho_out = 1350;
double mu_out = 1;
double mu_in = 0.0000178;
const char* _case = "9";
// case 1
if( strcmp( _case,"1") == 0 )
{
Re = sqrt(42.895);
mu_out = 2.73;
}
else if( strcmp( _case,"2") == 0 )
{
Re = 13.8487; // case 2
mu_out = 1.28;
}
else if( strcmp( _case,"3") == 0 )
{
Re = 33.0413; // case 3
mu_out = 0.5396; // case 3
}
else if( strcmp( _case,"6") == 0 )
{
Re = sqrt(3892.856); // case 6
mu_out = 0.2857; // case 6
}
else if( strcmp( _case,"7") == 0 )
{
Re = sqrt(18124.092); // case 7
mu_out = 0.1324; // case 7
}
else if( strcmp( _case,"8") == 0 )
{
Re = sqrt(41505.729); // case 8 (extream)
mu_out = 0.0875134907735; // extream
}
else if( strcmp( _case,"9") == 0 )
{
double bubbleDiam = 5.2E-3;
double gravity = 9.8;
double sigma = 0.0728;
rho_in = 1.205;
rho_out = 998.0;
mu_out = 958.08E-6;
mu_in = 18.21E-6;
Re = sqrt( CalcArchimedesBuoyancy(gravity,bubbleDiam,rho_out,mu_out) );
We = CalcEotvos(gravity,bubbleDiam,rho_out,sigma);
}
else
{
cerr << "test case " << _case << " not available!" << endl;
exit(1);
}
double cfl = 0.5;
const char* _frame = "fixed";
//const char* _frame = "moving";
// fixed
double c1 = 0.0; // lagrangian
double c2 = 1.0; // smooth vel
double c3 = 10.0; // smooth coord (fujiwara)
double d1 = 1.0; // surface tangent vel = (u-ut)
double d2 = 0.1; // surface smooth coord (fujiwara)
// moving
if( strcmp( _frame,"moving") == 0 )
{
c1 = 0.0; // lagrangian
c2 = 1.0; // smooth vel: OBS - different result with c1=0.0
c3 = 10.0; // smooth coord (fujiwara)
d1 = 0.0; // surface tangent velocity u_n=u-u_t
d2 = 0.1; // surface smooth cord (fujiwara)
}
string meshFile = "airWaterSugarPBC-wallNoSlip.msh";
Solver *solverP = new PetscSolver(KSPCG,PCICC);
Solver *solverV = new PetscSolver(KSPCG,PCILU);
//Solver *solverV = new PetscSolver(KSPCG,PCJACOBI);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
const char *binFolder = "/work/gcpoliveira/post-processing/3d/rising-compare/bin/";
const char *mshFolder = "/work/gcpoliveira/post-processing/3d/rising-compare/msh/";
const char *vtkFolder = "/work/gcpoliveira/post-processing/3d/rising-compare/vtk/";
const char *datFolder = "/work/gcpoliveira/post-processing/3d/rising-compare/dat/";
string meshDir = (string) getenv("MESH3D_DIR");
if( strcmp( _frame,"moving") == 0 )
meshDir += "/rising/movingFrame/" + meshFile;
else
meshDir += "/rising/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
if( *(argv+1) == NULL )
{
cout << endl;
cout << "--------------> STARTING FROM 0" << endl;
cout << endl;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setRe(Re);
s1.setSc(Sc);
s1.setWe(We);
s1.setFr(Fr);
s1.setC1(c1);
s1.setC2(c2);
s1.setC3(c3);
s1.setD1(d1);
s1.setD2(d2);
s1.setAlpha(alpha);
s1.setMu(mu_in,mu_out);
s1.setRho(rho_in,rho_out);
s1.setCfl(cfl);
s1.init();
s1.setDtALETwoPhase();
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
}
else if( strcmp( *(argv+1),"restart") == 0 )
{
cout << endl;
cout << "--------------> RE-STARTING..." << endl;
cout << endl;
// load surface mesh
string aux = *(argv+2);
string file = (string) "/work/gcpoliveira/post-processing/3d/rising/msh/newMesh-" + *(argv+2) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
s1(m1);
// load 3D mesh
file = (string) "/work/gcpoliveira/post-processing/3d/rising/vtk/sim-" + *(argv+2) + (string) ".vtk";
const char *vtkFile = file.c_str();
m1.readVTK(vtkFile);
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.readVTKHeaviside(vtkFile);
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
iter = s1.loadSolution("/work/gcpoliveira/post-processing/3d/rising/","sim",atoi(*(argv+2)));
}
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
double vinst=0;
double vref=0;
double xref=0;
double xinit=0;
double dx=0;
if( strcmp( _frame,"moving") == 0 )
{
// moving
vref = s1.getURef();
xref = s1.getXRef();
s1.setCentroidVelPos();
xinit = s1.getCentroidPosXAverage();
}
int nIter = 30000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
// moving
if( strcmp( _frame,"moving") == 0 )
{
// moving frame
dx = s1.getCentroidPosXAverage() - xinit;
vinst = s1.getCentroidVelXAverage() + dx/s1.getDt();
vref += vinst;
xref += vref*s1.getDt();
cout << "vref: " << vref << " xref: " << xref << endl;
cout << "dx: " << dx << endl;
s1.setUSol(vinst);
m1.setGenericBC(vref);
s1.setURef(vref);
s1.setXRef(xref);
}
//s1.stepLagrangian();
s1.stepALE();
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.setUnCoupledBC();
s1.setRHS();
s1.setGravity("-X");
//s1.setInterface();
s1.setInterfaceGeo();
s1.unCoupled();
if ( i%5 == 0 )
{
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
}
s1.saveOldData();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
s1.timeStep();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
h2.initRisingBubble();
h2.assemble();
h2.setk(0.2);
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
if ( i%5 == 0 )
{
h2.saveVTK(vtkFolder,"edge",iter-1);
h2.saveChordalEdge(datFolder,"edge",iter-1);
}
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
m1.insert3dMeshPointsByDiffusion(6.0);
m1.remove3dMeshPointsByDiffusion(0.5);
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("flat");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("flat");
//m1.removePointsByLength();
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
if( strcmp( _frame,"moving") == 0 )
m1.setGenericBC(vref);
else
m1.setGenericBC();
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
PetscInitialize(&argc,&argv,PETSC_NULL,PETSC_NULL);
//PetscInitializeNoArguments();
// bogdan's thesis 2010 (Bhaga and Weber, JFM 1980)
int iter = 1;
//double Re = 6.53; // case 1
double Re = 13.8487; // case 2
//double Re = 32.78; // case 3
double Sc = 1000;
double We = 115.66;
double Fr = 1.0;
double c1 = 0.0; // lagrangian
double c2 = 1.0; // smooth vel
double c3 = 10.0; // smooth coord (fujiwara)
double d1 = 1.0; // surface tangent velocity u_n=u-u_t
double d2 = 0.1; // surface smooth cord (fujiwara)
double alpha = 1.0;
double mu_in = 0.0000178;
double mu_out = 1.28;
double rho_in = 1.225;
double rho_out = 1350;
double cfl = 0.8;
string meshFile = "airWaterSugar.msh";
//string meshFile = "test.msh";
Solver *solverP = new PetscSolver(KSPGMRES,PCILU);
//Solver *solverP = new PetscSolver(KSPGMRES,PCJACOBI);
Solver *solverV = new PetscSolver(KSPCG,PCICC);
//Solver *solverV = new PetscSolver(KSPCG,PCJACOBI);
Solver *solverC = new PetscSolver(KSPCG,PCICC);
const char *binFolder = "./bin/";
const char *vtkFolder = "./vtk/";
const char *mshFolder = "./msh/";
const char *datFolder = "./dat/";
string meshDir = (string) getenv("DATA_DIR");
meshDir += "/gmsh/3d/rising/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
if( *(argv+1) == NULL )
{
cout << endl;
cout << "--------------> STARTING FROM 0" << endl;
cout << endl;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setRe(Re);
s1.setSc(Sc);
s1.setWe(We);
s1.setFr(Fr);
s1.setC1(c1);
s1.setC2(c2);
s1.setC3(c3);
s1.setD1(d1);
s1.setD2(d2);
s1.setAlpha(alpha);
s1.setMu(mu_in,mu_out);
s1.setRho(rho_in,rho_out);
s1.setCfl(cfl);
s1.init();
s1.initHeatTransfer();
s1.setDtALETwoPhase();
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
}
else if( strcmp( *(argv+1),"restart") == 0 )
{
cout << endl;
cout << "--------------> RE-STARTING..." << endl;
cout << endl;
// load surface mesh
string aux = *(argv+2);
string file = (string) "./msh/newMesh-" + *(argv+2) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D();
s1(m1);
// load 3D mesh
file = (string) "./vtk/sim-" + *(argv+2) + (string) ".vtk";
const char *vtkFile = file.c_str();
m1.readVTK(vtkFile);
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.readVTKHeaviside(vtkFile);
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
iter = s1.loadSolution("./","sim",atoi(*(argv+2)));
}
else if( strcmp( *(argv+1),"remesh") == 0 )
{
cout << endl;
cout << "--------------> RE-MESHING & STARTING..." << endl;
cout << endl;
// load old mesh
Model3D mOld;
string file = (string) "./vtk/sim-" + *(argv+2) + (string) ".vtk";
const char *vtkFile = file.c_str();
mOld.readVTK(vtkFile);
mOld.readVTKHeaviside(vtkFile);
mOld.setMapping();
// load surface mesh and create new mesh
file = (string) "./msh/newMesh-" + *(argv+2) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3DOriginal();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
m1.setGenericBC();
s1(m1);
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
iter = s1.loadSolution("./","sim",atoi(*(argv+2)));
s1.applyLinearInterpolation(mOld);
}
else if( strcmp( *(argv+1),"restop") == 0 )
{
cout << endl;
cout << "--------------> RE-MESHING (NO ITERATION)..." << endl;
cout << endl;
// load old mesh
Model3D mOld;
string file = (string) "./vtk/sim-" + *(argv+2) + (string) ".vtk";
const char *vtkFile = file.c_str();
mOld.readVTK(vtkFile);
mOld.readVTKHeaviside(vtkFile);
mOld.setMapping();
// load surface mesh and create new one
file = (string) "./msh/newMesh-" + *(argv+2) + (string) ".msh";
const char *mesh2 = file.c_str();
m1.readMSH(mesh2);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3DOriginal();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
s1(m1);
//file = (string) "sim-" + *(argv+2);
//const char *sol = file.c_str();
iter = s1.loadSolution("./","sim",atoi(*(argv+2)));
s1.applyLinearInterpolation(mOld);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.saveVTK(vtkFolder,"sim",atoi(*(argv+2)));
saveEnd.saveMSH(mshFolder,"newMesh",atoi(*(argv+2)));
saveEnd.saveSol(binFolder,"sim",atoi(*(argv+2)));
//saveEnd.saveVTKSurface(vtkFolder,"sim",atoi(*(argv+2)));
return 0;
}
// Point's distribution
Helmholtz3D h1(m1);
h1.setBC();
h1.initRisingBubble();
h1.assemble();
h1.setk(0.2);
h1.matMountC();
h1.setUnCoupledCBC();
h1.setCRHS();
h1.unCoupledC();
//h1.saveVTK(vtkFolder,"edge");
h1.setModel3DEdgeSize();
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
int nIter = 3000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
//s1.stepLagrangian();
s1.stepALE();
s1.setDtALETwoPhase();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
s1.movePoints();
s1.assemble();
s1.matMount();
s1.matMountC();
s1.setUnCoupledBC();
s1.setUnCoupledCBC();
s1.setRHS();
s1.setCRHS();
s1.setGravity("Z");
//s1.setInterface();
s1.setInterfaceGeo();
s1.unCoupled();
s1.unCoupledC();
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveSol(binFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
s1.saveOldData();
s1.timeStep();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
iter++;
}
Helmholtz3D h2(m1,h1);
h2.setBC();
h2.initRisingBubble();
h2.assemble();
h2.matMountC();
h2.setUnCoupledCBC();
h2.setCRHS();
h2.unCoupledC();
h2.saveVTK(vtkFolder,"edge",iter-1);
h2.saveChordalEdge(datFolder,"edge",iter-1);
h2.setModel3DEdgeSize();
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// 3D operations
//m1.insert3dMeshPointsByDiffusion();
m1.remove3dMeshPointsByDiffusion();
//m1.removePointByVolume();
//m1.removePointsByInterfaceDistance();
//m1.remove3dMeshPointsByDistance();
m1.remove3dMeshPointsByHeight();
m1.delete3DPoints();
// surface operations
m1.smoothPointsByCurvature();
m1.insertPointsByLength("curvature");
//m1.insertPointsByCurvature("flat");
//m1.removePointsByCurvature();
//m1.insertPointsByInterfaceDistance("flat");
m1.contractEdgesByLength("curvature");
//m1.removePointsByLength();
m1.flipTriangleEdges();
m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
//m1.mesh2Dto3DOriginal();
m1.mesh3DPoints();
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInterfaceBC();
m1.setGenericBC();
Simulator3D s2(m1,s1);
s2.applyLinearInterpolation(mOld);
s1 = s2;
s1.setSolverPressure(solverP);
s1.setSolverVelocity(solverV);
s1.setSolverConcentration(solverC);
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
/* This test case applies a prescribed 2D vortex field in a unit cube to
* test the re-meshing techinique of the surface mesh.
*
* OBS.: - comment stepSL() on Simulator3D::stepALE
* - switch to tetrahedralize( (char*) "QYYAp",&in,&out ) on
* Model3D::mesh3DPoints
*
* Since the field is prescribed, there is no need of calculating the
* convection in a Euleurian way (stepSL) and the insertion of nodes on
* the 3D mesh.
*
* */
PetscInitializeNoArguments();
int iter = 1;
double d1 = 0.0; // surface tangent velocity u_n=u-u_t
double d2 = 0.1; // surface smooth cord (fujiwara)
double dt = 0.01;
double time = 0.0;
string meshFile = "sphere.msh";
const char *vtkFolder = "./vtk/";
const char *mshFolder = "./msh/";
const char *datFolder = "./dat/";
string meshDir = (string) getenv("DATA_DIR");
meshDir += "/gmsh/3d/sphere/zalesak/" + meshFile;
const char *mesh = meshDir.c_str();
Model3D m1;
Simulator3D s1;
const char *mesh1 = mesh;
m1.readMSH(mesh1);
m1.setInterfaceBC();
m1.setTriEdge();
m1.mesh2Dto3D("QYYAp");
m1.setMapping();
#if NUMGLEU == 5
m1.setMiniElement();
#else
m1.setQuadElement();
#endif
m1.setSurfaceConfig();
m1.setInitSurfaceVolume();
m1.setInitSurfaceArea();
s1(m1);
s1.setD1(d1);
s1.setD2(d2);
s1.setDt(dt);
InOut save(m1,s1); // cria objeto de gravacao
save.saveVTK(vtkFolder,"geometry");
save.saveVTKSurface(vtkFolder,"geometry");
save.saveMeshInfo(datFolder);
save.saveInfo(datFolder,"info",mesh);
int nIter = 3000;
int nReMesh = 1;
for( int i=1;i<=nIter;i++ )
{
for( int j=0;j<nReMesh;j++ )
{
cout << color(none,magenta,black);
cout << "____________________________________ Iteration: "
<< iter << endl << endl;
cout << resetColor();
InOut save(m1,s1); // cria objeto de gravacao
save.printSimulationReport();
time = s1.getTime();
s1.stepImposedPeriodicField("rotating",0.0,time);
s1.stepALE();
s1.movePoints();
s1.setInterfaceGeo();
save.saveMSH(mshFolder,"newMesh",iter);
save.saveVTK(vtkFolder,"sim",iter);
save.saveVTKSurface(vtkFolder,"sim",iter);
save.saveBubbleInfo(datFolder);
//save.crossSectionalVoidFraction(datFolder,"voidFraction",iter);
s1.saveOldData();
cout << color(none,magenta,black);
cout << "________________________________________ END of "
<< iter << endl << endl;;
cout << resetColor();
iter++;
}
Model3D mOld = m1;
/* *********** MESH TREATMENT ************* */
// set normal and kappa values
m1.setNormalAndKappa();
m1.initMeshParameters();
// surface operations
//m1.smoothPointsByCurvature();
m1.insertPointsByLength("flat");
m1.contractEdgesByLength("flat");
//m1.removePointsByLength();
//m1.flipTriangleEdges();
//m1.removePointsByNeighbourCheck();
//m1.checkAngleBetweenPlanes();
/* **************************************** */
m1.setInterfaceBC();
m1.setMiniElement();
m1.restoreMappingArrays();
m1.setSurfaceVolume();
m1.setSurfaceArea();
m1.triMeshStats();
// computing velocity field X^(n+1),time+1 at new nodes too!
Simulator3D s2(m1,s1);
s2.stepImposedPeriodicField("rotating",0.0,time);
s2.saveOldData();
s1 = s2;
s1.setCentroidVelPos();
InOut saveEnd(m1,s1); // cria objeto de gravacao
saveEnd.printMeshReport();
saveEnd.saveMeshInfo(datFolder);
}
PetscFinalize();
return 0;
}
