Nektar::FieldUtils::InputNek5000 Class Reference

#include <InputNek5000.h>

Inheritance diagram for Nektar::FieldUtils::InputNek5000:

Public Member Functions
	InputNek5000 (FieldSharedPtr f)
	Set up InputNek5000 object. More...
	~InputNek5000 () override
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 ()
std::vector< ModuleKey >	GetModulePrerequisites ()
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
void	v_Process (po::variables_map &vm) override
	Process Nek5000 input file. More...
std::string	v_GetModuleName () override
std::string	v_GetModuleDescription () override
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 ()
virtual std::vector< ModuleKey >	v_GetModulePrerequisites ()

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 46 of file InputNek5000.h.

Constructor & Destructor Documentation

InputNek5000()

Nektar::FieldUtils::InputNek5000::InputNek5000

(

FieldSharedPtr

f

)

Set up InputNek5000 object.

Definition at line 57 of file InputNek5000.cpp.

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

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

~InputNek5000()

Nektar::FieldUtils::InputNek5000::~InputNek5000 ( )

override

Definition at line 65 of file InputNek5000.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 53 of file InputNek5000.h.

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

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

v_GetModuleDescription()

std::string Nektar::FieldUtils::InputNek5000::v_GetModuleDescription ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 68 of file InputNek5000.h.

    {
        return "Processing Nek5000 field file";
    }

v_GetModuleName()

std::string Nektar::FieldUtils::InputNek5000::v_GetModuleName ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 63 of file InputNek5000.h.

    {
        return "InputNek5000";
    }

v_GetModulePriority()

ModulePriority Nektar::FieldUtils::InputNek5000::v_GetModulePriority ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 73 of file InputNek5000.h.

    {
        return eCreateFieldData;
    }

References Nektar::FieldUtils::eCreateFieldData.

v_Process()

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

overrideprotectedvirtual

Process Nek5000 input file.

This routine reads a binary-format Nek5000 field file, loads the data into memory and populates the field definitions to match the data format. Nek5000 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.

This module is adapted from the VisIt visualisation software, which supports a number of Nek5000 inputs.

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 80 of file InputNek5000.cpp.

{
    ifstream file(m_config["infile"].as<string>().c_str(), ios::binary);
 
    // Header: 132 bytes for binary.
    vector<char> data(132);
    file.read(&data[0], 132);
 
    // Check header: should be the four characters #std
    string check(&data[0], 4);
    string header(&data[4], 128);
 
    ASSERTL0(check == "#std", "Unable to read file");
 
    // Determine whether we need to byte-swap data: 4-byte float at byte 80
    // should be 6.54321.
    bool byteSwap = false;
    float test;
 
    file.read((char *)(&test), 4);
    if (test > 6.5 && test < 6.6)
    {
        byteSwap = false;
    }
    else
    {
        swap_endian(test);
        ASSERTL0(test > 6.5 && test < 6.6,
                 "Unable to determine endian-ness of input file");
        byteSwap = true;
    }
 
    stringstream ss;
    ss.str(header);
 
    int nBytes, nBlocksXYZ[3], nBlocks, nTotBlocks, dir, nDirs, nCycle, nDim;
    NekDouble time;
 
    // Read header information (this is written as ASCII)
    string remain;
    ss >> nBytes >> nBlocksXYZ[0] >> nBlocksXYZ[1] >> nBlocksXYZ[2] >>
        nBlocks >> nTotBlocks >> time >> nCycle >> dir >> nDirs >> remain;
    boost::trim(remain);
 
    nDim = nBlocksXYZ[2] == 1 ? 2 : 3;
 
    // Print some basic information for input if in verbose mode.
    if (m_f->m_verbose)
    {
        cout << "Found header information:" << endl;
        cout << " -- " << (byteSwap ? "" : "do not ") << "need to swap endian"
             << endl;
        cout << " -- Data byte size       : " << nBytes << endl;
        cout << " -- Number of xyz blocks : " << nBlocksXYZ[0] << "x"
             << nBlocksXYZ[1] << "x" << nBlocksXYZ[2] << endl;
        cout << " -- Blocks in file/total : " << nBlocks << "/" << nTotBlocks
             << endl;
        cout << " -- Simulation time      : " << time << endl;
        cout << " -- Number of cycles     : " << nCycle << endl;
        cout << " -- Number of dirs       : " << dir << "/" << nDirs << endl;
        cout << " -- Remaining header     : " << remain << endl;
    }
 
    // Major limitation: we don't read out of multiple directories
    ASSERTL0(nDirs == 1, "Number of directories must be one");
 
    // We also don't read partial files.
    ASSERTL0(nBlocks == nTotBlocks, "Partial field output not supported");
 
    // We don't support non-double data
    ASSERTL0(nBytes == 8, "Data file must contain double-precision data");
 
    // Set up a field definition
    LibUtilities::FieldDefinitionsSharedPtr fielddef =
        MemoryManager<LibUtilities::FieldDefinitions>::AllocateSharedPtr();
    fielddef->m_shapeType         = LibUtilities::eHexahedron;
    fielddef->m_numHomogeneousDir = 0;
    fielddef->m_homoStrips        = false;
    fielddef->m_pointsDef         = false;
    fielddef->m_uniOrder          = true;
    fielddef->m_numPointsDef      = false;
 
    for (int i = 0; i < nDim; ++i)
    {
        fielddef->m_basis.push_back(LibUtilities::eGLL_Lagrange);
        fielddef->m_numModes.push_back(nBlocksXYZ[i]);
    }
 
    // Read element IDs
    NekUInt32 maxID = 0, minID = numeric_limits<NekUInt32>::max();
    for (NekUInt32 i = 0; i < nBlocks; ++i)
    {
        NekUInt32 blockNum;
        file.read((char *)&blockNum, 4);
        if (byteSwap)
        {
            swap_endian(blockNum);
        }
        fielddef->m_elementIDs.push_back(blockNum - 1);
 
        maxID = maxID > blockNum ? maxID : blockNum;
        minID = minID < blockNum ? minID : blockNum;
    }
 
    // Determine how many fields we have to extract
    size_t blockSize = nBlocksXYZ[0] * nBlocksXYZ[1] * nBlocksXYZ[2];
    size_t dataSize  = blockSize * nBlocks;
 
    for (string::size_type i = 0; i < remain.size(); ++i)
    {
        switch (remain[i])
        {
            case 'U':
                fielddef->m_fields.push_back("u");
                fielddef->m_fields.push_back("v");
                if (nDim == 3)
                {
                    fielddef->m_fields.push_back("w");
                }
                break;
            case 'P':
                fielddef->m_fields.push_back("p");
                break;
            case 'T':
                fielddef->m_fields.push_back("T");
                break;
            case '1':
            case '2':
            case '3':
                fielddef->m_fields.push_back(string("scalar") + remain[i]);
                break;
            case ' ':
                continue;
            default:
                cerr << "Field contains unknown variable: " << remain[i]
                     << endl;
                abort();
        }
    }
 
    m_f->m_data.resize(1);
    m_f->m_data[0].resize(fielddef->m_fields.size() * dataSize);
 
    // Now reprocess since different fields need different logic
    for (size_t i = 0, cnt = 0; i < remain.size(); ++i)
    {
        switch (remain[i])
        {
            case 'U':
            {
                size_t cntVel[3] = {cnt, cnt + dataSize, cnt + 2 * dataSize};
 
                for (size_t j = 0; j < nBlocks; ++j)
                {
                    for (size_t k = 0; k < nDim; ++k)
                    {
                        file.read((char *)&m_f->m_data[0][cntVel[k]],
                                  blockSize * sizeof(NekDouble));
                        cntVel[k] += blockSize;
                    }
                }
 
                cnt += nDim * dataSize;
                break;
            }
            case 'P':
            {
                file.read((char *)&m_f->m_data[0][cnt],
                          dataSize * sizeof(NekDouble));
                cnt += dataSize;
                break;
            }
            case '1':
            case '2':
            case '3':
            {
                file.read((char *)&m_f->m_data[0][cnt],
                          dataSize * sizeof(NekDouble));
                cnt += dataSize;
                break;
            }
            case ' ':
                continue;
        }
    }
 
    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::eGLL_Lagrange, Nektar::LibUtilities::eHexahedron, Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, Nektar::FieldUtils::swap_endian(), and Nektar::UnitTests::test().

Member Data Documentation

m_className

ModuleKey Nektar::FieldUtils::InputNek5000::m_className

static

Initial value:

= {
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eInputModule, "fld5000"), InputNek5000::create,
        "Reads Nek5000 field file.")}

ModuleKey for class.

Definition at line 58 of file InputNek5000.h.