#include <CoalescedGeomData.h>

Public Member Functions
	CoalescedGeomData (void)

virtual	~CoalescedGeomData (void)

const Array< OneD, const NekDouble > &	GetJac (std::vector< StdRegions::StdExpansionSharedPtr > &pColLExp)

const std::shared_ptr< VecVec_t >	GetJacInterLeave (std::vector< StdRegions::StdExpansionSharedPtr > &pCollExp, int nElmts)

const Array< OneD, const NekDouble > &	GetJacWithStdWeights (std::vector< StdRegions::StdExpansionSharedPtr > &pColLExp)

const Array< TwoD, const NekDouble > &	GetDerivFactors (std::vector< StdRegions::StdExpansionSharedPtr > &pColLExp)

const std::shared_ptr< VecVec_t >	GetDerivFactorsInterLeave (std::vector< StdRegions::StdExpansionSharedPtr > &pCollExp, int nElmts)

bool	IsDeformed (std::vector< StdRegions::StdExpansionSharedPtr > &pCollExp)

Private Attributes
std::map< GeomData, Array< OneD, NekDouble > >	m_oneDGeomData

std::map< GeomData, Array< TwoD, NekDouble > >	m_twoDGeomData

std::map< GeomData, std::shared_ptr< VecVec_t > >	m_oneDGeomDataInterLeave

std::map< GeomData, std::shared_ptr< VecVec_t > >	m_twoDGeomDataInterLeave

bool	m_deformed

bool	m_isDeformedSet {false}

Detailed Description

Definition at line 59 of file CoalescedGeomData.h.

Constructor & Destructor Documentation

◆ CoalescedGeomData()

Nektar::Collections::CoalescedGeomData::CoalescedGeomData ( void )

Definition at line 47 of file CoalescedGeomData.cpp.

48{

49}

◆ ~CoalescedGeomData()

Nektar::Collections::CoalescedGeomData::~CoalescedGeomData ( void )

virtual

Definition at line 51 of file CoalescedGeomData.cpp.

52{

53}

Member Function Documentation

◆ GetDerivFactors()

const Array< TwoD, const NekDouble > & Nektar::Collections::CoalescedGeomData::GetDerivFactors ( std::vector< StdRegions::StdExpansionSharedPtr > & pColLExp )

Definition at line 248 of file CoalescedGeomData.cpp.

{
    if (m_twoDGeomData.count(eDerivFactors) == 0)
    {
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
 
        int nElmts        = pCollExp.size();
        const int coordim = pCollExp[0]->GetCoordim();
        int dim           = ptsKeys.size();
 
        // set up Cached Jacobians to be continuous
        int npts = 1;
        for (int i = 0; i < dim; ++i)
        {
            npts *= ptsKeys[i].GetNumPoints();
        }
 
        Array<TwoD, NekDouble> newDFac;
 
        if (IsDeformed(pCollExp))
        {
            newDFac = Array<TwoD, NekDouble>(dim * coordim, npts * nElmts);
        }
        else
        {
            newDFac = Array<TwoD, NekDouble>(dim * coordim, nElmts);
        }
 
        // copy Jacobians into a continuous list and set new chatched value
        int cnt = 0;
        for (int i = 0; i < nElmts; ++i)
        {
            const StdRegions::StdExpansion *sep = &(*pCollExp[i]);
            const LocalRegions::Expansion *lep =
                dynamic_cast<const LocalRegions::Expansion *>(sep);
 
            const Array<TwoD, const NekDouble> Dfac =
                lep->GetMetricInfo()->GetDerivFactors(ptsKeys);
 
            if (IsDeformed(pCollExp))
            {
                for (int j = 0; j < dim * coordim; ++j)
                {
                    Vmath::Vcopy(npts, &Dfac[j][0], 1, &newDFac[j][cnt], 1);
                }
            }
            else
            {
                for (int j = 0; j < dim * coordim; ++j)
                {
                    newDFac[j][i] = Dfac[j][0];
                }
            }
            cnt += npts;
        }
 
        m_twoDGeomData[eDerivFactors] = newDFac;
    }
 
    return m_twoDGeomData[eDerivFactors];
}

References Nektar::Collections::eDerivFactors, Nektar::LocalRegions::Expansion::GetMetricInfo(), IsDeformed(), m_twoDGeomData, and Vmath::Vcopy().

Referenced by GetDerivFactorsInterLeave().

◆ GetDerivFactorsInterLeave()

const std::shared_ptr< VecVec_t > Nektar::Collections::CoalescedGeomData::GetDerivFactorsInterLeave	(	std::vector< StdRegions::StdExpansionSharedPtr > &	pCollExp,
		int	nElmts
	)

Definition at line 311 of file CoalescedGeomData.cpp.

{
    if (m_twoDGeomDataInterLeave.count(eDerivFactors) == 0)
    {
        ASSERTL1(nElmt % vec_t::width == 0,
                 "Number of elements not divisible by vector "
                 "width, padding not yet implemented.");
 
        int nBlocks = nElmt / vec_t::width;
 
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
        const int coordim                     = pCollExp[0]->GetCoordim();
        int dim                               = ptsKeys.size();
 
        unsigned int n_df = coordim * dim;
        alignas(vec_t::alignment) NekDouble vec[vec_t::width];
 
        const Array<TwoD, const NekDouble> df = GetDerivFactors(pCollExp);
        int dfsize                            = df.GetColumns();
 
        VecVec_t newdf;
 
        int nq = 1;
        for (int i = 0; i < dim; ++i)
        {
            nq *= ptsKeys[i].GetNumPoints();
        }
 
        if (IsDeformed(pCollExp))
        {
            newdf.resize(nBlocks * n_df * nq);
            auto *df_ptr = &newdf[0];
            for (int e = 0; e < nBlocks; ++e)
            {
                for (int q = 0; q < nq; q++)
                {
                    for (int dir = 0; dir < n_df; ++dir, ++df_ptr)
                    {
                        for (int j = 0; j < vec_t::width; ++j)
                        {
                            // manage padding
                            if ((vec_t::width * e + j) * nq + q < dfsize)
                            {
                                vec[j] =
                                    df[dir][(vec_t::width * e + j) * nq + q];
                            }
                            else
                            {
                                vec[j] = 0.0;
                            }
                        }
                        (*df_ptr).load(&vec[0]);
                    }
                }
            }
        }
        else
        {
            newdf.resize(nBlocks * n_df);
            for (int e = 0; e < nBlocks; ++e)
            {
                for (int dir = 0; dir < n_df; ++dir)
                {
                    for (int j = 0; j < vec_t::width; ++j)
                    {
                        // padding
                        if (vec_t::width * e + j < dfsize)
                        {
                            vec[j] = df[dir][vec_t::width * e + j];
                        }
                        else
                        {
                            vec[j] = 0.0;
                        }
                    }
                    // Must have all vec_t::width elemnts aligned to do a load.
                    newdf[e * n_df + dir].load(&vec[0]);
                }
            }
        }
 
        m_twoDGeomDataInterLeave[eDerivFactors] =
            MemoryManager<VecVec_t>::AllocateSharedPtr(newdf);
    }
 
    return m_twoDGeomDataInterLeave[eDerivFactors];
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::Collections::eDerivFactors, GetDerivFactors(), IsDeformed(), m_twoDGeomDataInterLeave, and Nektar::UnitTests::q().

◆ GetJac()

const Array< OneD, const NekDouble > & Nektar::Collections::CoalescedGeomData::GetJac ( std::vector< StdRegions::StdExpansionSharedPtr > & pColLExp )

Definition at line 55 of file CoalescedGeomData.cpp.

{
 
    if (m_oneDGeomData.count(eJac) == 0)
    {
 
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
        int nElmts                            = pCollExp.size();
 
        // set up Cached Jacobians to be continuous
        int npts = 1;
        for (int i = 0; i < ptsKeys.size(); ++i)
        {
            npts *= ptsKeys[i].GetNumPoints();
        }
 
        if (IsDeformed(pCollExp))
        {
            Array<OneD, NekDouble> newjac(npts * nElmts);
 
            // copy Jacobians into a continuous list and set new chatched value
            int cnt = 0;
            for (int i = 0; i < nElmts; ++i)
            {
                const StdRegions::StdExpansion *sep = &(*pCollExp[i]);
                const LocalRegions::Expansion *lep =
                    dynamic_cast<const LocalRegions::Expansion *>(sep);
 
                const Array<OneD, const NekDouble> jac =
                    lep->GetMetricInfo()->GetJac(ptsKeys);
 
                Vmath::Vcopy(npts, &jac[0], 1, &newjac[cnt], 1);
 
                cnt += npts;
            }
 
            m_oneDGeomData[eJac] = newjac;
        }
        else
        {
            Array<OneD, NekDouble> newjac(nElmts);
            // copy Jacobians into a continuous list
            for (int i = 0; i < nElmts; ++i)
            {
                const StdRegions::StdExpansion *sep = &(*pCollExp[i]);
                const LocalRegions::Expansion *lep =
                    dynamic_cast<const LocalRegions::Expansion *>(sep);
 
                const Array<OneD, const NekDouble> jac =
                    lep->GetMetricInfo()->GetJac(ptsKeys);
 
                newjac[i] = jac[0];
            }
            m_oneDGeomData[eJac] = newjac;
        }
    }
 
    return m_oneDGeomData[eJac];
}

References Nektar::Collections::eJac, Nektar::LocalRegions::Expansion::GetMetricInfo(), IsDeformed(), m_oneDGeomData, and Vmath::Vcopy().

Referenced by GetJacInterLeave().

◆ GetJacInterLeave()

const std::shared_ptr< VecVec_t > Nektar::Collections::CoalescedGeomData::GetJacInterLeave	(	std::vector< StdRegions::StdExpansionSharedPtr > &	pCollExp,
		int	nElmts
	)

Definition at line 116 of file CoalescedGeomData.cpp.

{
 
    if (m_oneDGeomDataInterLeave.count(eJac) == 0)
    {
        const Array<OneD, const NekDouble> jac = GetJac(pCollExp);
        int jacsize                            = jac.size();
 
        ASSERTL1(nElmt % vec_t::width == 0,
                 "Number of elements not divisible by vector "
                 "width, padding not yet implemented.");
        int nBlocks = nElmt / vec_t::width;
 
        VecVec_t newjac;
 
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
 
        // set up Cached Jacobians to be continuous
        int nq = 1;
        for (int i = 0; i < ptsKeys.size(); ++i)
        {
            nq *= ptsKeys[i].GetNumPoints();
        }
 
        if (IsDeformed(pCollExp))
        {
 
            newjac.resize(nBlocks * nq);
 
            alignas(vec_t::alignment) NekDouble tmp[vec_t::width];
 
            for (size_t block = 0; block < nBlocks; ++block)
            {
                size_t nblock_width = block * nq * vec_t::width;
                for (size_t q = 0; q < nq; q++)
                {
                    for (int j = 0; j < vec_t::width; ++j)
                    {
                        if (nblock_width + nq * j + q < jacsize)
                        {
                            tmp[j] = jac[nblock_width + nq * j + q];
                        }
                        else
                        {
                            tmp[j] = 0.0;
                        }
                    }
 
                    // Order is [block][quadpt]
                    newjac[block * nq + q].load(&tmp[0]);
                }
            }
        }
        else
        {
            newjac.resize(nBlocks);
 
            alignas(vec_t::alignment) NekDouble tmp[vec_t::width];
            for (size_t i = 0; i < nBlocks; ++i)
            {
                for (int j = 0; j < vec_t::width; ++j)
                {
                    if (vec_t::width * i + j < jacsize)
                    {
                        tmp[j] = jac[vec_t::width * i + j];
                    }
                    else
                    {
                        tmp[j] = 0.0;
                    }
                }
 
                newjac[i].load(&tmp[0]);
            }
        }
 
        m_oneDGeomDataInterLeave[eJac] =
            MemoryManager<VecVec_t>::AllocateSharedPtr(newjac);
    }
 
    return m_oneDGeomDataInterLeave[eJac];
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::Collections::eJac, GetJac(), IsDeformed(), m_oneDGeomDataInterLeave, and Nektar::UnitTests::q().

◆ GetJacWithStdWeights()

const Array< OneD, const NekDouble > & Nektar::Collections::CoalescedGeomData::GetJacWithStdWeights ( std::vector< StdRegions::StdExpansionSharedPtr > & pColLExp )

Definition at line 200 of file CoalescedGeomData.cpp.

{
    if (m_oneDGeomData.count(eJacWithStdWeights) == 0)
    {
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
        int nElmts                            = pCollExp.size();
 
        // set up Cached Jacobians to be continuous
        int npts = 1;
        for (int i = 0; i < ptsKeys.size(); ++i)
        {
            npts *= ptsKeys[i].GetNumPoints();
        }
 
        Array<OneD, NekDouble> newjac(npts * nElmts), tmp;
 
        // copy Jacobians into a continuous list and set new chatched value
        int cnt = 0;
        for (int i = 0; i < nElmts; ++i)
        {
            const StdRegions::StdExpansion *sep = &(*pCollExp[i]);
            const LocalRegions::Expansion *lep =
                dynamic_cast<const LocalRegions::Expansion *>(sep);
 
            const Array<OneD, const NekDouble> jac =
                lep->GetMetricInfo()->GetJac(ptsKeys);
 
            if (lep->GetMetricInfo()->GetGtype() == SpatialDomains::eDeformed)
            {
                Vmath::Vcopy(npts, &jac[0], 1, &newjac[cnt], 1);
            }
            else
            {
                Vmath::Fill(npts, jac[0], &newjac[cnt], 1);
            }
 
            pCollExp[0]->MultiplyByStdQuadratureMetric(newjac + cnt,
                                                       tmp = newjac + cnt);
            cnt += npts;
        }
 
        m_oneDGeomData[eJacWithStdWeights] = newjac;
    }
 
    return m_oneDGeomData[eJacWithStdWeights];
}

References Nektar::SpatialDomains::eDeformed, Nektar::Collections::eJacWithStdWeights, Vmath::Fill(), Nektar::LocalRegions::Expansion::GetMetricInfo(), m_oneDGeomData, and Vmath::Vcopy().

◆ IsDeformed()

bool Nektar::Collections::CoalescedGeomData::IsDeformed ( std::vector< StdRegions::StdExpansionSharedPtr > & pCollExp )

Definition at line 400 of file CoalescedGeomData.cpp.

{
    if (!m_isDeformedSet)
    {
        LibUtilities::PointsKeyVector ptsKeys = pCollExp[0]->GetPointsKeys();
        const StdRegions::StdExpansion *sep   = &(*pCollExp[0]);
        const LocalRegions::Expansion *lep =
            dynamic_cast<const LocalRegions::Expansion *>(sep);
 
        const Array<OneD, const NekDouble> jac =
            lep->GetMetricInfo()->GetJac(ptsKeys);
 
        m_deformed =
            lep->GetMetricInfo()->GetGtype() == SpatialDomains::eDeformed;
    }
 
    return m_deformed;
}

References Nektar::SpatialDomains::eDeformed, Nektar::LocalRegions::Expansion::GetMetricInfo(), m_deformed, and m_isDeformedSet.

Referenced by GetDerivFactors(), GetDerivFactorsInterLeave(), GetJac(), and GetJacInterLeave().

Member Data Documentation

◆ m_deformed

bool Nektar::Collections::CoalescedGeomData::m_deformed

private

Definition at line 88 of file CoalescedGeomData.h.

Referenced by IsDeformed().

◆ m_isDeformedSet

bool Nektar::Collections::CoalescedGeomData::m_isDeformedSet {false}

private

Definition at line 89 of file CoalescedGeomData.h.

Referenced by IsDeformed().

◆ m_oneDGeomData

std::map<GeomData, Array<OneD, NekDouble> > Nektar::Collections::CoalescedGeomData::m_oneDGeomData

private

Definition at line 84 of file CoalescedGeomData.h.

Referenced by GetJac(), and GetJacWithStdWeights().

◆ m_oneDGeomDataInterLeave

std::map<GeomData, std::shared_ptr<VecVec_t> > Nektar::Collections::CoalescedGeomData::m_oneDGeomDataInterLeave

private

Definition at line 86 of file CoalescedGeomData.h.

Referenced by GetJacInterLeave().

◆ m_twoDGeomData

std::map<GeomData, Array<TwoD, NekDouble> > Nektar::Collections::CoalescedGeomData::m_twoDGeomData

private

Definition at line 85 of file CoalescedGeomData.h.

Referenced by GetDerivFactors().

◆ m_twoDGeomDataInterLeave

std::map<GeomData, std::shared_ptr<VecVec_t> > Nektar::Collections::CoalescedGeomData::m_twoDGeomDataInterLeave

private

Definition at line 87 of file CoalescedGeomData.h.

Referenced by GetDerivFactorsInterLeave().

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CoalescedGeomData()

◆ ~CoalescedGeomData()

Member Function Documentation

◆ GetDerivFactors()

◆ GetDerivFactorsInterLeave()

◆ GetJac()

◆ GetJacInterLeave()

◆ GetJacWithStdWeights()

◆ IsDeformed()

Member Data Documentation

◆ m_deformed

◆ m_isDeformedSet

◆ m_oneDGeomData

◆ m_oneDGeomDataInterLeave

◆ m_twoDGeomData

◆ m_twoDGeomDataInterLeave