#include <FilterFieldConvert.h>

Inheritance diagram for Nektar::SolverUtils::FilterFieldConvert:

Collaboration diagram for Nektar::SolverUtils::FilterFieldConvert:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterFieldConvert (const LibUtilities::SessionReaderSharedPtr &pSession, const ParamMap &pParams)

virtual SOLVER_UTILS_EXPORT	~FilterFieldConvert ()

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession)

virtual SOLVER_UTILS_EXPORT	~Filter ()

SOLVER_UTILS_EXPORT void	Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT bool	IsTimeDependent ()

Static Public Member Functions
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Member Functions
virtual SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_FillVariablesName (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

virtual SOLVER_UTILS_EXPORT void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_ProcessSample (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_PrepareOutput (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT NekDouble	v_GetScale ()

virtual SOLVER_UTILS_EXPORT std::string	v_GetFileSuffix ()

void	OutputField (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, int dump=-1)

virtual SOLVER_UTILS_EXPORT bool	v_IsTimeDependent ()

void	CreateModules (vector< string > &modcmds)

void	CreateFields (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

void	ClearFields ()

Protected Attributes
unsigned int	m_numSamples

unsigned int	m_outputFrequency

unsigned int	m_sampleFrequency

std::string	m_outputFile

std::string	m_restartFile

unsigned int	m_index

unsigned int	m_outputIndex

vector< ModuleSharedPtr >	m_modules

LibUtilities::FieldMetaDataMap	m_fieldMetaData

std::vector< Array< OneD, NekDouble > >	m_outFields

std::vector< std::string >	m_variables

FieldSharedPtr	m_f

Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

Friends
class	MemoryManager< FilterFieldConvert >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap

Detailed Description

Definition at line 49 of file FilterFieldConvert.h.

Constructor & Destructor Documentation

Nektar::SolverUtils::FilterFieldConvert::FilterFieldConvert	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const ParamMap &	pParams
	)

Definition at line 48 of file FilterFieldConvert.cpp.

References ASSERTL0, CreateModules(), Nektar::LibUtilities::Equation::Evaluate(), m_f, m_index, m_numSamples, m_outputFile, m_outputFrequency, m_outputIndex, m_restartFile, m_sampleFrequency, and Nektar::SolverUtils::Filter::m_session.

     : Filter(pSession)
 {
     ParamMap::const_iterator it;
 
     // OutputFile
     it = pParams.find("OutputFile");
     if (it == pParams.end())
     {
         std::stringstream outname;
         outname << m_session->GetSessionName() << ".fld";
         m_outputFile = outname.str();
     }
     else
     {
         ASSERTL0(it->second.length() > 0, "Missing parameter 'OutputFile'.");
         if ( it->second.find_last_of('.') != string::npos)
         {
             m_outputFile = it->second;
         }
         else
         {
             std::stringstream outname;
             outname << it->second << ".fld";
             m_outputFile = outname.str();
         }
     }
 
     // Restart file
     it = pParams.find("RestartFile");
     if (it == pParams.end())
     {
         m_restartFile = "";
     }
     else
     {
         ASSERTL0(it->second.length() > 0, "Missing parameter 'RestartFile'.");
         if ( it->second.find_last_of('.') != string::npos)
         {
             m_restartFile = it->second;
         }
         else
         {
             std::stringstream outname;
             outname << it->second << ".fld";
             m_restartFile = outname.str();
         }
     }
 
     // SampleFrequency
     it = pParams.find("SampleFrequency");
     if (it == pParams.end())
     {
         m_sampleFrequency = 1;
     }
     else
     {
         LibUtilities::Equation equ(m_session, it->second);
         m_sampleFrequency = round(equ.Evaluate());
     }
 
     // OutputFrequency
     it = pParams.find("OutputFrequency");
     if (it == pParams.end())
     {
         m_outputFrequency = m_session->GetParameter("NumSteps");
     }
     else
     {
         LibUtilities::Equation equ(m_session, it->second);
         m_outputFrequency = round(equ.Evaluate());
     }
 
     m_numSamples  = 0;
     m_index       = 0;
     m_outputIndex = 0;
 
     //
     // FieldConvert modules
     //
     m_f = boost::shared_ptr<Field>(new Field());
     vector<string>          modcmds;
     // Process modules
     std::stringstream moduleStream;
     it = pParams.find("Modules");
     if (it != pParams.end())
     {
         moduleStream.str(it->second);
     }
     while (!moduleStream.fail())
     {
         std::string sMod;
         moduleStream >> sMod;
         if (!moduleStream.fail())
         {
             modcmds.push_back(sMod);
         }
     }
     // Output module
     modcmds.push_back(m_outputFile);
     // Create modules
     CreateModules(modcmds);
     // Strip options from m_outputFile
     vector<string> tmp;
     boost::split(tmp, m_outputFile, boost::is_any_of(":"));
     m_outputFile = tmp[0];
 }

Nektar::SolverUtils::FilterFieldConvert::~FilterFieldConvert ( )

virtual

Definition at line 158 of file FilterFieldConvert.cpp.

159 {

160 }

Member Function Documentation

void Nektar::SolverUtils::FilterFieldConvert::ClearFields ( )

protected

Definition at line 524 of file FilterFieldConvert.cpp.

References m_f, and Nektar::LibUtilities::NullPtsField.

Referenced by OutputField().

 {
     m_f->m_fieldPts = LibUtilities::NullPtsField;
     m_f->m_exp.clear();
     m_f->m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
     m_f->m_data = std::vector<std::vector<NekDouble> > ();
 }

static FilterSharedPtr Nektar::SolverUtils::FilterFieldConvert::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::map< std::string, std::string > &	pParams
	)

inlinestatic

Creates an instance of this class.

Definition at line 55 of file FilterFieldConvert.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

     {
         FilterSharedPtr p = MemoryManager<FilterFieldConvert>
                                 ::AllocateSharedPtr(pSession, pParams);
         return p;
     }

void Nektar::SolverUtils::FilterFieldConvert::CreateFields ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFields )

protected

Definition at line 471 of file FilterFieldConvert.cpp.

References ASSERTL1, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_f, m_fieldMetaData, m_outFields, m_variables, and Nektar::LibUtilities::NullPtsField.

Referenced by OutputField().

 {
     m_f->m_fieldMetaDataMap = m_fieldMetaData;
     m_f->m_fieldPts = LibUtilities::NullPtsField;
     // Create m_f->m_exp
     int NumHomogeneousDir = 0;
     if (pFields[0]->GetExpType() == MultiRegions::e3DH1D)
     {
         NumHomogeneousDir = 1;
     }
     else if (pFields[0]->GetExpType() == MultiRegions::e3DH2D)
     {
         NumHomogeneousDir = 2;
     }
 
     m_f->m_exp.resize(m_variables.size());
     m_f->m_exp[0] = pFields[0];
     int nfield;
     for (int n = 0; n < m_variables.size(); ++n)
     {
         // if n >= pFields.num_elements() assum we have used n=0 field
         nfield = (n < pFields.num_elements())? n: 0;
         
         m_f->m_exp[n] = m_f->AppendExpList(
                             NumHomogeneousDir, m_variables[0]);
         m_f->m_exp[n]->SetWaveSpace(false);
 
         ASSERTL1(pFields[nfield]->GetNcoeffs() == m_outFields[n].num_elements(),
                  "pFields[nfield] does not have the "
                  "same number of coefficients as m_outFields[n]");
         
         m_f->m_exp[n]->ExtractCoeffsToCoeffs(pFields[nfield], m_outFields[n],
                                              m_f->m_exp[n]->UpdateCoeffs());
 
         m_f->m_exp[n]->BwdTrans( m_f->m_exp[n]->GetCoeffs(),
                                  m_f->m_exp[n]->UpdatePhys());
     }
     std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
         pFields[0]->GetFieldDefinitions();
     std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
     for (int n = 0; n < m_outFields.size(); ++n)
     {
         for (int i = 0; i < FieldDef.size(); ++i)
         {
             FieldDef[i]->m_fields.push_back(m_variables[n]);
             m_f->m_exp[n]->AppendFieldData(FieldDef[i], FieldData[i]);
         }
     }
     m_f->m_fielddef = FieldDef;
     m_f->m_data     = FieldData;
 }

void Nektar::SolverUtils::FilterFieldConvert::CreateModules ( vector< string > & modcmds )

protected

Definition at line 380 of file FilterFieldConvert.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::FieldUtils::eOutputModule, Nektar::FieldUtils::eProcessModule, Nektar::FieldUtils::GetModuleFactory(), m_f, and m_modules.

Referenced by FilterFieldConvert().

 {
     for (int i = 0; i < modcmds.size(); ++i)
     {
         // First split each command by the colon separator.
         vector<string> tmp1;
         ModuleKey module;
         int offset = 1;
 
         boost::split(tmp1, modcmds[i], boost::is_any_of(":"));
 
         if (i == modcmds.size() - 1)
         {
             module.first = eOutputModule;
 
             // If no colon detected, automatically detect mesh type from
             // file extension. Otherwise override and use tmp1[1] as the
             // module to load. This also allows us to pass options to
             // input/output modules. So, for example, to override
             // filename.xml to be read as vtk, you use:
             //
             // filename.xml:vtk:opt1=arg1:opt2=arg2
             if (tmp1.size() == 1)
             {
                 int    dot    = tmp1[0].find_last_of('.') + 1;
                 string ext    = tmp1[0].substr(dot, tmp1[0].length() - dot);
 
                 module.second = ext;
                 tmp1.push_back(string("outfile=") + tmp1[0]);
             }
             else
             {
                 module.second = tmp1[1];
                 tmp1.push_back(string("outfile=") + tmp1[0]);
                 offset++;
             }
         }
         else
         {
             module.first  = eProcessModule;
             module.second = tmp1[0];
         }
 
         // Create modules
         ModuleSharedPtr mod;
         mod = GetModuleFactory().CreateInstance(module, m_f);
         m_modules.push_back(mod);
 
         // Set options for this module.
         for (int j = offset; j < tmp1.size(); ++j)
         {
             vector<string> tmp2;
             boost::split(tmp2, tmp1[j], boost::is_any_of("="));
 
             if (tmp2.size() == 1)
             {
                 mod->RegisterConfig(tmp2[0], "1");
             }
             else if (tmp2.size() == 2)
             {
                 mod->RegisterConfig(tmp2[0], tmp2[1]);
             }
             else
             {
                 cerr << "ERROR: Invalid module configuration: format is "
                      << "either :arg or :arg=val" << endl;
                 abort();
             }
         }
 
         // Ensure configuration options have been set.
         mod->SetDefaults();
     }
 
     bool RequiresEquiSpaced = false;
     for (int i = 0; i < m_modules.size(); ++i)
     {
         if(m_modules[i]->GetRequireEquiSpaced())
         {
             RequiresEquiSpaced = true;
         }
     }
     if (RequiresEquiSpaced)
     {
         for (int i = 0; i < m_modules.size(); ++i)
         {
             m_modules[i]->SetRequireEquiSpaced(true);
         }
     }
 }

void Nektar::SolverUtils::FilterFieldConvert::OutputField	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		int	dump = `-1`
	)

protected

Definition at line 312 of file FilterFieldConvert.cpp.

References ClearFields(), CreateFields(), m_modules, m_outFields, m_outputFile, Vmath::Smul(), v_GetFileSuffix(), and v_GetScale().

Referenced by v_Finalise(), and v_Update().

 {
     NekDouble scale = v_GetScale();
     for (int n = 0; n < m_outFields.size(); ++n)
     {
         Vmath::Smul(m_outFields[n].num_elements(),
                     scale,
                     m_outFields[n],
                     1,
                     m_outFields[n],
                     1);
     }
 
     CreateFields(pFields);
 
     // Determine new file name
     std::stringstream outname;
     int    dot    = m_outputFile.find_last_of('.');
     string name   = m_outputFile.substr(0, dot);
     string ext    = m_outputFile.substr(dot, m_outputFile.length() - dot);
     std::string suffix = v_GetFileSuffix();
     if (dump == -1) // final dump
     {
         outname << name << suffix << ext;
     }
     else
     {
         outname << name << "_" << dump << suffix << ext;
     }
     m_modules[m_modules.size()-1]->RegisterConfig("outfile", outname.str());
 
     // Prevent checking before overwritting
     po::options_description desc("Available options");
         desc.add_options()
             ("forceoutput,f",
                 "Force the output to be written without any checks");
     po::variables_map vm;
     vm.insert(std::make_pair("forceoutput", po::variable_value()));
     // Run field process.
     for (int i = 0; i < m_modules.size(); ++i)
     {
         m_modules[i]->Process(vm);
         cout.flush();
     }
 
     // Empty m_f to save memory
     ClearFields();
 
     if (dump != -1) // not final dump so rescale
     {
         for (int n = 0; n < m_outFields.size(); ++n)
         {
             Vmath::Smul(m_outFields[n].num_elements(),
                         1.0 / scale,
                         m_outFields[n],
                         1,
                         m_outFields[n],
                         1);
         }
     }
 }

void Nektar::SolverUtils::FilterFieldConvert::v_FillVariablesName ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFields )

protectedvirtual

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses.

Definition at line 257 of file FilterFieldConvert.cpp.

References m_variables.

Referenced by v_Initialise().

 {
     int nfield = pFields.num_elements();
     m_variables.resize(pFields.num_elements());
     for (int n = 0; n < nfield; ++n)
     {
         m_variables[n] = pFields[n]->GetSession()->GetVariable(n);
     }
 }

void Nektar::SolverUtils::FilterFieldConvert::v_Finalise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 289 of file FilterFieldConvert.cpp.

References m_fieldMetaData, OutputField(), and v_PrepareOutput().

 {
     m_fieldMetaData["FinalTime"] = boost::lexical_cast<std::string>(time);
     v_PrepareOutput(pFields, time);
     OutputField(pFields);
 }

virtual SOLVER_UTILS_EXPORT std::string Nektar::SolverUtils::FilterFieldConvert::v_GetFileSuffix ( )

inlineprotectedvirtual

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses, Nektar::SolverUtils::FilterMovingAverage, and Nektar::SolverUtils::FilterAverageFields.

Definition at line 97 of file FilterFieldConvert.h.

Referenced by OutputField().

     {
         return "_fc";
     }

virtual SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::FilterFieldConvert::v_GetScale ( )

inlineprotectedvirtual

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses, and Nektar::SolverUtils::FilterAverageFields.

Definition at line 93 of file FilterFieldConvert.h.

Referenced by OutputField(), and v_Initialise().

     {
         return 1.0;
     }

void Nektar::SolverUtils::FilterFieldConvert::v_Initialise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses.

Definition at line 162 of file FilterFieldConvert.cpp.

References Nektar::LibUtilities::FieldIO::CreateForFile(), m_f, m_fieldMetaData, m_numSamples, m_outFields, m_restartFile, Nektar::SolverUtils::Filter::m_session, m_variables, Vmath::Smul(), v_FillVariablesName(), and v_GetScale().

Referenced by Nektar::SolverUtils::FilterReynoldsStresses::v_Initialise().

 {
     v_FillVariablesName(pFields);
 
     // m_variables need to be filled by a derived class
     m_outFields.resize(m_variables.size());
     int nfield;
     
     for (int n = 0; n < m_variables.size(); ++n)
     {
         // if n >= pFields.num_elements() assum we have used n=0 field
         nfield = (n < pFields.num_elements())? n: 0;
 
         m_outFields[n] = Array<OneD, NekDouble>(pFields[nfield]->GetNcoeffs(), 0.0);
     }
     
     m_fieldMetaData["InitialTime"] = boost::lexical_cast<std::string>(time);
 
     // Fill some parameters of m_f
     m_f->m_session = m_session;
     m_f->m_graph = pFields[0]->GetGraph();
     m_f->m_comm = m_f->m_session->GetComm();
 
     // Load restart file if necessary
     if (m_restartFile != "")
     {
         // Load file
         std::vector<LibUtilities::FieldDefinitionsSharedPtr> fieldDef;
         std::vector<std::vector<NekDouble> > fieldData;
         LibUtilities::FieldMetaDataMap fieldMetaData;
         LibUtilities::FieldIOSharedPtr fld =
             LibUtilities::FieldIO::CreateForFile(m_session, m_restartFile);
         fld->Import(m_restartFile, fieldDef, fieldData, fieldMetaData);
 
         // Extract fields to output
         int nfield,k;
         for (int j = 0; j < m_variables.size(); ++j)
         {
             // see if m_variables is part of pFields definition and if
             // so use that field for extract
             for(k = 0; k < pFields.num_elements(); ++k)
             {
                 if(pFields[k]->GetSession()->GetVariable(k)
                    == m_variables[j])
                 {
                     nfield = k;
                     break;
                 }
             }
             if(k == pFields.num_elements())
             {
                 nfield = 0;
             }
             
             for (int i = 0; i < fieldData.size(); ++i)
             {
                 pFields[nfield]->ExtractDataToCoeffs(
                     fieldDef[i],
                     fieldData[i],
                     m_variables[j],
                     m_outFields[j]);
             }
         }
 
         // Load information for numSamples
         if (fieldMetaData.count("NumberOfFieldDumps"))
         {
             m_numSamples = atoi(fieldMetaData["NumberOfFieldDumps"].c_str());
         }
         else
         {
             m_numSamples = 1;
         }
 
         if(fieldMetaData.count("InitialTime"))
         {
             m_fieldMetaData["InitialTime"] = fieldMetaData["InitialTime"];
         }
         
         // Divide by scale
         NekDouble scale = v_GetScale();
         for (int n = 0; n < m_outFields.size(); ++n)
         {
             Vmath::Smul(m_outFields[n].num_elements(),
                         1.0/scale,
                         m_outFields[n],
                         1,
                         m_outFields[n],
                         1);
         }
     }
 }

bool Nektar::SolverUtils::FilterFieldConvert::v_IsTimeDependent ( )

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 375 of file FilterFieldConvert.cpp.

 {
     return true;
 }

void Nektar::SolverUtils::FilterFieldConvert::v_PrepareOutput	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

protectedvirtual

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses, Nektar::SolverUtils::FilterMovingAverage, and Nektar::SolverUtils::FilterAverageFields.

Definition at line 298 of file FilterFieldConvert.cpp.

References m_outFields, and Vmath::Vcopy().

Referenced by v_Finalise(), and v_Update().

 {
     for(int n = 0; n < pFields.num_elements(); ++n)
     {
         Vmath::Vcopy(m_outFields[n].num_elements(),
                     pFields[n]->GetCoeffs(),
                     1,
                     m_outFields[n],
                     1);
     }
 }

virtual SOLVER_UTILS_EXPORT void Nektar::SolverUtils::FilterFieldConvert::v_ProcessSample	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

inlineprotectedvirtual

Reimplemented in Nektar::SolverUtils::FilterReynoldsStresses, Nektar::SolverUtils::FilterMovingAverage, and Nektar::SolverUtils::FilterAverageFields.

Definition at line 84 of file FilterFieldConvert.h.

Referenced by v_Update().

     {
         // Do nothing by default
     }

void Nektar::SolverUtils::FilterFieldConvert::v_Update	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 268 of file FilterFieldConvert.cpp.

References m_fieldMetaData, m_index, m_numSamples, m_outputFrequency, m_outputIndex, m_sampleFrequency, OutputField(), v_PrepareOutput(), and v_ProcessSample().

 {
     m_index++;
     if (m_index % m_sampleFrequency > 0)
     {
         return;
     }
 
     m_numSamples++;
     v_ProcessSample(pFields, time);
 
     if (m_index % m_outputFrequency == 0)
     {
         m_fieldMetaData["FinalTime"] = boost::lexical_cast<std::string>(time);
         v_PrepareOutput(pFields, time);
         OutputField(pFields, ++m_outputIndex);
     }
 }

Friends And Related Function Documentation

friend class MemoryManager< FilterFieldConvert >

friend

Definition at line 52 of file FilterFieldConvert.h.

Member Data Documentation

std::string Nektar::SolverUtils::FilterFieldConvert::className

static

Initial value:

=
        GetFilterFactory().RegisterCreatorFunction(
                "FieldConvert", FilterFieldConvert::create)

Name of the class.

Definition at line 65 of file FilterFieldConvert.h.

FieldSharedPtr Nektar::SolverUtils::FilterFieldConvert::m_f

protected

Definition at line 126 of file FilterFieldConvert.h.

Referenced by ClearFields(), CreateFields(), CreateModules(), FilterFieldConvert(), and v_Initialise().

LibUtilities::FieldMetaDataMap Nektar::SolverUtils::FilterFieldConvert::m_fieldMetaData

protected

Definition at line 123 of file FilterFieldConvert.h.

Referenced by CreateFields(), v_Finalise(), v_Initialise(), Nektar::SolverUtils::FilterAverageFields::v_PrepareOutput(), Nektar::SolverUtils::FilterReynoldsStresses::v_PrepareOutput(), and v_Update().

unsigned int Nektar::SolverUtils::FilterFieldConvert::m_index

protected

Definition at line 120 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), and v_Update().

vector<ModuleSharedPtr> Nektar::SolverUtils::FilterFieldConvert::m_modules

protected

Definition at line 122 of file FilterFieldConvert.h.

Referenced by CreateModules(), and OutputField().

unsigned int Nektar::SolverUtils::FilterFieldConvert::m_numSamples

protected

Definition at line 115 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), Nektar::SolverUtils::FilterAverageFields::v_GetScale(), Nektar::SolverUtils::FilterReynoldsStresses::v_GetScale(), Nektar::SolverUtils::FilterReynoldsStresses::v_Initialise(), v_Initialise(), Nektar::SolverUtils::FilterAverageFields::v_PrepareOutput(), Nektar::SolverUtils::FilterReynoldsStresses::v_PrepareOutput(), Nektar::SolverUtils::FilterMovingAverage::v_ProcessSample(), Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample(), and v_Update().

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterFieldConvert::m_outFields

protected

Definition at line 124 of file FilterFieldConvert.h.

Referenced by CreateFields(), OutputField(), Nektar::SolverUtils::FilterReynoldsStresses::v_Initialise(), v_Initialise(), Nektar::SolverUtils::FilterReynoldsStresses::v_PrepareOutput(), v_PrepareOutput(), Nektar::SolverUtils::FilterAverageFields::v_ProcessSample(), Nektar::SolverUtils::FilterMovingAverage::v_ProcessSample(), and Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample().

std::string Nektar::SolverUtils::FilterFieldConvert::m_outputFile

protected

Definition at line 118 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), and OutputField().

unsigned int Nektar::SolverUtils::FilterFieldConvert::m_outputFrequency

protected

Definition at line 116 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), and v_Update().

unsigned int Nektar::SolverUtils::FilterFieldConvert::m_outputIndex

protected

Definition at line 121 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), and v_Update().

std::string Nektar::SolverUtils::FilterFieldConvert::m_restartFile

protected

Definition at line 119 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), and v_Initialise().

unsigned int Nektar::SolverUtils::FilterFieldConvert::m_sampleFrequency

protected

Definition at line 117 of file FilterFieldConvert.h.

Referenced by FilterFieldConvert(), Nektar::SolverUtils::FilterMovingAverage::FilterMovingAverage(), Nektar::SolverUtils::FilterReynoldsStresses::FilterReynoldsStresses(), and v_Update().

std::vector<std::string> Nektar::SolverUtils::FilterFieldConvert::m_variables

protected

Definition at line 125 of file FilterFieldConvert.h.

Referenced by CreateFields(), Nektar::SolverUtils::FilterReynoldsStresses::v_FillVariablesName(), v_FillVariablesName(), and v_Initialise().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation