#include <InputFld.h>

Inheritance diagram for Nektar::FieldUtils::InputFld:

Collaboration diagram for Nektar::FieldUtils::InputFld:

Public Member Functions
	InputFld (FieldSharedPtr f)
	Set up InputFld object. More...

virtual	~InputFld ()

virtual void	Process (po::variables_map &vm)

virtual std::string	GetModuleName ()

Public Member Functions inherited from Nektar::FieldUtils::InputModule
	InputModule (FieldSharedPtr p_m)

FIELD_UTILS_EXPORT void	AddFile (string fileType, string fileName)

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

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

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

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

FIELD_UTILS_EXPORT bool	GetRequireEquiSpaced (void)

FIELD_UTILS_EXPORT void	SetRequireEquiSpaced (bool pVal)

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

Static Public Member Functions
static ModuleSharedPtr	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	m_className []
	ModuleKey for class. More...

Additional Inherited Members
Protected Member Functions inherited from Nektar::FieldUtils::InputModule
void	PrintSummary ()
	Print summary of elements. More...

Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()

Protected Attributes inherited from Nektar::FieldUtils::InputModule
set< string >	m_allowedFiles

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

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

bool	m_requireEquiSpaced

Detailed Description

Converter for Fld files.

Definition at line 49 of file InputFld.h.

Constructor & Destructor Documentation

Nektar::FieldUtils::InputFld::InputFld ( FieldSharedPtr f )

Set up InputFld object.

Definition at line 69 of file InputFld.cpp.

References Nektar::FieldUtils::InputModule::m_allowedFiles.

                                    : InputModule(f)
 {
     m_allowedFiles.insert("fld");
     m_allowedFiles.insert("chk");
     m_allowedFiles.insert("rst");
     m_allowedFiles.insert("bse");
 }

Nektar::FieldUtils::InputFld::~InputFld ( )

virtual

Definition at line 80 of file InputFld.cpp.

81 {

82 }

Member Function Documentation

static ModuleSharedPtr Nektar::FieldUtils::InputFld::create ( FieldSharedPtr f )

inlinestatic

Creates an instance of this class.

Definition at line 57 of file InputFld.h.

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

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

virtual std::string Nektar::FieldUtils::InputFld::GetModuleName ( )

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 64 of file InputFld.h.

     {
         return "InputFld";
     }

void Nektar::FieldUtils::InputFld::Process ( po::variables_map & vm )

virtual

Implements Nektar::FieldUtils::Module.

Definition at line 87 of file InputFld.cpp.

References ASSERTL0, and Nektar::FieldUtils::Module::m_f.

 {
 
     if (m_f->m_verbose)
     {
         if (m_f->m_comm->TreatAsRankZero())
         {
             cout << "Processing input fld file" << endl;
         }
     }
 
     int i, j;
     string fldending;
     // Determine appropriate field input
     if (m_f->m_inputfiles.count("fld") != 0)
     {
         fldending = "fld";
     }
     else if (m_f->m_inputfiles.count("chk") != 0)
     {
         fldending = "chk";
     }
     else if (m_f->m_inputfiles.count("rst") != 0)
     {
         fldending = "rst";
     }
     else if (m_f->m_inputfiles.count("bse") != 0)
     {
         fldending = "bse";
     }
     else
     {
         ASSERTL0(false, "no input file found");
     }
 
     if(m_f->m_graph)
     {
         if (m_f->m_data.size() == 0)
         {
             // currently load all field (possibly could read data from
             //  expansion list but it is re-arranged in expansion)
 
             const SpatialDomains::ExpansionMap &expansions =
                 m_f->m_graph->GetExpansions();
 
             // if Range has been speficied it is possible to have a
             // partition which is empty so check this and return if
             // no elements present.
 
             if (!expansions.size())
             {
                 return;
             }
 
             m_f->m_exp.resize(1);
 
             Array<OneD, int> ElementGIDs(expansions.size());
             SpatialDomains::ExpansionMap::const_iterator expIt;
 
             i = 0;
             for (expIt = expansions.begin(); expIt != expansions.end(); ++expIt)
             {
                 ElementGIDs[i++] = expIt->second->m_geomShPtr->GetGlobalID();
             }
 
             m_f->m_fielddef.clear();
             m_f->m_data.clear();
 
             m_f->FieldIOForFile(m_f->m_inputfiles[fldending][0])->Import(
                 m_f->m_inputfiles[fldending][0], m_f->m_fielddef, m_f->m_data,
                 m_f->m_fieldMetaDataMap, ElementGIDs);
         }
     }
     else // load all data.
     {
         m_f->FieldIOForFile(m_f->m_inputfiles[fldending][0])->Import(
             m_f->m_inputfiles[fldending][0], m_f->m_fielddef, m_f->m_data,
             m_f->m_fieldMetaDataMap);
     }
 
     // if m_exp defined presume we want to load all field  into expansions
     if (m_f->m_exp.size())
     {
         int nfields, nstrips;
 
         m_f->m_session->LoadParameter("Strip_Z", nstrips, 1);
 
         if (vm.count("useSessionVariables"))
         {
             nfields = m_f->m_session->GetVariables().size();
         }
         else
         {
             nfields = m_f->m_fielddef[0]->m_fields.size();
         }
 
         m_f->m_exp.resize(nfields * nstrips);
 
         vector<string> vars = m_f->m_session->GetVariables();
 
         // declare other fields;
         for (int s = 0; s < nstrips; ++s) // homogeneous strip varient
         {
             for (i = 0; i < nfields; ++i)
             {
                 if (i < vars.size())
                 {
                     // check to see if field already defined
                     if (!m_f->m_exp[s * nfields + i])
                     {
                         m_f->m_exp[s * nfields + i] = m_f->AppendExpList(
                             m_f->m_fielddef[0]->m_numHomogeneousDir, vars[i]);
                     }
                 }
                 else
                 {
                     if (vars.size())
                     {
                         m_f->m_exp[s * nfields + i] = m_f->AppendExpList(
                             m_f->m_fielddef[0]->m_numHomogeneousDir, vars[0]);
                     }
                     else
                     {
                         m_f->m_exp[s * nfields + i] = m_f->AppendExpList(
                             m_f->m_fielddef[0]->m_numHomogeneousDir);
                     }
                 }
             }
         }
 
         // Extract data to coeffs and bwd transform
         for (int s = 0; s < nstrips; ++s) // homogeneous strip varient
         {
             for (j = 0; j < nfields; ++j)
             {
                 for (i = 0; i < m_f->m_data.size() / nstrips; ++i)
                 {
                     m_f->m_exp[s * nfields + j]->ExtractDataToCoeffs(
                         m_f->m_fielddef[i * nstrips + s],
                         m_f->m_data[i * nstrips + s],
                         m_f->m_fielddef[i * nstrips + s]->m_fields[j],
                         m_f->m_exp[s * nfields + j]->UpdateCoeffs());
                 }
                 m_f->m_exp[s * nfields + j]->BwdTrans(
                     m_f->m_exp[s * nfields + j]->GetCoeffs(),
                     m_f->m_exp[s * nfields + j]->UpdatePhys());
             }
         }
 
         // reset output field in case Import loaded elements that are not
         // in the expansion (because of range option of partitioning)
         std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
             m_f->m_exp[0]->GetFieldDefinitions();
         std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
 
         for (j = 0; j < nfields; ++j)
         {
             for (i = 0; i < FieldDef.size(); ++i)
             {
                 FieldDef[i]->m_fields.push_back(
                     m_f->m_fielddef[0]->m_fields[j]);
                 m_f->m_exp[j]->AppendFieldData(FieldDef[i], FieldData[i]);
             }
         }
         m_f->m_fielddef = FieldDef;
         m_f->m_data     = FieldData;
     }
 }

Member Data Documentation

ModuleKey Nektar::FieldUtils::InputFld::m_className

static

Initial value:

= {
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eInputModule, "fld"), InputFld::create, "Reads Fld file."),
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eInputModule, "chk"),
                                               InputFld::create,
                                               "Reads checkpoint file."),
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eInputModule, "rst"),
                                               InputFld::create,
                                               "Reads restart file."),
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eInputModule, "bse"),
        InputFld::create,
        "Reads stability base-flow file.")}

ModuleKey for class.

Definition at line 62 of file InputFld.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