Nektar::SolverUtils::SessionFunction Class Reference

#include <SessionFunction.h>

Public Member Functions
SOLVER_UTILS_EXPORT	SessionFunction (const LibUtilities::SessionReaderSharedPtr &session, const MultiRegions::ExpListSharedPtr &field, std::string functionName, bool toCache=false)
	Representation of a FUNCTION defined in the session xml file. More...
SOLVER_UTILS_EXPORT void	Evaluate (Array< OneD, Array< OneD, NekDouble > > &pArray, const NekDouble pTime=0.0, const int domain=0)
	Evaluates a function defined in the xml session file at each quadrature point. More...
SOLVER_UTILS_EXPORT void	Evaluate (std::vector< std::string > pFieldNames, Array< OneD, Array< OneD, NekDouble > > &pArray, const NekDouble &pTime=0.0, const int domain=0)
	Evaluates a function defined in the xml session file at each quadrature point. More...
SOLVER_UTILS_EXPORT void	Evaluate (std::vector< std::string > pFieldNames, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &pTime=0.0, const int domain=0)
	Evaluates a function defined in the xml session file at each quadrature point. More...
SOLVER_UTILS_EXPORT void	Evaluate (std::string pFieldName, Array< OneD, NekDouble > &pArray, const NekDouble &pTime=0.0, const int domain=0)
SOLVER_UTILS_EXPORT std::string	Describe (std::string pFieldName, const int domain=0)
	Provide a description of a function for a given field name. More...
SOLVER_UTILS_EXPORT const LibUtilities::SessionReaderSharedPtr &	GetSession ()
SOLVER_UTILS_EXPORT const MultiRegions::ExpListSharedPtr &	GetExpansion ()

Private Member Functions
SOLVER_UTILS_EXPORT void	EvaluateExp (std::string pFieldName, Array< OneD, NekDouble > &pArray, const NekDouble &pTime=0.0, const int domain=0)
SOLVER_UTILS_EXPORT void	EvaluateFld (std::string pFieldName, Array< OneD, NekDouble > &pArray, const NekDouble &pTime=0.0, const int domain=0)
SOLVER_UTILS_EXPORT void	EvaluatePts (std::string pFieldName, Array< OneD, NekDouble > &pArray, const NekDouble &pTime=0.0, const int domain=0)
	Evaluates a function from pts file. More...
SOLVER_UTILS_EXPORT void	PrintProgressbar (const int position, const int goal) const

Private Attributes
LibUtilities::SessionReaderSharedPtr	m_session
	The session reader. More...
MultiRegions::ExpListSharedPtr	m_field
	The expansion we want to evaluate this function for. More...
std::string	m_name
bool	m_toCache
	Store resulting arrays (and interpolators) More...
std::map< std::pair< std::string, int >, NekDouble >	m_lastCached
	Last time the cache for this variable & domain combo was updated. More...
std::map< std::string, FieldUtils::Interpolator >	m_interpolators
	Interpolator for pts file input for a variable & domain combination. More...
std::map< std::pair< std::string, int >, Array< OneD, NekDouble > >	m_arrays
	Cached result arrays. More...

Detailed Description

Definition at line 60 of file SessionFunction.h.

Constructor & Destructor Documentation

SessionFunction()

Nektar::SolverUtils::SessionFunction::SessionFunction	(	const LibUtilities::SessionReaderSharedPtr &	session,
		const MultiRegions::ExpListSharedPtr &	field,
		std::string	functionName,
		bool	toCache = false
	)

Representation of a FUNCTION defined in the session xml file.

Representation of a FUNCTION defined in the session xml file.

Parameters

session	The session where the function was defined.
field	The field the function is defined on.
functionName	The name of the function.
toCache	Store the evaluated function for later use.

Definition at line 58 of file SessionFunction.cpp.

References ASSERTL0, m_name, and m_session.

    : m_session(session), m_field(field), m_name(functionName), m_toCache(toCache)
{
    ASSERTL0(m_session->DefinesFunction(m_name),
             "Function '" + m_name + "' does not exist.");
}

Member Function Documentation

Describe()

std::string Nektar::SolverUtils::SessionFunction::Describe	(	std::string	pFieldName,
		const int	domain = 0
	)

Provide a description of a function for a given field name.

Parameters

pFieldName	Field name.
domain	The domain to evaluate the function in.

Definition at line 210 of file SessionFunction.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, m_name, and m_session.

{
    std::string retVal;

    LibUtilities::FunctionType vType =
        m_session->GetFunctionType(m_name, pFieldName, domain);
    if (vType == LibUtilities::eFunctionTypeExpression)
    {
        LibUtilities::EquationSharedPtr ffunc =
            m_session->GetFunction(m_name, pFieldName, domain);
        retVal = ffunc->GetExpression();
    }
    else if (vType == LibUtilities::eFunctionTypeFile ||
             vType == LibUtilities::eFunctionTypeTransientFile)
    {
        std::string filename =
            m_session->GetFunctionFilename(m_name, pFieldName, domain);
        retVal = "from file " + filename;
    }
    else
    {
        ASSERTL0(false, "unknown eFunctionType");
    }

    return retVal;
}

Evaluate() [1/4]

void Nektar::SolverUtils::SessionFunction::Evaluate	(	Array< OneD, Array< OneD, NekDouble > > &	pArray,
		const NekDouble	pTime = 0.0,
		const int	domain = 0
	)

Evaluates a function defined in the xml session file at each quadrature point.

Evaluates a function defined in the xml session file at each quadrature point.

Parameters

pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 75 of file SessionFunction.cpp.

References m_session.

Referenced by Evaluate().

{
    std::vector<std::string> vFieldNames = m_session->GetVariables();

    for (int i = 0; i < vFieldNames.size(); i++)
    {
        Evaluate(vFieldNames[i], pArray[i], pTime, domain);
    }
}

Evaluate() [2/4]

void Nektar::SolverUtils::SessionFunction::Evaluate	(	std::vector< std::string >	pFieldNames,
		Array< OneD, Array< OneD, NekDouble > > &	pArray,
		const NekDouble &	pTime = 0.0,
		const int	domain = 0
	)

Evaluates a function defined in the xml session file at each quadrature point.

Evaluates a function defined in the xml session file at each quadrature point.

Parameters

pFieldNames	The names of the fields to evaluate the function for.
pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 95 of file SessionFunction.cpp.

References ASSERTL1, Evaluate(), and m_name.

{
    ASSERTL1(pFieldNames.size() == pArray.num_elements(),
             "Function '" + m_name +
             "' variable list size mismatch with array storage.");

    for (int i = 0; i < pFieldNames.size(); i++)
    {
        Evaluate(pFieldNames[i], pArray[i], pTime, domain);
    }
}

Evaluate() [3/4]

void Nektar::SolverUtils::SessionFunction::Evaluate	(	std::vector< std::string >	pFieldNames,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	pTime = 0.0,
		const int	domain = 0
	)

Evaluates a function defined in the xml session file at each quadrature point.

Evaluates a function defined in the xml session file at each quadrature point.

Parameters

pFieldNames	The names of the fields to evaluate the function for.
pFields	The fields into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 118 of file SessionFunction.cpp.

References ASSERTL0, and Evaluate().

{
    ASSERTL0(pFieldNames.size() == pFields.num_elements(),
             "Field list / name list size mismatch.");

    for (int i = 0; i < pFieldNames.size(); i++)
    {
        Evaluate(pFieldNames[i], pFields[i]->UpdatePhys(), pTime, domain);
        pFields[i]->FwdTrans_IterPerExp(pFields[i]->GetPhys(),
                                        pFields[i]->UpdateCoeffs());
    }
}

Evaluate() [4/4]

void Nektar::SolverUtils::SessionFunction::Evaluate	(	std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const NekDouble &	pTime = 0.0,
		const int	domain = 0
	)

Evaluates a function defined in the xml session file at each quadrature point.

Parameters

pFieldName	The name of the field to evaluate the function for.
pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 143 of file SessionFunction.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, EvaluateExp(), EvaluateFld(), EvaluatePts(), Nektar::NekConstants::kNekZeroTol, m_arrays, m_field, m_lastCached, m_name, m_session, m_toCache, and Vmath::Vcopy().

{
    LibUtilities::FunctionType vType =
        m_session->GetFunctionType(m_name, pFieldName, domain);

    unsigned int nq = m_field->GetNpoints();

    std::pair<std::string, int> key(pFieldName, domain);
    // sorry
    if ((m_arrays.find(key) != m_arrays.end()) &&
            (vType == LibUtilities::eFunctionTypeFile ||
             ((m_lastCached.find(key) != m_lastCached.end()) &&
              (pTime - m_lastCached[key] < NekConstants::kNekZeroTol))))
    {
        // found cached field
        if (pArray.num_elements() < nq)
        {
            pArray = Array<OneD, NekDouble>(nq);
        }
        Vmath::Vcopy(nq, m_arrays[key], 1, pArray, 1);

        return;
    }

    if (vType == LibUtilities::eFunctionTypeExpression)
    {
        EvaluateExp(pFieldName, pArray, pTime, domain);
    }
    else if (vType == LibUtilities::eFunctionTypeFile ||
             vType == LibUtilities::eFunctionTypeTransientFile)
    {
        std::string filename =
            m_session->GetFunctionFilename(m_name, pFieldName, domain);

        if (boost::filesystem::path(filename).extension() == ".pts" ||
            boost::filesystem::path(filename).extension() == ".csv")
        {
            EvaluatePts(pFieldName, pArray, pTime, domain);
        }
        else
        {
            EvaluateFld(pFieldName, pArray, pTime, domain);
        }
    }
    else
    {
        ASSERTL0(false, "unknown eFunctionType");
    }

    if (m_toCache)
    {
        m_arrays[key] = Array<OneD, NekDouble>(nq);
        Vmath::Vcopy(nq, pArray, 1, m_arrays[key], 1);

        m_lastCached[key] = pTime;
    }
}

EvaluateExp()

void Nektar::SolverUtils::SessionFunction::EvaluateExp ( std::string  pFieldName, Array< OneD, NekDouble > &  pArray, const NekDouble &  pTime = 0.0, const int  domain = 0  )

private

Evaluates a function from expression

Parameters

pFieldName	The name of the field to evaluate the function for.
pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 245 of file SessionFunction.cpp.

References m_field, m_name, and m_session.

Referenced by Evaluate().

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.num_elements() < nq)
    {
        pArray = Array<OneD, NekDouble>(nq);
    }

    Array<OneD, NekDouble> x0(nq);
    Array<OneD, NekDouble> x1(nq);
    Array<OneD, NekDouble> x2(nq);

    // Get the coordinates (assuming all fields have the same
    // discretisation)
    m_field->GetCoords(x0, x1, x2);
    LibUtilities::EquationSharedPtr ffunc =
        m_session->GetFunction(m_name, pFieldName, domain);

    ffunc->Evaluate(x0, x1, x2, pTime, pArray);
}

EvaluateFld()

void Nektar::SolverUtils::SessionFunction::EvaluateFld ( std::string  pFieldName, Array< OneD, NekDouble > &  pArray, const NekDouble &  pTime = 0.0, const int  domain = 0  )

private

Evaluates a function from fld file

Parameters

pFieldName	The name of the field to evaluate the function for.
pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 277 of file SessionFunction.cpp.

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::LibUtilities::eFunctionTypeTransientFile, CellMLToNektar.pycml::format, m_field, m_name, m_session, and Nektar::LibUtilities::NullFieldMetaDataMap.

Referenced by Evaluate().

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.num_elements() < nq)
    {
        pArray = Array<OneD, NekDouble>(nq);
    }

    std::string filename =
        m_session->GetFunctionFilename(m_name, pFieldName, domain);
    std::string fileVar =
        m_session->GetFunctionFilenameVariable(m_name, pFieldName, domain);

    if (fileVar.length() == 0)
    {
        fileVar = pFieldName;
    }

    //  In case of eFunctionTypeTransientFile, generate filename from
    //  format string
    LibUtilities::FunctionType vType =
        m_session->GetFunctionType(m_name, pFieldName, domain);
    if (vType == LibUtilities::eFunctionTypeTransientFile)
    {
        try
        {
#if (defined _WIN32 && _MSC_VER < 1900)
            // We need this to make sure boost::format has always
            // two digits in the exponents of Scientific notation.
            unsigned int old_exponent_format;
            old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT);
            filename            = boost::str(boost::format(filename) % pTime);
            _set_output_format(old_exponent_format);
#else
            filename = boost::str(boost::format(filename) % pTime);
#endif
        }
        catch (...)
        {
            ASSERTL0(false,
                     "Invalid Filename in function \"" + m_name +
                     "\", variable \"" + fileVar + "\"")
        }
    }

    // Define list of global element ids
    int numexp = m_field->GetExpSize();
    Array<OneD, int> ElementGIDs(numexp);
    for (int i = 0; i < numexp; ++i)
    {
        ElementGIDs[i] = m_field->GetExp(i)->GetGeom()->GetGlobalID();
    }

    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble> > FieldData;
    LibUtilities::FieldIOSharedPtr fldIO =
        LibUtilities::FieldIO::CreateForFile(m_session, filename);
    fldIO->Import(filename,
                  FieldDef,
                  FieldData,
                  LibUtilities::NullFieldMetaDataMap,
                  ElementGIDs);

    int idx = -1;
    Array<OneD, NekDouble> vCoeffs(m_field->GetNcoeffs(), 0.0);
    // Loop over all the expansions
    for (int i = 0; i < FieldDef.size(); ++i)
    {
        // Find the index of the required field in the
        // expansion segment
        for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
        {
            if (FieldDef[i]->m_fields[j] == fileVar)
            {
                idx = j;
            }
        }

        if (idx >= 0)
        {
            m_field->ExtractDataToCoeffs(
                FieldDef[i], FieldData[i], FieldDef[i]->m_fields[idx], vCoeffs);
        }
        else
        {
            cout << "Field " + fileVar + " not found." << endl;
        }
    }

    m_field->BwdTrans_IterPerExp(vCoeffs, pArray);
}

EvaluatePts()

void Nektar::SolverUtils::SessionFunction::EvaluatePts ( std::string  pFieldName, Array< OneD, NekDouble > &  pArray, const NekDouble &  pTime = 0.0, const int  domain = 0  )

private

Evaluates a function from pts file.

Evaluates a function from pts file

Parameters

pFieldName	The name of the field to evaluate the function for.
pArray	The array into which to write the values.
pTime	The time at which to evaluate the function.
domain	The domain to evaluate the function in.

Definition at line 380 of file SessionFunction.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::eFunctionTypeTransientFile, Nektar::LibUtilities::eShepard, CellMLToNektar.pycml::format, Nektar::LibUtilities::PtsIO::Import(), m_field, m_interpolators, m_name, m_session, m_toCache, and PrintProgressbar().

Referenced by Evaluate().

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.num_elements() < nq)
    {
        pArray = Array<OneD, NekDouble>(nq);
    }

    std::string filename =
        m_session->GetFunctionFilename(m_name, pFieldName, domain);
    std::string fileVar =
        m_session->GetFunctionFilenameVariable(m_name, pFieldName, domain);

    if (fileVar.length() == 0)
    {
        fileVar = pFieldName;
    }

    //  In case of eFunctionTypeTransientFile, generate filename from
    //  format string
    LibUtilities::FunctionType vType =
        m_session->GetFunctionType(m_name, pFieldName, domain);
    if (vType == LibUtilities::eFunctionTypeTransientFile)
    {
        try
        {
#if (defined _WIN32 && _MSC_VER < 1900)
            // We need this to make sure boost::format has always
            // two digits in the exponents of Scientific notation.
            unsigned int old_exponent_format;
            old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT);
            filename            = boost::str(boost::format(filename) % pTime);
            _set_output_format(old_exponent_format);
#else
            filename = boost::str(boost::format(filename) % pTime);
#endif
        }
        catch (...)
        {
            ASSERTL0(false,
                     "Invalid Filename in function \"" + m_name +
                     "\", variable \"" + fileVar + "\"")
        }
    }

    LibUtilities::PtsFieldSharedPtr outPts;
    // check if we already loaded this file. For transient files,
    // funcFilename != filename so we can make sure we only keep the
    // latest pts field per funcFilename.
    std::string funcFilename =
        m_session->GetFunctionFilename(m_name, pFieldName, domain);

    LibUtilities::PtsFieldSharedPtr inPts;
    if (boost::filesystem::path(filename).extension() == ".pts")
    {
        LibUtilities::PtsIO ptsIO(m_session->GetComm());
        ptsIO.Import(filename, inPts);
    }
    else if (boost::filesystem::path(filename).extension() == ".csv")
    {
        LibUtilities::CsvIO csvIO(m_session->GetComm());
        csvIO.Import(filename, inPts);
    }
    else
    {
        ASSERTL1(false, "Unsupported file type");
    }


    Array<OneD, Array<OneD, NekDouble> > pts(inPts->GetDim() +
            inPts->GetNFields());
    for (int i = 0; i < inPts->GetDim() + inPts->GetNFields(); ++i)
    {
        pts[i] = Array<OneD, NekDouble>(nq);
    }
    if (inPts->GetDim() == 1)
    {
        m_field->GetCoords(pts[0]);
    }
    else if (inPts->GetDim() == 2)
    {
        m_field->GetCoords(pts[0], pts[1]);
    }
    else if (inPts->GetDim() == 3)
    {
        m_field->GetCoords(pts[0], pts[1], pts[2]);
    }
    outPts = MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 inPts->GetDim(), inPts->GetFieldNames(), pts);

    FieldUtils::Interpolator interp;
    if (m_interpolators.find(funcFilename) != m_interpolators.end())
    {
        interp = m_interpolators[funcFilename];
    }
    else
    {
        interp = FieldUtils::Interpolator(LibUtilities::eShepard);
        if (m_session->GetComm()->GetRank() == 0)
        {
            interp.SetProgressCallback(&SessionFunction::PrintProgressbar,
                                       this);
        }
        interp.CalcWeights(inPts, outPts);
        if (m_session->GetComm()->GetRank() == 0)
        {
            cout << endl;
            if (m_session->DefinesCmdLineArgument("verbose"))
            {
                interp.PrintStatistics();
            }
        }
    }

    if (m_toCache)
    {
        m_interpolators[funcFilename] = interp;
    }

    // TODO: only interpolate the field we actually want
    interp.Interpolate(inPts, outPts);

    int fieldInd;
    vector<string> fieldNames = outPts->GetFieldNames();
    for (fieldInd = 0; fieldInd < fieldNames.size(); ++fieldInd)
    {
        if (outPts->GetFieldName(fieldInd) == fileVar)
        {
            break;
        }
    }
    ASSERTL0(fieldInd != fieldNames.size(), "field not found");

    pArray = outPts->GetPts(fieldInd + outPts->GetDim());
}

GetExpansion()

SOLVER_UTILS_EXPORT const MultiRegions::ExpListSharedPtr& Nektar::SolverUtils::SessionFunction::GetExpansion ( )

inline

Definition at line 105 of file SessionFunction.h.

    {
        return m_field;
    }

GetSession()

SOLVER_UTILS_EXPORT const LibUtilities::SessionReaderSharedPtr& Nektar::SolverUtils::SessionFunction::GetSession ( )

inline

Definition at line 100 of file SessionFunction.h.

    {
        return m_session;
    }

PrintProgressbar()

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::SessionFunction::PrintProgressbar ( const int  position, const int  goal  ) const

inlineprivate

Definition at line 144 of file SessionFunction.h.

References Nektar::LibUtilities::PrintProgressbar().

Referenced by EvaluatePts().

    {
        LibUtilities::PrintProgressbar(position, goal, "Interpolating");
    }

Member Data Documentation

m_arrays

std::map<std::pair<std::string, int>, Array<OneD, NekDouble> > Nektar::SolverUtils::SessionFunction::m_arrays

private

Cached result arrays.

Definition at line 124 of file SessionFunction.h.

Referenced by Evaluate().

m_field

MultiRegions::ExpListSharedPtr Nektar::SolverUtils::SessionFunction::m_field

private

The expansion we want to evaluate this function for.

Definition at line 114 of file SessionFunction.h.

Referenced by Evaluate(), EvaluateExp(), EvaluateFld(), and EvaluatePts().

m_interpolators

std::map<std::string, FieldUtils::Interpolator> Nektar::SolverUtils::SessionFunction::m_interpolators

private

Interpolator for pts file input for a variable & domain combination.

Definition at line 122 of file SessionFunction.h.

Referenced by EvaluatePts().

m_lastCached

std::map<std::pair<std::string, int>, NekDouble> Nektar::SolverUtils::SessionFunction::m_lastCached

private

Last time the cache for this variable & domain combo was updated.

Definition at line 120 of file SessionFunction.h.

Referenced by Evaluate().

m_name

std::string Nektar::SolverUtils::SessionFunction::m_name

private

Definition at line 116 of file SessionFunction.h.

Referenced by Describe(), Evaluate(), EvaluateExp(), EvaluateFld(), EvaluatePts(), and SessionFunction().

m_session

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::SessionFunction::m_session

private

The session reader.

Definition at line 112 of file SessionFunction.h.

Referenced by Describe(), Evaluate(), EvaluateExp(), EvaluateFld(), EvaluatePts(), and SessionFunction().

m_toCache

bool Nektar::SolverUtils::SessionFunction::m_toCache

private

Store resulting arrays (and interpolators)

Definition at line 118 of file SessionFunction.h.

Referenced by Evaluate(), and EvaluatePts().