#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< std::vector< MultiRegions::ExpListSharedPtr > > >	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 59 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.

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 55 of file Core/SessionFunction.cpp.

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

References ASSERTL0, m_name, and m_session.

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 214 of file Core/SessionFunction.cpp.

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

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

◆ 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.

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 74 of file Core/SessionFunction.cpp.

{
    std::vector<std::string> vFieldNames = m_session->GetVariables();
 
    for (int i = 0; i < vFieldNames.size(); i++)
    {
        Evaluate(vFieldNames[i], pArray[i], pTime, domain);
    }
}

References Evaluate(), and m_session.

Referenced by Evaluate().

◆ Evaluate() [2/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 148 of file Core/SessionFunction.cpp.

{
    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.size() < 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 (fs::path(filename).extension() == ".pts" ||
            fs::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;
    }
}

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().

◆ Evaluate() [3/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.

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 94 of file Core/SessionFunction.cpp.

{
    ASSERTL1(pFieldNames.size() == pArray.size(),
             "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);
    }
}

References ASSERTL1, Evaluate(), and m_name.

◆ Evaluate() [4/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.

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 117 of file Core/SessionFunction.cpp.

{
    ASSERTL0(pFieldNames.size() == pFields.size(),
             "Field list / name list size mismatch.");
 
    for (int i = 0; i < pFieldNames.size(); i++)
    {
        Evaluate(pFieldNames[i], pFields[i]->UpdatePhys(), pTime, domain);
        if (pFields[i]->GetWaveSpace())
        {
            pFields[i]->HomogeneousFwdTrans(pFields[i]->GetTotPoints(),
                                            pFields[i]->GetPhys(),
                                            pFields[i]->UpdatePhys());
        }
        pFields[i]->FwdTransLocalElmt(pFields[i]->GetPhys(),
                                      pFields[i]->UpdateCoeffs());
    }
}

References ASSERTL0, and Evaluate().

◆ 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 249 of file Core/SessionFunction.cpp.

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.size() < 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);
}

References m_field, m_name, and m_session.

Referenced by Evaluate().

◆ 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 280 of file Core/SessionFunction.cpp.

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.size() < 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
        {
            std::cout << "Field " + fileVar + " not found." << std::endl;
        }
    }
 
    bool wavespace = m_field->GetWaveSpace();
    m_field->SetWaveSpace(false);
    m_field->BwdTrans(vCoeffs, pArray);
    m_field->SetWaveSpace(wavespace);
}

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().

◆ 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 381 of file Core/SessionFunction.cpp.

{
    unsigned int nq = m_field->GetNpoints();
    if (pArray.size() < 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 (fs::path(filename).extension() == ".pts")
    {
        LibUtilities::PtsIO ptsIO(m_session->GetComm());
        ptsIO.Import(filename, inPts);
    }
    else if (fs::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<std::vector<MultiRegions::ExpListSharedPtr>>
        interp;
    if (m_interpolators.find(funcFilename) != m_interpolators.end())
    {
        interp = m_interpolators[funcFilename];
    }
    else
    {
        interp = FieldUtils::Interpolator<
            std::vector<MultiRegions::ExpListSharedPtr>>(
            LibUtilities::eShepard);
        if (m_session->GetComm()->GetRank() == 0)
        {
            interp.SetProgressCallback(&SessionFunction::PrintProgressbar,
                                       this);
        }
        interp.CalcWeights(inPts, outPts);
        if (m_session->GetComm()->GetRank() == 0)
        {
            std::cout << std::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;
    std::vector<std::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());
}

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

Referenced by Evaluate().

◆ GetExpansion()

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

inline

Definition at line 104 of file SessionFunction.h.

    {
        return m_field;
    }

References m_field.

◆ GetSession()

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

inline

Definition at line 99 of file SessionFunction.h.

    {
        return m_session;
    }

References m_session.

◆ PrintProgressbar()

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

inlineprivate

Definition at line 145 of file SessionFunction.h.

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

References Nektar::LibUtilities::PrintProgressbar().

Referenced by EvaluatePts().

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 125 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 113 of file SessionFunction.h.

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

◆ m_interpolators

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

private

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

Definition at line 123 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 119 of file SessionFunction.h.

Referenced by Evaluate().

◆ m_name

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

private

Definition at line 115 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 111 of file SessionFunction.h.

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

◆ m_toCache

bool Nektar::SolverUtils::SessionFunction::m_toCache

private

Store resulting arrays (and interpolators)

Definition at line 117 of file SessionFunction.h.

Referenced by Evaluate(), and EvaluatePts().

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SessionFunction()

Member Function Documentation

◆ Describe()

◆ Evaluate() [1/4]

◆ Evaluate() [2/4]

◆ Evaluate() [3/4]

◆ Evaluate() [4/4]

◆ EvaluateExp()

◆ EvaluateFld()

◆ EvaluatePts()

◆ GetExpansion()

◆ GetSession()

◆ PrintProgressbar()

Member Data Documentation

◆ m_arrays

◆ m_field

◆ m_interpolators

◆ m_lastCached

◆ m_name

◆ m_session

◆ m_toCache