Nektar::Collections::Helmholtz_MatrixFree Class Reference

Helmholtz operator using matrix free operators. More...

Inheritance diagram for Nektar::Collections::Helmholtz_MatrixFree:

Public Member Functions
	~Helmholtz_MatrixFree () final
void	operator() (const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output0, Array< OneD, NekDouble > &output1, Array< OneD, NekDouble > &output2, Array< OneD, NekDouble > &wsp) override final
	Perform operation. More...
void	operator() (int dir, const Array< OneD, const NekDouble > &input, Array< OneD, NekDouble > &output, Array< OneD, NekDouble > &wsp) override final
virtual void	CheckFactors (StdRegions::FactorMap factors, int coll_phys_offset) override
	Check the validity of the supplied factor map. More...
Public Member Functions inherited from Nektar::Collections::Operator
	Operator (std::vector< StdRegions::StdExpansionSharedPtr > pCollExp, std::shared_ptr< CoalescedGeomData > GeomData, StdRegions::FactorMap factors)
	Constructor. More...
virtual COLLECTIONS_EXPORT	~Operator ()
unsigned int	GetWspSize ()
	Get the size of the required workspace. More...
unsigned int	GetNumElmt ()
	Get expansion pointer. More...
StdRegions::StdExpansionSharedPtr	GetExpSharedPtr ()
	Get expansion pointer. More...

Private Member Functions
	Helmholtz_MatrixFree (vector< StdRegions::StdExpansionSharedPtr > pCollExp, CoalescedGeomDataSharedPtr pGeomData, StdRegions::FactorMap factors)
Private Member Functions inherited from Nektar::Collections::MatrixFreeOneInOneOut
	MatrixFreeOneInOneOut (const unsigned int nIn, const unsigned int nOut, const unsigned int nCollSize)
	Constructor. More...

Private Attributes
std::shared_ptr< MatrixFree::Helmholtz >	m_oper
unsigned int	m_nmtot
StdRegions::FactorMap	m_factors
Private Attributes inherited from Nektar::Collections::MatrixFreeOneInOneOut
Array< OneD, NekDouble >	m_input
	padded input/output vectors More...
Array< OneD, NekDouble >	m_output

Additional Inherited Members
Protected Attributes inherited from Nektar::Collections::Operator
bool	m_isDeformed
StdRegions::StdExpansionSharedPtr	m_stdExp
unsigned int	m_numElmt
unsigned int	m_nqe
unsigned int	m_wspSize

Detailed Description

Helmholtz operator using matrix free operators.

Definition at line 551 of file library/Collections/Helmholtz.cpp.

Constructor & Destructor Documentation

~Helmholtz_MatrixFree()

Nektar::Collections::Helmholtz_MatrixFree::~Helmholtz_MatrixFree ( )

inlinefinal

Definition at line 556 of file library/Collections/Helmholtz.cpp.

    {
    }

Helmholtz_MatrixFree()

Nektar::Collections::Helmholtz_MatrixFree::Helmholtz_MatrixFree ( vector< StdRegions::StdExpansionSharedPtr >  pCollExp, CoalescedGeomDataSharedPtr  pGeomData, StdRegions::FactorMap  factors  )

inlineprivate

Definition at line 678 of file library/Collections/Helmholtz.cpp.

        : Operator(pCollExp, pGeomData, factors),
          MatrixFreeOneInOneOut(pCollExp[0]->GetStdExp()->GetNcoeffs(),
                                pCollExp[0]->GetStdExp()->GetNcoeffs(),
                                pCollExp.size())
    {
 
        m_nmtot = m_numElmt * pCollExp[0]->GetStdExp()->GetNcoeffs();
 
        const auto dim = pCollExp[0]->GetStdExp()->GetShapeDimension();
 
        // Basis vector.
        std::vector<LibUtilities::BasisSharedPtr> basis(dim);
        for (auto i = 0; i < dim; ++i)
        {
            basis[i] = pCollExp[0]->GetBasis(i);
        }
 
        // Get shape type
        auto shapeType = pCollExp[0]->GetStdExp()->DetShapeType();
 
        // Generate operator string and create operator.
        std::string op_string = "Helmholtz";
        op_string += MatrixFree::GetOpstring(shapeType, m_isDeformed);
        auto oper = MatrixFree::GetOperatorFactory().CreateInstance(
            op_string, basis, m_nElmtPad);
 
        // Set Jacobian
        oper->SetJac(pGeomData->GetJacInterLeave(pCollExp, m_nElmtPad));
 
        // Store derivative factor
        oper->SetDF(pGeomData->GetDerivFactorsInterLeave(pCollExp, m_nElmtPad));
 
        m_oper = std::dynamic_pointer_cast<MatrixFree::Helmholtz>(oper);
        ASSERTL0(m_oper, "Failed to cast pointer.");
 
        // Set factors
        m_factors = StdRegions::NullFactorMap;
        this->CheckFactors(factors, 0);
    }

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::Collections::GetOperatorFactory(), and Nektar::StdRegions::NullFactorMap.

Member Function Documentation

CheckFactors()

virtual void Nektar::Collections::Helmholtz_MatrixFree::CheckFactors ( StdRegions::FactorMap  factors, int  coll_phys_offset  )

inlineoverridevirtual

Check the validity of the supplied factor map.

Implements Nektar::Collections::Operator.

Definition at line 592 of file library/Collections/Helmholtz.cpp.

    {
        boost::ignore_unused(coll_phys_offset);
 
        if (factors == m_factors)
        {
            return;
        }
 
        m_factors = factors;
 
        // Set lambda for this call
        auto x = factors.find(StdRegions::eFactorLambda);
        ASSERTL1(
            x != factors.end(),
            "Constant factor not defined: " +
                std::string(
                    StdRegions::ConstFactorTypeMap[StdRegions::eFactorLambda]));
        m_oper->SetLambda(x->second);
 
        // set constant diffusion coefficients
        bool isConstVarDiff         = false;
        Array<OneD, NekDouble> diff = Array<OneD, NekDouble>(6, 0.0);
        diff[0] = diff[2] = diff[5] = 1.0;
 
        auto xd00 = factors.find(StdRegions::eFactorCoeffD00);
        if (xd00 != factors.end() && xd00->second != 1.0)
        {
            isConstVarDiff = true;
            diff[0]        = xd00->second;
        }
 
        auto xd01 = factors.find(StdRegions::eFactorCoeffD01);
        if (xd01 != factors.end() && xd01->second != 0.0)
        {
            isConstVarDiff = true;
            diff[1]        = xd01->second;
        }
 
        auto xd11 = factors.find(StdRegions::eFactorCoeffD11);
        if (xd11 != factors.end() && xd11->second != 1.0)
        {
            isConstVarDiff = true;
            diff[2]        = xd11->second;
        }
 
        auto xd02 = factors.find(StdRegions::eFactorCoeffD02);
        if (xd02 != factors.end() && xd02->second != 0.0)
        {
            isConstVarDiff = true;
            diff[3]        = xd02->second;
        }
 
        auto xd12 = factors.find(StdRegions::eFactorCoeffD12);
        if (xd12 != factors.end() && xd12->second != 0.0)
        {
            isConstVarDiff = true;
            diff[4]        = xd12->second;
        }
 
        auto xd22 = factors.find(StdRegions::eFactorCoeffD22);
        if (xd22 != factors.end() && xd22->second != 1.0)
        {
            isConstVarDiff = true;
            diff[5]        = xd22->second;
        }
 
        if (isConstVarDiff)
        {
            m_oper->SetConstVarDiffusion(diff);
        }
 
        // set random here for fn variable diffusion
        auto k = factors.find(StdRegions::eFactorTau);
        if (k != factors.end() && k->second != 0.0)
        {
            m_oper->SetVarDiffusion(diff);
        }
    }

References ASSERTL1, Nektar::StdRegions::ConstFactorTypeMap, Nektar::StdRegions::eFactorCoeffD00, Nektar::StdRegions::eFactorCoeffD01, Nektar::StdRegions::eFactorCoeffD02, Nektar::StdRegions::eFactorCoeffD11, Nektar::StdRegions::eFactorCoeffD12, Nektar::StdRegions::eFactorCoeffD22, Nektar::StdRegions::eFactorLambda, and Nektar::StdRegions::eFactorTau.

operator()() [1/2]

void Nektar::Collections::Helmholtz_MatrixFree::operator() ( const Array< OneD, const NekDouble > &  input, Array< OneD, NekDouble > &  output0, Array< OneD, NekDouble > &  output1, Array< OneD, NekDouble > &  output2, Array< OneD, NekDouble > &  wsp  )

inlinefinaloverridevirtual

Perform operation.

Implements Nektar::Collections::Operator.

Definition at line 560 of file library/Collections/Helmholtz.cpp.

    {
        boost::ignore_unused(output1, output2, wsp);
 
        if (m_isPadded)
        {
            // copy into padded vector
            Vmath::Vcopy(m_nmtot, input, 1, m_input, 1);
            (*m_oper)(m_input, m_output);
            Vmath::Vcopy(m_nmtot, m_output, 1, output0, 1);
        }
        else
        {
            (*m_oper)(input, output0);
        }
    }

References Vmath::Vcopy().

operator()() [2/2]

void Nektar::Collections::Helmholtz_MatrixFree::operator() ( int  dir, const Array< OneD, const NekDouble > &  input, Array< OneD, NekDouble > &  output, Array< OneD, NekDouble > &  wsp  )

inlinefinaloverridevirtual

Implements Nektar::Collections::Operator.

Definition at line 581 of file library/Collections/Helmholtz.cpp.

    {
        boost::ignore_unused(dir, input, output, wsp);
        NEKERROR(ErrorUtil::efatal, "Not valid for this operator.");
    }

References NEKERROR.

Member Data Documentation

m_factors

StdRegions::FactorMap Nektar::Collections::Helmholtz_MatrixFree::m_factors

private

Definition at line 676 of file library/Collections/Helmholtz.cpp.

m_nmtot

unsigned int Nektar::Collections::Helmholtz_MatrixFree::m_nmtot

private

Definition at line 675 of file library/Collections/Helmholtz.cpp.

m_oper

std::shared_ptr<MatrixFree::Helmholtz> Nektar::Collections::Helmholtz_MatrixFree::m_oper

private

Definition at line 674 of file library/Collections/Helmholtz.cpp.