Nektar::FieldUtils::InputSemtex Class Reference

#include <InputSemtex.h>

Inheritance diagram for Nektar::FieldUtils::InputSemtex:

Public Member Functions
	InputSemtex (FieldSharedPtr f)
	Set up InputSemtex object. More...
virtual	~InputSemtex ()
Public Member Functions inherited from Nektar::FieldUtils::InputModule
	InputModule (FieldSharedPtr p_m)
void	PrintSummary ()
	Print a brief summary of information. More...
Public Member Functions inherited from Nektar::FieldUtils::Module
FIELD_UTILS_EXPORT	Module (FieldSharedPtr p_f)
virtual	~Module ()=default
void	Process (po::variables_map &vm)
std::string	GetModuleName ()
std::string	GetModuleDescription ()
const ConfigOption &	GetConfigOption (const std::string &key) const
ModulePriority	GetModulePriority ()
FIELD_UTILS_EXPORT void	RegisterConfig (std::string key, std::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 void	AddFile (std::string fileType, std::string fileName)
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 Member Functions inherited from Nektar::FieldUtils::InputModule
static FIELD_UTILS_EXPORT std::string	GuessFormat (std::string fileName)
	Tries to guess the format of the input file. More...

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

Protected Member Functions
virtual void	v_Process (po::variables_map &vm) override
	Process Semtex input file. More...
virtual std::string	v_GetModuleName () override
virtual std::string	v_GetModuleDescription () override
virtual ModulePriority	v_GetModulePriority () override
Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()
virtual void	v_Process (po::variables_map &vm)
virtual std::string	v_GetModuleName ()
virtual std::string	v_GetModuleDescription ()
virtual ModulePriority	v_GetModulePriority ()

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...
Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...
std::set< std::string >	m_allowedFiles
	List of allowed file formats. More...

Detailed Description

Converter for Fld files.

Definition at line 48 of file InputSemtex.h.

Constructor & Destructor Documentation

InputSemtex()

Nektar::FieldUtils::InputSemtex::InputSemtex

(

FieldSharedPtr

f

)

Set up InputSemtex object.

Definition at line 62 of file InputSemtex.cpp.

                                         : InputModule(f)
{
    m_allowedFiles.insert("fldsem");
}

References Nektar::FieldUtils::Module::m_allowedFiles.

~InputSemtex()

Nektar::FieldUtils::InputSemtex::~InputSemtex ( )

virtual

Definition at line 70 of file InputSemtex.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 55 of file InputSemtex.h.

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

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

v_GetModuleDescription()

virtual std::string Nektar::FieldUtils::InputSemtex::v_GetModuleDescription ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 70 of file InputSemtex.h.

    {
        return "Processing Semtex field file";
    }

v_GetModuleName()

virtual std::string Nektar::FieldUtils::InputSemtex::v_GetModuleName ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 65 of file InputSemtex.h.

    {
        return "InputSemtex";
    }

v_GetModulePriority()

virtual ModulePriority Nektar::FieldUtils::InputSemtex::v_GetModulePriority ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 75 of file InputSemtex.h.

    {
        return eCreateFieldData;
    }

References Nektar::FieldUtils::eCreateFieldData.

v_Process()

void Nektar::FieldUtils::InputSemtex::v_Process ( po::variables_map &  vm )

overrideprotectedvirtual

Process Semtex input file.

This routine reads a binary-format Semtex field file, loads the data into memory and populates the field definitions to match the data format. Semtex is a classic nodal-Lagrangian spectral element code at a single polynomial order, meaning that the field data are set up according to this structure.

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 82 of file InputSemtex.cpp.

{
    boost::ignore_unused(vm);
 
    // Variables to be read from session file
    string sessionName, date, fields, endian;
    int nr, ns, nz, nelmt, step;
    NekDouble time, dt, kinvis, beta;
 
    ifstream file(m_config["infile"].as<string>().c_str(), ios::binary);
 
    // -- Read header information.
    char buf[25];
    string line;
 
    // Session name
    file.read(buf, 25);
    sessionName = string(buf, 25);
    boost::trim(sessionName);
    getline(file, line);
    m_f->m_fieldMetaDataMap["SessionName0"] = sessionName;
 
    // Date
    file.read(buf, 25);
    date = string(buf, 25);
    boost::trim(date);
    getline(file, line);
 
    // nP, nZ, nElmt
    file >> nr >> ns >> nz >> nelmt;
    getline(file, line);
 
    // Step
    file >> step;
    getline(file, line);
 
    // Time
    file >> time;
    getline(file, line);
    m_f->m_fieldMetaDataMap["Time"] = boost::lexical_cast<string>(time);
 
    // Timestep
    file >> dt;
    getline(file, line);
    m_f->m_fieldMetaDataMap["TimeStep"] = boost::lexical_cast<string>(dt);
 
    // Viscosity
    file >> kinvis;
    getline(file, line);
    m_f->m_fieldMetaDataMap["Kinvis"] = boost::lexical_cast<string>(kinvis);
 
    // Beta
    file >> beta;
    getline(file, line);
 
    // Fields
    file.read(buf, 25);
    fields = string(buf, 25);
    boost::trim(fields);
    getline(file, line);
 
    // Endian-ness
    LibUtilities::EndianType systemEndian = LibUtilities::Endianness();
    std::string endianSearch;
    if (systemEndian == LibUtilities::eEndianBig)
    {
        endianSearch = "big";
    }
    else if (systemEndian == LibUtilities::eEndianLittle)
    {
        endianSearch = "little";
    }
    else
    {
        ASSERTL0(false, "Only little- or big-endian systems are supported");
    }
 
    file.read(buf, 25);
    endian        = string(buf, 25);
    bool byteSwap = endian.find(endianSearch) == string::npos;
    getline(file, line);
 
    // Print some basic information for input if in verbose mode.
    if (m_f->m_verbose)
    {
        cout << "Found header information:" << endl;
        cout << " -- From session         : " << sessionName << endl;
        cout << " -- File generated       : " << date << endl;
        cout << " -- Polynomial order     : " << nr - 1 << endl;
        cout << " -- Number of planes     : " << nz << endl;
        cout << " -- Number of elements   : " << nelmt << endl;
        cout << " -- Simulation time      : " << time << endl;
        cout << " -- Timestep             : " << dt << endl;
        cout << " -- Viscosity            : " << kinvis << endl;
        cout << " -- Fields               : " << fields << " (" << fields.size()
             << " total)" << endl;
 
        if (nz > 1)
        {
            cout << " -- Homogeneous length   : " << 2 * M_PI / beta << endl;
        }
 
        cout << " -- " << (byteSwap ? "" : "do not ") << "need to swap endian"
             << endl;
    }
 
    ASSERTL0(nr == ns, "Semtex reader assumes values of nr and ns are equal");
 
    // Set up a field definition
    LibUtilities::FieldDefinitionsSharedPtr fielddef =
        MemoryManager<LibUtilities::FieldDefinitions>::AllocateSharedPtr();
    fielddef->m_shapeType    = LibUtilities::eQuadrilateral;
    fielddef->m_homoStrips   = false;
    fielddef->m_pointsDef    = false;
    fielddef->m_uniOrder     = true;
    fielddef->m_numPointsDef = false;
 
    // Set up basis
    fielddef->m_basis.push_back(LibUtilities::eGLL_Lagrange);
    fielddef->m_basis.push_back(LibUtilities::eGLL_Lagrange);
    fielddef->m_numModes.push_back(nr);
    fielddef->m_numModes.push_back(nr);
 
    // Set up elements
    fielddef->m_elementIDs.resize(nelmt);
    for (int i = 0; i < nelmt; ++i)
    {
        fielddef->m_elementIDs[i] = i;
    }
 
    // Deal with homogeneous direction.
    if (nz > 1)
    {
        fielddef->m_numHomogeneousDir = 1;
        fielddef->m_homogeneousLengths.push_back(2 * M_PI / beta);
        fielddef->m_numModes.push_back(nz);
        fielddef->m_basis.push_back(LibUtilities::eFourier);
 
        for (int i = 0; i < nz; ++i)
        {
            fielddef->m_homogeneousZIDs.push_back(i);
        }
    }
    else
    {
        fielddef->m_numHomogeneousDir = 0;
    }
 
    for (string::size_type i = 0; i < fields.size(); ++i)
    {
        fielddef->m_fields.push_back(string(&fields[i], 1));
    }
 
    // Size of data to read.
    size_t elmtSize  = nr * ns;
    size_t planeSize = elmtSize * nelmt;
    size_t fieldSize = planeSize * nz;
    size_t dataSize  = fieldSize * fields.size();
 
    // Allocate our storage.
    m_f->m_data.resize(1);
    m_f->m_data[0].resize(dataSize);
 
    // Temporary storage for one plane of data.
    vector<NekDouble> tmp(planeSize);
    size_t offset = nz * nr * ns;
 
    // Now reorder data; Semtex ordering traverses memory fastest over planes,
    // whereas Nektar++ expects it over elements
    for (int i = 0; i < fields.size(); ++i)
    {
        NekDouble *data = &m_f->m_data[0][i * fieldSize];
        for (int j = 0; j < nz; ++j)
        {
            size_t elSizeJ = j * elmtSize;
            file.read((char *)&tmp[0], planeSize * sizeof(NekDouble));
 
            if (byteSwap)
            {
                swap_endian(tmp);
            }
 
            double *x = &tmp[0];
            for (int k = 0; k < nelmt; ++k)
            {
                std::copy(x, x + elmtSize, data + k * offset + elSizeJ);
                x += elmtSize;
            }
        }
    }
 
    m_f->m_fielddef.push_back(fielddef);
 
    // save field names
    m_f->m_variables = m_f->m_fielddef[0]->m_fields;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::beta, CellMLToNektar.pycml::copy(), Nektar::LibUtilities::eEndianBig, Nektar::LibUtilities::eEndianLittle, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::Endianness(), Nektar::LibUtilities::eQuadrilateral, Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, and Nektar::FieldUtils::swap_endian().

Member Data Documentation

m_className

ModuleKey Nektar::FieldUtils::InputSemtex::m_className

static

Initial value:

= {
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eInputModule, "fldsem"), InputSemtex::create,
        "Reads Semtex field file.")}

ModuleKey for class.

Definition at line 60 of file InputSemtex.h.