void ExporterEnsight<MeshType>::caseVariableSection (std::ofstream& casef) { ASSERT (casef.good(), "There is an error while writing to file" ); casef << "VARIABLE\n"; std::string aux, str; for (typename super::dataVectorIterator_Type i = this->M_dataVector.begin(); i != this->M_dataVector.end(); ++i) { if ( i->regime() == exporterData_Type::SteadyRegime ) { str = ""; } else { std::string stars ("."); for (UInt cc (0); cc < this->M_timeIndexWidth; ++cc) { stars += "*"; } str = stars; } aux = i->variableName() + " " + super::M_prefix + "_" + i->variableName(); switch ( i->fieldType() ) { case exporterData_Type::ScalarField: ASSERT (casef.good(), "There is an error while writing to file" ); casef << "scalar per node: 1 " + aux + str << this->M_me << ".scl\n"; break; case exporterData_Type::VectorField: ASSERT (casef.good(), "There is an error while writing to file" ); casef << "vector per node: 1 " + aux + str << this->M_me << ".vct\n"; break; } } }
ExporterVTK<MeshType>::~ExporterVTK() { // Right before dying, the exporter will write a VTK collection in a pvd file // This allows ParaView to load a single file for the entire time series, // and each frame will be associated to the correct time value. // This will happen only if at least one time step was actually post-processed if ( this->M_timeSteps.size() ) { std::stringstream buffer (""); // a unique time collection is produced by the leader process if (this->M_procId == 0) { for (typename super::dataVectorIterator_Type iData = this->M_dataVector.begin(); iData != this->M_dataVector.end(); ++iData) { composeVTKCollection ( iData->variableName(), buffer ); std::string filename ( this->M_postDir + this->M_prefix + "_" + iData->variableName() + ".pvd" ); std::ofstream vtkCollectionFile; vtkCollectionFile.open ( filename.c_str() ); ASSERT (vtkCollectionFile.is_open(), "There is an error while opening " + filename ); ASSERT (vtkCollectionFile.good(), "There is an error while writing to " + filename ); vtkCollectionFile << buffer.str(); vtkCollectionFile.close(); buffer.str (""); } } } }
void ExporterEnsight<MeshType>::postProcess (const Real& time) { // writing the geo file and the list of global IDs, but only upon the first instance if ( M_firstTimeStep ) { if (!this->M_multimesh) { writeAsciiGeometry ( this->M_postDir + this->M_prefix + this->M_me + ".geo" ); } writeGlobalIDs ( this->M_postDir + super::M_prefix + "_globalIDs" + this->M_me + ".scl" ); M_firstTimeStep = false; } // prepare the file postfix this->computePostfix(); // the postfix will be full of stars, if this time step is not going to generate a snapshot std::size_t found ( this->M_postfix.find ( "*" ) ); if ( found == std::string::npos ) { if (!this->M_procId) { std::cout << " X- ExporterEnsight post-processing ... " << std::flush; } LifeChrono chrono; chrono.start(); for (typename super::dataVectorIterator_Type i = this->M_dataVector.begin(); i != this->M_dataVector.end(); ++i) { // the "regime" attribute needs to be valid if ( i->regime() != exporterData_Type::NullRegime ) { writeAscii (*i); } // if the solution is steady, we do not need to export it at each time step if (i->regime() == exporterData_Type::SteadyRegime) { i->setRegime ( exporterData_Type::NullRegime ); } } // write an updated case file writeCase (time); // write an updated geo file, if needed if (this->M_multimesh) { writeAsciiGeometry ( this->M_postDir + this->M_prefix + this->M_postfix + this->M_me + ".geo" ); } chrono.stop(); if (!this->M_procId) { std::cout << " done in " << chrono.diff() << " s." << std::endl; } } }
void ExporterVTK<MeshType>::postProcess (const Real& time) { // typedef std::list< ExporterData >::iterator Iterator; this->computePostfix(); std::size_t found ( this->M_postfix.find ( "*" ) ); if ( found == string::npos ) { if (this->M_procId == 0) { std::cout << " X- ExporterVTK post-processing" << std::flush; } LifeChrono chrono; chrono.start(); this->M_timeSteps.push_back (time); for (typename super::dataVectorIterator_Type iData = this->M_dataVector.begin(); iData != this->M_dataVector.end(); ++iData) { std::ofstream vtkFile; std::stringstream buffer (""); // a unique PVTU file + a time collection is produced by the leader process if (this->M_procId == 0) { composePVTUStream (*iData, buffer); std::string vtkPFileName ( this->M_prefix + "_" + iData->variableName() + this->M_postfix + ".pvtu" ); std::string vtkPFileNameWithDir (this->M_postDir + vtkPFileName); std::ofstream vtkPFile; vtkPFile.open ( vtkPFileNameWithDir.c_str() ); ASSERT (vtkPFile.is_open(), "There is an error while opening " + vtkPFileName ); ASSERT (vtkPFile.good(), "There is an error while writing to " + vtkPFileName ); vtkPFile << buffer.str(); vtkPFile.close(); buffer.str (""); this->M_pvtuFiles[iData->variableName()].push_back (vtkPFileName); } // redundant. should be done just the first time std::map<UInt, UInt> ltgPointsMap, gtlPointsMap; std::vector<Vector> pointsCoords; createPointsMaps ( iData->feSpacePtr(), gtlPointsMap, ltgPointsMap, pointsCoords ); composeVTUHeaderStream ( gtlPointsMap.size(), buffer ); composeVTUGeoStream ( iData->feSpacePtr(), gtlPointsMap, pointsCoords, buffer ); composeTypeDataHeaderStream (iData->where(), buffer); composeDataArrayStream (*iData, ltgPointsMap, buffer); composeTypeDataFooterStream (iData->where(), buffer); composeVTUFooterStream ( buffer ); // each process writes its own file std::string filename ( this->M_postDir + this->M_prefix + "_" + iData->variableName() + this->M_postfix + "." + this->M_procId + ".vtu" ); vtkFile.open ( filename.c_str() ); ASSERT (vtkFile.is_open(), "There is an error while opening " + filename ); ASSERT (vtkFile.good(), "There is an error while writing to " + filename ); vtkFile << buffer.str(); vtkFile.close(); buffer.str (""); } chrono.stop(); if (!this->M_procId) { std::cout << "...done in " << chrono.diff() << " s." << std::endl; } } }