Converter from fld to vtk. More...

#include <OutputFld.h>

Inheritance diagram for Nektar::Utilities::OutputFld:

Collaboration diagram for Nektar::Utilities::OutputFld:

Public Member Functions
	OutputFld (FieldSharedPtr f)

virtual	~OutputFld ()

virtual void	Process (po::variables_map &vm)
	Write fld to output file. More...

Public Member Functions inherited from Nektar::Utilities::OutputModule
	OutputModule (FieldSharedPtr p_f)

void	OpenStream ()
	Open a file for output. More...

	OutputModule (MeshSharedPtr p_m)

void	OpenStream ()

Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)

void	RegisterConfig (string key, string value)
	Register a configuration option with a module. More...

void	PrintConfig ()
	Print out all configuration options for a module. More...

void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

bool	GetRequireEquiSpaced (void)

void	SetRequireEquiSpaced (bool pVal)

void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

	Module (MeshSharedPtr p_m)

virtual void	Process ()=0

void	RegisterConfig (string key, string value)

void	PrintConfig ()

void	SetDefaults ()

MeshSharedPtr	GetMesh ()

virtual void	ProcessVertices ()
	Extract element vertices. More...

Static Public Member Functions
static boost::shared_ptr< Module >	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	m_className []

Additional Inherited Members
Protected Member Functions inherited from Nektar::Utilities::Module
	Module ()

virtual void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...

virtual void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...

virtual void	ProcessElements ()
	Generate element IDs. More...

virtual void	ProcessComposites ()
	Generate composites. More...

void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...

void	PrismLines (int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)

Protected Attributes inherited from Nektar::Utilities::OutputModule
ofstream	m_fldFile
	Output stream. More...

std::ofstream	m_mshFile
	Output stream. More...

Protected Attributes inherited from Nektar::Utilities::Module
FieldSharedPtr	m_f
	Field object. More...

map< string, ConfigOption >	m_config
	List of configuration values. More...

bool	m_requireEquiSpaced

MeshSharedPtr	m_mesh
	Mesh object. More...

Detailed Description

Converter from fld to vtk.

Definition at line 48 of file OutputFld.h.

Constructor & Destructor Documentation

Nektar::Utilities::OutputFld::OutputFld ( FieldSharedPtr f )

Definition at line 57 of file OutputFld.cpp.

                                      : OutputModule(f)
 {
 }

Nektar::Utilities::OutputFld::~OutputFld ( )

virtual

Definition at line 61 of file OutputFld.cpp.

62 {

63 }

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::OutputFld::create ( FieldSharedPtr f )

inlinestatic

Creates an instance of this class.

Definition at line 52 of file OutputFld.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

                                                                 {
             return MemoryManager<OutputFld>::AllocateSharedPtr(f);
         }

void Nektar::Utilities::OutputFld::Process ( po::variables_map & vm )

virtual

Write fld to output file.

Implements Nektar::Utilities::Module.

Definition at line 65 of file OutputFld.cpp.

References ASSERTL0, Nektar::SpatialDomains::BoundaryConditions::GetBoundaryRegions(), Nektar::Utilities::Module::m_config, Nektar::Utilities::Module::m_f, Nektar::LibUtilities::ReduceSum, and Vmath::Vcopy().

 {
     // Extract the output filename and extension
     string filename = m_config["outfile"].as<string>();
 
     if (m_f->m_writeBndFld)
     {
         ModuleKey      module;
 
         // Extract data to boundaryconditions
         if (m_f->m_fldToBnd)        {
             for (int i = 0; i < m_f->m_exp.size(); ++i)
             {
                 m_f->m_exp[i]->FillBndCondFromField();
             }
         }
 
         if (m_f->m_verbose)
         {
             cout << "OutputFld: Writing boundary file(s): ";
             for(int i = 0; i < m_f->m_bndRegionsToWrite.size(); ++i)
             {
                 if(i < m_f->m_bndRegionsToWrite.size()-1)
                 {
                     cout << ",";
                 }
             }
             cout << endl;
         }
 
         int nfields = m_f->m_exp.size();
         Array<OneD, Array<OneD, const MultiRegions::ExpListSharedPtr> >
             BndExp(nfields);
         for (int i = 0; i < nfields; ++i)
         {
             BndExp[i] = m_f->m_exp[i]->GetBndCondExpansions();
         }
 
         // get hold of partition boundary regions so we can match it to desired
         // region extraction
         SpatialDomains::BoundaryConditions bcs(m_f->m_session,
                                                m_f->m_exp[0]->GetGraph());
         const SpatialDomains::BoundaryRegionCollection bregions  =
                                                     bcs.GetBoundaryRegions();
         SpatialDomains::BoundaryRegionCollection::const_iterator breg_it;
         map<int,int> BndRegionMap;
         int cnt =0;
         for(breg_it = bregions.begin(); breg_it != bregions.end();
                 ++breg_it, ++cnt)
         {
             BndRegionMap[breg_it->first] = cnt;
         }
 
         // find ending of output file and insert _b1, _b2
         int    dot  = filename.find_last_of('.') + 1;
         string ext  = filename.substr(dot, filename.length() - dot);
         string name = filename.substr(0, dot-1);
 
         LibUtilities::BndRegionOrdering BndOrder =
                                     m_f->m_session->GetBndRegionOrdering();
 
         for(int i = 0; i < m_f->m_bndRegionsToWrite.size(); ++i)
         {
             string outname = name  + "_b"
                     + boost::lexical_cast<string>(m_f->m_bndRegionsToWrite[i])
                     + "." + ext;
 
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
 
             if(BndRegionMap.count(m_f->m_bndRegionsToWrite[i]) == 1)
             {
                 int Border = BndRegionMap[m_f->m_bndRegionsToWrite[i]];
 
                 FieldDef = BndExp[0][Border]->GetFieldDefinitions();
                 FieldData.resize(FieldDef.size());
 
                 for (int j = 0; j < nfields; ++j)
                 {
                     for (int k = 0; k < FieldDef.size(); ++k)
                     {
                         BndExp[j][Border]->AppendFieldData(FieldDef[k],
                                                            FieldData[k]);
 
                         if (m_f->m_fielddef.size() > 0)
                         {
                             FieldDef[k]->m_fields.push_back(
                                 m_f->m_fielddef[0]->m_fields[j]);
                         }
                         else
                         {
                             FieldDef[k]->m_fields.push_back(
                                 m_f->m_session->GetVariable(j));
                         }
                     }
                 }
 
                 if(m_f->m_addNormals)
                 {
                     ASSERTL0(m_f->m_exp[0]->GetCoordim(0) == 3,
                              "Add normals to extracted boundaries only set up in 3 dimensions");
                     int normdim = 3; // currently assuming 3D normals;
                     string normstr[3] = {"Norm_x","Norm_y","Norm_z"};
 
                     // Add normal information
                     StdRegions::StdExpansionSharedPtr elmt;
                     StdRegions::StdExpansion2DSharedPtr bc;
                     Array<OneD, int> BoundarytoElmtID, BoundarytoTraceID;
 
                     m_f->m_exp[0]->GetBoundaryToElmtMap(BoundarytoElmtID,
                                                         BoundarytoTraceID);
 
                     // determine offset of this Bnd Expansion Border
                     int cnt = 0;
                     for(int n = 0; n < Border; ++n)
                     {
                         cnt += BndExp[0][n]->GetExpSize();
                     }
 
                     Array<OneD, NekDouble> tmp_array;
                     Array<OneD, Array<OneD, NekDouble> > NormCoeff(normdim);
 
                     for(int j = 0; j < normdim; ++j)
                     {
                         NormCoeff[j] = Array<OneD, NekDouble>(BndExp[0][Border]->GetNcoeffs(),0.0);
                     }
 
                     // setup coeff arrays of normals.
                     for(int j = 0; j < BndExp[0][Border]->GetExpSize();
                         ++j, cnt++)
                     {
                         // find element and face of this expansion.
                         int elmtid = BoundarytoElmtID[cnt];
                         elmt = m_f->m_exp[0]->GetExp(elmtid);
 
                         // Get face 2D expansion from element expansion
                         bc  =  boost::dynamic_pointer_cast<StdRegions::StdExpansion2D> (BndExp[0][Border]->GetExp(j));
 
                         //identify boundary of element looking at.
                         int boundary = BoundarytoTraceID[cnt];
 
                         //Get face normals
                         const Array<OneD, const Array<OneD, NekDouble> > normals = elmt->GetFaceNormal(boundary);
 
                         for(int k = 0; k < normdim; ++k)
                         {
                             bc->FwdTrans(normals[k],tmp_array = NormCoeff[k]+BndExp[0][Border]->GetCoeff_Offset(j));
                         }
                     }
 
                     // add normal coefficients to list to be dumped
                     for (int j = 0; j < normdim; ++j)
                     {
                         Vmath::Vcopy(BndExp[0][Border]->GetNcoeffs(),
                                      NormCoeff[j],1,
                                      BndExp[0][Border]->UpdateCoeffs(),1);
 
                         for (int k = 0; k < FieldDef.size(); ++k)
                         {
                             BndExp[0][Border]->AppendFieldData(FieldDef[k],
                                                                FieldData[k]);
                             FieldDef[k]->m_fields.push_back(normstr[j]);
                         }
                     }
                 }
 
                 // output error for regression checking.
                 if (vm.count("error"))
                 {
                     int rank = m_f->m_session->GetComm()->GetRank();
 
                     for (int j = 0; j < nfields; ++j)
                     {
                         BndExp[j][Border]->BwdTrans(BndExp[j][Border]->GetCoeffs(),
                                                 BndExp[j][Border]->UpdatePhys());
 
                         //Note currently these calls will
                         //hange since not all partitions will
                         //call error.
                         NekDouble l2err   = BndExp[j][Border]
                                            ->L2(BndExp[j][Border]->GetPhys());
 
                         NekDouble linferr = BndExp[j][Border]
                                            ->Linf(BndExp[j][Border]->GetPhys());
 
                         if (rank == 0)
                         {
                             cout << "L 2 error (variable "
                                  << FieldDef[0]->m_fields[j]
                                  << ") : " << l2err  << endl;
 
                             cout << "L inf error (variable "
                                  << FieldDef[0]->m_fields[j]
                                  << ") : " << linferr << endl;
                         }
                     }
                 }
             }
 
             m_f->m_fld->Write(outname, FieldDef, FieldData,
                                                  m_f->m_fieldMetaDataMap);
 
         }
     }
     else
     {
         if (m_f->m_verbose)
         {
             cout << "OutputFld: Writing file..." << endl;
         }
 
         fs::path writefile(filename);
         int writefld = 1;
         if(fs::exists(writefile)&&(vm.count("forceoutput") == 0))
         {
             LibUtilities::CommSharedPtr comm = m_f->m_session->GetComm();
             int rank = comm->GetRank();
             writefld = 0; // set to zero for reduce all to be correct. 
 
             if(rank == 0)
             {
                 string answer;
                 cout << "Did you wish to overwrite " << filename << " (y/n)? ";
                 getline(cin,answer);
                 if(answer.compare("y") == 0)
                 {
                     writefld = 1;
                 }
                 else
                 {
                     cout << "Not writing file " << filename << " because it already exists" << endl;
                 }
             }
             
             comm->AllReduce(writefld,LibUtilities::ReduceSum);
             
         }
 
         if(writefld)
         {
             m_f->m_fld->Write(filename, m_f->m_fielddef, m_f->m_data);
         }
 
         // output error for regression checking.
         if (vm.count("error"))
         {
             int rank = m_f->m_session->GetComm()->GetRank();
 
             for (int j = 0; j < m_f->m_exp.size(); ++j)
             {
                 if (m_f->m_exp[j]->GetPhysState() == false)
                 {
                     m_f->m_exp[j]->BwdTrans(
                                         m_f->m_exp[j]->GetCoeffs(),
                                         m_f->m_exp[j]->UpdatePhys());
                 }
 
                 NekDouble l2err = m_f->m_exp[j]->L2(
                                         m_f->m_exp[j]->GetPhys());
 
                 NekDouble linferr = m_f->m_exp[j]->Linf(
                                         m_f->m_exp[j]->GetPhys());
                 if (rank == 0)
                 {
                     cout << "L 2 error (variable "
                          << m_f->m_fielddef[0]->m_fields[j]
                          << ") : " << l2err  << endl;
 
                     cout << "L inf error (variable "
                          << m_f->m_fielddef[0]->m_fields[j]
                          << ") : " << linferr << endl;
                 }
             }
         }
     }
 }

Member Data Documentation

ModuleKey Nektar::Utilities::OutputFld::m_className

static

Initial value:

= {
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eOutputModule, "fld"), OutputFld::create,
        "Writes a Fld file."),
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eOutputModule, "chk"), OutputFld::create,
        "Writes a Fld file."),
}

Definition at line 55 of file OutputFld.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation