void
postProcessFluxesPressures( OseenSolver< mesh_Type >& nssolver,
BCHandler& bcHandler,
const LifeV::Real& t, bool _verbose )
{
LifeV::Real Q, P;
UInt flag;
for ( BCHandler::bcBaseIterator_Type it = bcHandler.begin();
it != bcHandler.end(); ++it )
{
flag = it->flag();
Q = nssolver.flux(flag);
P = nssolver.pressure(flag);
if ( _verbose )
{
std::ofstream outfile;
std::stringstream filenamess;
std::string filename;
// file name contains the label
filenamess << flag;
// writing down fluxes
filename = "flux_label" + filenamess.str() + ".m";
outfile.open(filename.c_str(),std::ios::app);
outfile << Q << " " << t << "\n";
outfile.close();
// writing down pressures
filename = "pressure_label" + filenamess.str() + ".m";
outfile.open(filename.c_str(),std::ios::app);
outfile << P << " " << t << "\n";
outfile.close();
// reset ostringstream
filenamess.str("");
}
}
}
void
EnsightToHdf5::run()
{
// Reading from data file
GetPot dataFile ( d->data_file_name.c_str() );
bool verbose = (d->comm->MyPID() == 0);
// Fluid solver
boost::shared_ptr<OseenData> oseenData (new OseenData() );
oseenData->setup ( dataFile );
MeshData meshData;
meshData.setup (dataFile, "fluid/space_discretization");
boost::shared_ptr<mesh_Type > fullMeshPtr (new mesh_Type ( d->comm ) );
readMesh (*fullMeshPtr, meshData);
// writeMesh("test.mesh", *fullMeshPtr);
// Scale, Rotate, Translate (if necessary)
boost::array< Real, NDIM > geometryScale;
boost::array< Real, NDIM > geometryRotate;
boost::array< Real, NDIM > geometryTranslate;
geometryScale[0] = dataFile ( "fluid/space_discretization/transform", 1., 0);
geometryScale[1] = dataFile ( "fluid/space_discretization/transform", 1., 1);
geometryScale[2] = dataFile ( "fluid/space_discretization/transform", 1., 2);
geometryRotate[0] = dataFile ( "fluid/space_discretization/transform", 0., 3) * M_PI / 180;
geometryRotate[1] = dataFile ( "fluid/space_discretization/transform", 0., 4) * M_PI / 180;
geometryRotate[2] = dataFile ( "fluid/space_discretization/transform", 0., 5) * M_PI / 180;
geometryTranslate[0] = dataFile ( "fluid/space_discretization/transform", 0., 6);
geometryTranslate[1] = dataFile ( "fluid/space_discretization/transform", 0., 7);
geometryTranslate[2] = dataFile ( "fluid/space_discretization/transform", 0., 8);
MeshUtility::MeshTransformer<mesh_Type, mesh_Type::markerCommon_Type > _transformMesh (*fullMeshPtr);
_transformMesh.transformMesh ( geometryScale, geometryRotate, geometryTranslate );
boost::shared_ptr<mesh_Type > meshPtr;
{
MeshPartitioner< mesh_Type > meshPart (fullMeshPtr, d->comm);
meshPtr = meshPart.meshPartition();
}
std::string uOrder = dataFile ( "fluid/space_discretization/vel_order", "P1");
std::string pOrder = dataFile ( "fluid/space_discretization/press_order", "P1");
//oseenData->meshData()->setMesh(meshPtr);
if (verbose)
{
std::cout << "Building the velocity FE space ... " << std::flush;
}
feSpacePtr_Type uFESpacePtr ( new feSpace_Type (meshPtr, uOrder, 3, d->comm) );
if (verbose)
{
std::cout << "ok." << std::endl;
}
if (verbose)
{
std::cout << "Building the pressure FE space ... " << std::flush;
}
feSpacePtr_Type pFESpacePtr ( new feSpace_Type ( meshPtr, pOrder, 1, d->comm ) );
if (verbose)
{
std::cout << "ok." << std::endl;
}
if (verbose)
{
std::cout << "Building the P0 pressure FE space ... " << std::flush;
}
feSpacePtr_Type p0FESpacePtr ( new feSpace_Type ( meshPtr, feTetraP0, quadRuleTetra1pt,
quadRuleTria1pt, 1, d->comm ) );
if (verbose)
{
std::cout << "ok." << std::endl;
}
UInt totalVelDof = uFESpacePtr->map().map (Unique)->NumGlobalElements();
UInt totalPressDof = pFESpacePtr->map().map (Unique)->NumGlobalElements();
UInt totalP0PresDof = p0FESpacePtr->map().map (Unique)->NumGlobalElements();
if (verbose)
{
std::cout << "Total Velocity DOF = " << totalVelDof << std::endl;
}
if (verbose)
{
std::cout << "Total Pressure DOF = " << totalPressDof << std::endl;
}
if (verbose)
{
std::cout << "Total P0Press DOF = " << totalP0PresDof << std::endl;
}
if (verbose)
{
std::cout << "Calling the fluid constructor ... ";
}
OseenSolver< mesh_Type > fluid (oseenData,
*uFESpacePtr,
*pFESpacePtr,
d->comm);
MapEpetra fullMap (fluid.getMap() );
if (verbose)
{
std::cout << "ok." << std::endl;
}
fluid.setUp (dataFile);
// Initialization
Real dt = oseenData->dataTime()->timeStep();
Real t0 = oseenData->dataTime()->initialTime();
Real tFinal = oseenData->dataTime()->endTime();
boost::shared_ptr< Exporter<mesh_Type > > exporter;
boost::shared_ptr< Exporter<mesh_Type > > importer;
std::string const exporterType = dataFile ( "exporter/type", "hdf5");
std::string const exporterName = dataFile ( "exporter/filename", "ethiersteinman");
std::string const exportDir = dataFile ( "exporter/exportDir", "./");
std::string const importerType = dataFile ( "importer/type", "ensight");
std::string const importerName = dataFile ( "importer/filename", "ethiersteinman");
std::string const importDir = dataFile ( "importer/importDir", "importDir/");
#ifdef HAVE_HDF5
if (exporterType.compare ("hdf5") == 0)
{
exporter.reset ( new ExporterHDF5<mesh_Type > ( dataFile, exporterName ) );
}
else
#endif
exporter.reset ( new ExporterEnsight<mesh_Type > ( dataFile, exporterName ) );
exporter->setPostDir ( exportDir ); // This is a test to see if M_post_dir is working
exporter->setMeshProcId ( meshPtr, d->comm->MyPID() );
#ifdef HAVE_HDF5
if (importerType.compare ("hdf5") == 0)
{
importer.reset ( new ExporterHDF5<mesh_Type > ( dataFile, importerName ) );
}
else
#endif
importer.reset ( new ExporterEnsight<mesh_Type > ( dataFile, importerName ) );
// todo this will not work with the ExporterEnsight filter (it uses M_importDir, a private variable)
importer->setPostDir ( importDir ); // This is a test to see if M_post_dir is working
importer->setMeshProcId ( meshPtr, d->comm->MyPID() );
vectorPtr_Type velAndPressureExport ( new vector_Type (*fluid.solution(), exporter->mapType() ) );
vectorPtr_Type velAndPressureImport ( new vector_Type (*fluid.solution(), importer->mapType() ) );
if ( exporter->mapType() == Unique )
{
velAndPressureExport->setCombineMode (Zero);
}
importer->addVariable ( ExporterData<mesh_Type>::VectorField, "velocity", uFESpacePtr,
velAndPressureImport, UInt (0) );
importer->addVariable ( ExporterData<mesh_Type>::ScalarField, "pressure", pFESpacePtr,
velAndPressureImport, UInt (3 * uFESpacePtr->dof().numTotalDof() ) );
importer->import ( t0 );
*velAndPressureExport = *velAndPressureImport;
vectorPtr_Type P0pres ( new vector_Type (p0FESpacePtr->map() ) );
MPI_Barrier (MPI_COMM_WORLD);
computeP0pressure (pFESpacePtr, p0FESpacePtr, uFESpacePtr, *velAndPressureImport, *P0pres, t0);
exporter->addVariable ( ExporterData<mesh_Type>::VectorField, "velocity", uFESpacePtr,
velAndPressureExport, UInt (0) );
exporter->addVariable ( ExporterData<mesh_Type>::ScalarField, "pressure", pFESpacePtr,
velAndPressureExport, UInt (3 * uFESpacePtr->dof().numTotalDof() ) );
exporter->addVariable (ExporterData<mesh_Type>::ScalarField, "P0pressure", p0FESpacePtr,
P0pres, UInt (0),
ExporterData<mesh_Type>::SteadyRegime, ExporterData<mesh_Type>::Cell );
exporter->postProcess ( t0 );
// Temporal loop
LifeChrono chrono;
int iter = 1;
for ( Real time = t0 + dt ; time <= tFinal + dt / 2.; time += dt, iter++)
{
chrono.stop();
importer->import ( time );
*velAndPressureExport = *velAndPressureImport;
MPI_Barrier (MPI_COMM_WORLD);
computeP0pressure (pFESpacePtr, p0FESpacePtr, uFESpacePtr, *velAndPressureImport, *P0pres, time);
exporter->postProcess ( time );
chrono.stop();
if (verbose)
{
std::cout << "Total iteration time " << chrono.diff() << " s." << std::endl;
}
}
}
void
Cylinder::run()
{
typedef FESpace< mesh_Type, MapEpetra > feSpace_Type;
typedef boost::shared_ptr<feSpace_Type> feSpacePtr_Type;
typedef OseenSolver< mesh_Type >::vector_Type vector_Type;
typedef boost::shared_ptr<vector_Type> vectorPtr_Type;
// Reading from data file
//
GetPot dataFile( d->data_file_name );
// int save = dataFile("fluid/miscellaneous/save", 1);
bool verbose = (d->comm->MyPID() == 0);
// Boundary conditions
BCHandler bcH;
BCFunctionBase uZero( zero_scalar );
std::vector<ID> zComp(1);
zComp[0] = 3;
BCFunctionBase uIn ( d->getU_2d() );
BCFunctionBase uOne ( d->getU_one() );
BCFunctionBase uPois( d->getU_pois() );
//BCFunctionBase unormal( d->get_normal() );
//cylinder
bcH.addBC( "Inlet", INLET, Essential, Full, uPois , 3 );
bcH.addBC( "Ringin", RINGIN, Essential, Full, uZero , 3 );
bcH.addBC( "Ringout", RINGOUT, Essential, Full, uZero , 3 );
bcH.addBC( "Outlet", OUTLET, Natural, Full, uZero, 3 );
bcH.addBC( "Wall", WALL, Essential, Full, uZero, 3 );
int numLM = 0;
boost::shared_ptr<OseenData> oseenData(new OseenData());
oseenData->setup( dataFile );
MeshData meshData;
meshData.setup(dataFile, "fluid/space_discretization");
boost::shared_ptr<mesh_Type> fullMeshPtr ( new mesh_Type( d->comm ) );
readMesh(*fullMeshPtr, meshData);
boost::shared_ptr<mesh_Type> meshPtr;
{
MeshPartitioner< mesh_Type > meshPart(fullMeshPtr, d->comm);
meshPtr = meshPart.meshPartition();
}
if (verbose) std::cout << std::endl;
if (verbose) std::cout << "Time discretization order " << oseenData->dataTime()->orderBDF() << std::endl;
//oseenData.meshData()->setMesh(meshPtr);
std::string uOrder = dataFile( "fluid/space_discretization/vel_order", "P1");
if (verbose)
std::cout << "Building the velocity FE space ... " << std::flush;
feSpacePtr_Type uFESpacePtr( new feSpace_Type(meshPtr,uOrder,3,d->comm) );
if (verbose)
std::cout << "ok." << std::endl;
std::string pOrder = dataFile( "fluid/space_discretization/press_order", "P1");
if (verbose)
std::cout << "Building the pressure FE space ... " << std::flush;
feSpacePtr_Type pFESpacePtr( new feSpace_Type(meshPtr,pOrder,1,d->comm) );
if (verbose)
std::cout << "ok." << std::endl;
UInt totalVelDof = uFESpacePtr->map().map(Unique)->NumGlobalElements();
UInt totalPressDof = pFESpacePtr->map().map(Unique)->NumGlobalElements();
if (verbose) std::cout << "Total Velocity DOF = " << totalVelDof << std::endl;
if (verbose) std::cout << "Total Pressure DOF = " << totalPressDof << std::endl;
if (verbose) std::cout << "Calling the fluid constructor ... ";
bcH.setOffset( "Inlet", totalVelDof + totalPressDof - 1 );
OseenSolver< mesh_Type > fluid (oseenData,
*uFESpacePtr,
*pFESpacePtr,
d->comm, numLM);
MapEpetra fullMap(fluid.getMap());
if (verbose) std::cout << "ok." << std::endl;
fluid.setUp(dataFile);
fluid.buildSystem();
MPI_Barrier(MPI_COMM_WORLD);
// Initialization
Real dt = oseenData->dataTime()->timeStep();
Real t0 = oseenData->dataTime()->initialTime();
Real tFinal = oseenData->dataTime()->endTime();
// bdf object to store the previous solutions
TimeAdvanceBDFNavierStokes<vector_Type> bdf;
bdf.setup(oseenData->dataTime()->orderBDF());
vector_Type beta( fullMap );
vector_Type rhs ( fullMap );
#ifdef HAVE_HDF5
ExporterHDF5<mesh_Type > ensight( dataFile, meshPtr, "cylinder", d->comm->MyPID());
#else
ExporterEnsight<mesh_Type > ensight( dataFile, meshPtr, "cylinder", d->comm->MyPID());
#endif
vectorPtr_Type velAndPressure ( new vector_Type(*fluid.solution(), ensight.mapType() ) );
ensight.addVariable( ExporterData<mesh_Type>::VectorField, "velocity", uFESpacePtr,
velAndPressure, UInt(0) );
ensight.addVariable( ExporterData<mesh_Type>::ScalarField, "pressure", pFESpacePtr,
velAndPressure, UInt(3*uFESpacePtr->dof().numTotalDof() ) );
// initialization with stokes solution
if (d->initial_sol == "stokes")
{
if (verbose) std::cout << std::endl;
if (verbose) std::cout << "Computing the stokes solution ... " << std::endl << std::endl;
oseenData->dataTime()->setTime(t0);
MPI_Barrier(MPI_COMM_WORLD);
beta *= 0.;
rhs *= 0.;
fluid.updateSystem(0, beta, rhs );
fluid.iterate( bcH );
// fluid.postProcess();
*velAndPressure = *fluid.solution();
ensight.postProcess( 0 );
fluid.resetPreconditioner();
}
bdf.bdfVelocity().setInitialCondition( *fluid.solution() );
// Temporal loop
LifeChrono chrono;
int iter = 1;
for ( Real time = t0 + dt ; time <= tFinal + dt/2.; time += dt, iter++)
{
oseenData->dataTime()->setTime(time);
if (verbose)
{
std::cout << std::endl;
std::cout << "We are now at time "<< oseenData->dataTime()->time() << " s. " << std::endl;
std::cout << std::endl;
}
chrono.start();
double alpha = bdf.bdfVelocity().coefficientFirstDerivative( 0 ) / oseenData->dataTime()->timeStep();
beta = bdf.bdfVelocity().extrapolation();
bdf.bdfVelocity().updateRHSContribution( oseenData->dataTime()->timeStep());
rhs = fluid.matrixMass()*bdf.bdfVelocity().rhsContributionFirstDerivative();
fluid.updateSystem( alpha, beta, rhs );
fluid.iterate( bcH );
bdf.bdfVelocity().shiftRight( *fluid.solution() );
// if (((iter % save == 0) || (iter == 1 )))
// {
*velAndPressure = *fluid.solution();
ensight.postProcess( time );
// }
// postProcessFluxesPressures(fluid, bcH, time, verbose);
MPI_Barrier(MPI_COMM_WORLD);
chrono.stop();
if (verbose) std::cout << "Total iteration time " << chrono.diff() << " s." << std::endl;
}
}
