Nektar++
Public Member Functions | Public Attributes | Private Attributes | List of all members
Nektar::FieldUtils::Field Struct Reference

#include <Field.hpp>

Public Member Functions

FIELD_UTILS_EXPORT Field ()
 
FIELD_UTILS_EXPORT ~Field ()
 
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList (int NumHomogeneousDir, bool fldfilegiven=false)
 
FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr FieldIOForFile (std::string filename)
 Construct a FieldIO object for the file filename. More...
 
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList (int NumHomogeneousDir, std::string var="DefaultVar", bool NewField=false)
 
FIELD_UTILS_EXPORT void ClearField ()
 

Public Attributes

bool m_verbose
 
std::vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
 
std::vector< std::vector< double > > m_data
 
std::vector< MultiRegions::ExpListSharedPtr > m_exp
 
std::vector< std::string > m_variables
 
int m_numHomogeneousDir
 
bool m_declareExpansionAsContField
 
bool m_declareExpansionAsDisContField
 
bool m_requireBoundaryExpansion
 
bool m_useFFT
 
LibUtilities::CommSharedPtr m_comm
 
LibUtilities::SessionReaderSharedPtr m_session
 
SpatialDomains::MeshGraphSharedPtr m_graph
 
std::map< std::string, std::vector< std::string > > m_inputfiles
 
bool m_writeBndFld
 
std::vector< unsigned int > m_bndRegionsToWrite
 
bool m_addNormals
 
LibUtilities::PtsFieldSharedPtr m_fieldPts
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 

Private Attributes

std::map< std::string, LibUtilities::FieldIOSharedPtr > m_fld
 Map to store FieldIO instances. Key is the reader type, value is the FieldIO object. More...
 

Detailed Description

Definition at line 61 of file Field.hpp.

Constructor & Destructor Documentation

◆ Field()

FIELD_UTILS_EXPORT Nektar::FieldUtils::Field::Field ( )
inline

Definition at line 63 of file Field.hpp.

64  : m_verbose(false), m_declareExpansionAsContField(false),
65  m_declareExpansionAsDisContField(false),
66  m_requireBoundaryExpansion(false), m_writeBndFld(false),
67  m_addNormals(false), m_fieldPts(LibUtilities::NullPtsField)
68  {
69  }
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:87
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:86
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:180
Nektar::FieldUtils::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:102

◆ ~Field()

FIELD_UTILS_EXPORT Nektar::FieldUtils::Field::~Field ( )
inline

Definition at line 71 of file Field.hpp.

References m_comm.

72  {
73  if (m_comm)
74  {
75  m_comm->Finalise();
76  }
77  }
Nektar::FieldUtils::Field::m_comm
LibUtilities::CommSharedPtr m_comm
Definition: Field.hpp:93

Member Function Documentation

◆ AppendExpList()

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

Definition at line 453 of file Field.hpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, and m_requireBoundaryExpansion.

457  {
458  if (var.compare("DefaultVar") == 0 && m_requireBoundaryExpansion)
459  {
460  if (m_session->GetVariables().size())
461  {
462  var = m_session->GetVariables()[0];
463  }
464  }
465  MultiRegions::ExpListSharedPtr tmp;
466  switch (m_graph->GetMeshDimension())
467  {
468  case 1:
469  {
470  if (NumHomogeneousDir == 1)
471  {
472  ASSERTL0(!(m_declareExpansionAsContField ||
473  m_declareExpansionAsDisContField),
474  "ContField2DHomogeneous1D or "
475  "DisContField2DHomogenenous1D has not been "
476  "implemented");
477 
478  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
479  std::dynamic_pointer_cast<
480  MultiRegions::ExpList2DHomogeneous1D>(m_exp[0]);
481 
482  tmp = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
483  AllocateSharedPtr(*tmp2);
484  }
485  else if (NumHomogeneousDir == 2)
486  {
487  if (m_declareExpansionAsContField)
488  {
489  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
490  std::dynamic_pointer_cast<
491  MultiRegions::ContField3DHomogeneous2D>(
492  m_exp[0]);
493 
494  tmp = MemoryManager<
495  MultiRegions::ContField3DHomogeneous2D>::
496  AllocateSharedPtr(*tmp2);
497  }
498  else if (m_declareExpansionAsDisContField)
499  {
500  MultiRegions::DisContField3DHomogeneous2DSharedPtr
501  tmp2 = std::dynamic_pointer_cast<
502  MultiRegions::DisContField3DHomogeneous2D>(
503  m_exp[0]);
504 
505  tmp = MemoryManager<
506  MultiRegions::DisContField3DHomogeneous2D>::
507  AllocateSharedPtr(*tmp2);
508  }
509  else
510  {
511  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
512  std::dynamic_pointer_cast<
513  MultiRegions::ExpList3DHomogeneous2D>(m_exp[0]);
514 
515  tmp = MemoryManager<
516  MultiRegions::ExpList3DHomogeneous2D>::
517  AllocateSharedPtr(*tmp2);
518  }
519  }
520  else
521  {
522  if (m_declareExpansionAsContField)
523  {
524  MultiRegions::ContField1DSharedPtr tmp2 =
525  std::dynamic_pointer_cast<
526  MultiRegions::ContField1D>(m_exp[0]);
527 
528  tmp = MemoryManager<MultiRegions::ContField1D>::
529  AllocateSharedPtr(m_session, m_graph, var);
530  }
531  else if (m_declareExpansionAsDisContField)
532  {
533  MultiRegions::DisContField1DSharedPtr tmp2 =
534  std::dynamic_pointer_cast<
535  MultiRegions::DisContField1D>(m_exp[0]);
536 
537  tmp = MemoryManager<MultiRegions::DisContField1D>::
538  AllocateSharedPtr(m_session, m_graph, var);
539  }
540  else
541  {
542  MultiRegions::ExpList1DSharedPtr tmp2 =
543  std::dynamic_pointer_cast<
544  MultiRegions::ExpList1D>(m_exp[0]);
545 
546  tmp = MemoryManager<
547  MultiRegions::ExpList1D>::AllocateSharedPtr(*tmp2);
548  }
549  }
550  }
551  break;
552  case 2:
553  {
554  if (NumHomogeneousDir == 1)
555  {
556  if (m_declareExpansionAsContField)
557  {
558  if (NewField)
559  {
560  bool dealiasing = false;
561 
562  tmp = MemoryManager<
563  MultiRegions::ContField3DHomogeneous1D>::
564  AllocateSharedPtr(
565  m_session, m_exp[0]
566  ->GetHomogeneousBasis()
567  ->GetBasisKey(),
568  m_exp[0]->GetHomoLen(), m_useFFT,
569  dealiasing, m_graph, var);
570  }
571  else
572  {
573  MultiRegions::ContField3DHomogeneous1DSharedPtr
574  tmp2 = std::dynamic_pointer_cast<
575  MultiRegions::ContField3DHomogeneous1D>(
576  m_exp[0]);
577 
578  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
579  tmp = MemoryManager<
580  MultiRegions::ContField3DHomogeneous1D>::
581  AllocateSharedPtr(*tmp2, m_graph, var);
582  }
583  }
584  else if (m_declareExpansionAsDisContField)
585  {
586  if (NewField)
587  {
588  bool dealiasing = false;
589 
590  tmp = MemoryManager<
591  MultiRegions::DisContField3DHomogeneous1D>::
592  AllocateSharedPtr(
593  m_session, m_exp[0]
594  ->GetHomogeneousBasis()
595  ->GetBasisKey(),
596  m_exp[0]->GetHomoLen(), m_useFFT,
597  dealiasing, m_graph, var);
598  }
599  else
600  {
601  MultiRegions::DisContField3DHomogeneous1DSharedPtr
602  tmp2 = std::dynamic_pointer_cast<
603  MultiRegions::DisContField3DHomogeneous1D>(
604  m_exp[0]);
605  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
606 
607  tmp = MemoryManager<
608  MultiRegions::DisContField3DHomogeneous1D>::
609  AllocateSharedPtr(*tmp2);
610  }
611  }
612  else
613  {
614  if (NewField)
615  {
616  bool dealiasing = false;
617 
618  tmp = MemoryManager<
619  MultiRegions::ExpList3DHomogeneous1D>::
620  AllocateSharedPtr(
621  m_session, m_exp[0]
622  ->GetHomogeneousBasis()
623  ->GetBasisKey(),
624  m_exp[0]->GetHomoLen(), m_useFFT,
625  dealiasing, m_graph);
626  }
627  else
628  {
629  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
630  std::dynamic_pointer_cast<
631  MultiRegions::ExpList3DHomogeneous1D>(
632  m_exp[0]);
633  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
634 
635  tmp = MemoryManager<
636  MultiRegions::ExpList3DHomogeneous1D>::
637  AllocateSharedPtr(*tmp2);
638  }
639  }
640  }
641  else
642  {
643  if (m_declareExpansionAsContField)
644  {
645  if (NewField)
646  {
647  tmp = MemoryManager<MultiRegions::ContField2D>::
648  AllocateSharedPtr(m_session, m_graph, var);
649  }
650  else // call copy constructor
651  {
652 
653  MultiRegions::ContField2DSharedPtr tmp2 =
654  std::dynamic_pointer_cast<
655  MultiRegions::ContField2D>(m_exp[0]);
656 
657  tmp = MemoryManager<MultiRegions::ContField2D>::
658  AllocateSharedPtr(*tmp2, m_graph, var);
659  }
660  }
661  else if (m_declareExpansionAsDisContField)
662  {
663  if (NewField)
664  {
665  tmp = MemoryManager<MultiRegions::DisContField2D>::
666  AllocateSharedPtr(m_session, m_graph, var);
667  }
668  else // call copy constructor
669  {
670  MultiRegions::DisContField2DSharedPtr tmp2 =
671  std::dynamic_pointer_cast<
672  MultiRegions::DisContField2D>(m_exp[0]);
673 
674  tmp = MemoryManager<MultiRegions::DisContField2D>::
675  AllocateSharedPtr(*tmp2, m_graph, var);
676  }
677  }
678  else
679  {
680  MultiRegions::ExpList2DSharedPtr tmp2 =
681  std::dynamic_pointer_cast<
682  MultiRegions::ExpList2D>(m_exp[0]);
683 
684  tmp = MemoryManager<
685  MultiRegions::ExpList2D>::AllocateSharedPtr(*tmp2);
686  }
687  }
688  }
689  break;
690  case 3:
691  {
692  if (m_declareExpansionAsContField)
693  {
694  if (NewField)
695  {
696  tmp = MemoryManager<MultiRegions::ContField3D>::
697  AllocateSharedPtr(m_session, m_graph, var);
698  }
699  else
700  {
701  MultiRegions::ContField3DSharedPtr tmp2 =
702  std::dynamic_pointer_cast<
703  MultiRegions::ContField3D>(m_exp[0]);
704 
705  tmp = MemoryManager<MultiRegions::ContField3D>::
706  AllocateSharedPtr(*tmp2, m_graph, var);
707  }
708  }
709  else if (m_declareExpansionAsDisContField)
710  {
711  if (NewField)
712  {
713  tmp = MemoryManager<MultiRegions::DisContField3D>::
714  AllocateSharedPtr(m_session, m_graph, var);
715  }
716  else
717  {
718  MultiRegions::DisContField3DSharedPtr tmp2 =
719  std::dynamic_pointer_cast<
720  MultiRegions::DisContField3D>(m_exp[0]);
721 
722  tmp = MemoryManager<MultiRegions::DisContField3D>::
723  AllocateSharedPtr(*tmp2, m_graph, var);
724  }
725  }
726  else
727  {
728  MultiRegions::ExpList3DSharedPtr tmp2 =
729  std::dynamic_pointer_cast<MultiRegions::ExpList3D>(
730  m_exp[0]);
731 
732  tmp = MemoryManager<
733  MultiRegions::ExpList3D>::AllocateSharedPtr(*tmp2);
734  }
735  }
736  break;
737  default:
738  ASSERTL0(false, "Expansion dimension not recognised");
739  break;
740  }
741 
742  return tmp;
743  }
Nektar::MultiRegions::DisContField2DSharedPtr
std::shared_ptr< DisContField2D > DisContField2DSharedPtr
Definition: DisContField2D.h:306
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
std::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:302
Nektar::MultiRegions::ContField1DSharedPtr
std::shared_ptr< ContField1D > ContField1DSharedPtr
Definition: ContField1D.h:238
Nektar::MultiRegions::DisContField3DSharedPtr
std::shared_ptr< DisContField3D > DisContField3DSharedPtr
Definition: DisContField3D.h:273
Nektar::MultiRegions::ExpListSharedPtr
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:55
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:87
Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr
std::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
Definition: ContField3DHomogeneous2D.h:103
Nektar::MultiRegions::ContField2DSharedPtr
std::shared_ptr< ContField2D > ContField2DSharedPtr
Definition: ContField2D.h:289
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:94
Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr
std::shared_ptr< ExpList3DHomogeneous1D > ExpList3DHomogeneous1DSharedPtr
Shared pointer to an ExpList3DHomogeneous1D object.
Definition: ExpList3DHomogeneous1D.h:51
Nektar::MultiRegions::ExpList2DSharedPtr
std::shared_ptr< ExpList2D > ExpList2DSharedPtr
Shared pointer to an ExpList2D object.
Definition: ExpList2D.h:48
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:95
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:86
Nektar::MultiRegions::ContField3DSharedPtr
std::shared_ptr< ContField3D > ContField3DSharedPtr
Definition: ContField3D.h:208
Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr
std::shared_ptr< ExpList2DHomogeneous1D > ExpList2DHomogeneous1DSharedPtr
Shared pointer to an ExpList2DHomogeneous1D object.
Definition: ExpList2DHomogeneous1D.h:49
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr
std::shared_ptr< DisContField3DHomogeneous2D > DisContField3DHomogeneous2DSharedPtr
Definition: DisContField3DHomogeneous2D.h:162
Nektar::FieldUtils::Field::m_exp
std::vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:81
Nektar::MultiRegions::DisContField1DSharedPtr
std::shared_ptr< DisContField1D > DisContField1DSharedPtr
Definition: DisContField1D.h:281
Nektar::MultiRegions::ExpList3DSharedPtr
std::shared_ptr< ExpList3D > ExpList3DSharedPtr
Shared pointer to an ExpList3D object.
Definition: ExpList3D.h:111
Nektar::MultiRegions::ExpList1DSharedPtr
std::shared_ptr< ExpList1D > ExpList1DSharedPtr
Shared pointer to an ExpList1D object.
Definition: ExpList1D.h:49
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
std::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:108
Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr
std::shared_ptr< ExpList3DHomogeneous2D > ExpList3DHomogeneous2DSharedPtr
Shared pointer to an ExpList3DHomogeneous2D object.
Definition: ExpList3DHomogeneous2D.h:49

◆ ClearField()

FIELD_UTILS_EXPORT void Nektar::FieldUtils::Field::ClearField ( )
inline

Definition at line 745 of file Field.hpp.

References Nektar::LibUtilities::NullPtsField.

746  {
747  m_session = LibUtilities::SessionReaderSharedPtr();
748  m_graph = SpatialDomains::MeshGraphSharedPtr();
749  m_fieldPts = LibUtilities::NullPtsField;
750  m_exp.clear();
751  m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
752  m_data = std::vector<std::vector<NekDouble> > ();
753  m_variables.clear();
754  }
Nektar::SpatialDomains::MeshGraphSharedPtr
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:163
Nektar::FieldUtils::Field::m_variables
std::vector< std::string > m_variables
Definition: Field.hpp:82
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:94
Nektar::FieldUtils::Field::m_data
std::vector< std::vector< double > > m_data
Definition: Field.hpp:80
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:95
Nektar::FieldUtils::Field::m_fielddef
std::vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
Definition: Field.hpp:79
Nektar::FieldUtils::Field::m_exp
std::vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:81
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:180
Nektar::FieldUtils::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:102
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:112

◆ FieldIOForFile()

FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr Nektar::FieldUtils::Field::FieldIOForFile ( std::string  filename)
inline

Construct a FieldIO object for the file filename.

This routine constructs an appropriate FieldIO object for a filename through the LibUtilities::FieldIO::GetFileType function to detect the file format. The result is then cached in Field::m_fld to avoid needing to repeatedly construct the object.

Parameters
filenameFilename to open.
Returns
Reader for filename.

Definition at line 433 of file Field.hpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::GetFieldIOFactory(), Nektar::LibUtilities::FieldIO::GetFileType(), m_comm, and m_fld.

435  {
436  LibUtilities::CommSharedPtr c = m_comm;
437  std::string fmt = LibUtilities::FieldIO::GetFileType(filename, c);
438  auto it = m_fld.find(fmt);
439 
440  if (it == m_fld.end())
441  {
442  LibUtilities::FieldIOSharedPtr fld =
443  LibUtilities::GetFieldIOFactory().CreateInstance(fmt, c, true);
444  m_fld[fmt] = fld;
445  return fld;
446  }
447  else
448  {
449  return it->second;
450  }
451  }
Nektar::FieldUtils::Field::m_comm
LibUtilities::CommSharedPtr m_comm
Definition: Field.hpp:93
Nektar::FieldUtils::Field::m_fld
std::map< std::string, LibUtilities::FieldIOSharedPtr > m_fld
Map to store FieldIO instances. Key is the reader type, value is the FieldIO object.
Definition: Field.hpp:759
Nektar::LibUtilities::CommSharedPtr
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:53
Nektar::LibUtilities::GetFieldIOFactory
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:72
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
Nektar::LibUtilities::FieldIO::GetFileType
static const std::string GetFileType(const std::string &filename, CommSharedPtr comm)
Determine file type of given input file.
Definition: FieldIO.cpp:97
Nektar::LibUtilities::FieldIOSharedPtr
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:306

◆ SetUpFirstExpList()

FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr Nektar::FieldUtils::Field::SetUpFirstExpList ( int  NumHomogeneousDir,
bool  fldfilegiven = false 
)
inline

Definition at line 106 of file Field.hpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::Collections::eNoCollection, and Nektar::LibUtilities::ePolyEvenlySpaced.

108  {
109 
110  MultiRegions::ExpListSharedPtr exp;
111 
112  // Set up expansion list
113  int expdim = m_graph->GetMeshDimension();
114  bool dealiasing = false;
115 
116  m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
117 
118  switch (expdim)
119  {
120  case 1:
121  {
122  ASSERTL0(NumHomogeneousDir <= 2,
123  "Quasi-3D approach is only set up for 1 or 2 "
124  "homogeneous directions");
125 
126  if (NumHomogeneousDir == 1)
127  {
128  MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
129 
130  // Define Homogeneous expansion
131  int nplanes;
132  NekDouble ly;
133  LibUtilities::BasisType btype;
134 
135  if (fldfilegiven)
136  {
137  nplanes = m_fielddef[0]->m_numModes[1];
138  ly = m_fielddef[0]->m_homogeneousLengths[0];
139  btype = m_fielddef[0]->m_basis[1];
140  }
141  else
142  {
143  m_session->LoadParameter("HomModesZ", nplanes);
144  m_session->LoadParameter("LY", ly);
145  btype = LibUtilities::eFourier;
146  }
147 
148  // Choose points to be at evenly spaced points at
149  // nplanes points
150  const LibUtilities::PointsKey Pkey(
151  nplanes, LibUtilities::eFourierEvenlySpaced);
152 
153  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
154 
155  if (m_declareExpansionAsContField ||
156  m_declareExpansionAsDisContField)
157  {
158  ASSERTL0(false, "ContField2DHomogeneous1D or "
159  "DisContField2DHomogenenous1D has "
160  "not been implemented");
161  }
162 
163  Exp2DH1 =
164  MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
165  AllocateSharedPtr(m_session, Bkey, ly, m_useFFT,
166  dealiasing, m_graph,
167  Collections::eNoCollection);
168  exp = Exp2DH1;
169  }
170  else if (NumHomogeneousDir == 2)
171  {
172  MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
173 
174  int nylines, nzlines;
175  NekDouble ly, lz;
176  LibUtilities::BasisType btype1, btype2;
177 
178  if (fldfilegiven)
179  {
180  nylines = m_fielddef[0]->m_numModes[1];
181  nzlines = m_fielddef[0]->m_numModes[2];
182  ly = m_fielddef[0]->m_homogeneousLengths[0];
183  lz = m_fielddef[0]->m_homogeneousLengths[1];
184  btype1 = m_fielddef[0]->m_basis[1];
185  btype2 = m_fielddef[0]->m_basis[2];
186  }
187  else
188  {
189  m_session->LoadParameter("HomModesY", nylines);
190  m_session->LoadParameter("HomModesZ", nzlines);
191  m_session->LoadParameter("LY", ly);
192  m_session->LoadParameter("LZ", lz);
193  btype1 = LibUtilities::eFourier;
194  btype2 = LibUtilities::eFourier;
195  }
196 
197  // Choose points to be at evenly spaced points at
198  // nplanes points
199  const LibUtilities::PointsKey PkeyY(
200  nylines, LibUtilities::eFourierEvenlySpaced);
201  const LibUtilities::BasisKey BkeyY(btype1, nylines, PkeyY);
202 
203  const LibUtilities::PointsKey PkeyZ(
204  nzlines, LibUtilities::eFourierEvenlySpaced);
205  const LibUtilities::BasisKey BkeyZ(btype2, nzlines, PkeyZ);
206 
207  if (m_declareExpansionAsContField)
208  {
209  Exp3DH2 = MemoryManager<
210  MultiRegions::ContField3DHomogeneous2D>::
211  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
212  m_useFFT, dealiasing, m_graph,
213  m_session->GetVariable(0),
214  Collections::eNoCollection);
215  }
216  else if (m_declareExpansionAsDisContField)
217  {
218  Exp3DH2 = MemoryManager<
219  MultiRegions::DisContField3DHomogeneous2D>::
220  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
221  m_useFFT, dealiasing, m_graph,
222  m_session->GetVariable(0),
223  Collections::eNoCollection);
224  }
225  else
226  {
227  Exp3DH2 = MemoryManager<
228  MultiRegions::ExpList3DHomogeneous2D>::
229  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
230  m_useFFT, dealiasing, m_graph,
231  Collections::eNoCollection);
232  }
233 
234  exp = Exp3DH2;
235  }
236  else
237  {
238  MultiRegions::ExpList1DSharedPtr Exp1D;
239 
240  if (m_declareExpansionAsContField)
241  {
242  Exp1D = MemoryManager<MultiRegions::ContField1D>::
243  AllocateSharedPtr(m_session, m_graph,
244  m_session->GetVariable(0),
245  Collections::eNoCollection);
246  }
247  else if (m_declareExpansionAsDisContField)
248  {
249  Exp1D = MemoryManager<MultiRegions::DisContField1D>::
250  AllocateSharedPtr(m_session, m_graph,
251  m_session->GetVariable(0),
252  true,
253  Collections::eNoCollection);
254  }
255  else
256  {
257  Exp1D = MemoryManager<MultiRegions::ExpList1D>::
258  AllocateSharedPtr(m_session, m_graph,
259  true,
260  Collections::eNoCollection);
261  }
262 
263  exp = Exp1D;
264  }
265  }
266  break;
267  case 2:
268  {
269  ASSERTL0(NumHomogeneousDir <= 1,
270  "NumHomogeneousDir is only set up for 1");
271 
272  if (NumHomogeneousDir == 1)
273  {
274  MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
275 
276  // Define Homogeneous expansion
277  int nplanes;
278  NekDouble lz;
279  LibUtilities::BasisType btype;
280  LibUtilities::PointsType ptype =
281  LibUtilities::eFourierEvenlySpaced;
282 
283  if (fldfilegiven)
284  {
285  nplanes = m_fielddef[0]->m_numModes[2];
286  lz = m_fielddef[0]->m_homogeneousLengths[0];
287  btype = m_fielddef[0]->m_basis[2];
288 
289  if (btype == LibUtilities::eFourierSingleMode)
290  {
291  btype = LibUtilities::eFourier;
292  m_fielddef[0]->m_basis[2] =
293  LibUtilities::eFourierSingleMode;
294  if (nplanes <= 2)
295  {
296  nplanes = 4;
297  }
298  }
299  else if (btype == LibUtilities::eFourierHalfModeRe &&
300  nplanes == 1)
301  {
302  ptype = LibUtilities::ePolyEvenlySpaced;
303  }
304  }
305  else
306  {
307  m_session->LoadParameter("HomModesZ", nplanes);
308  m_session->LoadParameter("LZ", lz);
309  btype = LibUtilities::eFourier;
310  }
311 
312  // Choose points to be at evenly spaced points at
313  // nplanes points
314  const LibUtilities::PointsKey Pkey(
315  nplanes, ptype);
316 
317  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
318 
319  if (m_declareExpansionAsContField)
320  {
321  Exp3DH1 = MemoryManager<
322  MultiRegions::ContField3DHomogeneous1D>::
323  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
324  dealiasing, m_graph,
325  m_session->GetVariable(0),
326  Collections::eNoCollection);
327  }
328  else if (m_declareExpansionAsDisContField)
329  {
330  Exp3DH1 = MemoryManager<
331  MultiRegions::DisContField3DHomogeneous1D>::
332  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
333  dealiasing, m_graph,
334  m_session->GetVariable(0),
335  Collections::eNoCollection);
336  }
337  else
338  {
339  Exp3DH1 = MemoryManager<
340  MultiRegions::ExpList3DHomogeneous1D>::
341  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
342  dealiasing, m_graph,
343  "DefaultVar",
344  Collections::eNoCollection);
345  }
346  exp = Exp3DH1;
347  }
348  else
349  {
350  MultiRegions::ExpList2DSharedPtr Exp2D;
351 
352  if (m_declareExpansionAsContField)
353  {
354  Exp2D = MemoryManager<MultiRegions::ContField2D>::
355  AllocateSharedPtr(m_session, m_graph,
356  m_session->GetVariable(0),
357  true,false,
358  Collections::eNoCollection);
359  }
360  else if (m_declareExpansionAsDisContField)
361  {
362  Exp2D = MemoryManager<MultiRegions::DisContField2D>::
363  AllocateSharedPtr(m_session, m_graph,
364  m_session->GetVariable(0),
365  true,true,
366  Collections::eNoCollection);
367  }
368  else
369  {
370  Exp2D = MemoryManager<MultiRegions::ExpList2D>::
371  AllocateSharedPtr(m_session, m_graph,
372  true,
373  "DefaultVar",
374  Collections::eNoCollection);
375  }
376 
377  exp = Exp2D;
378  }
379  }
380  break;
381  case 3:
382  {
383  MultiRegions::ExpList3DSharedPtr Exp3D;
384 
385  if (m_declareExpansionAsContField)
386  {
387  Exp3D = MemoryManager<MultiRegions::ContField3D>::
388  AllocateSharedPtr(m_session, m_graph,
389  m_session->GetVariable(0),
390  false,
391  Collections::eNoCollection);
392  }
393  else if (m_declareExpansionAsDisContField)
394  {
395  Exp3D = MemoryManager<MultiRegions::DisContField3D>::
396  AllocateSharedPtr(m_session, m_graph,
397  m_session->GetVariable(0),
398  true,
399  Collections::eNoCollection);
400  }
401  else
402  {
403  Exp3D = MemoryManager<
404  MultiRegions::ExpList3D>::AllocateSharedPtr(
405  m_session,
406  m_graph,
407  "DefaultVar",
408  Collections::eNoCollection);
409  }
410 
411  exp = Exp3D;
412  }
413  break;
414  default:
415  ASSERTL0(false, "Expansion dimension not recognised");
416  break;
417  }
418 
419  return exp;
420  };
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::MultiRegions::ExpListSharedPtr
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:55
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:87
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:94
Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr
std::shared_ptr< ExpList3DHomogeneous1D > ExpList3DHomogeneous1DSharedPtr
Shared pointer to an ExpList3DHomogeneous1D object.
Definition: ExpList3DHomogeneous1D.h:51
Nektar::LibUtilities::eFourier
Fourier Expansion .
Definition: BasisType.h:53
Nektar::MultiRegions::ExpList2DSharedPtr
std::shared_ptr< ExpList2D > ExpList2DSharedPtr
Shared pointer to an ExpList2D object.
Definition: ExpList2D.h:48
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:95
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:86
Nektar::LibUtilities::ePolyEvenlySpaced
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:64
Nektar::FieldUtils::Field::m_fielddef
std::vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
Definition: Field.hpp:79
Nektar::LibUtilities::eFourierEvenlySpaced
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:65
Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr
std::shared_ptr< ExpList2DHomogeneous1D > ExpList2DHomogeneous1DSharedPtr
Shared pointer to an ExpList2DHomogeneous1D object.
Definition: ExpList2DHomogeneous1D.h:49
Nektar::LibUtilities::eFourierHalfModeRe
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:60
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::LibUtilities::eFourierSingleMode
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:59
Nektar::MultiRegions::ExpList3DSharedPtr
std::shared_ptr< ExpList3D > ExpList3DSharedPtr
Shared pointer to an ExpList3D object.
Definition: ExpList3D.h:111
Nektar::MultiRegions::ExpList1DSharedPtr
std::shared_ptr< ExpList1D > ExpList1DSharedPtr
Shared pointer to an ExpList1D object.
Definition: ExpList1D.h:49
Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr
std::shared_ptr< ExpList3DHomogeneous2D > ExpList3DHomogeneous2DSharedPtr
Shared pointer to an ExpList3DHomogeneous2D object.
Definition: ExpList3DHomogeneous2D.h:49

Member Data Documentation

◆ m_addNormals

bool Nektar::FieldUtils::Field::m_addNormals

Definition at line 100 of file Field.hpp.

◆ m_bndRegionsToWrite

std::vector<unsigned int> Nektar::FieldUtils::Field::m_bndRegionsToWrite

Definition at line 99 of file Field.hpp.

◆ m_comm

LibUtilities::CommSharedPtr Nektar::FieldUtils::Field::m_comm

Definition at line 93 of file Field.hpp.

Referenced by FieldIOForFile(), and ~Field().

◆ m_data

std::vector<std::vector<double> > Nektar::FieldUtils::Field::m_data

Definition at line 80 of file Field.hpp.

◆ m_declareExpansionAsContField

bool Nektar::FieldUtils::Field::m_declareExpansionAsContField

Definition at line 86 of file Field.hpp.

◆ m_declareExpansionAsDisContField

bool Nektar::FieldUtils::Field::m_declareExpansionAsDisContField

Definition at line 87 of file Field.hpp.

◆ m_exp

std::vector<MultiRegions::ExpListSharedPtr> Nektar::FieldUtils::Field::m_exp

Definition at line 81 of file Field.hpp.

◆ m_fielddef

std::vector<LibUtilities::FieldDefinitionsSharedPtr> Nektar::FieldUtils::Field::m_fielddef

Definition at line 79 of file Field.hpp.

◆ m_fieldMetaDataMap

LibUtilities::FieldMetaDataMap Nektar::FieldUtils::Field::m_fieldMetaDataMap

Definition at line 104 of file Field.hpp.

◆ m_fieldPts

LibUtilities::PtsFieldSharedPtr Nektar::FieldUtils::Field::m_fieldPts

Definition at line 102 of file Field.hpp.

◆ m_fld

std::map<std::string, LibUtilities::FieldIOSharedPtr> Nektar::FieldUtils::Field::m_fld
private

Map to store FieldIO instances. Key is the reader type, value is the FieldIO object.

Definition at line 759 of file Field.hpp.

Referenced by FieldIOForFile().

◆ m_graph

SpatialDomains::MeshGraphSharedPtr Nektar::FieldUtils::Field::m_graph

Definition at line 95 of file Field.hpp.

◆ m_inputfiles

std::map<std::string, std::vector<std::string> > Nektar::FieldUtils::Field::m_inputfiles

Definition at line 96 of file Field.hpp.

◆ m_numHomogeneousDir

int Nektar::FieldUtils::Field::m_numHomogeneousDir

Definition at line 84 of file Field.hpp.

◆ m_requireBoundaryExpansion

bool Nektar::FieldUtils::Field::m_requireBoundaryExpansion

Definition at line 89 of file Field.hpp.

Referenced by AppendExpList().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::FieldUtils::Field::m_session

Definition at line 94 of file Field.hpp.

◆ m_useFFT

bool Nektar::FieldUtils::Field::m_useFFT

Definition at line 91 of file Field.hpp.

◆ m_variables

std::vector<std::string> Nektar::FieldUtils::Field::m_variables

Definition at line 82 of file Field.hpp.

◆ m_verbose

bool Nektar::FieldUtils::Field::m_verbose

Definition at line 78 of file Field.hpp.

◆ m_writeBndFld

bool Nektar::FieldUtils::Field::m_writeBndFld

Definition at line 98 of file Field.hpp.

Generated on Wed Jan 20 2021 03:33:58 for Nektar++ by   doxygen 1.8.13