Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Public Attributes | List of all members
Nektar::Utilities::Field Struct Reference

#include <Field.hpp>

Collaboration diagram for Nektar::Utilities::Field:
Collaboration graph
[legend]

Public Member Functions

 Field ()
 ~Field ()
MultiRegions::ExpListSharedPtr SetUpFirstExpList (int NumHomogeneousDir, bool fldfilegiven=false)
MultiRegions::ExpListSharedPtr AppendExpList (int NumHomogeneousDir, string var="DefaultVar", bool NewField=false)

Public Attributes

bool m_verbose
vector
< LibUtilities::FieldDefinitionsSharedPtr > 		m_fielddef
vector< vector< double > > m_data
vector
< MultiRegions::ExpListSharedPtr > 		m_exp
bool m_declareExpansionAsContField
bool m_declareExpansionAsDisContField
LibUtilities::CommSharedPtr m_comm
LibUtilities::SessionReaderSharedPtr m_session
SpatialDomains::MeshGraphSharedPtr m_graph
LibUtilities::FieldIOSharedPtr m_fld
map< string, vector< string > > m_inputfiles
bool m_writeBndFld
vector< unsigned int > m_bndRegionsToWrite
bool m_fldToBnd
FieldPtsSharedPtr m_fieldPts

Detailed Description

Definition at line 170 of file Field.hpp.

Constructor & Destructor Documentation

Nektar::Utilities::Field::Field ( )
inline

Definition at line 171 of file Field.hpp.

: m_verbose(false),
m_declareExpansionAsContField(false),
m_declareExpansionAsDisContField(false),
m_writeBndFld(false),
m_fieldPts(NullFieldPts){}
Nektar::Utilities::Field::~Field ( )
inline

Definition at line 177 of file Field.hpp.

{
if (m_session)
{
m_session->Finalise();
}
}

Member Function Documentation

MultiRegions::ExpListSharedPtr Nektar::Utilities::Field::AppendExpList ( int  NumHomogeneousDir,
string  var = "DefaultVar",
bool  NewField = false 
)
inline

Definition at line 482 of file Field.hpp.

References ASSERTL0.

{
MultiRegions::ExpListSharedPtr tmp;
switch (m_graph->GetMeshDimension())
{
case 1:
{
if (NumHomogeneousDir == 1)
{
ASSERTL0(m_declareExpansionAsContField ||
m_declareExpansionAsDisContField,
"ContField2DHomogeneous1D or "
"DisContField2DHomogenenous1D has not been "
"implemented");
MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList2DHomogeneous1D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::
ExpList2DHomogeneous1D>::
AllocateSharedPtr(*tmp2);
}
else if (NumHomogeneousDir == 2)
{
if(m_declareExpansionAsContField)
{
MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ContField3DHomogeneous2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::
ContField3DHomogeneous2D>::
AllocateSharedPtr(*tmp2);
}
else if(m_declareExpansionAsDisContField)
{
MultiRegions::DisContField3DHomogeneous2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
DisContField3DHomogeneous2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::
DisContField3DHomogeneous2D>::
AllocateSharedPtr(*tmp2);
}
else
{
MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList3DHomogeneous2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::
ExpList3DHomogeneous2D>::
AllocateSharedPtr(*tmp2);
}
}
else
{
if(m_declareExpansionAsContField)
{
MultiRegions::ContField1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ContField1D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ContField1D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else if(m_declareExpansionAsDisContField)
{
MultiRegions::DisContField1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
DisContField1D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::DisContField1D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else
{
MultiRegions::ExpList1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList1D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ExpList1D>::
AllocateSharedPtr(*tmp2);
}
}
}
break;
case 2:
{
if (NumHomogeneousDir == 1)
{
if(m_declareExpansionAsContField)
{
if(NewField)
{
bool useFFT = false;
bool dealiasing = false;
tmp = MemoryManager<MultiRegions::
ContField3DHomogeneous1D>::AllocateSharedPtr(
m_session,
m_exp[0]->GetHomogeneousBasis()
->GetBasisKey(),
m_exp[0]->GetHomoLen(),
useFFT, dealiasing, m_graph, var);
}
else
{
MultiRegions::ContField3DHomogeneous1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ContField3DHomogeneous1D>(m_exp[0]);
ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
tmp = MemoryManager<MultiRegions::
ContField3DHomogeneous1D>::
AllocateSharedPtr(*tmp2);
}
}
else if(m_declareExpansionAsDisContField)
{
if(NewField)
{
bool useFFT = false;
bool dealiasing = false;
tmp = MemoryManager<MultiRegions::
DisContField3DHomogeneous1D>::AllocateSharedPtr(
m_session,
m_exp[0]->GetHomogeneousBasis()
->GetBasisKey(),
m_exp[0]->GetHomoLen(),
useFFT, dealiasing, m_graph,var);
}
else
{
MultiRegions::DisContField3DHomogeneous1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
DisContField3DHomogeneous1D>(m_exp[0]);
ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
tmp = MemoryManager<MultiRegions::
DisContField3DHomogeneous1D>::
AllocateSharedPtr(*tmp2);
}
}
else
{
if(NewField)
{
bool useFFT = false;
bool dealiasing = false;
tmp = MemoryManager<MultiRegions::
ExpList3DHomogeneous1D>::AllocateSharedPtr(
m_session,
m_exp[0]->GetHomogeneousBasis()
->GetBasisKey(),
m_exp[0]->GetHomoLen(),
useFFT, dealiasing, m_graph);
}
else
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList3DHomogeneous1D>(m_exp[0]);
ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
tmp = MemoryManager<MultiRegions::
ExpList3DHomogeneous1D>::
AllocateSharedPtr(*tmp2);
}
}
}
else
{
if(m_declareExpansionAsContField)
{
if(NewField)
{
tmp = MemoryManager<MultiRegions::ContField2D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else // call copy constructor
{
MultiRegions::ContField2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ContField2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ContField2D>::
AllocateSharedPtr(*tmp2,m_graph,var);
}
}
else if(m_declareExpansionAsDisContField)
{
if(NewField)
{
tmp = MemoryManager<MultiRegions::DisContField2D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else // call copy constructor
{
MultiRegions::DisContField2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
DisContField2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::DisContField2D>::
AllocateSharedPtr(*tmp2,m_graph,var);
}
}
else
{
MultiRegions::ExpList2DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList2D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ExpList2D>::
AllocateSharedPtr(*tmp2);
}
}
}
break;
case 3:
{
if(m_declareExpansionAsContField)
{
if(NewField)
{
tmp = MemoryManager<MultiRegions::ContField3D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else
{
MultiRegions::ContField3DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ContField3D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ContField3D>::
AllocateSharedPtr(*tmp2,m_graph,var);
}
}
else if(m_declareExpansionAsDisContField)
{
if(NewField)
{
tmp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(m_session,m_graph,var);
}
else
{
MultiRegions::DisContField3DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
DisContField3D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(*tmp2,m_graph,var);
}
}
else
{
MultiRegions::ExpList3DSharedPtr tmp2 =
boost::dynamic_pointer_cast<MultiRegions::
ExpList3D>(m_exp[0]);
tmp = MemoryManager<MultiRegions::ExpList3D>::
AllocateSharedPtr(*tmp2);
}
}
break;
default:
ASSERTL0(false, "Expansion dimension not recognised");
break;
}
return tmp;
}
MultiRegions::ExpListSharedPtr Nektar::Utilities::Field::SetUpFirstExpList ( int  NumHomogeneousDir,
bool  fldfilegiven = false 
)
inline

Definition at line 205 of file Field.hpp.

References ASSERTL0, Nektar::LibUtilities::eFourier, and Nektar::LibUtilities::ePolyEvenlySpaced.

{
MultiRegions::ExpListSharedPtr exp;
// Set up expansion list
int expdim = m_graph->GetMeshDimension();
bool useFFT = false;
bool dealiasing = false;
switch (expdim)
{
case 1:
{
ASSERTL0(NumHomogeneousDir <= 2,
"Quasi-3D approach is only set up for 1 or 2 "
"homogeneous directions");
if (NumHomogeneousDir == 1)
{
MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
// Define Homogeneous expansion
int nplanes;
NekDouble ly;
LibUtilities::BasisType btype;
if(fldfilegiven)
{
nplanes = m_fielddef[0]->m_numModes[1];
ly = m_fielddef[0]->m_homogeneousLengths[0];
btype = m_fielddef[0]->m_basis[1];
}
else
{
m_session->LoadParameter("HomModesZ", nplanes);
m_session->LoadParameter("LY",ly);
btype = LibUtilities::eFourier;
}
// Choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey
Pkey(nplanes, LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
if(m_declareExpansionAsContField||
m_declareExpansionAsDisContField)
{
ASSERTL0(false,"ContField2DHomogeneous1D or "
"DisContField2DHomogenenous1D has "
"not been implemented");
}
Exp2DH1 = MemoryManager<MultiRegions::
ExpList2DHomogeneous1D>::
AllocateSharedPtr(m_session, Bkey, ly,
useFFT, dealiasing,
m_graph);
exp = Exp2DH1;
}
else if (NumHomogeneousDir == 2)
{
MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
int nylines,nzlines;
NekDouble ly,lz;
LibUtilities::BasisType btype1,btype2;
if(fldfilegiven)
{
nylines = m_fielddef[0]->m_numModes[1];
nzlines = m_fielddef[0]->m_numModes[2];
ly = m_fielddef[0]->m_homogeneousLengths[0];
lz = m_fielddef[0]->m_homogeneousLengths[1];
btype1 = m_fielddef[0]->m_basis[1];
btype2 = m_fielddef[0]->m_basis[2];
}
else
{
m_session->LoadParameter("HomModesY", nylines);
m_session->LoadParameter("HomModesZ", nzlines);
m_session->LoadParameter("LY",ly);
m_session->LoadParameter("LZ",lz);
btype1 = LibUtilities::eFourier;
btype2 = LibUtilities::eFourier;
}
// Choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey
PkeyY(nylines, LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyY(btype1, nylines, PkeyY);
const LibUtilities::PointsKey
PkeyZ(nzlines, LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey BkeyZ(btype2, nzlines, PkeyZ);
if(m_declareExpansionAsContField)
{
Exp3DH2 = MemoryManager<MultiRegions::
ContField3DHomogeneous2D>::
AllocateSharedPtr(m_session, BkeyY, BkeyZ,
ly, lz, useFFT, dealiasing,
m_graph,
m_session->GetVariable(0));
}
else if(m_declareExpansionAsDisContField)
{
Exp3DH2 = MemoryManager<MultiRegions::
DisContField3DHomogeneous2D>::
AllocateSharedPtr(m_session, BkeyY, BkeyZ,
ly, lz, useFFT, dealiasing,
m_graph,
m_session->GetVariable(0));
}
else
{
Exp3DH2 = MemoryManager<MultiRegions::
ExpList3DHomogeneous2D>::
AllocateSharedPtr(m_session, BkeyY, BkeyZ,
ly, lz, useFFT, dealiasing,
m_graph);
}
exp = Exp3DH2;
}
else
{
MultiRegions::ExpList1DSharedPtr Exp1D;
if(m_declareExpansionAsContField)
{
Exp1D = MemoryManager<MultiRegions::ContField1D>
::AllocateSharedPtr(m_session, m_graph,
m_session->GetVariable(0));
}
else if(m_declareExpansionAsDisContField)
{
Exp1D = MemoryManager<MultiRegions::DisContField1D>
::AllocateSharedPtr(m_session, m_graph,
m_session->GetVariable(0));
}
else
{
Exp1D = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(m_session, m_graph);
}
exp = Exp1D;
}
}
break;
case 2:
{
ASSERTL0(NumHomogeneousDir <= 1,
"NumHomogeneousDir is only set up for 1");
if (NumHomogeneousDir == 1)
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
// Define Homogeneous expansion
int nplanes;
NekDouble lz;
LibUtilities::BasisType btype;
if(fldfilegiven)
{
nplanes = m_fielddef[0]->m_numModes[2];
lz = m_fielddef[0]->m_homogeneousLengths[0];
btype = m_fielddef[0]->m_basis[2];
}
else
{
m_session->LoadParameter("HomModesZ", nplanes);
m_session->LoadParameter("LZ",lz);
btype = LibUtilities::eFourier;
}
// Choose points to be at evenly spaced points at
// nplanes points
const LibUtilities::PointsKey
Pkey(nplanes, LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
if(m_declareExpansionAsContField)
{
Exp3DH1 = MemoryManager<MultiRegions::
ContField3DHomogeneous1D>::
AllocateSharedPtr(m_session, Bkey, lz, useFFT,
dealiasing, m_graph,
m_session->GetVariable(0));
}
else if (m_declareExpansionAsDisContField)
{
Exp3DH1 = MemoryManager<MultiRegions::
DisContField3DHomogeneous1D>::
AllocateSharedPtr(m_session,
Bkey, lz, useFFT,
dealiasing, m_graph,
m_session->GetVariable(0));
}
else
{
Exp3DH1 = MemoryManager<MultiRegions::
ExpList3DHomogeneous1D>::
AllocateSharedPtr(m_session, Bkey, lz, useFFT,
dealiasing, m_graph);
}
exp = Exp3DH1;
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
if(m_declareExpansionAsContField)
{
Exp2D = MemoryManager<MultiRegions::ContField2D>
::AllocateSharedPtr(m_session,m_graph,
m_session->GetVariable(0));
}
else if(m_declareExpansionAsDisContField)
{
Exp2D = MemoryManager<MultiRegions::DisContField2D>
::AllocateSharedPtr(m_session,m_graph,
m_session->GetVariable(0));
}
else
{
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(m_session,m_graph);
}
exp = Exp2D;
}
}
break;
case 3:
{
MultiRegions::ExpList3DSharedPtr Exp3D;
if(m_declareExpansionAsContField)
{
Exp3D = MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(m_session,m_graph,
m_session->GetVariable(0));
}
else if(m_declareExpansionAsDisContField)
{
Exp3D = MemoryManager<MultiRegions::DisContField3D>
::AllocateSharedPtr(m_session,m_graph,
m_session->GetVariable(0));
}
else
{
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(m_session, m_graph);
}
exp = Exp3D;
}
break;
default:
ASSERTL0(false, "Expansion dimension not recognised");
break;
}
return exp;
};

Member Data Documentation

vector<unsigned int> Nektar::Utilities::Field::m_bndRegionsToWrite

Definition at line 199 of file Field.hpp.

LibUtilities::CommSharedPtr Nektar::Utilities::Field::m_comm

Definition at line 192 of file Field.hpp.

vector<vector<double> > Nektar::Utilities::Field::m_data

Definition at line 186 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsContField

Definition at line 189 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsDisContField

Definition at line 190 of file Field.hpp.

vector<MultiRegions::ExpListSharedPtr> Nektar::Utilities::Field::m_exp

Definition at line 187 of file Field.hpp.

vector<LibUtilities::FieldDefinitionsSharedPtr> Nektar::Utilities::Field::m_fielddef

Definition at line 185 of file Field.hpp.

FieldPtsSharedPtr Nektar::Utilities::Field::m_fieldPts

Definition at line 202 of file Field.hpp.

LibUtilities::FieldIOSharedPtr Nektar::Utilities::Field::m_fld

Definition at line 195 of file Field.hpp.

bool Nektar::Utilities::Field::m_fldToBnd

Definition at line 200 of file Field.hpp.

SpatialDomains::MeshGraphSharedPtr Nektar::Utilities::Field::m_graph

Definition at line 194 of file Field.hpp.

map<string, vector<string> > Nektar::Utilities::Field::m_inputfiles

Definition at line 196 of file Field.hpp.

LibUtilities::SessionReaderSharedPtr Nektar::Utilities::Field::m_session

Definition at line 193 of file Field.hpp.

bool Nektar::Utilities::Field::m_verbose

Definition at line 184 of file Field.hpp.

bool Nektar::Utilities::Field::m_writeBndFld

Definition at line 198 of file Field.hpp.

Generated on Sun Mar 15 2015 00:12:08 for Nektar++ by   doxygen 1.8.1.2