#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 58 of file CoalescedGeomData.h.

Constructor & Destructor Documentation

◆ CoalescedGeomData()

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

Definition at line 45 of file CoalescedGeomData.cpp.

46 {

47 }

◆ ~CoalescedGeomData()

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

virtual

Definition at line 49 of file CoalescedGeomData.cpp.

50 {

51 }

Member Function Documentation

◆ GetDerivFactors()

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

Definition at line 251 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(), and Vmath::Vcopy().

◆ GetDerivFactorsInterLeave()

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

Definition at line 315 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 ASSERTL1, and Nektar::Collections::eDerivFactors.

◆ GetJac()

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

Definition at line 53 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(), and Vmath::Vcopy().

◆ GetJacInterLeave()

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

Definition at line 115 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 ASSERTL1, and Nektar::Collections::eJac.

◆ GetJacWithStdWeights()

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

Definition at line 203 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(), and Vmath::Vcopy().

◆ IsDeformed()

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

Definition at line 406 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, and Nektar::LocalRegions::Expansion::GetMetricInfo().

Member Data Documentation

◆ m_deformed

bool Nektar::Collections::CoalescedGeomData::m_deformed

private

Definition at line 90 of file CoalescedGeomData.h.

◆ m_isDeformedSet

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

private

Definition at line 91 of file CoalescedGeomData.h.

◆ m_oneDGeomData

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

private

Definition at line 86 of file CoalescedGeomData.h.

◆ m_oneDGeomDataInterLeave

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

private

Definition at line 88 of file CoalescedGeomData.h.

◆ m_twoDGeomData

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

private

Definition at line 87 of file CoalescedGeomData.h.

◆ m_twoDGeomDataInterLeave

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

private

Definition at line 89 of file CoalescedGeomData.h.

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