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 ()
virtual void	Process (po::variables_map &vm)
	Process Semtex input file. More...
virtual std::string	GetModuleName ()
virtual std::string	GetModuleDescription ()
virtual ModulePriority	GetModulePriority ()
Public Member Functions inherited from Nektar::FieldUtils::InputModule
	InputModule (FieldSharedPtr p_m)
FIELD_UTILS_EXPORT void	AddFile (std::string fileType, std::string fileName)
Public Member Functions inherited from Nektar::FieldUtils::Module
FIELD_UTILS_EXPORT	Module (FieldSharedPtr p_f)
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	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...

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
std::set< std::string >	m_allowedFiles
Protected Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...
std::map< std::string, ConfigOption >	m_config
	List of configuration values. 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 63 of file InputSemtex.cpp.

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

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

~InputSemtex()

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

virtual

Definition at line 71 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 56 of file InputSemtex.h.

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

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

GetModuleDescription()

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

inlinevirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 68 of file InputSemtex.h.

    {
        return "Processing Semtex field file";
    }

GetModuleName()

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

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 63 of file InputSemtex.h.

    {
        return "InputSemtex";
    }

GetModulePriority()

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

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 73 of file InputSemtex.h.

References Nektar::FieldUtils::eCreateFieldData.

    {
        return eCreateFieldData;
    }

Process()

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

virtual

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.

Implements Nektar::FieldUtils::Module.

Definition at line 83 of file InputSemtex.cpp.

References ASSERTL0, 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().

{
    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;
}

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 61 of file InputSemtex.h.