Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::MultiRegions::DisContField3D Class Reference

#include <DisContField3D.h>

Inheritance diagram for Nektar::MultiRegions::DisContField3D:
Inheritance graph
[legend]
Collaboration diagram for Nektar::MultiRegions::DisContField3D:
Collaboration graph
[legend]

Public Member Functions

 DisContField3D ()
 Default constructor. More...
 
 DisContField3D (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph3D, const std::string &variable, const bool SetUpJustDG=true)
 Constructs a global discontinuous field based on an input mesh with boundary conditions. More...
 
 DisContField3D (const DisContField3D &In, const SpatialDomains::MeshGraphSharedPtr &graph3D, const std::string &variable, const bool SetUpJustDG=false)
 
 DisContField3D (const DisContField3D &In)
 Constructs a global discontinuous field based on another discontinuous field. More...
 
virtual ~DisContField3D ()
 Destructor. More...
 
GlobalLinSysSharedPtr GetGlobalBndLinSys (const GlobalLinSysKey &mkey)
 
void EvaluateHDGPostProcessing (Array< OneD, NekDouble > &outarray)
 Evaluate HDG post-processing to increase polynomial order of solution. More...
 
bool GetLeftAdjacentFaces (int cnt)
 
- Public Member Functions inherited from Nektar::MultiRegions::ExpList3D
 ExpList3D ()
 Default constructor. More...
 
 ExpList3D (const ExpList3D &In)
 Copy constructor. More...
 
 ExpList3D (const ExpList3D &In, const std::vector< unsigned int > &eIDs)
 Constructor copying only elements defined in eIds. More...
 
 ExpList3D (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::BasisKey &TBa, const LibUtilities::BasisKey &TBb, const LibUtilities::BasisKey &TBc, const LibUtilities::BasisKey &HBa, const LibUtilities::BasisKey &HBb, const LibUtilities::BasisKey &HBc, const SpatialDomains::MeshGraphSharedPtr &graph3D, const LibUtilities::PointsType TetNb=LibUtilities::SIZE_PointsType)
 
 ExpList3D (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph3D, const std::string &variable="DefaultVar")
 Sets up a list of local expansions based on an input mesh. More...
 
 ExpList3D (const SpatialDomains::ExpansionMap &expansions)
 Sets up a list of local expansions based on an expansion vector. More...
 
virtual ~ExpList3D ()
 Destructor. More...
 
- Public Member Functions inherited from Nektar::MultiRegions::ExpList
 ExpList ()
 The default constructor. More...
 
 ExpList (const LibUtilities::SessionReaderSharedPtr &pSession)
 The default constructor. More...
 
 ExpList (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 The default constructor. More...
 
 ExpList (const ExpList &in, const std::vector< unsigned int > &eIDs, const bool DeclareCoeffPhysArrays=true)
 Constructor copying only elements defined in eIds. More...
 
 ExpList (const ExpList &in, const bool DeclareCoeffPhysArrays=true)
 The copy constructor. More...
 
virtual ~ExpList ()
 The default destructor. More...
 
int GetNcoeffs (void) const
 Returns the total number of local degrees of freedom $N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_m$. More...
 
int GetNcoeffs (const int eid) const
 Returns the total number of local degrees of freedom for element eid. More...
 
ExpansionType GetExpType (void)
 Returns the type of the expansion. More...
 
void SetExpType (ExpansionType Type)
 Returns the type of the expansion. More...
 
int EvalBasisNumModesMax (void) const
 Evaulates the maximum number of modes in the elemental basis order over all elements. More...
 
const Array< OneD, int > EvalBasisNumModesMaxPerExp (void) const
 Returns the vector of the number of modes in the elemental basis order over all elements. More...
 
int GetTotPoints (void) const
 Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$. More...
 
int GetTotPoints (const int eid) const
 Returns the total number of quadrature points for eid's element $=Q_{\mathrm{tot}}$. More...
 
int GetNpoints (void) const
 Returns the total number of quadrature points m_npoints $=Q_{\mathrm{tot}}$. More...
 
int Get1DScaledTotPoints (const NekDouble scale) const
 Returns the total number of qudature points scaled by the factor scale on each 1D direction. More...
 
void SetWaveSpace (const bool wavespace)
 Sets the wave space to the one of the possible configuration true or false. More...
 
void SetModifiedBasis (const bool modbasis)
 Set Modified Basis for the stability analysis. More...
 
void SetPhys (int i, NekDouble val)
 Set the i th value of m_phys to value val. More...
 
bool GetWaveSpace (void) const
 This function returns the third direction expansion condition, which can be in wave space (coefficient) or not It is stored in the variable m_WaveSpace. More...
 
void SetPhys (const Array< OneD, const NekDouble > &inarray)
 Fills the array m_phys. More...
 
void SetPhysArray (Array< OneD, NekDouble > &inarray)
 Sets the array m_phys. More...
 
void SetPhysState (const bool physState)
 This function manually sets whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not. More...
 
bool GetPhysState (void) const
 This function indicates whether the array of physical values $\boldsymbol{u}_l$ (implemented as m_phys) is filled or not. More...
 
NekDouble PhysIntegral (void)
 This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion. More...
 
NekDouble PhysIntegral (const Array< OneD, const NekDouble > &inarray)
 This function integrates a function $f(\boldsymbol{x})$ over the domain consisting of all the elements of the expansion. More...
 
void IProductWRTBase_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to all {local} expansion modes $\phi_n^e(\boldsymbol{x})$. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative (in direction. More...
 
void IProductWRTDerivBase (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
 This function calculates the inner product of a function $f(\boldsymbol{x})$ with respect to the derivative (in direction. More...
 
void FwdTrans_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function elementally evaluates the forward transformation of a function $u(\boldsymbol{x})$ onto the global spectral/hp expansion. More...
 
void FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
void MultiplyByElmtInvMass (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function elementally mulplies the coefficient space of Sin my the elemental inverse of the mass matrix. More...
 
void MultiplyByInvMassMatrix (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
void SmoothField (Array< OneD, NekDouble > &field)
 Smooth a field across elements. More...
 
void HelmSolve (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const FlagList &flags, const StdRegions::ConstFactorMap &factors, const StdRegions::VarCoeffMap &varcoeff=StdRegions::NullVarCoeffMap, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
 Solve helmholtz problem. More...
 
void LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
 Solve Advection Diffusion Reaction. More...
 
void LinearAdvectionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
 Solve Advection Diffusion Reaction. More...
 
void FwdTrans_BndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void BwdTrans_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function elementally evaluates the backward transformation of the global spectral/hp element expansion. More...
 
void BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
void GetCoords (Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1=NullNekDouble1DArray, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)
 This function calculates the coordinates of all the elemental quadrature points $\boldsymbol{x}_i$. More...
 
void HomogeneousFwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)
 
void HomogeneousBwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)
 
void DealiasedProd (const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
void GetBCValues (Array< OneD, NekDouble > &BndVals, const Array< OneD, NekDouble > &TotField, int BndID)
 
void NormVectorIProductWRTBase (Array< OneD, const NekDouble > &V1, Array< OneD, const NekDouble > &V2, Array< OneD, NekDouble > &outarray, int BndID)
 
void NormVectorIProductWRTBase (Array< OneD, Array< OneD, NekDouble > > &V, Array< OneD, NekDouble > &outarray)
 
void ApplyGeomInfo ()
 Apply geometry information to each expansion. More...
 
void Reset ()
 Reset geometry information and reset matrices. More...
 
void WriteTecplotHeader (std::ostream &outfile, std::string var="")
 
void WriteTecplotZone (std::ostream &outfile, int expansion=-1)
 
void WriteTecplotField (std::ostream &outfile, int expansion=-1)
 
void WriteTecplotConnectivity (std::ostream &outfile, int expansion=-1)
 
void WriteVtkHeader (std::ostream &outfile)
 
void WriteVtkFooter (std::ostream &outfile)
 
void WriteVtkPieceHeader (std::ostream &outfile, int expansion, int istrip=0)
 
void WriteVtkPieceFooter (std::ostream &outfile, int expansion)
 
void WriteVtkPieceData (std::ostream &outfile, int expansion, std::string var="v")
 
int GetCoordim (int eid)
 This function returns the dimension of the coordinates of the element eid. More...
 
void SetCoeff (int i, NekDouble val)
 Set the i th coefficiient in m_coeffs to value val. More...
 
void SetCoeffs (int i, NekDouble val)
 Set the i th coefficiient in m_coeffs to value val. More...
 
void SetCoeffsArray (Array< OneD, NekDouble > &inarray)
 Set the m_coeffs array to inarray. More...
 
const Array< OneD, const
NekDouble > & 
GetCoeffs () const
 This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients. More...
 
void ImposeDirichletConditions (Array< OneD, NekDouble > &outarray)
 Impose Dirichlet Boundary Conditions onto Array. More...
 
void FillBndCondFromField (void)
 Fill Bnd Condition expansion from the values stored in expansion. More...
 
void LocalToGlobal (void)
 Put the coefficients into global ordering using m_coeffs. More...
 
void GlobalToLocal (void)
 Put the coefficients into local ordering and place in m_coeffs. More...
 
NekDouble GetCoeff (int i)
 Get the i th value (coefficient) of m_coeffs. More...
 
NekDouble GetCoeffs (int i)
 Get the i th value (coefficient) of m_coeffs. More...
 
const Array< OneD, const
NekDouble > & 
GetPhys () const
 This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points. More...
 
NekDouble Linf (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
 This function calculates the $L_\infty$ error of the global spectral/hp element approximation. More...
 
NekDouble L2 (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
 This function calculates the $L_2$ error with respect to soln of the global spectral/hp element approximation. More...
 
NekDouble H1 (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
 Calculates the $H^1$ error of the global spectral/hp element approximation. More...
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 
Array< OneD, const NekDoubleHomogeneousEnergy (void)
 This function calculates the energy associated with each one of the modesof a 3D homogeneous nD expansion. More...
 
void SetHomo1DSpecVanVisc (Array< OneD, NekDouble > visc)
 This function sets the Spectral Vanishing Viscosity in homogeneous1D expansion. More...
 
Array< OneD, const unsigned int > GetZIDs (void)
 This function returns a vector containing the wave numbers in z-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction. More...
 
LibUtilities::TranspositionSharedPtr GetTransposition (void)
 This function returns the transposition class associaed with the homogeneous expansion. More...
 
NekDouble GetHomoLen (void)
 This function returns the Width of homogeneous direction associaed with the homogeneous expansion. More...
 
Array< OneD, const unsigned int > GetYIDs (void)
 This function returns a vector containing the wave numbers in y-direction associated with the 3D homogenous expansion. Required if a parellelisation is applied in the Fourier direction. More...
 
void PhysInterp1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function interpolates the physical space points in inarray to outarray using the same points defined in the expansion but where the number of points are rescaled by 1DScale. More...
 
void PhysGalerkinProjection1DScaled (const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function Galerkin projects the physical space points in inarray to outarray where inarray is assumed to be defined in the expansion but where the number of points are rescaled by 1DScale. More...
 
int GetExpSize (void)
 This function returns the number of elements in the expansion. More...
 
int GetNumElmts (void)
 This function returns the number of elements in the expansion which may be different for a homogeoenous extended expansionp. More...
 
const boost::shared_ptr
< LocalRegions::ExpansionVector
GetExp () const
 This function returns the vector of elements in the expansion. More...
 
LocalRegions::ExpansionSharedPtrGetExp (int n) const
 This function returns (a shared pointer to) the local elemental expansion of the $n^{\mathrm{th}}$ element. More...
 
LocalRegions::ExpansionSharedPtrGetExp (const Array< OneD, const NekDouble > &gloCoord)
 This function returns (a shared pointer to) the local elemental expansion containing the arbitrary point given by gloCoord. More...
 
int GetExpIndex (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0, bool returnNearestElmt=false)
 
int GetExpIndex (const Array< OneD, const NekDouble > &gloCoords, Array< OneD, NekDouble > &locCoords, NekDouble tol=0.0, bool returnNearestElmt=false)
 
int GetCoeff_Offset (int n) const
 Get the start offset position for a global list of m_coeffs correspoinding to element n. More...
 
int GetPhys_Offset (int n) const
 Get the start offset position for a global list of m_phys correspoinding to element n. More...
 
int GetOffset_Elmt_Id (int n) const
 Get the element id associated with the n th consecutive block of data in m_phys and m_coeffs. More...
 
Array< OneD, NekDouble > & UpdateCoeffs ()
 This function returns (a reference to) the array $\boldsymbol{\hat{u}}_l$ (implemented as m_coeffs) containing all local expansion coefficients. More...
 
Array< OneD, NekDouble > & UpdatePhys ()
 This function returns (a reference to) the array $\boldsymbol{u}_l$ (implemented as m_phys) containing the function $u^{\delta}(\boldsymbol{x})$ evaluated at the quadrature points. More...
 
void PhysDeriv (Direction edir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)
 
void PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 This function discretely evaluates the derivative of a function $f(\boldsymbol{x})$ on the domain consisting of all elements of the expansion. More...
 
void PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)
 
const Array< OneD, const
boost::shared_ptr< ExpList > > & 
GetBndCondExpansions ()
 
boost::shared_ptr< ExpList > & UpdateBndCondExpansion (int i)
 
void Upwind (const Array< OneD, const Array< OneD, NekDouble > > &Vec, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)
 
void Upwind (const Array< OneD, const NekDouble > &Vn, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)
 
boost::shared_ptr< ExpList > & GetTrace ()
 
boost::shared_ptr
< AssemblyMapDG > & 
GetTraceMap (void)
 
const Array< OneD, const int > & GetTraceBndMap (void)
 
void GetNormals (Array< OneD, Array< OneD, NekDouble > > &normals)
 
void AddTraceIntegral (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void AddTraceIntegral (const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
void AddFwdBwdTraceIntegral (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &outarray)
 
void GetFwdBwdTracePhys (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
 
void GetFwdBwdTracePhys (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
 
const std::vector< bool > & GetLeftAdjacentFaces (void) const
 
void ExtractTracePhys (Array< OneD, NekDouble > &outarray)
 
void ExtractTracePhys (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
const Array< OneD, const
SpatialDomains::BoundaryConditionShPtr > & 
GetBndConditions ()
 
Array< OneD,
SpatialDomains::BoundaryConditionShPtr > & 
UpdateBndConditions ()
 
void EvaluateBoundaryConditions (const NekDouble time=0.0, const std::string varName="", const NekDouble=NekConstants::kNekUnsetDouble, const NekDouble=NekConstants::kNekUnsetDouble)
 
void GeneralMatrixOp (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 This function calculates the result of the multiplication of a matrix of type specified by mkey with a vector given by inarray. More...
 
void GeneralMatrixOp_IterPerExp (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void SetUpPhysNormals ()
 
void GetBoundaryToElmtMap (Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)
 
void GetBndElmtExpansion (int i, boost::shared_ptr< ExpList > &result)
 
void ExtractElmtToBndPhys (int i, Array< OneD, NekDouble > &elmt, Array< OneD, NekDouble > &boundary)
 
void ExtractPhysToBndElmt (int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bndElmt)
 
void GetBoundaryNormals (int i, Array< OneD, Array< OneD, NekDouble > > &normals)
 
void GeneralGetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef, int NumHomoDir=0, Array< OneD, LibUtilities::BasisSharedPtr > &HomoBasis=LibUtilities::NullBasisSharedPtr1DArray, std::vector< NekDouble > &HomoLen=LibUtilities::NullNekDoubleVector, bool homoStrips=false, std::vector< unsigned int > &HomoSIDs=LibUtilities::NullUnsignedIntVector, std::vector< unsigned int > &HomoZIDs=LibUtilities::NullUnsignedIntVector, std::vector< unsigned int > &HomoYIDs=LibUtilities::NullUnsignedIntVector)
 
const
NekOptimize::GlobalOptParamSharedPtr
GetGlobalOptParam (void)
 
std::map< int,
RobinBCInfoSharedPtr
GetRobinBCInfo ()
 
void GetPeriodicEntities (PeriodicMap &periodicVerts, PeriodicMap &periodicEdges, PeriodicMap &periodicFaces=NullPeriodicMap)
 
std::vector
< LibUtilities::FieldDefinitionsSharedPtr
GetFieldDefinitions ()
 
void GetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
 
void AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata)
 Append the element data listed in elements fielddef->m_ElementIDs onto fielddata. More...
 
void AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, Array< OneD, NekDouble > &coeffs)
 Append the data in coeffs listed in elements fielddef->m_ElementIDs onto fielddata. More...
 
void ExtractElmtDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs)
 Extract the data in fielddata into the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case. More...
 
void ExtractCoeffsToCoeffs (const boost::shared_ptr< ExpList > &fromExpList, const Array< OneD, const NekDouble > &fromCoeffs, Array< OneD, NekDouble > &toCoeffs)
 Extract the data from fromField using fromExpList the coeffs using the basic ExpList Elemental expansions rather than planes in homogeneous case. More...
 
void ExtractDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs)
 Extract the data in fielddata into the coeffs. More...
 
boost::shared_ptr< ExpListGetSharedThisPtr ()
 Returns a shared pointer to the current object. More...
 
boost::shared_ptr
< LibUtilities::SessionReader
GetSession ()
 Returns the session object. More...
 
boost::shared_ptr
< LibUtilities::Comm
GetComm ()
 Returns the comm object. More...
 
SpatialDomains::MeshGraphSharedPtr GetGraph ()
 
LibUtilities::BasisSharedPtr GetHomogeneousBasis (void)
 
boost::shared_ptr< ExpList > & GetPlane (int n)
 
void CreateCollections (Collections::ImplementationType ImpType=Collections::eNoImpType)
 Construct collections of elements containing a single element type and polynomial order from the list of expansions. More...
 
void ClearGlobalLinSysManager (void)
 

Protected Member Functions

void SetUpDG (const std::string="DefaultVar")
 Set up all DG member variables and maps. More...
 
bool SameTypeOfBoundaryConditions (const DisContField3D &In)
 
void GenerateBoundaryConditionExpansion (const SpatialDomains::MeshGraphSharedPtr &graph3D, const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
 
void FindPeriodicFaces (const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
 Determine the periodic faces, edges and vertices for the given graph. More...
 
bool IsLeftAdjacentFace (const int n, const int e)
 
virtual void v_GetFwdBwdTracePhys (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
 This method extracts the "forward" and "backward" trace data from the array field and puts the data into output vectors Fwd and Bwd. More...
 
virtual void v_GetFwdBwdTracePhys (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
 
virtual const std::vector< bool > & v_GetLeftAdjacentFaces (void) const
 
virtual void v_ExtractTracePhys (Array< OneD, NekDouble > &outarray)
 
virtual void v_ExtractTracePhys (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddTraceIntegral (const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 Add trace contributions into elemental coefficient spaces. More...
 
virtual void v_AddFwdBwdTraceIntegral (const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &outarray)
 Add trace contributions into elemental coefficient spaces. More...
 
virtual void v_HelmSolve (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const FlagList &flags, const StdRegions::ConstFactorMap &factors, const StdRegions::VarCoeffMap &varcoeff, const Array< OneD, const NekDouble > &dirForcing)
 
virtual void v_GeneralMatrixOp (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 Calculates the result of the multiplication of a global matrix of type specified by mkey with a vector given by inarray. More...
 
virtual void v_GetBoundaryToElmtMap (Array< OneD, int > &ElmtID, Array< OneD, int > &FaceID)
 Set up a list of elemeent IDs and edge IDs that link to the boundary conditions. More...
 
virtual void v_GetBndElmtExpansion (int i, boost::shared_ptr< ExpList > &result)
 
virtual void v_Reset ()
 Reset this field, so that geometry information can be updated. More...
 
virtual void v_GetPeriodicEntities (PeriodicMap &periodicVerts, PeriodicMap &periodicEdges, PeriodicMap &periodicFaces)
 
virtual ExpListSharedPtrv_GetTrace ()
 
virtual AssemblyMapDGSharedPtrv_GetTraceMap ()
 
virtual const Array< OneD,
const
MultiRegions::ExpListSharedPtr > & 
v_GetBndCondExpansions ()
 
virtual const Array< OneD,
const
SpatialDomains::BoundaryConditionShPtr > & 
v_GetBndConditions ()
 
virtual
MultiRegions::ExpListSharedPtr
v_UpdateBndCondExpansion (int i)
 
virtual Array< OneD,
SpatialDomains::BoundaryConditionShPtr > & 
v_UpdateBndConditions ()
 
virtual void v_EvaluateBoundaryConditions (const NekDouble time=0.0, const std::string varName="", const NekDouble x2_in=NekConstants::kNekUnsetDouble, const NekDouble x3_in=NekConstants::kNekUnsetDouble)
 This function evaluates the boundary conditions at a certain time-level. More...
 
virtual std::map< int,
RobinBCInfoSharedPtr
v_GetRobinBCInfo ()
 
- Protected Member Functions inherited from Nektar::MultiRegions::ExpList3D
virtual void v_SetUpPhysNormals ()
 Set up the normals on each expansion. More...
 
- Protected Member Functions inherited from Nektar::MultiRegions::ExpList
boost::shared_ptr< DNekMatGenGlobalMatrixFull (const GlobalLinSysKey &mkey, const boost::shared_ptr< AssemblyMapCG > &locToGloMap)
 
const DNekScalBlkMatSharedPtr GenBlockMatrix (const GlobalMatrixKey &gkey)
 This function assembles the block diagonal matrix of local matrices of the type mtype. More...
 
const DNekScalBlkMatSharedPtrGetBlockMatrix (const GlobalMatrixKey &gkey)
 
void MultiplyByBlockMatrix (const GlobalMatrixKey &gkey, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
boost::shared_ptr< GlobalMatrixGenGlobalMatrix (const GlobalMatrixKey &mkey, const boost::shared_ptr< AssemblyMapCG > &locToGloMap)
 Generates a global matrix from the given key and map. More...
 
void GlobalEigenSystem (const boost::shared_ptr< DNekMat > &Gmat, Array< OneD, NekDouble > &EigValsReal, Array< OneD, NekDouble > &EigValsImag, Array< OneD, NekDouble > &EigVecs=NullNekDouble1DArray)
 
boost::shared_ptr< GlobalLinSysGenGlobalLinSys (const GlobalLinSysKey &mkey, const boost::shared_ptr< AssemblyMapCG > &locToGloMap)
 This operation constructs the global linear system of type mkey. More...
 
boost::shared_ptr< GlobalLinSysGenGlobalBndLinSys (const GlobalLinSysKey &mkey, const AssemblyMapSharedPtr &locToGloMap)
 Generate a GlobalLinSys from information provided by the key "mkey" and the mapping provided in LocToGloBaseMap. More...
 
void ReadGlobalOptimizationParameters ()
 
virtual int v_GetNumElmts (void)
 
virtual void v_Upwind (const Array< OneD, const Array< OneD, NekDouble > > &Vec, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)
 
virtual void v_Upwind (const Array< OneD, const NekDouble > &Vn, const Array< OneD, const NekDouble > &Fwd, const Array< OneD, const NekDouble > &Bwd, Array< OneD, NekDouble > &Upwind)
 
virtual const Array< OneD,
const int > & 
v_GetTraceBndMap ()
 
virtual void v_GetNormals (Array< OneD, Array< OneD, NekDouble > > &normals)
 
virtual void v_AddTraceIntegral (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
virtual void v_MultiplyByInvMassMatrix (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate)
 
virtual void v_LinearAdvectionDiffusionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
 
virtual void v_LinearAdvectionReactionSolve (const Array< OneD, Array< OneD, NekDouble > > &velocity, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const NekDouble lambda, CoeffState coeffstate=eLocal, const Array< OneD, const NekDouble > &dirForcing=NullNekDouble1DArray)
 
virtual void v_ImposeDirichletConditions (Array< OneD, NekDouble > &outarray)
 
virtual void v_FillBndCondFromField ()
 
virtual void v_LocalToGlobal (void)
 
virtual void v_GlobalToLocal (void)
 
virtual void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate)
 
virtual void v_BwdTrans_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate)
 
virtual void v_FwdTrans_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_SmoothField (Array< OneD, NekDouble > &field)
 
virtual void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate)
 
virtual void v_IProductWRTBase_IterPerExp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)
 
virtual void v_PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2)
 
virtual void v_PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)
 
virtual void v_PhysDeriv (Direction edir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d)
 
virtual void v_HomogeneousFwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)
 
virtual void v_HomogeneousBwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal, bool Shuff=true, bool UnShuff=true)
 
virtual void v_DealiasedProd (const Array< OneD, NekDouble > &inarray1, const Array< OneD, NekDouble > &inarray2, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
 
virtual void v_GetBCValues (Array< OneD, NekDouble > &BndVals, const Array< OneD, NekDouble > &TotField, int BndID)
 
virtual void v_NormVectorIProductWRTBase (Array< OneD, const NekDouble > &V1, Array< OneD, const NekDouble > &V2, Array< OneD, NekDouble > &outarray, int BndID)
 
virtual void v_NormVectorIProductWRTBase (Array< OneD, Array< OneD, NekDouble > > &V, Array< OneD, NekDouble > &outarray)
 
virtual void v_ExtractElmtToBndPhys (int i, Array< OneD, NekDouble > &elmt, Array< OneD, NekDouble > &boundary)
 
virtual void v_ExtractPhysToBndElmt (int i, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &bndElmt)
 
virtual void v_GetBoundaryNormals (int i, Array< OneD, Array< OneD, NekDouble > > &normals)
 
virtual std::vector
< LibUtilities::FieldDefinitionsSharedPtr
v_GetFieldDefinitions (void)
 
virtual void v_GetFieldDefinitions (std::vector< LibUtilities::FieldDefinitionsSharedPtr > &fielddef)
 
virtual void v_AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata)
 
virtual void v_AppendFieldData (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, Array< OneD, NekDouble > &coeffs)
 
virtual void v_ExtractDataToCoeffs (LibUtilities::FieldDefinitionsSharedPtr &fielddef, std::vector< NekDouble > &fielddata, std::string &field, Array< OneD, NekDouble > &coeffs)
 Extract data from raw field data into expansion list. More...
 
virtual void v_ExtractCoeffsToCoeffs (const boost::shared_ptr< ExpList > &fromExpList, const Array< OneD, const NekDouble > &fromCoeffs, Array< OneD, NekDouble > &toCoeffs)
 
virtual void v_WriteTecplotHeader (std::ostream &outfile, std::string var="")
 
virtual void v_WriteTecplotZone (std::ostream &outfile, int expansion)
 
virtual void v_WriteTecplotField (std::ostream &outfile, int expansion)
 
virtual void v_WriteTecplotConnectivity (std::ostream &outfile, int expansion)
 
virtual void v_WriteVtkPieceData (std::ostream &outfile, int expansion, std::string var)
 
virtual NekDouble v_L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &soln=NullNekDouble1DArray)
 
virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray)
 
virtual Array< OneD, const
NekDouble
v_HomogeneousEnergy (void)
 
virtual
LibUtilities::TranspositionSharedPtr 
v_GetTransposition (void)
 
virtual NekDouble v_GetHomoLen (void)
 
virtual Array< OneD, const
unsigned int > 
v_GetZIDs (void)
 
virtual Array< OneD, const
unsigned int > 
v_GetYIDs (void)
 
virtual void v_ClearGlobalLinSysManager (void)
 
void ExtractFileBCs (const std::string &fileName, const std::string &varName, const boost::shared_ptr< ExpList > locExpList)
 

Protected Attributes

Array< OneD,
MultiRegions::ExpListSharedPtr
m_bndCondExpansions
 An object which contains the discretised boundary conditions. More...
 
Array< OneD,
SpatialDomains::BoundaryConditionShPtr
m_bndConditions
 An array which contains the information about the boundary condition on the different boundary regions. More...
 
GlobalLinSysMapShPtr m_globalBndMat
 
ExpListSharedPtr m_trace
 
AssemblyMapDGSharedPtr m_traceMap
 
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
 Map of local trace (the points at the face of the element) to the trace space discretisation. More...
 
std::set< int > m_boundaryFaces
 A set storing the global IDs of any boundary faces. More...
 
PeriodicMap m_periodicFaces
 A map which identifies pairs of periodic faces. More...
 
PeriodicMap m_periodicEdges
 A map which identifies groups of periodic edges. More...
 
PeriodicMap m_periodicVerts
 A map which identifies groups of periodic vertices. More...
 
std::vector< bool > m_leftAdjacentFaces
 
std::vector< int > m_periodicFwdCopy
 A vector indicating degress of freedom which need to be copied from forwards to backwards space in case of a periodic boundary condition. More...
 
std::vector< int > m_periodicBwdCopy
 
- Protected Attributes inherited from Nektar::MultiRegions::ExpList
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
LibUtilities::SessionReaderSharedPtr m_session
 Session. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Mesh associated with this expansion list. More...
 
int m_ncoeffs
 The total number of local degrees of freedom. m_ncoeffs $=N_{\mathrm{eof}}=\sum_{e=1}^{{N_{\mathrm{el}}}}N^{e}_l$. More...
 
int m_npoints
 
Array< OneD, NekDoublem_coeffs
 Concatenation of all local expansion coefficients. More...
 
Array< OneD, NekDoublem_phys
 The global expansion evaluated at the quadrature points. More...
 
bool m_physState
 The state of the array m_phys. More...
 
boost::shared_ptr
< LocalRegions::ExpansionVector
m_exp
 The list of local expansions. More...
 
Collections::CollectionVector m_collections
 
std::vector< int > m_coll_coeff_offset
 Offset of elemental data into the array m_coeffs. More...
 
std::vector< int > m_coll_phys_offset
 Offset of elemental data into the array m_phys. More...
 
Array< OneD, int > m_coeff_offset
 Offset of elemental data into the array m_coeffs. More...
 
Array< OneD, int > m_phys_offset
 Offset of elemental data into the array m_phys. More...
 
Array< OneD, int > m_offset_elmt_id
 Array containing the element id m_offset_elmt_id[n] that the n^th consecutive block of data in m_coeffs and m_phys is associated, i.e. for an array of constant expansion size and single shape elements m_phys[n*m_npoints] is the data related to m_exp[m_offset_elmt_id[n]];. More...
 
NekOptimize::GlobalOptParamSharedPtr m_globalOptParam
 
BlockMatrixMapShPtr m_blockMat
 
bool m_WaveSpace
 

Additional Inherited Members

- Public Attributes inherited from Nektar::MultiRegions::ExpList
ExpansionType m_expType
 
- Static Protected Member Functions inherited from Nektar::MultiRegions::ExpList
static
SpatialDomains::BoundaryConditionShPtr 
GetBoundaryCondition (const SpatialDomains::BoundaryConditionCollection &collection, unsigned int index, const std::string &variable)
 

Detailed Description

Abstraction of a global discontinuous three-dimensional spectral/hp element expansion which approximates the solution of a set of partial differential equations.

Definition at line 55 of file DisContField3D.h.

Constructor & Destructor Documentation

Nektar::MultiRegions::DisContField3D::DisContField3D ( )

Default constructor.

Definition at line 66 of file DisContField3D.cpp.

66  :
67  ExpList3D (),
69  m_bndConditions (),
71  {
72  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static ExpListSharedPtr NullExpListSharedPtr
Definition: ExpList.h:1395
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
ExpList3D()
Default constructor.
Definition: ExpList3D.cpp:54
Nektar::MultiRegions::DisContField3D::DisContField3D ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr graph3D,
const std::string &  variable,
const bool  SetUpJustDG = true 
)

Constructs a global discontinuous field based on an input mesh with boundary conditions.

Definition at line 78 of file DisContField3D.cpp.

References Nektar::MultiRegions::ExpList::EvaluateBoundaryConditions(), FindPeriodicFaces(), GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::ExpList::GetBoundaryToElmtMap(), m_bndCondExpansions, Nektar::MultiRegions::ExpList::m_session, and SetUpDG().

83  : ExpList3D (pSession, graph3D, variable),
85  m_bndConditions (),
87  {
88  // do not set up BCs if default variable
89  if (variable.compare("DefaultVar") != 0)
90  {
91  SpatialDomains::BoundaryConditions bcs(m_session, graph3D);
92 
93  GenerateBoundaryConditionExpansion(graph3D,bcs,variable);
94  EvaluateBoundaryConditions(0.0, variable);
95 
96  // Find periodic edges for this variable.
97  FindPeriodicFaces(bcs, variable);
98  }
99 
100  if(SetUpJustDG)
101  {
102  SetUpDG();
103  }
104  else
105  {
106  // Set element edges to point to Robin BC edges if required.
107  int i, cnt, f;
108  Array<OneD, int> ElmtID, FaceID;
109  GetBoundaryToElmtMap(ElmtID, FaceID);
110 
111  for(cnt = i = 0; i < m_bndCondExpansions.num_elements(); ++i)
112  {
114  locExpList = m_bndCondExpansions[i];
115 
116  for(f = 0; f < locExpList->GetExpSize(); ++f)
117  {
119  = (*m_exp)[ElmtID[cnt+f]]->
120  as<LocalRegions::Expansion3D>();
122  = locExpList->GetExp(f)->
123  as<LocalRegions::Expansion2D>();
124 
125  exp3d->SetFaceExp(FaceID[cnt+f],exp2d);
126  exp2d->SetAdjacentElementExp(FaceID[cnt+f],exp3d);
127  }
128  cnt += m_bndCondExpansions[i]->GetExpSize();
129  }
130  }
131  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static ExpListSharedPtr NullExpListSharedPtr
Definition: ExpList.h:1395
void EvaluateBoundaryConditions(const NekDouble time=0.0, const std::string varName="", const NekDouble=NekConstants::kNekUnsetDouble, const NekDouble=NekConstants::kNekUnsetDouble)
Definition: ExpList.h:2091
void GetBoundaryToElmtMap(Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)
Definition: ExpList.h:2144
void FindPeriodicFaces(const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
Determine the periodic faces, edges and vertices for the given graph.
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
void GenerateBoundaryConditionExpansion(const SpatialDomains::MeshGraphSharedPtr &graph3D, const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:910
void SetUpDG(const std::string="DefaultVar")
Set up all DG member variables and maps.
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
ExpList3D()
Default constructor.
Definition: ExpList3D.cpp:54
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
Nektar::MultiRegions::DisContField3D::DisContField3D ( const DisContField3D In,
const SpatialDomains::MeshGraphSharedPtr graph3D,
const std::string &  variable,
const bool  SetUpJustDG = false 
)

Definition at line 137 of file DisContField3D.cpp.

References Nektar::MultiRegions::ExpList::ApplyGeomInfo(), Nektar::MultiRegions::ExpList::EvaluateBoundaryConditions(), FindPeriodicFaces(), GenerateBoundaryConditionExpansion(), Nektar::MultiRegions::ExpList::GetBoundaryToElmtMap(), m_bndCondExpansions, m_globalBndMat, m_locTraceToTraceMap, m_periodicEdges, m_periodicFaces, m_periodicVerts, Nektar::MultiRegions::ExpList::m_session, m_trace, m_traceMap, SameTypeOfBoundaryConditions(), SetUpDG(), and Nektar::MultiRegions::ExpList::SetUpPhysNormals().

142  : ExpList3D(In),
144  {
145  SpatialDomains::BoundaryConditions bcs(m_session, graph3D);
146 
147  GenerateBoundaryConditionExpansion(graph3D,bcs,variable);
148  EvaluateBoundaryConditions(0.0, variable);
149  ApplyGeomInfo();
150 
152  {
153  // Find periodic edges for this variable.
154  FindPeriodicFaces(bcs, variable);
155 
156  if (SetUpJustDG)
157  {
158  SetUpDG(variable);
159  }
160  else
161  {
162  int i,cnt,f;
163  Array<OneD, int> ElmtID,FaceID;
164  GetBoundaryToElmtMap(ElmtID,FaceID);
165 
166  for(cnt = i = 0; i < m_bndCondExpansions.num_elements(); ++i)
167  {
169  locExpList = m_bndCondExpansions[i];
170 
171  for(f = 0; f < locExpList->GetExpSize(); ++f)
172  {
174  = (*m_exp)[ElmtID[cnt+f]]->
175  as<LocalRegions::Expansion3D>();
177  = locExpList->GetExp(f)->
178  as<LocalRegions::Expansion2D>();
179 
180  exp3d->SetFaceExp(FaceID[cnt+f],exp2d);
181  exp2d->SetAdjacentElementExp(FaceID[cnt+f],exp3d);
182  }
183 
184  cnt += m_bndCondExpansions[i]->GetExpSize();
185  }
187  }
188 
189  }
190  //else if we have the same boundary condition
191  else
192  {
193  m_globalBndMat = In.m_globalBndMat;
194  m_trace = In.m_trace;
195  m_traceMap = In.m_traceMap;
196  m_locTraceToTraceMap = In.m_locTraceToTraceMap;
197  m_periodicVerts = In.m_periodicVerts;
198  m_periodicEdges = In.m_periodicEdges;
199  m_periodicFaces = In.m_periodicFaces;
200 
201  if(SetUpJustDG)
202  {
203  }
204  else
205  {
206  int i,cnt,f;
207  Array<OneD, int> ElmtID,FaceID;
208  GetBoundaryToElmtMap(ElmtID,FaceID);
209 
210  for (cnt = i = 0;
211  i < m_bndCondExpansions.num_elements(); ++i)
212  {
214  locExpList = m_bndCondExpansions[i];
215 
216  for(f = 0; f < locExpList->GetExpSize(); ++f)
217  {
219  = (*m_exp)[ElmtID[cnt+f]]->
220  as<LocalRegions::Expansion3D>();
222  = locExpList->GetExp(f)->
223  as<LocalRegions::Expansion2D>();
224 
225  exp3d->SetFaceExp(FaceID[cnt+f], exp2d);
226  exp2d->SetAdjacentElementExp(FaceID[cnt+f], exp3d);
227  }
228 
229  cnt += m_bndCondExpansions[i]->GetExpSize();
230  }
231 
232  if (m_session->DefinesSolverInfo("PROJECTION"))
233  {
234  std::string ProjectStr =
235  m_session->GetSolverInfo("PROJECTION");
236  if (ProjectStr == "MixedCGDG" ||
237  ProjectStr == "Mixed_CG_Discontinuous")
238  {
239  SetUpDG(variable);
240  }
241  else
242  {
244  }
245  }
246  else
247  {
249  }
250  }
251  }
252  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static ExpListSharedPtr NullExpListSharedPtr
Definition: ExpList.h:1395
void EvaluateBoundaryConditions(const NekDouble time=0.0, const std::string varName="", const NekDouble=NekConstants::kNekUnsetDouble, const NekDouble=NekConstants::kNekUnsetDouble)
Definition: ExpList.h:2091
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
void GetBoundaryToElmtMap(Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)
Definition: ExpList.h:2144
void ApplyGeomInfo()
Apply geometry information to each expansion.
Definition: ExpList.cpp:1424
void FindPeriodicFaces(const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
Determine the periodic faces, edges and vertices for the given graph.
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
void GenerateBoundaryConditionExpansion(const SpatialDomains::MeshGraphSharedPtr &graph3D, const SpatialDomains::BoundaryConditions &bcs, const std::string &variable)
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:910
void SetUpDG(const std::string="DefaultVar")
Set up all DG member variables and maps.
bool SameTypeOfBoundaryConditions(const DisContField3D &In)
PeriodicMap m_periodicVerts
A map which identifies groups of periodic vertices.
ExpList3D()
Default constructor.
Definition: ExpList3D.cpp:54
PeriodicMap m_periodicEdges
A map which identifies groups of periodic edges.
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
Nektar::MultiRegions::DisContField3D::DisContField3D ( const DisContField3D In)

Constructs a global discontinuous field based on another discontinuous field.

Definition at line 257 of file DisContField3D.cpp.

257  :
258  ExpList3D(In),
259  m_bndCondExpansions (In.m_bndCondExpansions),
260  m_bndConditions (In.m_bndConditions),
261  m_globalBndMat (In.m_globalBndMat),
262  m_trace (In.m_trace),
263  m_traceMap (In.m_traceMap),
264  m_locTraceToTraceMap (In.m_locTraceToTraceMap),
265  m_periodicFaces (In.m_periodicFaces),
266  m_periodicEdges (In.m_periodicEdges),
267  m_periodicVerts (In.m_periodicVerts)
268  {
269  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
PeriodicMap m_periodicVerts
A map which identifies groups of periodic vertices.
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
ExpList3D()
Default constructor.
Definition: ExpList3D.cpp:54
PeriodicMap m_periodicEdges
A map which identifies groups of periodic edges.
Nektar::MultiRegions::DisContField3D::~DisContField3D ( )
virtual

Destructor.

Definition at line 274 of file DisContField3D.cpp.

275  {
276  }

Member Function Documentation

void Nektar::MultiRegions::DisContField3D::EvaluateHDGPostProcessing ( Array< OneD, NekDouble > &  outarray)

Evaluate HDG post-processing to increase polynomial order of solution.

This function takes the solution (assumed to be one order lower) in physical space, and postprocesses at the current polynomial order by solving the system:

\[ \begin{aligned} (\nabla w, \nabla u^*) &= (\nabla w, u), \\ \langle \nabla u^*, 1 \rangle &= \langle \nabla u, 1 \rangle \end{aligned} \]

where $ u $ corresponds with the current solution as stored inside m_coeffs.

Parameters
outarrayThe resulting field $ u^* $.

Definition at line 2232 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eGaussRadauMAlpha2Beta0, Nektar::LibUtilities::eHexahedron, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eTetrahedron, Nektar::eWrapper, Nektar::MultiRegions::ExpList::GetExpSize(), Nektar::NekVector< DataType >::GetPtr(), Nektar::MultiRegions::ExpList::m_coeff_offset, Nektar::MultiRegions::ExpList::m_coeffs, Nektar::MultiRegions::ExpList::m_offset_elmt_id, m_trace, m_traceMap, Vmath::Vadd(), and Vmath::Vcopy().

2234  {
2235  int i,cnt,f,ncoeff_face;
2236  Array<OneD, NekDouble> force, out_tmp,qrhs,qrhs1;
2237  Array<OneD, Array< OneD, LocalRegions::ExpansionSharedPtr> >
2238  &elmtToTrace = m_traceMap->GetElmtToTrace();
2239 
2240  int eid,nq_elmt, nm_elmt;
2241  int LocBndCoeffs = m_traceMap->GetNumLocalBndCoeffs();
2242  Array<OneD, NekDouble> loc_lambda(LocBndCoeffs), face_lambda;
2243  Array<OneD, NekDouble> tmp_coeffs;
2244  m_traceMap->GlobalToLocalBnd(m_trace->GetCoeffs(),loc_lambda);
2245 
2246  face_lambda = loc_lambda;
2247 
2248  // Calculate Q using standard DG formulation.
2249  for(i = cnt = 0; i < GetExpSize(); ++i)
2250  {
2252  (*m_exp)[i]->as<LocalRegions::Expansion3D>();
2253 
2254  eid = m_offset_elmt_id[i];
2255  nq_elmt = (*m_exp)[eid]->GetTotPoints();
2256  nm_elmt = (*m_exp)[eid]->GetNcoeffs();
2257  qrhs = Array<OneD, NekDouble>(nq_elmt);
2258  qrhs1 = Array<OneD, NekDouble>(nq_elmt);
2259  force = Array<OneD, NekDouble>(2*nm_elmt);
2260  out_tmp = force + nm_elmt;
2262 
2263  int num_points0 = (*m_exp)[eid]->GetBasis(0)->GetNumPoints();
2264  int num_points1 = (*m_exp)[eid]->GetBasis(1)->GetNumPoints();
2265  int num_points2 = (*m_exp)[eid]->GetBasis(2)->GetNumPoints();
2266  int num_modes0 = (*m_exp)[eid]->GetBasis(0)->GetNumModes();
2267  int num_modes1 = (*m_exp)[eid]->GetBasis(1)->GetNumModes();
2268  int num_modes2 = (*m_exp)[eid]->GetBasis(2)->GetNumModes();
2269 
2270  // Probably a better way of setting up lambda than this. Note
2271  // cannot use PutCoeffsInToElmts since lambda space is mapped
2272  // during the solve.
2273  int nFaces = (*m_exp)[eid]->GetNfaces();
2274  Array<OneD, Array<OneD, NekDouble> > faceCoeffs(nFaces);
2275  for(f = 0; f < nFaces; ++f)
2276  {
2277  ncoeff_face = elmtToTrace[eid][f]->GetNcoeffs();
2278  faceCoeffs[f] = Array<OneD, NekDouble>(ncoeff_face);
2279  Vmath::Vcopy(ncoeff_face, face_lambda, 1, faceCoeffs[f], 1);
2280  exp->SetFaceToGeomOrientation(f, faceCoeffs[f]);
2281  face_lambda = face_lambda + ncoeff_face;
2282  }
2283 
2284  //creating orthogonal expansion (checking if we have quads or triangles)
2285  LibUtilities::ShapeType shape = (*m_exp)[eid]->DetShapeType();
2286  switch(shape)
2287  {
2289  {
2290  const LibUtilities::PointsKey PkeyH1(num_points0,LibUtilities::eGaussLobattoLegendre);
2291  const LibUtilities::PointsKey PkeyH2(num_points1,LibUtilities::eGaussLobattoLegendre);
2292  const LibUtilities::PointsKey PkeyH3(num_points2,LibUtilities::eGaussLobattoLegendre);
2293  LibUtilities::BasisKey BkeyH1(LibUtilities::eOrtho_A, num_modes0, PkeyH1);
2294  LibUtilities::BasisKey BkeyH2(LibUtilities::eOrtho_A, num_modes1, PkeyH2);
2295  LibUtilities::BasisKey BkeyH3(LibUtilities::eOrtho_A, num_modes2, PkeyH3);
2296  SpatialDomains::HexGeomSharedPtr hGeom = boost::dynamic_pointer_cast<SpatialDomains::HexGeom>((*m_exp)[eid]->GetGeom());
2297  ppExp = MemoryManager<LocalRegions::HexExp>::AllocateSharedPtr(BkeyH1, BkeyH2, BkeyH3, hGeom);
2298  }
2299  break;
2301  {
2302  const LibUtilities::PointsKey PkeyT1(num_points0,LibUtilities::eGaussLobattoLegendre);
2303  const LibUtilities::PointsKey PkeyT2(num_points1,LibUtilities::eGaussRadauMAlpha1Beta0);
2304  const LibUtilities::PointsKey PkeyT3(num_points2,LibUtilities::eGaussRadauMAlpha2Beta0);
2305  LibUtilities::BasisKey BkeyT1(LibUtilities::eOrtho_A, num_modes0, PkeyT1);
2306  LibUtilities::BasisKey BkeyT2(LibUtilities::eOrtho_B, num_modes1, PkeyT2);
2307  LibUtilities::BasisKey BkeyT3(LibUtilities::eOrtho_C, num_modes2, PkeyT3);
2308  SpatialDomains::TetGeomSharedPtr tGeom = boost::dynamic_pointer_cast<SpatialDomains::TetGeom>((*m_exp)[eid]->GetGeom());
2309  ppExp = MemoryManager<LocalRegions::TetExp>::AllocateSharedPtr(BkeyT1, BkeyT2, BkeyT3, tGeom);
2310  }
2311  break;
2312  case LibUtilities::ePrism:
2313  {
2314  const LibUtilities::PointsKey PkeyP1(num_points0,LibUtilities::eGaussLobattoLegendre);
2315  const LibUtilities::PointsKey PkeyP2(num_points1,LibUtilities::eGaussLobattoLegendre);
2316  const LibUtilities::PointsKey PkeyP3(num_points2,LibUtilities::eGaussRadauMAlpha1Beta0);
2317  LibUtilities::BasisKey BkeyP1(LibUtilities::eOrtho_A, num_modes0, PkeyP1);
2318  LibUtilities::BasisKey BkeyP2(LibUtilities::eOrtho_A, num_modes1, PkeyP2);
2319  LibUtilities::BasisKey BkeyP3(LibUtilities::eOrtho_B, num_modes2, PkeyP3);
2320  SpatialDomains::PrismGeomSharedPtr pGeom = boost::dynamic_pointer_cast<SpatialDomains::PrismGeom>((*m_exp)[eid]->GetGeom());
2321  ppExp = MemoryManager<LocalRegions::PrismExp>::AllocateSharedPtr(BkeyP1, BkeyP2, BkeyP3, pGeom);
2322  }
2323  break;
2324  default:
2325  ASSERTL0(false, "Wrong shape type, HDG postprocessing is not implemented");
2326  };
2327 
2328 
2329  //DGDeriv
2330  // (d/dx w, q_0)
2331  (*m_exp)[eid]->DGDeriv(
2332  0,tmp_coeffs = m_coeffs + m_coeff_offset[eid],
2333  elmtToTrace[eid], faceCoeffs, out_tmp);
2334  (*m_exp)[eid]->BwdTrans(out_tmp,qrhs);
2335  ppExp->IProductWRTDerivBase(0,qrhs,force);
2336 
2337 
2338  // + (d/dy w, q_1)
2339  (*m_exp)[eid]->DGDeriv(
2340  1,tmp_coeffs = m_coeffs + m_coeff_offset[eid],
2341  elmtToTrace[eid], faceCoeffs, out_tmp);
2342  (*m_exp)[eid]->BwdTrans(out_tmp,qrhs);
2343  ppExp->IProductWRTDerivBase(1,qrhs,out_tmp);
2344 
2345  Vmath::Vadd(nm_elmt,force,1,out_tmp,1,force,1);
2346 
2347  // + (d/dz w, q_2)
2348  (*m_exp)[eid]->DGDeriv(
2349  2,tmp_coeffs = m_coeffs + m_coeff_offset[eid],
2350  elmtToTrace[eid], faceCoeffs, out_tmp);
2351  (*m_exp)[eid]->BwdTrans(out_tmp,qrhs);
2352  ppExp->IProductWRTDerivBase(2,qrhs,out_tmp);
2353 
2354  Vmath::Vadd(nm_elmt,force,1,out_tmp,1,force,1);
2355  // determine force[0] = (1,u)
2356  (*m_exp)[eid]->BwdTrans(
2357  tmp_coeffs = m_coeffs + m_coeff_offset[eid],qrhs);
2358  force[0] = (*m_exp)[eid]->Integral(qrhs);
2359 
2360  // multiply by inverse Laplacian matrix
2361  // get matrix inverse
2362  LocalRegions::MatrixKey lapkey(StdRegions::eInvLaplacianWithUnityMean, ppExp->DetShapeType(), *ppExp);
2363  DNekScalMatSharedPtr lapsys = ppExp->GetLocMatrix(lapkey);
2364 
2365  NekVector<NekDouble> in (nm_elmt, force, eWrapper);
2366  NekVector<NekDouble> out(nm_elmt);
2367 
2368  out = (*lapsys)*in;
2369 
2370  // Transforming back to modified basis
2371  Array<OneD, NekDouble> work(nq_elmt);
2372  ppExp->BwdTrans(out.GetPtr(), work);
2373  (*m_exp)[eid]->FwdTrans(work,
2374  tmp_coeffs = outarray + m_coeff_offset[eid]);
2375  }
2376  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:110
Array< OneD, NekDouble > m_coeffs
Concatenation of all local expansion coefficients.
Definition: ExpList.h:939
int GetExpSize(void)
This function returns the number of elements in the expansion.
Definition: ExpList.h:1896
boost::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:57
Principle Orthogonal Functions .
Definition: BasisType.h:47
Array< OneD, int > m_coeff_offset
Offset of elemental data into the array m_coeffs.
Definition: ExpList.h:988
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
Array< OneD, int > m_offset_elmt_id
Array containing the element id m_offset_elmt_id[n] that the n^th consecutive block of data in m_coef...
Definition: ExpList.h:999
Principle Orthogonal Functions .
Definition: BasisType.h:48
Principle Orthogonal Functions .
Definition: BasisType.h:46
boost::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:68
boost::shared_ptr< PrismGeom > PrismGeomSharedPtr
Definition: PrismGeom.h:109
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:58
boost::shared_ptr< TetGeom > TetGeomSharedPtr
Definition: TetGeom.h:106
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:50
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
void Nektar::MultiRegions::DisContField3D::FindPeriodicFaces ( const SpatialDomains::BoundaryConditions bcs,
const std::string &  variable 
)
protected

Determine the periodic faces, edges and vertices for the given graph.

Parameters
bcsInformation about the boundary conditions.
variableSpecifies the field.

Definition at line 668 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::StdRegions::eForwards, Nektar::StdRegions::eNoOrientation, Nektar::SpatialDomains::ePeriodic, Nektar::MultiRegions::ExpList::GetBoundaryCondition(), Nektar::SpatialDomains::BoundaryConditions::GetBoundaryConditions(), Nektar::SpatialDomains::BoundaryConditions::GetBoundaryRegions(), Nektar::SpatialDomains::QuadGeom::GetFaceOrientation(), Nektar::SpatialDomains::TriGeom::GetFaceOrientation(), Nektar::iterator, Nektar::MultiRegions::ExpList::m_graph, m_periodicEdges, m_periodicFaces, m_periodicVerts, Nektar::MultiRegions::ExpList::m_session, Nektar::LibUtilities::ReduceSum, and Vmath::Vsum().

Referenced by DisContField3D().

671  {
673  = bcs.GetBoundaryRegions();
675  = bcs.GetBoundaryConditions();
677  = boost::dynamic_pointer_cast<
678  SpatialDomains::MeshGraph3D>(m_graph);
679  SpatialDomains::BoundaryRegionCollection::const_iterator it;
680 
682  m_session->GetComm()->GetRowComm();
684  m_session->GetCompositeOrdering();
685  LibUtilities::BndRegionOrdering bndRegOrder =
686  m_session->GetBndRegionOrdering();
688  m_graph->GetComposites();
689 
690  // perComps: Stores a unique collection of pairs of periodic
691  // composites (i.e. if composites 1 and 2 are periodic then this map
692  // will contain either the pair (1,2) or (2,1) but not both).
693  //
694  // The four maps allVerts, allCoord, allEdges and allOrient map a
695  // periodic face to a vector containing the vertex ids of the face;
696  // their coordinates; the edge ids of the face; and their
697  // orientation within that face respectively.
698  //
699  // Finally the three sets locVerts, locEdges and locFaces store any
700  // vertices, edges and faces that belong to a periodic composite and
701  // lie on this process.
702  map<int,int> perComps;
703  map<int,vector<int> > allVerts;
704  map<int,SpatialDomains::PointGeomVector> allCoord;
705  map<int,vector<int> > allEdges;
706  map<int,vector<StdRegions::Orientation> > allOrient;
707  set<int> locVerts;
708  set<int> locEdges;
709  set<int> locFaces;
710 
711  int region1ID, region2ID, i, j, k, cnt;
713 
714  // Set up a set of all local verts and edges.
715  for(i = 0; i < (*m_exp).size(); ++i)
716  {
717  for(j = 0; j < (*m_exp)[i]->GetNverts(); ++j)
718  {
719  int id = (*m_exp)[i]->GetGeom()->GetVid(j);
720  locVerts.insert(id);
721  }
722 
723  for(j = 0; j < (*m_exp)[i]->GetNedges(); ++j)
724  {
725  int id = (*m_exp)[i]->GetGeom()->GetEid(j);
726  locEdges.insert(id);
727  }
728  }
729 
730  // Begin by populating the perComps map. We loop over all periodic
731  // boundary conditions and determine the composite associated with
732  // it, then fill out the all* maps.
733  for (it = bregions.begin(); it != bregions.end(); ++it)
734  {
735  locBCond = GetBoundaryCondition(
736  bconditions, it->first, variable);
737 
738  if (locBCond->GetBoundaryConditionType()
740  {
741  continue;
742  }
743 
744  // Identify periodic boundary region IDs.
745  region1ID = it->first;
746  region2ID = boost::static_pointer_cast<
747  SpatialDomains::PeriodicBoundaryCondition>(
748  locBCond)->m_connectedBoundaryRegion;
749 
750  // Check the region only contains a single composite.
751  ASSERTL0(it->second->size() == 1,
752  "Boundary region "+boost::lexical_cast<string>(
753  region1ID)+" should only contain 1 composite.");
754 
755  // From this identify composites by looking at the original
756  // boundary region ordering. Note that in serial the mesh
757  // partitioner is not run, so this map will be empty and
758  // therefore needs to be populated by using the corresponding
759  // boundary region.
760  int cId1, cId2;
761  if (vComm->GetSize() == 1)
762  {
763  cId1 = it->second->begin()->first;
764  cId2 = bregions.find(region2ID)->second->begin()->first;
765  }
766  else
767  {
768  cId1 = bndRegOrder.find(region1ID)->second[0];
769  cId2 = bndRegOrder.find(region2ID)->second[0];
770  }
771 
772  SpatialDomains::Composite c = it->second->begin()->second;
773  vector<unsigned int> tmpOrder;
774 
775  // From the composite, we now construct the allVerts, allEdges
776  // and allCoord map so that they can be transferred across
777  // processors. We also populate the locFaces set to store a
778  // record of all faces local to this process.
779  for (i = 0; i < c->size(); ++i)
780  {
782  boost::dynamic_pointer_cast<
783  SpatialDomains::Geometry2D>((*c)[i]);
784  ASSERTL1(faceGeom, "Unable to cast to shared ptr");
785 
786  // Get geometry ID of this face and store in locFaces.
787  int faceId = (*c)[i]->GetGlobalID();
788  locFaces.insert(faceId);
789 
790  // In serial, mesh partitioning will not have occurred so
791  // need to fill composite ordering map manually.
792  if (vComm->GetSize() == 1)
793  {
794  tmpOrder.push_back((*c)[i]->GetGlobalID());
795  }
796 
797  // Loop over vertices and edges of the face to populate
798  // allVerts, allEdges and allCoord maps.
799  vector<int> vertList, edgeList;
801  vector<StdRegions::Orientation> orientVec;
802  for (j = 0; j < faceGeom->GetNumVerts(); ++j)
803  {
804  vertList .push_back(faceGeom->GetVid (j));
805  edgeList .push_back(faceGeom->GetEid (j));
806  coordVec .push_back(faceGeom->GetVertex(j));
807  orientVec.push_back(faceGeom->GetEorient(j));
808  }
809 
810  allVerts [faceId] = vertList;
811  allEdges [faceId] = edgeList;
812  allCoord [faceId] = coordVec;
813  allOrient[faceId] = orientVec;
814  }
815 
816  // In serial, record the composite ordering in compOrder for
817  // later in the routine.
818  if (vComm->GetSize() == 1)
819  {
820  compOrder[it->second->begin()->first] = tmpOrder;
821  }
822 
823  // See if we already have either region1 or region2 stored in
824  // perComps map already and do a sanity check to ensure regions
825  // are mutually periodic.
826  if (perComps.count(cId1) == 0)
827  {
828  if (perComps.count(cId2) == 0)
829  {
830  perComps[cId1] = cId2;
831  }
832  else
833  {
834  std::stringstream ss;
835  ss << "Boundary region " << cId2 << " should be "
836  << "periodic with " << perComps[cId2] << " but "
837  << "found " << cId1 << " instead!";
838  ASSERTL0(perComps[cId2] == cId1, ss.str());
839  }
840  }
841  else
842  {
843  std::stringstream ss;
844  ss << "Boundary region " << cId1 << " should be "
845  << "periodic with " << perComps[cId1] << " but "
846  << "found " << cId2 << " instead!";
847  ASSERTL0(perComps[cId1] == cId1, ss.str());
848  }
849  }
850 
851  // The next routines process local face lists to exchange vertices,
852  // edges and faces.
853  int n = vComm->GetSize();
854  int p = vComm->GetRank();
855  int totFaces;
856  Array<OneD, int> facecounts(n,0);
857  Array<OneD, int> vertcounts(n,0);
858  Array<OneD, int> faceoffset(n,0);
859  Array<OneD, int> vertoffset(n,0);
860 
861  // First exchange the number of faces on each process.
862  facecounts[p] = locFaces.size();
863  vComm->AllReduce(facecounts, LibUtilities::ReduceSum);
864 
865  // Set up an offset map to allow us to distribute face IDs to all
866  // processors.
867  faceoffset[0] = 0;
868  for (i = 1; i < n; ++i)
869  {
870  faceoffset[i] = faceoffset[i-1] + facecounts[i-1];
871  }
872 
873  // Calculate total number of faces.
874  totFaces = Vmath::Vsum(n, facecounts, 1);
875 
876  // faceIds holds face IDs for each periodic face. faceVerts holds
877  // the number of vertices in this face.
878  Array<OneD, int> faceIds (totFaces, 0);
879  Array<OneD, int> faceVerts(totFaces, 0);
880 
881  // Process p writes IDs of its faces into position faceoffset[p] of
882  // faceIds which allows us to perform an AllReduce to distribute
883  // information amongst processors.
884  set<int>::iterator sIt;
885  for (i = 0, sIt = locFaces.begin(); sIt != locFaces.end(); ++sIt)
886  {
887  faceIds [faceoffset[p] + i ] = *sIt;
888  faceVerts[faceoffset[p] + i++] = allVerts[*sIt].size();
889  }
890 
891  vComm->AllReduce(faceIds, LibUtilities::ReduceSum);
892  vComm->AllReduce(faceVerts, LibUtilities::ReduceSum);
893 
894  // procVerts holds number of vertices (and also edges since each
895  // face is 2D) on each process.
896  Array<OneD, int> procVerts(n,0);
897  int nTotVerts;
898 
899  // Note if there are no periodic faces at all calling Vsum will
900  // cause a segfault.
901  if (totFaces > 0)
902  {
903  // Calculate number of vertices on each processor.
904  nTotVerts = Vmath::Vsum(totFaces, faceVerts, 1);
905  }
906  else
907  {
908  nTotVerts = 0;
909  }
910 
911  for (i = 0; i < n; ++i)
912  {
913  if (facecounts[i] > 0)
914  {
915  procVerts[i] = Vmath::Vsum(
916  facecounts[i], faceVerts + faceoffset[i], 1);
917  }
918  else
919  {
920  procVerts[i] = 0;
921  }
922  }
923 
924  // vertoffset is defined in the same manner as edgeoffset
925  // beforehand.
926  vertoffset[0] = 0;
927  for (i = 1; i < n; ++i)
928  {
929  vertoffset[i] = vertoffset[i-1] + procVerts[i-1];
930  }
931 
932  // At this point we exchange all vertex IDs, edge IDs and vertex
933  // coordinates for each face. The coordinates are necessary because
934  // we need to calculate relative face orientations between periodic
935  // faces to determined edge and vertex connectivity.
936  Array<OneD, int> vertIds(nTotVerts, 0);
937  Array<OneD, int> edgeIds(nTotVerts, 0);
938  Array<OneD, int> edgeOrt(nTotVerts, 0);
939  Array<OneD, NekDouble> vertX (nTotVerts, 0.0);
940  Array<OneD, NekDouble> vertY (nTotVerts, 0.0);
941  Array<OneD, NekDouble> vertZ (nTotVerts, 0.0);
942 
943  for (cnt = 0, sIt = locFaces.begin();
944  sIt != locFaces.end(); ++sIt)
945  {
946  for (j = 0; j < allVerts[*sIt].size(); ++j)
947  {
948  int vertId = allVerts[*sIt][j];
949  vertIds[vertoffset[p] + cnt ] = vertId;
950  vertX [vertoffset[p] + cnt ] = (*allCoord[*sIt][j])(0);
951  vertY [vertoffset[p] + cnt ] = (*allCoord[*sIt][j])(1);
952  vertZ [vertoffset[p] + cnt ] = (*allCoord[*sIt][j])(2);
953  edgeIds[vertoffset[p] + cnt ] = allEdges [*sIt][j];
954  edgeOrt[vertoffset[p] + cnt++] = allOrient[*sIt][j];
955  }
956  }
957 
958  vComm->AllReduce(vertIds, LibUtilities::ReduceSum);
959  vComm->AllReduce(vertX, LibUtilities::ReduceSum);
960  vComm->AllReduce(vertY, LibUtilities::ReduceSum);
961  vComm->AllReduce(vertZ, LibUtilities::ReduceSum);
962  vComm->AllReduce(edgeIds, LibUtilities::ReduceSum);
963  vComm->AllReduce(edgeOrt, LibUtilities::ReduceSum);
964 
965  // Finally now we have all of this information, we construct maps
966  // which make accessing the information easier. These are
967  // conceptually the same as all* maps at the beginning of the
968  // routine, but now hold information for all periodic vertices.
969  map<int, vector<int> > vertMap;
970  map<int, vector<int> > edgeMap;
971  map<int, SpatialDomains::PointGeomVector> coordMap;
972 
973  // These final two maps are required for determining the relative
974  // orientation of periodic edges. vCoMap associates vertex IDs with
975  // their coordinates, and eIdMap maps an edge ID to the two vertices
976  // which construct it.
977  map<int, SpatialDomains::PointGeomSharedPtr> vCoMap;
978  map<int, pair<int, int> > eIdMap;
979 
980  for (cnt = i = 0; i < totFaces; ++i)
981  {
982  vector<int> edges(faceVerts[i]);
983  vector<int> verts(faceVerts[i]);
984  SpatialDomains::PointGeomVector coord(faceVerts[i]);
985 
986  // Keep track of cnt to enable correct edge vertices to be
987  // inserted into eIdMap.
988  int tmp = cnt;
989  for (j = 0; j < faceVerts[i]; ++j, ++cnt)
990  {
991  edges[j] = edgeIds[cnt];
992  verts[j] = vertIds[cnt];
995  3, verts[j], vertX[cnt], vertY[cnt], vertZ[cnt]);
996  vCoMap[vertIds[cnt]] = coord[j];
997 
998  // Try to insert edge into the eIdMap to avoid re-inserting.
999  pair<map<int, pair<int, int> >::iterator, bool> testIns =
1000  eIdMap.insert(make_pair(
1001  edgeIds[cnt],
1002  make_pair(vertIds[tmp+j],
1003  vertIds[tmp+((j+1) % faceVerts[i])])));
1004 
1005  if (testIns.second == false)
1006  {
1007  continue;
1008  }
1009 
1010  // If the edge is reversed with respect to the face, then
1011  // swap the edges so that we have the original ordering of
1012  // the edge in the 3D element. This is necessary to properly
1013  // determine edge orientation.
1014  if ((StdRegions::Orientation)edgeOrt[cnt]
1016  {
1017  swap(testIns.first->second.first,
1018  testIns.first->second.second);
1019  }
1020  }
1021 
1022  vertMap [faceIds[i]] = verts;
1023  edgeMap [faceIds[i]] = edges;
1024  coordMap[faceIds[i]] = coord;
1025  }
1026 
1027  // Go through list of composites and figure out which edges are
1028  // parallel from original ordering in session file. This includes
1029  // composites which are not necessarily on this process.
1030  map<int,int>::iterator cIt, pIt;
1031  map<int,int>::const_iterator oIt;
1032 
1033  // Store temporary map of periodic vertices which will hold all
1034  // periodic vertices on the entire mesh so that doubly periodic
1035  // vertices/edges can be counted properly across partitions. Local
1036  // vertices/edges are copied into m_periodicVerts and
1037  // m_periodicEdges at the end of the function.
1038  PeriodicMap periodicVerts;
1039  PeriodicMap periodicEdges;
1040 
1041  // Construct two maps which determine how vertices and edges of
1042  // faces connect given a specific face orientation. The key of the
1043  // map is the number of vertices in the face, used to determine
1044  // difference between tris and quads.
1045  map<int, map<StdRegions::Orientation, vector<int> > > vmap;
1046  map<int, map<StdRegions::Orientation, vector<int> > > emap;
1047 
1048  map<StdRegions::Orientation, vector<int> > quadVertMap;
1049  quadVertMap[StdRegions::eDir1FwdDir1_Dir2FwdDir2] += 0,1,2,3;
1050  quadVertMap[StdRegions::eDir1FwdDir1_Dir2BwdDir2] += 3,2,1,0;
1051  quadVertMap[StdRegions::eDir1BwdDir1_Dir2FwdDir2] += 1,0,3,2;
1052  quadVertMap[StdRegions::eDir1BwdDir1_Dir2BwdDir2] += 2,3,0,1;
1053  quadVertMap[StdRegions::eDir1FwdDir2_Dir2FwdDir1] += 0,3,2,1;
1054  quadVertMap[StdRegions::eDir1FwdDir2_Dir2BwdDir1] += 1,2,3,0;
1055  quadVertMap[StdRegions::eDir1BwdDir2_Dir2FwdDir1] += 3,0,1,2;
1056  quadVertMap[StdRegions::eDir1BwdDir2_Dir2BwdDir1] += 2,1,0,3;
1057 
1058  map<StdRegions::Orientation, vector<int> > quadEdgeMap;
1059  quadEdgeMap[StdRegions::eDir1FwdDir1_Dir2FwdDir2] += 0,1,2,3;
1060  quadEdgeMap[StdRegions::eDir1FwdDir1_Dir2BwdDir2] += 2,1,0,3;
1061  quadEdgeMap[StdRegions::eDir1BwdDir1_Dir2FwdDir2] += 0,3,2,1;
1062  quadEdgeMap[StdRegions::eDir1BwdDir1_Dir2BwdDir2] += 2,3,0,1;
1063  quadEdgeMap[StdRegions::eDir1FwdDir2_Dir2FwdDir1] += 3,2,1,0;
1064  quadEdgeMap[StdRegions::eDir1FwdDir2_Dir2BwdDir1] += 1,2,3,0;
1065  quadEdgeMap[StdRegions::eDir1BwdDir2_Dir2FwdDir1] += 3,0,1,2;
1066  quadEdgeMap[StdRegions::eDir1BwdDir2_Dir2BwdDir1] += 1,0,3,2;
1067 
1068  map<StdRegions::Orientation, vector<int> > triVertMap;
1069  triVertMap[StdRegions::eDir1FwdDir1_Dir2FwdDir2] += 0,1,2;
1070  triVertMap[StdRegions::eDir1BwdDir1_Dir2FwdDir2] += 1,0,2;
1071 
1072  map<StdRegions::Orientation, vector<int> > triEdgeMap;
1073  triEdgeMap[StdRegions::eDir1FwdDir1_Dir2FwdDir2] += 0,1,2;
1074  triEdgeMap[StdRegions::eDir1BwdDir1_Dir2FwdDir2] += 0,2,1;
1075 
1076  vmap[3] = triVertMap;
1077  vmap[4] = quadVertMap;
1078  emap[3] = triEdgeMap;
1079  emap[4] = quadEdgeMap;
1080 
1081  map<int,int> allCompPairs;
1082 
1083  // Finally we have enough information to populate the periodic
1084  // vertex, edge and face maps. Begin by looping over all pairs of
1085  // periodic composites to determine pairs of periodic faces.
1086  for (cIt = perComps.begin(); cIt != perComps.end(); ++cIt)
1087  {
1089  const int id1 = cIt->first;
1090  const int id2 = cIt->second;
1091  std::string id1s = boost::lexical_cast<string>(id1);
1092  std::string id2s = boost::lexical_cast<string>(id2);
1093 
1094  if (compMap.count(id1) > 0)
1095  {
1096  c[0] = compMap[id1];
1097  }
1098 
1099  if (compMap.count(id2) > 0)
1100  {
1101  c[1] = compMap[id2];
1102  }
1103 
1104  ASSERTL0(c[0] || c[1],
1105  "Neither composite not found on this process!");
1106 
1107  // Loop over composite ordering to construct list of all
1108  // periodic faces, regardless of whether they are on this
1109  // process.
1110  map<int,int> compPairs;
1111 
1112  ASSERTL0(compOrder.count(id1) > 0,
1113  "Unable to find composite "+id1s+" in order map.");
1114  ASSERTL0(compOrder.count(id2) > 0,
1115  "Unable to find composite "+id2s+" in order map.");
1116  ASSERTL0(compOrder[id1].size() == compOrder[id2].size(),
1117  "Periodic composites "+id1s+" and "+id2s+
1118  " should have the same number of elements.");
1119  ASSERTL0(compOrder[id1].size() > 0,
1120  "Periodic composites "+id1s+" and "+id2s+
1121  " are empty!");
1122 
1123  // Look up composite ordering to determine pairs.
1124  for (i = 0; i < compOrder[id1].size(); ++i)
1125  {
1126  int eId1 = compOrder[id1][i];
1127  int eId2 = compOrder[id2][i];
1128 
1129  ASSERTL0(compPairs.count(eId1) == 0,
1130  "Already paired.");
1131 
1132  // Sanity check that the faces are mutually periodic.
1133  if (compPairs.count(eId2) != 0)
1134  {
1135  ASSERTL0(compPairs[eId2] == eId1, "Pairing incorrect");
1136  }
1137  compPairs[eId1] = eId2;
1138  }
1139 
1140  // Now that we have all pairs of periodic faces, loop over the
1141  // ones local to this process and populate face/edge/vertex
1142  // maps.
1143  for (pIt = compPairs.begin(); pIt != compPairs.end(); ++pIt)
1144  {
1145  int ids [2] = {pIt->first, pIt->second};
1146  bool local[2] = {locFaces.count(pIt->first) > 0,
1147  locFaces.count(pIt->second) > 0};
1148 
1149  ASSERTL0(coordMap.count(ids[0]) > 0 &&
1150  coordMap.count(ids[1]) > 0,
1151  "Unable to find face in coordinate map");
1152 
1153  allCompPairs[pIt->first ] = pIt->second;
1154  allCompPairs[pIt->second] = pIt->first;
1155 
1156  // Loop up coordinates of the faces, check they have the
1157  // same number of vertices.
1159  = { coordMap[ids[0]], coordMap[ids[1]] };
1160 
1161  ASSERTL0(tmpVec[0].size() == tmpVec[1].size(),
1162  "Two periodic faces have different number "
1163  "of vertices!");
1164 
1165  // o will store relative orientation of faces. Note that in
1166  // some transpose cases (Dir1FwdDir2_Dir2BwdDir1 and
1167  // Dir1BwdDir1_Dir2FwdDir1) it seems orientation will be
1168  // different going from face1->face2 instead of face2->face1
1169  // (check this).
1171 
1172  // Record periodic faces.
1173  for (i = 0; i < 2; ++i)
1174  {
1175  if (!local[i])
1176  {
1177  continue;
1178  }
1179 
1180  // Reference to the other face.
1181  int other = (i+1) % 2;
1182 
1183  // Calculate relative face orientation.
1184  if (tmpVec[0].size() == 3)
1185  {
1187  tmpVec[i], tmpVec[other]);
1188  }
1189  else
1190  {
1192  tmpVec[i], tmpVec[other]);
1193  }
1194 
1195  // Record face ID, orientation and whether other face is
1196  // local.
1197  PeriodicEntity ent(ids [other], o,
1198  local[other]);
1199  m_periodicFaces[ids[i]].push_back(ent);
1200  }
1201 
1202  int nFaceVerts = vertMap[ids[0]].size();
1203 
1204  // Determine periodic vertices.
1205  for (i = 0; i < 2; ++i)
1206  {
1207  int other = (i+1) % 2;
1208 
1209  // Calculate relative face orientation.
1210  if (tmpVec[0].size() == 3)
1211  {
1213  tmpVec[i], tmpVec[other]);
1214  }
1215  else
1216  {
1218  tmpVec[i], tmpVec[other]);
1219  }
1220 
1221  if (nFaceVerts == 3)
1222  {
1223  ASSERTL0(
1226  "Unsupported face orientation for face "+
1227  boost::lexical_cast<string>(ids[i]));
1228  }
1229 
1230  // Look up vertices for this face.
1231  vector<int> per1 = vertMap[ids[i]];
1232  vector<int> per2 = vertMap[ids[other]];
1233 
1234  // tmpMap will hold the pairs of vertices which are
1235  // periodic.
1236  map<int, pair<int, bool> > tmpMap;
1237  map<int, pair<int, bool> >::iterator mIt;
1238 
1239  // Use vmap to determine which vertices connect given
1240  // the orientation o.
1241  for (j = 0; j < nFaceVerts; ++j)
1242  {
1243  int v = vmap[nFaceVerts][o][j];
1244  tmpMap[per1[j]] = make_pair(
1245  per2[v], locVerts.count(per2[v]) > 0);
1246  }
1247 
1248  // Now loop over tmpMap to associate periodic vertices.
1249  for (mIt = tmpMap.begin(); mIt != tmpMap.end(); ++mIt)
1250  {
1251  PeriodicEntity ent2(mIt->second.first,
1253  mIt->second.second);
1254 
1255  // See if this vertex has been recorded already.
1256  PeriodicMap::iterator perIt = periodicVerts.find(
1257  mIt->first);
1258 
1259  if (perIt == periodicVerts.end())
1260  {
1261  // Vertex is new - just record this entity as
1262  // usual.
1263  periodicVerts[mIt->first].push_back(ent2);
1264  perIt = periodicVerts.find(mIt->first);
1265  }
1266  else
1267  {
1268  // Vertex is known - loop over the vertices
1269  // inside the record and potentially add vertex
1270  // mIt->second to the list.
1271  for (k = 0; k < perIt->second.size(); ++k)
1272  {
1273  if (perIt->second[k].id == mIt->second.first)
1274  {
1275  break;
1276  }
1277  }
1278 
1279  if (k == perIt->second.size())
1280  {
1281  perIt->second.push_back(ent2);
1282  }
1283  }
1284  }
1285  }
1286 
1287  // Determine periodic edges. Logic is the same as above,
1288  // and perhaps should be condensed to avoid replication.
1289  for (i = 0; i < 2; ++i)
1290  {
1291  int other = (i+1) % 2;
1292 
1293  if (tmpVec[0].size() == 3)
1294  {
1296  tmpVec[i], tmpVec[other]);
1297  }
1298  else
1299  {
1301  tmpVec[i], tmpVec[other]);
1302  }
1303 
1304  vector<int> per1 = edgeMap[ids[i]];
1305  vector<int> per2 = edgeMap[ids[other]];
1306 
1307  map<int, pair<int, bool> > tmpMap;
1308  map<int, pair<int, bool> >::iterator mIt;
1309 
1310  for (j = 0; j < nFaceVerts; ++j)
1311  {
1312  int e = emap[nFaceVerts][o][j];
1313  tmpMap[per1[j]] = make_pair(
1314  per2[e], locEdges.count(per2[e]) > 0);
1315  }
1316 
1317  for (mIt = tmpMap.begin(); mIt != tmpMap.end(); ++mIt)
1318  {
1319  // Note we assume orientation of edges is forwards -
1320  // this may be reversed later.
1321  PeriodicEntity ent2(mIt->second.first,
1323  mIt->second.second);
1324  PeriodicMap::iterator perIt = periodicEdges.find(
1325  mIt->first);
1326 
1327  if (perIt == periodicEdges.end())
1328  {
1329  periodicEdges[mIt->first].push_back(ent2);
1330  perIt = periodicEdges.find(mIt->first);
1331  }
1332  else
1333  {
1334  for (k = 0; k < perIt->second.size(); ++k)
1335  {
1336  if (perIt->second[k].id == mIt->second.first)
1337  {
1338  break;
1339  }
1340  }
1341 
1342  if (k == perIt->second.size())
1343  {
1344  perIt->second.push_back(ent2);
1345  }
1346  }
1347  }
1348  }
1349  }
1350  }
1351 
1352  Array<OneD, int> pairSizes(n, 0);
1353  pairSizes[p] = allCompPairs.size();
1354  vComm->AllReduce(pairSizes, LibUtilities::ReduceSum);
1355 
1356  int totPairSizes = Vmath::Vsum(n, pairSizes, 1);
1357 
1358  Array<OneD, int> pairOffsets(n, 0);
1359  pairOffsets[0] = 0;
1360 
1361  for (i = 1; i < n; ++i)
1362  {
1363  pairOffsets[i] = pairOffsets[i-1] + pairSizes[i-1];
1364  }
1365 
1366  Array<OneD, int> first (totPairSizes, 0);
1367  Array<OneD, int> second(totPairSizes, 0);
1368 
1369  cnt = pairOffsets[p];
1370 
1371  for (pIt = allCompPairs.begin(); pIt != allCompPairs.end(); ++pIt)
1372  {
1373  first [cnt ] = pIt->first;
1374  second[cnt++] = pIt->second;
1375  }
1376 
1377  vComm->AllReduce(first, LibUtilities::ReduceSum);
1378  vComm->AllReduce(second, LibUtilities::ReduceSum);
1379 
1380  allCompPairs.clear();
1381 
1382  for(cnt = 0; cnt < totPairSizes; ++cnt)
1383  {
1384  allCompPairs[first[cnt]] = second[cnt];
1385  }
1386 
1387  // Search for periodic vertices and edges which are not
1388  // in a periodic composite but lie in this process. First,
1389  // loop over all information we have from other
1390  // processors.
1391  for (cnt = i = 0; i < totFaces; ++i)
1392  {
1393  int faceId = faceIds[i];
1394 
1395  ASSERTL0(allCompPairs.count(faceId) > 0,
1396  "Unable to find matching periodic face.");
1397 
1398  int perFaceId = allCompPairs[faceId];
1399 
1400  for (j = 0; j < faceVerts[i]; ++j, ++cnt)
1401  {
1402  int vId = vertIds[cnt];
1403 
1404  PeriodicMap::iterator perId = periodicVerts.find(vId);
1405 
1406  if (perId == periodicVerts.end())
1407  {
1408 
1409  // This vertex is not included in the map. Figure out which
1410  // vertex it is supposed to be periodic with. perFaceId is
1411  // the face ID which is periodic with faceId. The logic is
1412  // much the same as the loop above.
1414  = { coordMap[faceId], coordMap[perFaceId] };
1415 
1416  int nFaceVerts = tmpVec[0].size();
1417  StdRegions::Orientation o = nFaceVerts == 3 ?
1419  tmpVec[0], tmpVec[1]) :
1420  SpatialDomains::QuadGeom::GetFaceOrientation(
1421  tmpVec[0], tmpVec[1]);
1422 
1423  // Use vmap to determine which vertex of the other face
1424  // should be periodic with this one.
1425  int perVertexId = vertMap[perFaceId][vmap[nFaceVerts][o][j]];
1426 
1427 
1428  PeriodicEntity ent(perVertexId,
1430  locVerts.count(perVertexId) > 0);
1431 
1432  periodicVerts[vId].push_back(ent);
1433  }
1434 
1435  int eId = edgeIds[cnt];
1436 
1437  perId = periodicEdges.find(eId);
1438 
1439  if (perId == periodicEdges.end())
1440  {
1441  // This edge is not included in the map. Figure
1442  // out which edge it is supposed to be periodic
1443  // with. perFaceId is the face ID which is
1444  // periodic with faceId. The logic is much the
1445  // same as the loop above.
1447  = { coordMap[faceId], coordMap[perFaceId] };
1448 
1449  int nFaceEdges = tmpVec[0].size();
1450  StdRegions::Orientation o = nFaceEdges == 3 ?
1452  tmpVec[0], tmpVec[1]) :
1453  SpatialDomains::QuadGeom::GetFaceOrientation(
1454  tmpVec[0], tmpVec[1]);
1455 
1456  // Use emap to determine which edge of the other
1457  // face should be periodic with this one.
1458  int perEdgeId = edgeMap[perFaceId][emap[nFaceEdges][o][j]];
1459 
1460 
1461  PeriodicEntity ent(perEdgeId,
1463  locEdges.count(perEdgeId) > 0);
1464 
1465  periodicEdges[eId].push_back(ent);
1466  }
1467  }
1468  }
1469 
1470  // Finally, we must loop over the periodicVerts and periodicEdges
1471  // map to complete connectivity information.
1472  PeriodicMap::iterator perIt, perIt2;
1473  for (perIt = periodicVerts.begin();
1474  perIt != periodicVerts.end(); ++perIt)
1475  {
1476  // For each vertex that is periodic with this one...
1477  for (i = 0; i < perIt->second.size(); ++i)
1478  {
1479  // Find the vertex in the periodicVerts map...
1480  perIt2 = periodicVerts.find(perIt->second[i].id);
1481  ASSERTL0(perIt2 != periodicVerts.end(),
1482  "Couldn't find periodic vertex.");
1483 
1484  // Now search through this vertex's list and make sure that
1485  // we have a record of any vertices which aren't in the
1486  // original list.
1487  for (j = 0; j < perIt2->second.size(); ++j)
1488  {
1489  if (perIt2->second[j].id == perIt->first)
1490  {
1491  continue;
1492  }
1493 
1494  for (k = 0; k < perIt->second.size(); ++k)
1495  {
1496  if (perIt2->second[j].id == perIt->second[k].id)
1497  {
1498  break;
1499  }
1500  }
1501 
1502  if (k == perIt->second.size())
1503  {
1504  perIt->second.push_back(perIt2->second[j]);
1505  }
1506  }
1507  }
1508  }
1509 
1510  for (perIt = periodicEdges.begin();
1511  perIt != periodicEdges.end(); ++perIt)
1512  {
1513  for (i = 0; i < perIt->second.size(); ++i)
1514  {
1515  perIt2 = periodicEdges.find(perIt->second[i].id);
1516  ASSERTL0(perIt2 != periodicEdges.end(),
1517  "Couldn't find periodic edge.");
1518 
1519  for (j = 0; j < perIt2->second.size(); ++j)
1520  {
1521  if (perIt2->second[j].id == perIt->first)
1522  {
1523  continue;
1524  }
1525 
1526  for (k = 0; k < perIt->second.size(); ++k)
1527  {
1528  if (perIt2->second[j].id == perIt->second[k].id)
1529  {
1530  break;
1531  }
1532  }
1533 
1534  if (k == perIt->second.size())
1535  {
1536  perIt->second.push_back(perIt2->second[j]);
1537  }
1538  }
1539  }
1540  }
1541 
1542  // Loop over periodic edges to determine relative edge orientations.
1543  for (perIt = periodicEdges.begin();
1544  perIt != periodicEdges.end(); perIt++)
1545  {
1546  // Find edge coordinates
1547  map<int, pair<int, int> >::iterator eIt
1548  = eIdMap.find(perIt->first);
1549  SpatialDomains::PointGeom v[2] = {
1550  *vCoMap[eIt->second.first],
1551  *vCoMap[eIt->second.second]
1552  };
1553 
1554  // Loop over each edge, and construct a vector that takes us
1555  // from one vertex to another. Use this to figure out which
1556  // vertex maps to which.
1557  for (i = 0; i < perIt->second.size(); ++i)
1558  {
1559  eIt = eIdMap.find(perIt->second[i].id);
1560 
1561  SpatialDomains::PointGeom w[2] = {
1562  *vCoMap[eIt->second.first],
1563  *vCoMap[eIt->second.second]
1564  };
1565 
1566  NekDouble cx = 0.5*(w[0](0)-v[0](0)+w[1](0)-v[1](0));
1567  NekDouble cy = 0.5*(w[0](1)-v[0](1)+w[1](1)-v[1](1));
1568  NekDouble cz = 0.5*(w[0](2)-v[0](2)+w[1](2)-v[1](2));
1569 
1570  int vMap[2] = {-1,-1};
1571  for (j = 0; j < 2; ++j)
1572  {
1573  NekDouble x = v[j](0);
1574  NekDouble y = v[j](1);
1575  NekDouble z = v[j](2);
1576  for (k = 0; k < 2; ++k)
1577  {
1578  NekDouble x1 = w[k](0)-cx;
1579  NekDouble y1 = w[k](1)-cy;
1580  NekDouble z1 = w[k](2)-cz;
1581 
1582  if (sqrt((x1-x)*(x1-x)+(y1-y)*(y1-y)+(z1-z)*(z1-z))
1583  < 1e-8)
1584  {
1585  vMap[k] = j;
1586  break;
1587  }
1588  }
1589  }
1590 
1591  // Sanity check the map.
1592  ASSERTL0(vMap[0] >= 0 && vMap[1] >= 0,
1593  "Unable to align periodic vertices.");
1594  ASSERTL0((vMap[0] == 0 || vMap[0] == 1) &&
1595  (vMap[1] == 0 || vMap[1] == 1) &&
1596  (vMap[0] != vMap[1]),
1597  "Unable to align periodic vertices.");
1598 
1599  // If 0 -> 0 then edges are aligned already; otherwise
1600  // reverse the orientation.
1601  if (vMap[0] != 0)
1602  {
1603  perIt->second[i].orient = StdRegions::eBackwards;
1604  }
1605  }
1606  }
1607 
1608  // Do one final loop over periodic vertices/edges to remove
1609  // non-local vertices/edges from map.
1610  for (perIt = periodicVerts.begin();
1611  perIt != periodicVerts.end(); ++perIt)
1612  {
1613  if (locVerts.count(perIt->first) > 0)
1614  {
1615  m_periodicVerts.insert(*perIt);
1616  }
1617  }
1618 
1619  for (perIt = periodicEdges.begin();
1620  perIt != periodicEdges.end(); ++perIt)
1621  {
1622  if (locEdges.count(perIt->first) > 0)
1623  {
1624  m_periodicEdges.insert(*perIt);
1625  }
1626  }
1627  }
boost::shared_ptr< MeshGraph3D > MeshGraph3DSharedPtr
Definition: MeshGraph3D.h:224
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
std::vector< PointGeomSharedPtr > PointGeomVector
Definition: Geometry3D.h:61
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
std::map< int, std::vector< unsigned int > > BndRegionOrdering
Definition: MeshPartition.h:54
std::map< int, std::vector< unsigned int > > CompositeOrdering
Definition: MeshPartition.h:53
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:53
static StdRegions::Orientation GetFaceOrientation(const QuadGeom &face1, const QuadGeom &face2)
Get the orientation of face1.
Definition: QuadGeom.cpp:254
std::map< int, BoundaryRegionShPtr > BoundaryRegionCollection
Definition: Conditions.h:206
SpatialDomains::MeshGraphSharedPtr m_graph
Mesh associated with this expansion list.
Definition: ExpList.h:913
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:910
double NekDouble
std::map< int, BoundaryConditionMapShPtr > BoundaryConditionCollection
Definition: Conditions.h:215
boost::shared_ptr< GeometryVector > Composite
Definition: MeshGraph.h:114
std::map< int, std::vector< PeriodicEntity > > PeriodicMap
std::map< int, Composite > CompositeMap
Definition: MeshGraph.h:115
boost::shared_ptr< Geometry2D > Geometry2DSharedPtr
Definition: Geometry2D.h:59
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
PeriodicMap m_periodicVerts
A map which identifies groups of periodic vertices.
static SpatialDomains::BoundaryConditionShPtr GetBoundaryCondition(const SpatialDomains::BoundaryConditionCollection &collection, unsigned int index, const std::string &variable)
Definition: ExpList.cpp:2860
static StdRegions::Orientation GetFaceOrientation(const TriGeom &face1, const TriGeom &face2)
Definition: TriGeom.cpp:237
boost::shared_ptr< BoundaryConditionBase > BoundaryConditionShPtr
Definition: Conditions.h:208
T Vsum(int n, const T *x, const int incx)
Subtract return sum(x)
Definition: Vmath.cpp:723
struct Nektar::MultiRegions::_PeriodicEntity PeriodicEntity
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
PeriodicMap m_periodicEdges
A map which identifies groups of periodic edges.
void Nektar::MultiRegions::DisContField3D::GenerateBoundaryConditionExpansion ( const SpatialDomains::MeshGraphSharedPtr graph3D,
const SpatialDomains::BoundaryConditions bcs,
const std::string &  variable 
)
protected

According to their boundary region, the separate segmental boundary expansions are bundled together in an object of the class MultiRegions::ExpList2D.

Parameters
graph3DA mesh, containing information about the domain and the spectral/hp element expansion.
bcsAn entity containing information about the boundaries and boundary conditions.
variableAn optional parameter to indicate for which variable the boundary conditions should be discretised.

Definition at line 603 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SpatialDomains::eDirichlet, Nektar::SpatialDomains::ePeriodic, Nektar::MultiRegions::ExpList::GetBoundaryCondition(), Nektar::SpatialDomains::BoundaryConditions::GetBoundaryConditions(), Nektar::SpatialDomains::BoundaryConditions::GetBoundaryRegions(), m_bndCondExpansions, m_bndConditions, Nektar::MultiRegions::ExpList::m_session, and Nektar::MultiRegions::ExpList::SetUpPhysNormals().

Referenced by DisContField3D().

607  {
608  int cnt = 0;
611 
613  bcs.GetBoundaryRegions();
614  const SpatialDomains::BoundaryConditionCollection &bconditions =
615  bcs.GetBoundaryConditions();
616  SpatialDomains::BoundaryRegionCollection::const_iterator it;
617 
618  // count the number of non-periodic boundary regions
619  for (it = bregions.begin(); it != bregions.end(); ++it)
620  {
621  SpatialDomains::BoundaryConditionShPtr boundaryCondition =
622  GetBoundaryCondition(bconditions, it->first, variable);
623  if (boundaryCondition->GetBoundaryConditionType() !=
625  {
626  cnt++;
627  }
628  }
629 
630  m_bndCondExpansions = Array<OneD,MultiRegions::ExpListSharedPtr>(cnt);
631  m_bndConditions = Array<OneD,SpatialDomains::BoundaryConditionShPtr>(cnt);
632 
633  cnt = 0;
634 
635  // list Dirichlet boundaries first
636  for (it = bregions.begin(); it != bregions.end(); ++it)
637  {
638  locBCond = GetBoundaryCondition(
639  bconditions, it->first, variable);
640 
641  if(locBCond->GetBoundaryConditionType()
643  {
645  ::AllocateSharedPtr(m_session, *(it->second),
646  graph3D, variable);
647 
648  // Set up normals on non-Dirichlet boundary conditions
649  if(locBCond->GetBoundaryConditionType() !=
651  {
653  }
654 
655  m_bndCondExpansions[cnt] = locExpList;
656  m_bndConditions[cnt++] = locBCond;
657  }
658  }
659  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
std::map< int, BoundaryRegionShPtr > BoundaryRegionCollection
Definition: Conditions.h:206
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:910
std::map< int, BoundaryConditionMapShPtr > BoundaryConditionCollection
Definition: Conditions.h:215
boost::shared_ptr< ExpList2D > ExpList2DSharedPtr
Shared pointer to an ExpList2D object.
Definition: ExpList2D.h:49
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
static SpatialDomains::BoundaryConditionShPtr GetBoundaryCondition(const SpatialDomains::BoundaryConditionCollection &collection, unsigned int index, const std::string &variable)
Definition: ExpList.cpp:2860
boost::shared_ptr< BoundaryConditionBase > BoundaryConditionShPtr
Definition: Conditions.h:208
GlobalLinSysSharedPtr Nektar::MultiRegions::DisContField3D::GetGlobalBndLinSys ( const GlobalLinSysKey mkey)

Definition at line 278 of file DisContField3D.cpp.

References ASSERTL0, ASSERTL1, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::MultiRegions::ExpList::GenGlobalBndLinSys(), Nektar::MultiRegions::GlobalLinSysKey::GetGlobalSysSolnType(), Nektar::MultiRegions::GlobalMatrixKey::GetMatrixType(), Nektar::iterator, m_globalBndMat, and m_traceMap.

Referenced by v_HelmSolve().

280  {
281  ASSERTL0(mkey.GetMatrixType() == StdRegions::eHybridDGHelmBndLam,
282  "Routine currently only tested for HybridDGHelmholtz");
283  ASSERTL1(mkey.GetGlobalSysSolnType() ==
284  m_traceMap->GetGlobalSysSolnType(),
285  "The local to global map is not set up for the requested "
286  "solution type");
287 
288  GlobalLinSysSharedPtr glo_matrix;
289  GlobalLinSysMap::iterator matrixIter = m_globalBndMat->find(mkey);
290 
291  if (matrixIter == m_globalBndMat->end())
292  {
293  glo_matrix = GenGlobalBndLinSys(mkey, m_traceMap);
294  (*m_globalBndMat)[mkey] = glo_matrix;
295  }
296  else
297  {
298  glo_matrix = matrixIter->second;
299  }
300 
301  return glo_matrix;
302  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
boost::shared_ptr< GlobalLinSys > GenGlobalBndLinSys(const GlobalLinSysKey &mkey, const AssemblyMapSharedPtr &locToGloMap)
Generate a GlobalLinSys from information provided by the key "mkey" and the mapping provided in LocTo...
Definition: ExpList.cpp:1194
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
boost::shared_ptr< GlobalLinSys > GlobalLinSysSharedPtr
Pointer to a GlobalLinSys object.
Definition: GlobalLinSys.h:52
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
bool Nektar::MultiRegions::DisContField3D::GetLeftAdjacentFaces ( int  cnt)
inline

Definition at line 86 of file DisContField3D.h.

References m_leftAdjacentFaces.

87  {
88  return m_leftAdjacentFaces[cnt];
89  }
bool Nektar::MultiRegions::DisContField3D::IsLeftAdjacentFace ( const int  n,
const int  e 
)
protected

Definition at line 1629 of file DisContField3D.cpp.

References ASSERTL2, Nektar::iterator, m_boundaryFaces, Nektar::MultiRegions::ExpList::m_exp, m_periodicFaces, m_trace, and m_traceMap.

Referenced by SetUpDG().

1630  {
1631  set<int>::iterator it;
1633  m_traceMap->GetElmtToTrace()[n][e]->
1634  as<LocalRegions::Expansion2D>();
1635 
1636  int offset = m_trace->GetPhys_Offset(traceEl->GetElmtId());
1637 
1638  bool fwd = true;
1639  if (traceEl->GetLeftAdjacentElementFace () == -1 ||
1640  traceEl->GetRightAdjacentElementFace() == -1)
1641  {
1642  // Boundary edge (1 connected element). Do nothing in
1643  // serial.
1644  it = m_boundaryFaces.find(traceEl->GetElmtId());
1645 
1646  // If the edge does not have a boundary condition set on
1647  // it, then assume it is a partition edge.
1648  if (it == m_boundaryFaces.end())
1649  {
1650  int traceGeomId = traceEl->GetGeom2D()->GetGlobalID();
1652  traceGeomId);
1653 
1654  if (pIt != m_periodicFaces.end() && !pIt->second[0].isLocal)
1655  {
1656  fwd = traceGeomId == min(traceGeomId,pIt->second[0].id);
1657  }
1658  else
1659  {
1660  fwd = m_traceMap->
1661  GetTraceToUniversalMapUnique(offset) >= 0;
1662  }
1663  }
1664  }
1665  else if (traceEl->GetLeftAdjacentElementFace () != -1 &&
1666  traceEl->GetRightAdjacentElementFace() != -1)
1667  {
1668  // Non-boundary edge (2 connected elements).
1669  fwd = dynamic_cast<Nektar::StdRegions::StdExpansion*>
1670  (traceEl->GetLeftAdjacentElementExp().get()) ==
1671  (*m_exp)[n].get();
1672  }
1673  else
1674  {
1675  ASSERTL2(false, "Unconnected trace element!");
1676  }
1677 
1678  return fwd;
1679  }
std::set< int > m_boundaryFaces
A set storing the global IDs of any boundary faces.
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
The base class for all shapes.
Definition: StdExpansion.h:69
boost::shared_ptr< LocalRegions::ExpansionVector > m_exp
The list of local expansions.
Definition: ExpList.h:977
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:213
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
bool Nektar::MultiRegions::DisContField3D::SameTypeOfBoundaryConditions ( const DisContField3D In)
protected

For each boundary region, checks that the types and number of boundary expansions in that region match.

Parameters
InContField3D to compare with.
Returns
true if boundary conditions match.

Definition at line 561 of file DisContField3D.cpp.

References Nektar::MultiRegions::ExpList::GetExpSize(), m_bndCondExpansions, m_bndConditions, Nektar::MultiRegions::ExpList::m_comm, and Nektar::LibUtilities::ReduceMin.

Referenced by Nektar::MultiRegions::ContField3D::ContField3D(), and DisContField3D().

563  {
564  int i;
565  bool returnval = true;
566 
567  for(i = 0; i < m_bndConditions.num_elements(); ++i)
568  {
569 
570  // check to see if boundary condition type is the same
571  // and there are the same number of boundary
572  // conditions in the boundary definition.
573  if((m_bndConditions[i]->GetBoundaryConditionType()
574  != In.m_bndConditions[i]->GetBoundaryConditionType())||
576  != In.m_bndCondExpansions[i]->GetExpSize()))
577  {
578  returnval = false;
579  break;
580  }
581  }
582 
583  // Compare with all other processes. Return true only if all
584  // processes report having the same boundary conditions.
585  int vSame = returnval ? 1 : 0;
586  m_comm->AllReduce(vSame, LibUtilities::ReduceMin);
587 
588  return (vSame == 1);
589  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
int GetExpSize(void)
This function returns the number of elements in the expansion.
Definition: ExpList.h:1896
LibUtilities::CommSharedPtr m_comm
Communicator.
Definition: ExpList.h:907
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
void Nektar::MultiRegions::DisContField3D::SetUpDG ( const std::string  variable = "DefaultVar")
protected

Set up all DG member variables and maps.

Definition at line 307 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::SpatialDomains::ePeriodic, Nektar::LocalRegions::Expansion3D::GetGeom3D(), Nektar::MultiRegions::_PeriodicEntity::id, IsLeftAdjacentFace(), Nektar::MultiRegions::_PeriodicEntity::isLocal, Nektar::iterator, m_bndCondExpansions, m_bndConditions, m_boundaryFaces, Nektar::MultiRegions::ExpList::m_exp, m_globalBndMat, Nektar::MultiRegions::ExpList::m_graph, m_leftAdjacentFaces, m_locTraceToTraceMap, m_periodicBwdCopy, m_periodicFaces, m_periodicFwdCopy, Nektar::MultiRegions::ExpList::m_session, m_trace, m_traceMap, Nektar::MultiRegions::NullExpListSharedPtr, Nektar::MultiRegions::_PeriodicEntity::orient, Nektar::LocalRegions::Expansion2D::SetAdjacentElementExp(), and Nektar::MultiRegions::ExpList::SetUpPhysNormals().

Referenced by DisContField3D(), and v_GetTrace().

308  {
310  {
311  return;
312  }
313 
314  ExpList2DSharedPtr trace;
315 
317  boost::dynamic_pointer_cast<SpatialDomains::MeshGraph3D>(
318  m_graph);
319 
320  // Set up matrix map
323 
324  // Set up Trace space
325  bool UseGenSegExp = true;
328  *m_exp,graph3D, m_periodicFaces, UseGenSegExp);
329 
330  m_trace = trace;
331 
333  m_session,graph3D,trace,*this,m_bndCondExpansions,
334  m_bndConditions, m_periodicFaces,variable);
335 
336  Array<OneD, Array<OneD, LocalRegions::ExpansionSharedPtr> >
337  &elmtToTrace = m_traceMap->GetElmtToTrace();
338 
339  // Scatter trace segments to 3D elements. For each element, we
340  // find the trace segment associated to each edge. The element
341  // then retains a pointer to the trace space segments, to ensure
342  // uniqueness of normals when retrieving from two adjoining
343  // elements which do not lie in a plane.
344  for (int i = 0; i < m_exp->size(); ++i)
345  {
346  for (int j = 0; j < (*m_exp)[i]->GetNfaces(); ++j)
347  {
349  (*m_exp)[i]->as<LocalRegions::Expansion3D>();
351  elmtToTrace[i][j]->as<LocalRegions::Expansion2D>();
352  exp3d->SetFaceExp (j, exp2d);
353  exp2d->SetAdjacentElementExp(j, exp3d);
354  }
355  }
356 
357  // Set up physical normals
359 
360  // Set up information for parallel jobs.
361  for (int i = 0; i < m_trace->GetExpSize(); ++i)
362  {
364  m_trace->GetExp(i)->as<LocalRegions::Expansion2D>();
365 
366  int offset = m_trace->GetPhys_Offset(i);
367  int traceGeomId = traceEl->GetGeom2D()->GetGlobalID();
369  traceGeomId);
370 
371  if (pIt != m_periodicFaces.end() && !pIt->second[0].isLocal)
372  {
373  if (traceGeomId != min(pIt->second[0].id, traceGeomId))
374  {
375  traceEl->GetLeftAdjacentElementExp()->NegateFaceNormal(
376  traceEl->GetLeftAdjacentElementFace());
377  }
378  }
379  else if (m_traceMap->GetTraceToUniversalMapUnique(offset) < 0)
380  {
381  traceEl->GetLeftAdjacentElementExp()->NegateFaceNormal(
382  traceEl->GetLeftAdjacentElementFace());
383  }
384  }
385 
386  int cnt, n, e;
387 
388  // Identify boundary faces
389  for(cnt = 0, n = 0; n < m_bndCondExpansions.num_elements(); ++n)
390  {
391  if (m_bndConditions[n]->GetBoundaryConditionType() !=
393  {
394  for(e = 0; e < m_bndCondExpansions[n]->GetExpSize(); ++e)
395  {
396  m_boundaryFaces.insert(
397  m_traceMap->GetBndCondTraceToGlobalTraceMap(cnt+e));
398  }
399  }
400  cnt += m_bndCondExpansions[n]->GetExpSize();
401  }
402 
403  // Set up information for periodic boundary conditions.
404  boost::unordered_map<int,pair<int,int> > perFaceToExpMap;
405  boost::unordered_map<int,pair<int,int> >::iterator it2;
406  cnt = 0;
408  for (int n = 0; n < m_exp->size(); ++n)
409  {
410  exp3d = (*m_exp)[n]->as<LocalRegions::Expansion3D>();
411  for (int e = 0; e < exp3d->GetNfaces(); ++e, ++cnt)
412  {
414  exp3d->GetGeom3D()->GetFid(e));
415 
416  if (it != m_periodicFaces.end())
417  {
418  perFaceToExpMap[it->first] = make_pair(n, e);
419  }
420  }
421  }
422 
423  // Set up left-adjacent face list.
424  m_leftAdjacentFaces.resize(cnt);
425  cnt = 0;
426  for (int i = 0; i < m_exp->size(); ++i)
427  {
428  for (int j = 0; j < (*m_exp)[i]->GetNfaces(); ++j, ++cnt)
429  {
431  }
432  }
433 
434  // Set up mapping to copy Fwd of periodic bcs to Bwd of other edge.
435  cnt = 0;
436  for (int n = 0; n < m_exp->size(); ++n)
437  {
438  exp3d = (*m_exp)[n]->as<LocalRegions::Expansion3D>();
439  for (int e = 0; e < exp3d->GetNfaces(); ++e, ++cnt)
440  {
441  int faceGeomId = exp3d->GetGeom3D()->GetFid(e);
442  int offset = m_trace->GetPhys_Offset(
443  elmtToTrace[n][e]->GetElmtId());
444 
445  // Check to see if this face is periodic.
446  PeriodicMap::iterator it = m_periodicFaces.find(faceGeomId);
447 
448  if (it != m_periodicFaces.end())
449  {
450  const PeriodicEntity &ent = it->second[0];
451  it2 = perFaceToExpMap.find(ent.id);
452 
453  if (it2 == perFaceToExpMap.end())
454  {
455  if (m_session->GetComm()->GetSize() > 1 &&
456  !ent.isLocal)
457  {
458  continue;
459  }
460  else
461  {
462  ASSERTL1(false, "Periodic edge not found!");
463  }
464  }
465 
467  "Periodic face in non-forward space?");
468 
469  int offset2 = m_trace->GetPhys_Offset(
470  elmtToTrace[it2->second.first][it2->second.second]->
471  GetElmtId());
472 
473  // Calculate relative orientations between faces to
474  // calculate copying map.
475  int nquad1 = elmtToTrace[n][e]->GetNumPoints(0);
476  int nquad2 = elmtToTrace[n][e]->GetNumPoints(1);
477 
478  vector<int> tmpBwd(nquad1*nquad2);
479  vector<int> tmpFwd(nquad1*nquad2);
480 
481  if (ent.orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
482  ent.orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
483  ent.orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
485  {
486  for (int i = 0; i < nquad2; ++i)
487  {
488  for (int j = 0; j < nquad1; ++j)
489  {
490  tmpBwd[i*nquad1+j] = offset2 + i*nquad1+j;
491  tmpFwd[i*nquad1+j] = offset + j*nquad2+i;
492  }
493  }
494  }
495  else
496  {
497  for (int i = 0; i < nquad2; ++i)
498  {
499  for (int j = 0; j < nquad1; ++j)
500  {
501  tmpBwd[i*nquad1+j] = offset2 + i*nquad1+j;
502  tmpFwd[i*nquad1+j] = offset + i*nquad1+j;
503  }
504  }
505  }
506 
507  if (ent.orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
508  ent.orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
509  ent.orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
511  {
512  // Reverse x direction
513  for (int i = 0; i < nquad2; ++i)
514  {
515  for (int j = 0; j < nquad1/2; ++j)
516  {
517  swap(tmpFwd[i*nquad1 + j],
518  tmpFwd[i*nquad1 + nquad1-j-1]);
519  }
520  }
521  }
522 
523  if (ent.orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
524  ent.orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
525  ent.orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
527  {
528  // Reverse y direction
529  for (int j = 0; j < nquad1; ++j)
530  {
531  for (int i = 0; i < nquad2/2; ++i)
532  {
533  swap(tmpFwd[i*nquad1 + j],
534  tmpFwd[(nquad2-i-1)*nquad1 + j]);
535  }
536  }
537  }
538 
539  for (int i = 0; i < nquad1*nquad2; ++i)
540  {
541  m_periodicFwdCopy.push_back(tmpFwd[i]);
542  m_periodicBwdCopy.push_back(tmpBwd[i]);
543  }
544  }
545  }
546  }
547 
549  AllocateSharedPtr(*this, m_trace, elmtToTrace,
551 
552  }
boost::shared_ptr< MeshGraph3D > MeshGraph3DSharedPtr
Definition: MeshGraph3D.h:224
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static ExpListSharedPtr NullExpListSharedPtr
Definition: ExpList.h:1395
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
bool IsLeftAdjacentFace(const int n, const int e)
std::set< int > m_boundaryFaces
A set storing the global IDs of any boundary faces.
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
std::vector< int > m_periodicFwdCopy
A vector indicating degress of freedom which need to be copied from forwards to backwards space in ca...
boost::shared_ptr< LocalRegions::ExpansionVector > m_exp
The list of local expansions.
Definition: ExpList.h:977
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
SpatialDomains::MeshGraphSharedPtr m_graph
Mesh associated with this expansion list.
Definition: ExpList.h:913
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:910
boost::shared_ptr< ExpList2D > ExpList2DSharedPtr
Shared pointer to an ExpList2D object.
Definition: ExpList2D.h:49
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
struct Nektar::MultiRegions::_PeriodicEntity PeriodicEntity
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
void Nektar::MultiRegions::DisContField3D::v_AddFwdBwdTraceIntegral ( const Array< OneD, const NekDouble > &  Fwd,
const Array< OneD, const NekDouble > &  Bwd,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Add trace contributions into elemental coefficient spaces.

Given some quantity $ \vec{Fn} $, which conatins this routine calculates the integral

\[ \int_{\Omega^e} \vec{Fn}, \mathrm{d}S \]

and adds this to the coefficient space provided by outarray. The value of q is determined from the routine IsLeftAdjacentFace() which if true we use Fwd else we use Bwd

See also
Expansion3D::AddFaceNormBoundaryInt
Parameters
FwdThe trace quantities associated with left (fwd) adjancent elmt.
BwdThe trace quantities associated with right (bwd) adjacent elet.
outarrayResulting 3D coefficient space.

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1878 of file DisContField3D.cpp.

References m_locTraceToTraceMap, and m_trace.

1882  {
1883  Array<OneD, NekDouble> Coeffs(m_trace->GetNcoeffs());
1884 
1885  m_trace->IProductWRTBase(Fwd,Coeffs);
1886  m_locTraceToTraceMap->AddTraceCoeffsToFieldCoeffs(0,Coeffs,outarray);
1887  m_trace->IProductWRTBase(Bwd,Coeffs);
1888  m_locTraceToTraceMap->AddTraceCoeffsToFieldCoeffs(1,Coeffs,outarray);
1889  }
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
void Nektar::MultiRegions::DisContField3D::v_AddTraceIntegral ( const Array< OneD, const NekDouble > &  Fn,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Add trace contributions into elemental coefficient spaces.

Given some quantity $ \vec{Fn} $, which conatins this routine calculates the integral

\[ \int_{\Omega^e} \vec{Fn}, \mathrm{d}S \]

and adds this to the coefficient space provided by outarray.

See also
Expansion3D::AddFaceNormBoundaryInt
Parameters
FnThe trace quantities.
outarrayResulting 3D coefficient space.

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1844 of file DisContField3D.cpp.

References m_locTraceToTraceMap, and m_trace.

1847  {
1848 
1849  Array<OneD, NekDouble> Fcoeffs(m_trace->GetNcoeffs());
1850  m_trace->IProductWRTBase(Fn, Fcoeffs);
1851 
1852  m_locTraceToTraceMap->AddTraceCoeffsToFieldCoeffs(Fcoeffs,
1853  outarray);
1854  }
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
void Nektar::MultiRegions::DisContField3D::v_EvaluateBoundaryConditions ( const NekDouble  time = 0.0,
const std::string  varName = "",
const NekDouble  x2_in = NekConstants::kNekUnsetDouble,
const NekDouble  x3_in = NekConstants::kNekUnsetDouble 
)
protectedvirtual

This function evaluates the boundary conditions at a certain time-level.

Based on the boundary condition $g(\boldsymbol{x},t)$ evaluated at a given time-level t, this function transforms the boundary conditions onto the coefficients of the (one-dimensional) boundary expansion. Depending on the type of boundary conditions, these expansion coefficients are calculated in different ways:

  • Dirichlet boundary conditions
    In order to ensure global $C^0$ continuity of the spectral/hp approximation, the Dirichlet boundary conditions are projected onto the boundary expansion by means of a modified $C^0$ continuous Galerkin projection. This projection can be viewed as a collocation projection at the vertices, followed by an $L^2$ projection on the interior modes of the edges. The resulting coefficients $\boldsymbol{\hat{u}}^{\mathcal{D}}$ will be stored for the boundary expansion.
  • Neumann boundary conditions In the discrete Galerkin formulation of the problem to be solved, the Neumann boundary conditions appear as the set of surface integrals:

    \[\boldsymbol{\hat{g}}=\int_{\Gamma} \phi^e_n(\boldsymbol{x})g(\boldsymbol{x})d(\boldsymbol{x})\quad \forall n \]

    As a result, it are the coefficients $\boldsymbol{\hat{g}}$ that will be stored in the boundary expansion
Parameters
timeThe time at which the boundary conditions should be evaluated.
bndCondExpansionsList of boundary conditions.
bndConditionsInformation about the boundary conditions.

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 2410 of file DisContField3D.cpp.

References ASSERTL0, Nektar::SpatialDomains::eDirichlet, Nektar::SpatialDomains::eNeumann, Nektar::SpatialDomains::eRobin, Nektar::LibUtilities::Equation::Evaluate(), Nektar::MultiRegions::ExpList::ExtractFileBCs(), m_bndCondExpansions, m_bndConditions, and Vmath::Vmul().

2415  {
2416  int i;
2417  int npoints;
2418  int nbnd = m_bndCondExpansions.num_elements();
2419  MultiRegions::ExpListSharedPtr locExpList;
2420 
2421  for (i = 0; i < nbnd; ++i)
2422  {
2423  if (time == 0.0 || m_bndConditions[i]->IsTimeDependent())
2424  {
2425  locExpList = m_bndCondExpansions[i];
2426  npoints = locExpList->GetNpoints();
2427 
2428  Array<OneD, NekDouble> x0(npoints, 0.0);
2429  Array<OneD, NekDouble> x1(npoints, 0.0);
2430  Array<OneD, NekDouble> x2(npoints, 0.0);
2431  Array<OneD, NekDouble> valuesFile(npoints, 1.0), valuesExp(npoints, 1.0);
2432 
2433  locExpList->GetCoords(x0, x1, x2);
2434 
2435  if (m_bndConditions[i]->GetBoundaryConditionType()
2437  {
2438  string filebcs = boost::static_pointer_cast<
2439  SpatialDomains::DirichletBoundaryCondition>(
2440  m_bndConditions[i])->m_filename;
2441 
2442  string exprbcs = boost::static_pointer_cast<
2443  SpatialDomains::DirichletBoundaryCondition>(
2444  m_bndConditions[i])->m_expr;
2445 
2446  if (filebcs != "")
2447  {
2448  ExtractFileBCs(filebcs, varName, locExpList);
2449  valuesFile = locExpList->GetPhys();
2450  }
2451 
2452  if (exprbcs != "")
2453  {
2454  LibUtilities::Equation condition = boost::static_pointer_cast<SpatialDomains::
2455  DirichletBoundaryCondition >(
2456  m_bndConditions[i])->m_dirichletCondition;
2457 
2458  condition.Evaluate(x0, x1, x2, time, valuesExp);
2459  }
2460 
2461  Vmath::Vmul(npoints, valuesExp, 1, valuesFile, 1, locExpList->UpdatePhys(), 1);
2462 
2463  locExpList->FwdTrans_BndConstrained(
2464  locExpList->GetPhys(),
2465  locExpList->UpdateCoeffs());
2466  }
2467  else if (m_bndConditions[i]->GetBoundaryConditionType()
2469  {
2470  string filebcs = boost::static_pointer_cast<
2471  SpatialDomains::NeumannBoundaryCondition>(
2472  m_bndConditions[i])->m_filename;
2473 
2474  if (filebcs != "")
2475  {
2476  ExtractFileBCs(filebcs, varName, locExpList);
2477  }
2478  else
2479  {
2480 
2481  LibUtilities::Equation condition = boost::
2482  static_pointer_cast<SpatialDomains::
2483  NeumannBoundaryCondition>(
2484  m_bndConditions[i])->m_neumannCondition;
2485 
2486  condition.Evaluate(x0, x1, x2, time,
2487  locExpList->UpdatePhys());
2488 
2489  locExpList->IProductWRTBase(locExpList->GetPhys(),
2490  locExpList->UpdateCoeffs());
2491  }
2492  }
2493  else if (m_bndConditions[i]->GetBoundaryConditionType()
2495  {
2496 
2497  string filebcs = boost::static_pointer_cast<
2498  SpatialDomains::RobinBoundaryCondition>
2499  (m_bndConditions[i])->m_filename;
2500 
2501  if (filebcs != "")
2502  {
2503  ExtractFileBCs(filebcs, varName, locExpList);
2504  }
2505  else
2506  {
2507  LibUtilities::Equation condition = boost::
2508  static_pointer_cast<SpatialDomains::
2509  RobinBoundaryCondition>(
2510  m_bndConditions[i])->m_robinFunction;
2511 
2512  condition.Evaluate(x0, x1, x2, time,
2513  locExpList->UpdatePhys());
2514 
2515  }
2516 
2517  LibUtilities::Equation coeff = boost::
2518  static_pointer_cast<SpatialDomains::
2519  RobinBoundaryCondition>(
2520  m_bndConditions[i])->m_robinPrimitiveCoeff;
2521 
2522  locExpList->IProductWRTBase(locExpList->GetPhys(),
2523  locExpList->UpdateCoeffs());
2524 
2525  // Put primitive coefficient into the physical
2526  // space storage
2527  coeff.Evaluate(x0, x1, x2, time,
2528  locExpList->UpdatePhys());
2529 
2530  }
2531  else
2532  {
2533  ASSERTL0(false, "This type of BC not implemented yet");
2534  }
2535  }
2536  }
2537  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
void ExtractFileBCs(const std::string &fileName, const std::string &varName, const boost::shared_ptr< ExpList > locExpList)
Definition: ExpList.cpp:1911
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
void Nektar::MultiRegions::DisContField3D::v_ExtractTracePhys ( Array< OneD, NekDouble > &  outarray)
protectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1800 of file DisContField3D.cpp.

References ASSERTL1, Nektar::MultiRegions::ExpList::m_phys, and Nektar::MultiRegions::ExpList::m_physState.

1802  {
1803  ASSERTL1(m_physState == true,
1804  "Field is not in physical space.");
1805 
1806  v_ExtractTracePhys(m_phys, outarray);
1807  }
virtual void v_ExtractTracePhys(Array< OneD, NekDouble > &outarray)
Array< OneD, NekDouble > m_phys
The global expansion evaluated at the quadrature points.
Definition: ExpList.h:956
bool m_physState
The state of the array m_phys.
Definition: ExpList.h:965
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Nektar::MultiRegions::DisContField3D::v_ExtractTracePhys ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1809 of file DisContField3D.cpp.

References m_locTraceToTraceMap, m_traceMap, and Vmath::Zero().

1812  {
1813 
1814  Vmath::Zero(outarray.num_elements(), outarray, 1);
1815 
1816  Array<OneD, NekDouble> facevals(m_locTraceToTraceMap->GetNFwdLocTracePts());
1817  m_locTraceToTraceMap->FwdLocTracesFromField(inarray,facevals);
1818  m_locTraceToTraceMap->InterpLocFacesToTrace(0,facevals,outarray);
1819 
1820  // gather entries along parallel partitions which have
1821  // only filled in Fwd part on their own partition
1822  m_traceMap->UniversalTraceAssemble(outarray);
1823 
1824  }
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
void Nektar::MultiRegions::DisContField3D::v_GeneralMatrixOp ( const GlobalMatrixKey gkey,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
CoeffState  coeffstate = eLocal 
)
protectedvirtual

Calculates the result of the multiplication of a global matrix of type specified by mkey with a vector given by inarray.

Parameters
mkeyKey representing desired matrix multiplication.
inarrayInput vector.
outarrayResulting multiplication.

Reimplemented from Nektar::MultiRegions::ExpList.

Reimplemented in Nektar::MultiRegions::ContField3D.

Definition at line 2147 of file DisContField3D.cpp.

References Nektar::eWrapper, Nektar::MultiRegions::ExpList::GetBlockMatrix(), and m_traceMap.

2152  {
2153  int LocBndCoeffs = m_traceMap->GetNumLocalBndCoeffs();
2154  Array<OneD, NekDouble> loc_lambda(LocBndCoeffs);
2155  DNekVec LocLambda(LocBndCoeffs,loc_lambda,eWrapper);
2156  const DNekScalBlkMatSharedPtr& HDGHelm = GetBlockMatrix(gkey);
2157 
2158  m_traceMap->GlobalToLocalBnd(inarray, loc_lambda);
2159  LocLambda = (*HDGHelm) * LocLambda;
2160  m_traceMap->AssembleBnd(loc_lambda,outarray);
2161  }
const DNekScalBlkMatSharedPtr & GetBlockMatrix(const GlobalMatrixKey &gkey)
Definition: ExpList.cpp:814
boost::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:74
NekVector< NekDouble > DNekVec
Definition: NekTypeDefs.hpp:49
virtual const Array<OneD,const MultiRegions::ExpListSharedPtr>& Nektar::MultiRegions::DisContField3D::v_GetBndCondExpansions ( void  )
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 233 of file DisContField3D.h.

References m_bndCondExpansions.

234  {
235  return m_bndCondExpansions;
236  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
virtual const Array<OneD,const SpatialDomains::BoundaryConditionShPtr>& Nektar::MultiRegions::DisContField3D::v_GetBndConditions ( void  )
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 240 of file DisContField3D.h.

References m_bndConditions.

241  {
242  return m_bndConditions;
243  }
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
void Nektar::MultiRegions::DisContField3D::v_GetBndElmtExpansion ( int  i,
boost::shared_ptr< ExpList > &  result 
)
protectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1952 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::MultiRegions::ExpList::GetBoundaryToElmtMap(), Nektar::MultiRegions::ExpList::GetCoeff_Offset(), Nektar::MultiRegions::ExpList::GetCoeffs(), Nektar::MultiRegions::ExpList::GetExp(), Nektar::MultiRegions::ExpList::GetPhys(), Nektar::MultiRegions::ExpList::GetPhys_Offset(), m_bndCondExpansions, and Vmath::Vcopy().

1954  {
1955  int n, cnt, nq;
1956  int offsetOld, offsetNew;
1957  Array<OneD, NekDouble> tmp1, tmp2;
1958  std::vector<unsigned int> eIDs;
1959 
1960  Array<OneD, int> ElmtID,EdgeID;
1961  GetBoundaryToElmtMap(ElmtID,EdgeID);
1962 
1963  // Skip other boundary regions
1964  for (cnt = n = 0; n < i; ++n)
1965  {
1966  cnt += m_bndCondExpansions[n]->GetExpSize();
1967  }
1968 
1969  // Populate eIDs with information from BoundaryToElmtMap
1970  for (n = 0; n < m_bndCondExpansions[i]->GetExpSize(); ++n)
1971  {
1972  eIDs.push_back(ElmtID[cnt+n]);
1973  }
1974 
1975  // Create expansion list
1976  result =
1978 
1979  // Copy phys and coeffs to new explist
1980  for (n = 0; n < result->GetExpSize(); ++n)
1981  {
1982  nq = GetExp(ElmtID[cnt+n])->GetTotPoints();
1983  offsetOld = GetPhys_Offset(ElmtID[cnt+n]);
1984  offsetNew = result->GetPhys_Offset(n);
1985  Vmath::Vcopy(nq, tmp1 = GetPhys()+ offsetOld, 1,
1986  tmp2 = result->UpdatePhys()+ offsetNew, 1);
1987 
1988  nq = GetExp(ElmtID[cnt+n])->GetNcoeffs();
1989  offsetOld = GetCoeff_Offset(ElmtID[cnt+n]);
1990  offsetNew = result->GetCoeff_Offset(n);
1991  Vmath::Vcopy(nq, tmp1 = GetCoeffs()+ offsetOld, 1,
1992  tmp2 = result->UpdateCoeffs()+ offsetNew, 1);
1993  }
1994  }
const Array< OneD, const NekDouble > & GetCoeffs() const
This function returns (a reference to) the array (implemented as m_coeffs) containing all local expa...
Definition: ExpList.h:1834
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
int GetCoeff_Offset(int n) const
Get the start offset position for a global list of m_coeffs correspoinding to element n...
Definition: ExpList.h:1926
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
int GetPhys_Offset(int n) const
Get the start offset position for a global list of m_phys correspoinding to element n...
Definition: ExpList.h:1934
const boost::shared_ptr< LocalRegions::ExpansionVector > GetExp() const
This function returns the vector of elements in the expansion.
Definition: ExpList.h:1917
void GetBoundaryToElmtMap(Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)
Definition: ExpList.h:2144
const Array< OneD, const NekDouble > & GetPhys() const
This function returns (a reference to) the array (implemented as m_phys) containing the function ev...
Definition: ExpList.h:1887
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
void Nektar::MultiRegions::DisContField3D::v_GetBoundaryToElmtMap ( Array< OneD, int > &  ElmtID,
Array< OneD, int > &  FaceID 
)
protectedvirtual

Set up a list of elemeent IDs and edge IDs that link to the boundary conditions.

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1895 of file DisContField3D.cpp.

References Nektar::MultiRegions::ExpList::GetExpSize(), m_bndCondExpansions, m_bndConditions, and Nektar::MultiRegions::ExpList::m_graph.

1898  {
1899  map<int,int> globalIdMap;
1900  int i, n;
1901  int cnt;
1902  int nbcs = 0;
1903 
1905  boost::dynamic_pointer_cast<SpatialDomains::MeshGraph3D>(
1906  m_graph);
1907 
1908  // Populate global ID map (takes global geometry ID to local
1909  // expansion list ID).
1911  for (i = 0; i < GetExpSize(); ++i)
1912  {
1913  exp3d = (*m_exp)[i]->as<LocalRegions::Expansion3D>();
1914  globalIdMap[exp3d->GetGeom3D()->GetGlobalID()] = i;
1915  }
1916 
1917  // Determine number of boundary condition expansions.
1918  for(i = 0; i < m_bndConditions.num_elements(); ++i)
1919  {
1920  nbcs += m_bndCondExpansions[i]->GetExpSize();
1921  }
1922 
1923  // make sure arrays are of sufficient length
1924  if(ElmtID.num_elements() != nbcs)
1925  {
1926  ElmtID = Array<OneD, int>(nbcs);
1927  }
1928 
1929  if(FaceID.num_elements() != nbcs)
1930  {
1931  FaceID = Array<OneD, int>(nbcs);
1932  }
1933 
1935  for(cnt = n = 0; n < m_bndCondExpansions.num_elements(); ++n)
1936  {
1937  for(i = 0; i < m_bndCondExpansions[n]->GetExpSize(); ++i, ++cnt)
1938  {
1939  exp2d = m_bndCondExpansions[n]->GetExp(i)->
1940  as<LocalRegions::Expansion2D>();
1941  // Use face to element map from MeshGraph3D.
1943  graph3D->GetElementsFromFace(exp2d->GetGeom2D());
1944 
1945  ElmtID[cnt] = globalIdMap[(*tmp)[0]->
1946  m_Element->GetGlobalID()];
1947  FaceID[cnt] = (*tmp)[0]->m_FaceIndx;
1948  }
1949  }
1950  }
boost::shared_ptr< MeshGraph3D > MeshGraph3DSharedPtr
Definition: MeshGraph3D.h:224
boost::shared_ptr< ElementFaceVector > ElementFaceVectorSharedPtr
Definition: MeshGraph.h:138
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
int GetExpSize(void)
This function returns the number of elements in the expansion.
Definition: ExpList.h:1896
boost::shared_ptr< Expansion3D > Expansion3DSharedPtr
Definition: Expansion2D.h:48
SpatialDomains::MeshGraphSharedPtr m_graph
Mesh associated with this expansion list.
Definition: ExpList.h:913
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
boost::shared_ptr< Expansion2D > Expansion2DSharedPtr
Definition: Expansion1D.h:49
void Nektar::MultiRegions::DisContField3D::v_GetFwdBwdTracePhys ( Array< OneD, NekDouble > &  Fwd,
Array< OneD, NekDouble > &  Bwd 
)
protectedvirtual

This method extracts the "forward" and "backward" trace data from the array field and puts the data into output vectors Fwd and Bwd.

We first define the convention which defines "forwards" and "backwards". First an association is made between the face of each element and its corresponding face in the trace space using the mapping m_traceMap. The element can either be left-adjacent or right-adjacent to this trace face (see Expansion2D::GetLeftAdjacentElementExp). Boundary faces are always left-adjacent since left-adjacency is populated first.

If the element is left-adjacent we extract the face trace data from field into the forward trace space Fwd; otherwise, we place it in the backwards trace space Bwd. In this way, we form a unique set of trace normals since these are always extracted from left-adjacent elements.

Parameters
fieldis a NekDouble array which contains the 3D data from which we wish to extract the backward and forward orientated trace/face arrays.
Returns
Updates a NekDouble array Fwd and Bwd

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1706 of file DisContField3D.cpp.

References Nektar::MultiRegions::ExpList::m_phys.

1708  {
1709  v_GetFwdBwdTracePhys(m_phys, Fwd, Bwd);
1710  }
virtual void v_GetFwdBwdTracePhys(Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
This method extracts the "forward" and "backward" trace data from the array field and puts the data i...
Array< OneD, NekDouble > m_phys
The global expansion evaluated at the quadrature points.
Definition: ExpList.h:956
void Nektar::MultiRegions::DisContField3D::v_GetFwdBwdTracePhys ( const Array< OneD, const NekDouble > &  field,
Array< OneD, NekDouble > &  Fwd,
Array< OneD, NekDouble > &  Bwd 
)
protectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1712 of file DisContField3D.cpp.

References ASSERTL0, Nektar::SpatialDomains::eDirichlet, Nektar::SpatialDomains::eNeumann, Nektar::SpatialDomains::eRobin, Nektar::MultiRegions::ExpList::GetPhys(), m_bndCondExpansions, m_bndConditions, m_locTraceToTraceMap, m_periodicBwdCopy, m_periodicFwdCopy, m_trace, m_traceMap, npts, Vmath::Vcopy(), and Vmath::Zero().

1716  {
1717  int n, cnt, npts, e;
1718 
1719  // Zero vectors.
1720  Vmath::Zero(Fwd.num_elements(), Fwd, 1);
1721  Vmath::Zero(Bwd.num_elements(), Bwd, 1);
1722 
1723  Array<OneD, NekDouble> facevals(m_locTraceToTraceMap->
1724  GetNLocTracePts());
1725  m_locTraceToTraceMap->LocTracesFromField(field,facevals);
1726  m_locTraceToTraceMap->InterpLocFacesToTrace(0, facevals, Fwd);
1727 
1728  Array<OneD, NekDouble> invals = facevals + m_locTraceToTraceMap->
1729  GetNFwdLocTracePts();
1730  m_locTraceToTraceMap->InterpLocFacesToTrace(1, invals, Bwd);
1731 
1732  // Fill boundary conditions into missing elements
1733  int id1, id2 = 0;
1734  cnt = 0;
1735 
1736  for(n = 0; n < m_bndCondExpansions.num_elements(); ++n)
1737  {
1738  if(m_bndConditions[n]->GetBoundaryConditionType() ==
1740  {
1741  for(e = 0; e < m_bndCondExpansions[n]->GetExpSize(); ++e)
1742  {
1743  npts = m_bndCondExpansions[n]->GetExp(e)->GetTotPoints();
1744  id1 = m_bndCondExpansions[n]->GetPhys_Offset(e);
1745  id2 = m_trace->GetPhys_Offset(
1746  m_traceMap->GetBndCondTraceToGlobalTraceMap(cnt+e));
1747  Vmath::Vcopy(npts,
1748  &(m_bndCondExpansions[n]->GetPhys())[id1], 1,
1749  &Bwd[id2], 1);
1750  }
1751 
1752  cnt += e;
1753  }
1754  else if (m_bndConditions[n]->GetBoundaryConditionType() ==
1756  m_bndConditions[n]->GetBoundaryConditionType() ==
1758  {
1759  for(e = 0; e < m_bndCondExpansions[n]->GetExpSize(); ++e)
1760  {
1761  npts = m_bndCondExpansions[n]->GetExp(e)->GetTotPoints();
1762  id1 = m_bndCondExpansions[n]->GetPhys_Offset(e);
1763  id2 = m_trace->GetPhys_Offset(
1764  m_traceMap->GetBndCondTraceToGlobalTraceMap(cnt+e));
1765 
1766  // Turning this off since we can have non-zero
1767  //Neumann in mixed CG-DG method
1768  //ASSERTL1((m_bndCondExpansions[n]->GetPhys())[id1]
1769  //== 0.0, "method not set up for non-zero
1770  //Neumann " "boundary condition");
1771 
1772  Vmath::Vcopy(npts,&Fwd[id2],1,&Bwd[id2],1);
1773  }
1774 
1775  cnt += e;
1776  }
1777  else
1778  {
1779  ASSERTL0(false, "Method only set up for Dirichlet, Neumann "
1780  "and Robin conditions.");
1781  }
1782  }
1783 
1784  // Copy any periodic boundary conditions.
1785  for (n = 0; n < m_periodicFwdCopy.size(); ++n)
1786  {
1787  Bwd[m_periodicBwdCopy[n]] = Fwd[m_periodicFwdCopy[n]];
1788  }
1789 
1790  // Do parallel exchange for forwards/backwards spaces.
1791  m_traceMap->UniversalTraceAssemble(Fwd);
1792  m_traceMap->UniversalTraceAssemble(Bwd);
1793  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
std::vector< int > m_periodicFwdCopy
A vector indicating degress of freedom which need to be copied from forwards to backwards space in ca...
LocTraceToTraceMapSharedPtr m_locTraceToTraceMap
Map of local trace (the points at the face of the element) to the trace space discretisation.
static std::string npts
Definition: InputFld.cpp:43
const Array< OneD, const NekDouble > & GetPhys() const
This function returns (a reference to) the array (implemented as m_phys) containing the function ev...
Definition: ExpList.h:1887
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
const vector< bool > & Nektar::MultiRegions::DisContField3D::v_GetLeftAdjacentFaces ( void  ) const
protectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1795 of file DisContField3D.cpp.

References m_leftAdjacentFaces.

1796  {
1797  return m_leftAdjacentFaces;
1798  }
virtual void Nektar::MultiRegions::DisContField3D::v_GetPeriodicEntities ( PeriodicMap periodicVerts,
PeriodicMap periodicEdges,
PeriodicMap periodicFaces 
)
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 207 of file DisContField3D.h.

References m_periodicEdges, m_periodicFaces, and m_periodicVerts.

211  {
212  periodicVerts = m_periodicVerts;
213  periodicEdges = m_periodicEdges;
214  periodicFaces = m_periodicFaces;
215  }
PeriodicMap m_periodicFaces
A map which identifies pairs of periodic faces.
PeriodicMap m_periodicVerts
A map which identifies groups of periodic vertices.
PeriodicMap m_periodicEdges
A map which identifies groups of periodic edges.
map< int, RobinBCInfoSharedPtr > Nektar::MultiRegions::DisContField3D::v_GetRobinBCInfo ( void  )
protectedvirtual

Search through the edge expansions and identify which ones have Robin/Mixed type boundary conditions. If find a Robin boundary then store the edge id of the boundary condition and the array of points of the physical space boundary condition which are hold the boundary condition primitive variable coefficient at the quatrature points

Returns
std map containing the robin boundary condition info using a key of the element id

There is a next member to allow for more than one Robin boundary condition per element

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 2176 of file DisContField3D.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SpatialDomains::eRobin, Nektar::MultiRegions::ExpList::GetBoundaryToElmtMap(), m_bndCondExpansions, and m_bndConditions.

2177  {
2178  int i,cnt;
2179  map<int, RobinBCInfoSharedPtr> returnval;
2180  Array<OneD, int> ElmtID,FaceID;
2181  GetBoundaryToElmtMap(ElmtID,FaceID);
2182 
2183  for(cnt = i = 0; i < m_bndCondExpansions.num_elements(); ++i)
2184  {
2185  MultiRegions::ExpListSharedPtr locExpList;
2186 
2187  if(m_bndConditions[i]->GetBoundaryConditionType() == SpatialDomains::eRobin)
2188  {
2189  int e,elmtid;
2190  Array<OneD, NekDouble> Array_tmp;
2191 
2192  locExpList = m_bndCondExpansions[i];
2193 
2194  for(e = 0; e < locExpList->GetExpSize(); ++e)
2195  {
2196  RobinBCInfoSharedPtr rInfo = MemoryManager<RobinBCInfo>::AllocateSharedPtr(FaceID[cnt+e],Array_tmp = locExpList->GetPhys() + locExpList->GetPhys_Offset(e));
2197  elmtid = ElmtID[cnt+e];
2198  // make link list if necessary
2199  if(returnval.count(elmtid) != 0)
2200  {
2201  rInfo->next = returnval.find(elmtid)->second;
2202  }
2203  returnval[elmtid] = rInfo;
2204  }
2205  }
2206  cnt += m_bndCondExpansions[i]->GetExpSize();
2207  }
2208 
2209  return returnval;
2210  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< RobinBCInfo > RobinBCInfoSharedPtr
void GetBoundaryToElmtMap(Array< OneD, int > &ElmtID, Array< OneD, int > &EdgeID)
Definition: ExpList.h:2144
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
virtual ExpListSharedPtr& Nektar::MultiRegions::DisContField3D::v_GetTrace ( )
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 217 of file DisContField3D.h.

References m_trace, Nektar::MultiRegions::NullExpListSharedPtr, and SetUpDG().

218  {
220  {
221  SetUpDG();
222  }
223 
224  return m_trace;
225  }
static ExpListSharedPtr NullExpListSharedPtr
Definition: ExpList.h:1395
void SetUpDG(const std::string="DefaultVar")
Set up all DG member variables and maps.
virtual AssemblyMapDGSharedPtr& Nektar::MultiRegions::DisContField3D::v_GetTraceMap ( void  )
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 227 of file DisContField3D.h.

References m_traceMap.

228  {
229  return m_traceMap;
230  }
void Nektar::MultiRegions::DisContField3D::v_HelmSolve ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const FlagList flags,
const StdRegions::ConstFactorMap factors,
const StdRegions::VarCoeffMap varcoeff,
const Array< OneD, const NekDouble > &  dirForcing 
)
protectedvirtual

Solving Helmholtz Equation in 3D

Reimplemented from Nektar::MultiRegions::ExpList.

Reimplemented in Nektar::MultiRegions::ContField3D.

Definition at line 2013 of file DisContField3D.cpp.

References Nektar::SpatialDomains::eDirichlet, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::eWrapper, Nektar::MultiRegions::ExpList::GetBlockMatrix(), Nektar::MultiRegions::ExpList::GetExpSize(), GetGlobalBndLinSys(), Nektar::MultiRegions::ExpList::GetNcoeffs(), Nektar::MultiRegions::ExpList::IProductWRTBase(), m_bndCondExpansions, m_bndConditions, Nektar::MultiRegions::ExpList::m_ncoeffs, Nektar::MultiRegions::ExpList::m_offset_elmt_id, m_trace, m_traceMap, Vmath::Neg(), Nektar::MultiRegions::NullAssemblyMapSharedPtr, Nektar::Transpose(), and Vmath::Zero().

2020  {
2021  int i,j,n,cnt,cnt1,nbndry;
2022  int nexp = GetExpSize();
2024 
2025  Array<OneD,NekDouble> f(m_ncoeffs);
2026  DNekVec F(m_ncoeffs,f,eWrapper);
2027  Array<OneD,NekDouble> e_f, e_l;
2028 
2029  //----------------------------------
2030  // Setup RHS Inner product
2031  //----------------------------------
2032  IProductWRTBase(inarray,f);
2033  Vmath::Neg(m_ncoeffs,f,1);
2034 
2035  //----------------------------------
2036  // Solve continuous flux System
2037  //----------------------------------
2038  int GloBndDofs = m_traceMap->GetNumGlobalBndCoeffs();
2039  int NumDirichlet = m_traceMap->GetNumLocalDirBndCoeffs();
2040  int e_ncoeffs,id;
2041 
2042  // Retrieve block matrix of U^e
2043  GlobalMatrixKey HDGLamToUKey(StdRegions::eHybridDGLamToU,NullAssemblyMapSharedPtr,factors,varcoeff);
2044  const DNekScalBlkMatSharedPtr &HDGLamToU = GetBlockMatrix(HDGLamToUKey);
2045 
2046  // Retrieve global trace space storage, \Lambda, from trace expansion
2047  Array<OneD,NekDouble> BndSol = m_trace->UpdateCoeffs();
2048 
2049  // Create trace space forcing, F
2050  Array<OneD,NekDouble> BndRhs(GloBndDofs,0.0);
2051 
2052  // Zero \Lambda
2053  Vmath::Zero(GloBndDofs,BndSol,1);
2054 
2055  // Retrieve number of local trace space coefficients N_{\lambda},
2056  // and set up local elemental trace solution \lambda^e.
2057  int LocBndCoeffs = m_traceMap->GetNumLocalBndCoeffs();
2058  Array<OneD, NekDouble> loc_lambda(LocBndCoeffs);
2059  DNekVec LocLambda(LocBndCoeffs,loc_lambda,eWrapper);
2060 
2061  //----------------------------------
2062  // Evaluate Trace Forcing vector F
2063  // Kirby et al, 2010, P23, Step 5.
2064  //----------------------------------
2065  // Loop over all expansions in the domain
2066  for(cnt = cnt1 = n = 0; n < nexp; ++n)
2067  {
2068  nbndry = (*m_exp)[m_offset_elmt_id[n]]->NumDGBndryCoeffs();
2069 
2070  e_ncoeffs = (*m_exp)[m_offset_elmt_id[n]]->GetNcoeffs();
2071  e_f = f + cnt;
2072  e_l = loc_lambda + cnt1;
2073 
2074  // Local trace space \lambda^e
2075  DNekVec Floc (nbndry, e_l, eWrapper);
2076  // Local forcing f^e
2077  DNekVec ElmtFce (e_ncoeffs, e_f, eWrapper);
2078  // Compute local (U^e)^{\top} f^e
2079  Floc = Transpose(*(HDGLamToU->GetBlock(n,n)))*ElmtFce;
2080 
2081  cnt += e_ncoeffs;
2082  cnt1 += nbndry;
2083  }
2084 
2085  // Assemble local \lambda_e into global \Lambda
2086  m_traceMap->AssembleBnd(loc_lambda,BndRhs);
2087 
2088  // Copy Dirichlet boundary conditions and weak forcing into trace
2089  // space
2090  cnt = 0;
2091  for(i = 0; i < m_bndCondExpansions.num_elements(); ++i)
2092  {
2093  if(m_bndConditions[i]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)
2094  {
2095  for(j = 0; j < (m_bndCondExpansions[i])->GetNcoeffs(); ++j)
2096  {
2097  id = m_traceMap->GetBndCondCoeffsToGlobalCoeffsMap(cnt++);
2098  BndSol[id] = m_bndCondExpansions[i]->GetCoeffs()[j];
2099  }
2100  }
2101  else
2102  {
2103  //Add weak boundary condition to trace forcing
2104  for(j = 0; j < (m_bndCondExpansions[i])->GetNcoeffs(); ++j)
2105  {
2106  id = m_traceMap->GetBndCondCoeffsToGlobalCoeffsMap(cnt++);
2107  BndRhs[id] += m_bndCondExpansions[i]->GetCoeffs()[j];
2108  }
2109  }
2110  }
2111 
2112  //----------------------------------
2113  // Solve trace problem: \Lambda = K^{-1} F
2114  // K is the HybridDGHelmBndLam matrix.
2115  //----------------------------------
2116  if(GloBndDofs - NumDirichlet > 0)
2117  {
2118  GlobalLinSysKey key(StdRegions::eHybridDGHelmBndLam,
2119  m_traceMap,factors,varcoeff);
2121  LinSys->Solve(BndRhs,BndSol,m_traceMap);
2122  }
2123 
2124  //----------------------------------
2125  // Internal element solves
2126  //----------------------------------
2127  GlobalMatrixKey invHDGhelmkey(StdRegions::eInvHybridDGHelmholtz,NullAssemblyMapSharedPtr,factors,varcoeff);
2128  const DNekScalBlkMatSharedPtr& InvHDGHelm = GetBlockMatrix(invHDGhelmkey);
2129  DNekVec out(m_ncoeffs,outarray,eWrapper);
2130  Vmath::Zero(m_ncoeffs,outarray,1);
2131 
2132  // get local trace solution from BndSol
2133  m_traceMap->GlobalToLocalBnd(BndSol,loc_lambda);
2134 
2135  // out = u_f + u_lam = (*InvHDGHelm)*f + (LamtoU)*Lam
2136  out = (*InvHDGHelm)*F + (*HDGLamToU)*LocLambda;
2137  }
const DNekScalBlkMatSharedPtr & GetBlockMatrix(const GlobalMatrixKey &gkey)
Definition: ExpList.cpp:814
GlobalLinSysSharedPtr GetGlobalBndLinSys(const GlobalLinSysKey &mkey)
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
int GetExpSize(void)
This function returns the number of elements in the expansion.
Definition: ExpList.h:1896
int m_ncoeffs
The total number of local degrees of freedom. m_ncoeffs .
Definition: ExpList.h:917
Array< OneD, int > m_offset_elmt_id
Array containing the element id m_offset_elmt_id[n] that the n^th consecutive block of data in m_coef...
Definition: ExpList.h:999
boost::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:74
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
static AssemblyMapSharedPtr NullAssemblyMapSharedPtr
Definition: AssemblyMap.h:55
NekVector< NekDouble > DNekVec
Definition: NekTypeDefs.hpp:49
void IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, CoeffState coeffstate=eLocal)
Definition: ExpList.h:1559
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...
int GetNcoeffs(void) const
Returns the total number of local degrees of freedom .
Definition: ExpList.h:1403
boost::shared_ptr< GlobalLinSys > GlobalLinSysSharedPtr
Pointer to a GlobalLinSys object.
Definition: GlobalLinSys.h:52
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
void Nektar::MultiRegions::DisContField3D::v_Reset ( )
protectedvirtual

Reset this field, so that geometry information can be updated.

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 1999 of file DisContField3D.cpp.

References m_bndCondExpansions, and Nektar::MultiRegions::ExpList::v_Reset().

2000  {
2001  ExpList::v_Reset();
2002 
2003  // Reset boundary condition expansions.
2004  for (int n = 0; n < m_bndCondExpansions.num_elements(); ++n)
2005  {
2006  m_bndCondExpansions[n]->Reset();
2007  }
2008  }
virtual void v_Reset()
Reset geometry information, metrics, matrix managers and geometry information.
Definition: ExpList.cpp:1437
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
virtual MultiRegions::ExpListSharedPtr& Nektar::MultiRegions::DisContField3D::v_UpdateBndCondExpansion ( int  i)
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 246 of file DisContField3D.h.

247  {
248  return m_bndCondExpansions[i];
249  }
Array< OneD, MultiRegions::ExpListSharedPtr > m_bndCondExpansions
An object which contains the discretised boundary conditions.
virtual Array<OneD, SpatialDomains::BoundaryConditionShPtr>& Nektar::MultiRegions::DisContField3D::v_UpdateBndConditions ( )
inlineprotectedvirtual

Reimplemented from Nektar::MultiRegions::ExpList.

Definition at line 252 of file DisContField3D.h.

References m_bndConditions.

253  {
254  return m_bndConditions;
255  }
Array< OneD, SpatialDomains::BoundaryConditionShPtr > m_bndConditions
An array which contains the information about the boundary condition on the different boundary region...

Member Data Documentation

Array<OneD,MultiRegions::ExpListSharedPtr> Nektar::MultiRegions::DisContField3D::m_bndCondExpansions
protected
Array<OneD,SpatialDomains::BoundaryConditionShPtr> Nektar::MultiRegions::DisContField3D::m_bndConditions
protected
std::set<int> Nektar::MultiRegions::DisContField3D::m_boundaryFaces
protected

A set storing the global IDs of any boundary faces.

Definition at line 121 of file DisContField3D.h.

Referenced by IsLeftAdjacentFace(), and SetUpDG().

GlobalLinSysMapShPtr Nektar::MultiRegions::DisContField3D::m_globalBndMat
protected

Definition at line 111 of file DisContField3D.h.

Referenced by DisContField3D(), GetGlobalBndLinSys(), and SetUpDG().

std::vector<bool> Nektar::MultiRegions::DisContField3D::m_leftAdjacentFaces
protected

Definition at line 142 of file DisContField3D.h.

Referenced by GetLeftAdjacentFaces(), SetUpDG(), and v_GetLeftAdjacentFaces().

LocTraceToTraceMapSharedPtr Nektar::MultiRegions::DisContField3D::m_locTraceToTraceMap
protected

Map of local trace (the points at the face of the element) to the trace space discretisation.

Definition at line 116 of file DisContField3D.h.

Referenced by DisContField3D(), SetUpDG(), v_AddFwdBwdTraceIntegral(), v_AddTraceIntegral(), v_ExtractTracePhys(), and v_GetFwdBwdTracePhys().

std::vector<int> Nektar::MultiRegions::DisContField3D::m_periodicBwdCopy
protected

Definition at line 150 of file DisContField3D.h.

Referenced by SetUpDG(), and v_GetFwdBwdTracePhys().

PeriodicMap Nektar::MultiRegions::DisContField3D::m_periodicEdges
protected

A map which identifies groups of periodic edges.

Definition at line 131 of file DisContField3D.h.

Referenced by Nektar::MultiRegions::ContField3D::ContField3D(), DisContField3D(), FindPeriodicFaces(), and v_GetPeriodicEntities().

PeriodicMap Nektar::MultiRegions::DisContField3D::m_periodicFaces
protected

A map which identifies pairs of periodic faces.

Definition at line 126 of file DisContField3D.h.

Referenced by Nektar::MultiRegions::ContField3D::ContField3D(), DisContField3D(), FindPeriodicFaces(), IsLeftAdjacentFace(), SetUpDG(), and v_GetPeriodicEntities().

std::vector<int> Nektar::MultiRegions::DisContField3D::m_periodicFwdCopy
protected

A vector indicating degress of freedom which need to be copied from forwards to backwards space in case of a periodic boundary condition.

Definition at line 149 of file DisContField3D.h.

Referenced by SetUpDG(), and v_GetFwdBwdTracePhys().

PeriodicMap Nektar::MultiRegions::DisContField3D::m_periodicVerts
protected

A map which identifies groups of periodic vertices.

Definition at line 136 of file DisContField3D.h.

Referenced by Nektar::MultiRegions::ContField3D::ContField3D(), DisContField3D(), FindPeriodicFaces(), and v_GetPeriodicEntities().

ExpListSharedPtr Nektar::MultiRegions::DisContField3D::m_trace
protected
AssemblyMapDGSharedPtr Nektar::MultiRegions::DisContField3D::m_traceMap
protected