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 void SetUpExp (boost::program_options::variables_map &vm)
 
FIELD_UTILS_EXPORT void CreateExp (boost::program_options::variables_map &vm, bool newExp)
 
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::CommSharedPtr m_defComm
 
LibUtilities::CommSharedPtr m_partComm
 
int m_nParts = 1
 
po::variables_map m_vm
 
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 62 of file Field.hpp.

Constructor & Destructor Documentation

◆ Field()

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

Definition at line 64 of file Field.hpp.

65  : m_verbose(false), m_declareExpansionAsContField(false),
66  m_declareExpansionAsDisContField(false),
67  m_requireBoundaryExpansion(false), m_writeBndFld(false),
68  m_addNormals(false), m_fieldPts(LibUtilities::NullPtsField)
69  {
70  }
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:191
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:89
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:88
Nektar::FieldUtils::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:109

◆ ~Field()

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

Definition at line 72 of file Field.hpp.

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

References m_comm.

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 664 of file Field.hpp.

667  {
668  if (var.compare("DefaultVar") == 0 && m_requireBoundaryExpansion)
669  {
670  if (m_session->GetVariables().size())
671  {
672  var = m_session->GetVariables()[0];
673  }
674  }
675  MultiRegions::ExpListSharedPtr tmp;
676  switch (m_graph->GetMeshDimension())
677  {
678  case 1:
679  {
680  if (NumHomogeneousDir == 1)
681  {
682  ASSERTL0(!(m_declareExpansionAsContField ||
683  m_declareExpansionAsDisContField),
684  "ContFieldHomogeneous1D or "
685  "DisContFieldHomogenenous1D has not been "
686  "implemented");
687 
688  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
689  std::dynamic_pointer_cast<
690  MultiRegions::ExpList2DHomogeneous1D>(m_exp[0]);
691 
692  tmp = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
693  AllocateSharedPtr(*tmp2);
694  }
695  else if (NumHomogeneousDir == 2)
696  {
697  if (m_declareExpansionAsContField)
698  {
699  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
700  std::dynamic_pointer_cast<
701  MultiRegions::ContField3DHomogeneous2D>(
702  m_exp[0]);
703 
704  tmp = MemoryManager<
705  MultiRegions::ContField3DHomogeneous2D>::
706  AllocateSharedPtr(*tmp2);
707  }
708  else if (m_declareExpansionAsDisContField)
709  {
710  MultiRegions::DisContField3DHomogeneous2DSharedPtr
711  tmp2 = std::dynamic_pointer_cast<
712  MultiRegions::DisContField3DHomogeneous2D>(
713  m_exp[0]);
714 
715  tmp = MemoryManager<
716  MultiRegions::DisContField3DHomogeneous2D>::
717  AllocateSharedPtr(*tmp2);
718  }
719  else
720  {
721  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
722  std::dynamic_pointer_cast<
723  MultiRegions::ExpList3DHomogeneous2D>(m_exp[0]);
724 
725  tmp = MemoryManager<
726  MultiRegions::ExpList3DHomogeneous2D>::
727  AllocateSharedPtr(*tmp2);
728  }
729  }
730  else
731  {
732  if (m_declareExpansionAsContField)
733  {
734  MultiRegions::ContFieldSharedPtr tmp2 =
735  std::dynamic_pointer_cast<MultiRegions::ContField>(
736  m_exp[0]);
737 
738  tmp = MemoryManager<MultiRegions::ContField>::
739  AllocateSharedPtr(m_session, m_graph, var, true,
740  false,
741  Collections::eNoCollection);
742  }
743  else if (m_declareExpansionAsDisContField)
744  {
745  MultiRegions::DisContFieldSharedPtr tmp2 =
746  std::dynamic_pointer_cast<
747  MultiRegions::DisContField>(m_exp[0]);
748 
749  tmp = MemoryManager<MultiRegions::DisContField>::
750  AllocateSharedPtr(m_session, m_graph, var, true,
751  Collections::eNoCollection);
752  }
753  else
754  {
755  MultiRegions::ExpListSharedPtr tmp2 =
756  std::dynamic_pointer_cast<MultiRegions::ExpList>(
757  m_exp[0]);
758 
759  tmp = MemoryManager<
760  MultiRegions::ExpList>::AllocateSharedPtr(*tmp2);
761  }
762  }
763  }
764  break;
765  case 2:
766  {
767  if (NumHomogeneousDir == 1)
768  {
769  if (m_declareExpansionAsContField)
770  {
771  if (NewField)
772  {
773  bool dealiasing = false;
774 
775  tmp = MemoryManager<
776  MultiRegions::ContField3DHomogeneous1D>::
777  AllocateSharedPtr(m_session,
778  m_exp[0]
779  ->GetHomogeneousBasis()
780  ->GetBasisKey(),
781  m_exp[0]->GetHomoLen(),
782  m_useFFT, dealiasing, m_graph,
783  var,
784  Collections::eNoCollection);
785  }
786  else
787  {
788  MultiRegions::ContField3DHomogeneous1DSharedPtr
789  tmp2 = std::dynamic_pointer_cast<
790  MultiRegions::ContField3DHomogeneous1D>(
791  m_exp[0]);
792 
793  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
794  tmp = MemoryManager<
795  MultiRegions::ContField3DHomogeneous1D>::
796  AllocateSharedPtr(*tmp2, m_graph, var);
797  }
798  }
799  else if (m_declareExpansionAsDisContField)
800  {
801  if (NewField)
802  {
803  bool dealiasing = false;
804 
805  tmp = MemoryManager<
806  MultiRegions::DisContField3DHomogeneous1D>::
807  AllocateSharedPtr(m_session,
808  m_exp[0]
809  ->GetHomogeneousBasis()
810  ->GetBasisKey(),
811  m_exp[0]->GetHomoLen(),
812  m_useFFT, dealiasing, m_graph,
813  var,
814  Collections::eNoCollection);
815  }
816  else
817  {
818  MultiRegions::DisContField3DHomogeneous1DSharedPtr
819  tmp2 = std::dynamic_pointer_cast<
820  MultiRegions::DisContField3DHomogeneous1D>(
821  m_exp[0]);
822  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
823 
824  tmp = MemoryManager<
825  MultiRegions::DisContField3DHomogeneous1D>::
826  AllocateSharedPtr(*tmp2);
827  }
828  }
829  else
830  {
831  if (NewField)
832  {
833  bool dealiasing = false;
834 
835  tmp = MemoryManager<
836  MultiRegions::ExpList3DHomogeneous1D>::
837  AllocateSharedPtr(m_session,
838  m_exp[0]
839  ->GetHomogeneousBasis()
840  ->GetBasisKey(),
841  m_exp[0]->GetHomoLen(),
842  m_useFFT, dealiasing, m_graph,
843  "DefaultVar",
844  Collections::eNoCollection);
845  }
846  else
847  {
848  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
849  std::dynamic_pointer_cast<
850  MultiRegions::ExpList3DHomogeneous1D>(
851  m_exp[0]);
852  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
853 
854  tmp = MemoryManager<
855  MultiRegions::ExpList3DHomogeneous1D>::
856  AllocateSharedPtr(*tmp2);
857  }
858  }
859  }
860  else
861  {
862  if (m_declareExpansionAsContField)
863  {
864  if (NewField)
865  {
866  tmp = MemoryManager<MultiRegions::ContField>::
867  AllocateSharedPtr(m_session, m_graph, var, true,
868  false,
869  Collections::eNoCollection);
870  }
871  else // call copy constructor
872  {
873 
874  MultiRegions::ContFieldSharedPtr tmp2 =
875  std::dynamic_pointer_cast<
876  MultiRegions::ContField>(m_exp[0]);
877 
878  tmp = MemoryManager<MultiRegions::ContField>::
879  AllocateSharedPtr(*tmp2, m_graph, var);
880  }
881  }
882  else if (m_declareExpansionAsDisContField)
883  {
884  if (NewField)
885  {
886  tmp = MemoryManager<MultiRegions::DisContField>::
887  AllocateSharedPtr(m_session, m_graph, var, true,
888  true,
889  Collections::eNoCollection);
890  }
891  else // call copy constructor
892  {
893  MultiRegions::DisContFieldSharedPtr tmp2 =
894  std::dynamic_pointer_cast<
895  MultiRegions::DisContField>(m_exp[0]);
896 
897  tmp = MemoryManager<MultiRegions::DisContField>::
898  AllocateSharedPtr(*tmp2, m_graph, var);
899  }
900  }
901  else
902  {
903  MultiRegions::ExpListSharedPtr tmp2 =
904  std::dynamic_pointer_cast<MultiRegions::ExpList>(
905  m_exp[0]);
906 
907  tmp = MemoryManager<
908  MultiRegions::ExpList>::AllocateSharedPtr(*tmp2);
909  }
910  }
911  }
912  break;
913  case 3:
914  {
915  if (m_declareExpansionAsContField)
916  {
917  if (NewField)
918  {
919  tmp = MemoryManager<MultiRegions::ContField>::
920  AllocateSharedPtr(m_session, m_graph, var, true,
921  false,
922  Collections::eNoCollection);
923  }
924  else
925  {
926  MultiRegions::ContFieldSharedPtr tmp2 =
927  std::dynamic_pointer_cast<MultiRegions::ContField>(
928  m_exp[0]);
929 
930  tmp = MemoryManager<
931  MultiRegions::ContField>::AllocateSharedPtr(*tmp2,
932  m_graph,
933  var);
934  }
935  }
936  else if (m_declareExpansionAsDisContField)
937  {
938  if (NewField)
939  {
940  tmp = MemoryManager<MultiRegions::DisContField>::
941  AllocateSharedPtr(m_session, m_graph, var, true,
942  true, Collections::eNoCollection);
943  }
944  else
945  {
946  MultiRegions::DisContFieldSharedPtr tmp2 =
947  std::dynamic_pointer_cast<
948  MultiRegions::DisContField>(m_exp[0]);
949 
950  tmp = MemoryManager<MultiRegions::DisContField>::
951  AllocateSharedPtr(*tmp2, m_graph, var);
952  }
953  }
954  else
955  {
956  MultiRegions::ExpListSharedPtr tmp2 =
957  std::dynamic_pointer_cast<MultiRegions::ExpList>(
958  m_exp[0]);
959 
960  tmp =
961  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
962  *tmp2);
963  }
964  }
965  break;
966  default:
967  ASSERTL0(false, "Expansion dimension not recognised");
968  break;
969  }
970 
971  return tmp;
972  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr
std::shared_ptr< DisContField3DHomogeneous2D > DisContField3DHomogeneous2DSharedPtr
Definition: DisContField3DHomogeneous2D.h:138
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
std::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:219
Nektar::MultiRegions::DisContFieldSharedPtr
std::shared_ptr< DisContField > DisContFieldSharedPtr
Definition: DisContField.h:341
Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr
std::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
Definition: ContField3DHomogeneous2D.h:98
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
std::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:105
Nektar::MultiRegions::ExpListSharedPtr
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:55
Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr
std::shared_ptr< ExpList2DHomogeneous1D > ExpList2DHomogeneous1DSharedPtr
Shared pointer to an ExpList2DHomogeneous1D object.
Definition: ExpList2DHomogeneous1D.h:49
Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr
std::shared_ptr< ExpList3DHomogeneous2D > ExpList3DHomogeneous2DSharedPtr
Shared pointer to an ExpList3DHomogeneous2D object.
Definition: ExpList3DHomogeneous2D.h:49
Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr
std::shared_ptr< ExpList3DHomogeneous1D > ExpList3DHomogeneous1DSharedPtr
Shared pointer to an ExpList3DHomogeneous1D object.
Definition: ExpList3DHomogeneous1D.h:51
Nektar::MultiRegions::ContFieldSharedPtr
std::shared_ptr< ContField > ContFieldSharedPtr
Definition: ContField.h:289
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:102
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:101
Nektar::FieldUtils::Field::m_exp
std::vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:82

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::Collections::eNoCollection, m_declareExpansionAsContField, m_declareExpansionAsDisContField, m_exp, m_graph, m_requireBoundaryExpansion, m_session, and m_useFFT.

Referenced by CreateExp().

◆ ClearField()

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

Definition at line 974 of file Field.hpp.

975  {
976  m_session = LibUtilities::SessionReaderSharedPtr();
977  m_graph = SpatialDomains::MeshGraphSharedPtr();
978  m_fieldPts = LibUtilities::NullPtsField;
979  m_exp.clear();
980  m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
981  m_data = std::vector<std::vector<NekDouble>>();
982  m_variables.clear();
983  }
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:115
Nektar::SpatialDomains::MeshGraphSharedPtr
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:172
Nektar::FieldUtils::Field::m_variables
std::vector< std::string > m_variables
Definition: Field.hpp:84
Nektar::FieldUtils::Field::m_fielddef
std::vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
Definition: Field.hpp:80
Nektar::FieldUtils::Field::m_data
std::vector< std::vector< double > > m_data
Definition: Field.hpp:81

References m_data, m_exp, m_fielddef, m_fieldPts, m_graph, m_session, m_variables, and Nektar::LibUtilities::NullPtsField.

Referenced by export_Field().

◆ CreateExp()

FIELD_UTILS_EXPORT void Nektar::FieldUtils::Field::CreateExp ( boost::program_options::variables_map &  vm,
bool  newExp 
)
inline

Definition at line 125 of file Field.hpp.

127  {
128 
129  bool fldfilegiven = (m_fielddef.size() != 0);
130  if (newExp)
131  {
132  LibUtilities::Timer timerpart;
133  if (m_verbose)
134  {
135  if (m_comm->TreatAsRankZero())
136  {
137  timerpart.Start();
138  }
139  }
140  // check to see if fld file defined so can use in
141  // expansion defintion if required
142 
143  bool expFromFld = fldfilegiven && !vm.count("useSessionExpansion");
144 
145  // load fielddef header if fld file is defined. This gives
146  // precedence to Homogeneous definition in fld file
147  m_numHomogeneousDir = 0;
148  if (expFromFld)
149  {
150  m_numHomogeneousDir = m_fielddef[0]->m_numHomogeneousDir;
151 
152  // Set up Expansion information to use mode order from field
153  m_graph->SetExpansionInfo(m_fielddef);
154  }
155  else
156  {
157  if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
158  {
159  std::string HomoStr =
160  m_session->GetSolverInfo("HOMOGENEOUS");
161 
162  if ((HomoStr == "HOMOGENEOUS1D") ||
163  (HomoStr == "Homogeneous1D") || (HomoStr == "1D") ||
164  (HomoStr == "Homo1D"))
165  {
166  m_numHomogeneousDir = 1;
167  }
168  if ((HomoStr == "HOMOGENEOUS2D") ||
169  (HomoStr == "Homogeneous2D") || (HomoStr == "2D") ||
170  (HomoStr == "Homo2D"))
171  {
172  m_numHomogeneousDir = 2;
173  }
174  }
175  }
176 
177  m_exp.resize(1);
178  // Check if there are any elements to process
179  std::vector<int> IDs;
180  auto domain = m_graph->GetDomain();
181  for (size_t d = 0; d < domain.size(); ++d)
182  {
183  for (auto &compIter : domain[d])
184  {
185  for (auto &x : compIter.second->m_geomVec)
186  {
187  IDs.push_back(x->GetGlobalID());
188  }
189  }
190  }
191  // if Range has been specified it is possible to have a
192  // partition which is empty so check this and return with empty
193  // expansion if no elements present.
194  if (!IDs.size())
195  {
196  m_exp[0] =
197  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr();
198 
199  return;
200  }
201 
202  // Adjust number of quadrature points
203  if (vm.count("output-points"))
204  {
205  int nPointsNew = vm["output-points"].as<int>();
206  m_graph->SetExpansionInfoToPointOrder(nPointsNew);
207  }
208 
209  if (m_verbose)
210  {
211  if (m_comm->TreatAsRankZero())
212  {
213  timerpart.Stop();
214  NekDouble cpuTime = timerpart.TimePerTest(1);
215 
216  std::stringstream ss;
217  ss << cpuTime << "s";
218  std::cout << "\t CreateExp setexpansion CPU Time: "
219  << std::setw(8) << std::left << ss.str()
220  << std::endl;
221  timerpart.Start();
222  }
223  }
224  // Override number of planes with value from cmd line
225  if (m_numHomogeneousDir == 1 && vm.count("output-points-hom-z"))
226  {
227  int expdim = m_graph->GetMeshDimension();
228  m_fielddef[0]->m_numModes[expdim] =
229  vm["output-points-hom-z"].as<int>();
230  }
231  m_exp[0] = SetUpFirstExpList(m_numHomogeneousDir, expFromFld);
232  if (m_verbose)
233  {
234  if (m_comm->TreatAsRankZero())
235  {
236  timerpart.Stop();
237  NekDouble cpuTime = timerpart.TimePerTest(1);
238 
239  std::stringstream ss1;
240 
241  ss1 << cpuTime << "s";
242  std::cout << "\t CreateExp set first exp CPU Time: "
243  << std::setw(8) << std::left << ss1.str()
244  << std::endl;
245  }
246  }
247  }
248 
249  if (fldfilegiven)
250  {
251  size_t i, j, nfields, nstrips;
252  m_session->LoadParameter("Strip_Z", nstrips, 1);
253  std::vector<std::string> vars = m_session->GetVariables();
254 
255  if (vm.count("useSessionVariables"))
256  {
257  m_variables = vars;
258  }
259  nfields = m_variables.size();
260 
261  m_exp.resize(nfields * nstrips);
262  // declare other fields;
263  for (size_t s = 0; s < nstrips; ++s) // homogeneous strip varient
264  {
265  for (i = 0; i < nfields; ++i)
266  {
267  if (i < vars.size())
268  {
269  // check to see if field already defined
270  if (!m_exp[s * nfields + i])
271  {
272  m_exp[s * nfields + i] =
273  AppendExpList(m_numHomogeneousDir, vars[i]);
274  }
275  }
276  else
277  {
278  if (vars.size())
279  {
280  m_exp[s * nfields + i] =
281  AppendExpList(m_numHomogeneousDir, vars[0]);
282  }
283  else
284  {
285  m_exp[s * nfields + i] =
286  AppendExpList(m_numHomogeneousDir);
287  }
288  }
289  }
290  }
291 
292  // Extract data to coeffs and bwd transform
293  for (size_t s = 0; s < nstrips; ++s) // homogeneous strip varient
294  {
295  for (j = 0; j < nfields; ++j)
296  {
297  for (i = 0; i < m_data.size() / nstrips; ++i)
298  {
299  size_t n = i * nstrips + s;
300  // In case of multiple flds, we might not have a
301  // variable in this m_data[n] -> skip in this case
302  auto it =
303  find(m_fielddef[n]->m_fields.begin(),
304  m_fielddef[n]->m_fields.end(), m_variables[j]);
305  if (it != m_fielddef[n]->m_fields.end())
306  {
307  m_exp[s * nfields + j]->ExtractDataToCoeffs(
308  m_fielddef[n], m_data[n], m_variables[j],
309  m_exp[s * nfields + j]->UpdateCoeffs());
310  }
311  }
312  m_exp[s * nfields + j]->BwdTrans(
313  m_exp[s * nfields + j]->GetCoeffs(),
314  m_exp[s * nfields + j]->UpdatePhys());
315  }
316  }
317  // Clear fielddef and data
318  // (they should not be used after running this module)
319  m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
320  m_data = std::vector<std::vector<NekDouble>>();
321  }
322  }
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:444
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::FieldUtils::Field::SetUpFirstExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList(int NumHomogeneousDir, bool fldfilegiven=false)
Definition: Field.hpp:324
Nektar::FieldUtils::Field::AppendExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList(int NumHomogeneousDir, std::string var="DefaultVar", bool NewField=false)
Definition: Field.hpp:664

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), AppendExpList(), Nektar::StdRegions::find(), m_comm, m_data, m_exp, m_fielddef, m_graph, m_numHomogeneousDir, m_session, m_variables, m_verbose, SetUpFirstExpList(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by SetUpExp().

◆ 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 643 of file Field.hpp.

645  {
646  LibUtilities::CommSharedPtr c = m_comm;
647  std::string fmt = LibUtilities::FieldIO::GetFileType(filename, c);
648 
649  auto it = m_fld.find(fmt);
650 
651  if (it == m_fld.end())
652  {
653  LibUtilities::FieldIOSharedPtr fld =
654  LibUtilities::GetFieldIOFactory().CreateInstance(fmt, c, true);
655  m_fld[fmt] = fld;
656  return fld;
657  }
658  else
659  {
660  return it->second;
661  }
662  }
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::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
Nektar::LibUtilities::FieldIOSharedPtr
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:327
Nektar::LibUtilities::GetFieldIOFactory
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:72
Nektar::LibUtilities::CommSharedPtr
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:54
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:988

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

◆ SetUpExp()

FIELD_UTILS_EXPORT void Nektar::FieldUtils::Field::SetUpExp ( boost::program_options::variables_map &  vm)
inline

Definition at line 113 of file Field.hpp.

114  {
115  if (m_graph && !m_exp.size())
116  {
117  CreateExp(vm, true);
118  }
119  else if (m_graph && m_data.size())
120  {
121  CreateExp(vm, false);
122  }
123  }
Nektar::FieldUtils::Field::CreateExp
FIELD_UTILS_EXPORT void CreateExp(boost::program_options::variables_map &vm, bool newExp)
Definition: Field.hpp:125

References CreateExp(), m_data, m_exp, and m_graph.

◆ SetUpFirstExpList()

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

Definition at line 324 of file Field.hpp.

326  {
327 
328  MultiRegions::ExpListSharedPtr exp;
329 
330  // Set up expansion list
331  int expdim = m_graph->GetMeshDimension();
332  bool dealiasing = false;
333 
334  m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
335 
336  switch (expdim)
337  {
338  case 1:
339  {
340  ASSERTL0(NumHomogeneousDir <= 2,
341  "Quasi-3D approach is only set up for 1 or 2 "
342  "homogeneous directions");
343 
344  if (NumHomogeneousDir == 1)
345  {
346  MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
347 
348  // Define Homogeneous expansion
349  int nplanes;
350  NekDouble ly;
351  LibUtilities::BasisType btype;
352 
353  if (fldfilegiven)
354  {
355  nplanes = m_fielddef[0]->m_numModes[1];
356  ly = m_fielddef[0]->m_homogeneousLengths[0];
357  btype = m_fielddef[0]->m_basis[1];
358  }
359  else
360  {
361  m_session->LoadParameter("HomModesZ", nplanes);
362  m_session->LoadParameter("LY", ly);
363  btype = LibUtilities::eFourier;
364  }
365 
366  // Choose points to be at evenly spaced points at
367  // nplanes points
368  const LibUtilities::PointsKey Pkey(
369  nplanes, LibUtilities::eFourierEvenlySpaced);
370 
371  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
372 
373  if (m_declareExpansionAsContField ||
374  m_declareExpansionAsDisContField)
375  {
376  ASSERTL0(false, "ContFieldHomogeneous1D or "
377  "DisContFieldHomogenenous1D has "
378  "not been implemented");
379  }
380 
381  Exp2DH1 =
382  MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
383  AllocateSharedPtr(m_session, Bkey, ly, m_useFFT,
384  dealiasing, m_graph,
385  Collections::eNoCollection);
386  exp = Exp2DH1;
387  }
388  else if (NumHomogeneousDir == 2)
389  {
390  MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
391 
392  int nylines, nzlines;
393  NekDouble ly, lz;
394  LibUtilities::BasisType btype1, btype2;
395 
396  if (fldfilegiven)
397  {
398  nylines = m_fielddef[0]->m_numModes[1];
399  nzlines = m_fielddef[0]->m_numModes[2];
400  ly = m_fielddef[0]->m_homogeneousLengths[0];
401  lz = m_fielddef[0]->m_homogeneousLengths[1];
402  btype1 = m_fielddef[0]->m_basis[1];
403  btype2 = m_fielddef[0]->m_basis[2];
404  }
405  else
406  {
407  m_session->LoadParameter("HomModesY", nylines);
408  m_session->LoadParameter("HomModesZ", nzlines);
409  m_session->LoadParameter("LY", ly);
410  m_session->LoadParameter("LZ", lz);
411  btype1 = LibUtilities::eFourier;
412  btype2 = LibUtilities::eFourier;
413  }
414 
415  // Choose points to be at evenly spaced points at
416  // nplanes points
417  const LibUtilities::PointsKey PkeyY(
418  nylines, LibUtilities::eFourierEvenlySpaced);
419  const LibUtilities::BasisKey BkeyY(btype1, nylines, PkeyY);
420 
421  const LibUtilities::PointsKey PkeyZ(
422  nzlines, LibUtilities::eFourierEvenlySpaced);
423  const LibUtilities::BasisKey BkeyZ(btype2, nzlines, PkeyZ);
424 
425  if (m_declareExpansionAsContField)
426  {
427  Exp3DH2 = MemoryManager<
428  MultiRegions::ContField3DHomogeneous2D>::
429  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
430  m_useFFT, dealiasing, m_graph,
431  m_session->GetVariable(0),
432  Collections::eNoCollection);
433  }
434  else if (m_declareExpansionAsDisContField)
435  {
436  Exp3DH2 = MemoryManager<
437  MultiRegions::DisContField3DHomogeneous2D>::
438  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
439  m_useFFT, dealiasing, m_graph,
440  m_session->GetVariable(0),
441  Collections::eNoCollection);
442  }
443  else
444  {
445  Exp3DH2 = MemoryManager<
446  MultiRegions::ExpList3DHomogeneous2D>::
447  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
448  m_useFFT, dealiasing, m_graph,
449  Collections::eNoCollection);
450  }
451 
452  exp = Exp3DH2;
453  }
454  else
455  {
456  MultiRegions::ExpListSharedPtr Exp1D;
457 
458  if (m_declareExpansionAsContField)
459  {
460  Exp1D = MemoryManager<MultiRegions::ContField>::
461  AllocateSharedPtr(
462  m_session, m_graph, m_session->GetVariable(0),
463  true, false, Collections::eNoCollection);
464  }
465  else if (m_declareExpansionAsDisContField)
466  {
467  Exp1D = MemoryManager<MultiRegions::DisContField>::
468  AllocateSharedPtr(m_session, m_graph,
469  m_session->GetVariable(0), true,
470  Collections::eNoCollection);
471  }
472  else
473  {
474  Exp1D = MemoryManager<MultiRegions::ExpList>::
475  AllocateSharedPtr(m_session, m_graph, true,
476  "DefaultVar",
477  Collections::eNoCollection);
478  }
479 
480  exp = Exp1D;
481  }
482  }
483  break;
484  case 2:
485  {
486  ASSERTL0(NumHomogeneousDir <= 1,
487  "NumHomogeneousDir is only set up for 1");
488 
489  if (NumHomogeneousDir == 1)
490  {
491  MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
492 
493  // Define Homogeneous expansion
494  int nplanes;
495  NekDouble lz;
496  LibUtilities::BasisType btype;
497  LibUtilities::PointsType ptype =
498  LibUtilities::eFourierEvenlySpaced;
499 
500  if (fldfilegiven)
501  {
502  nplanes = m_fielddef[0]->m_numModes[2];
503  lz = m_fielddef[0]->m_homogeneousLengths[0];
504  btype = m_fielddef[0]->m_basis[2];
505 
506  if (btype == LibUtilities::eFourierSingleMode)
507  {
508  btype = LibUtilities::eFourier;
509  m_fielddef[0]->m_basis[2] =
510  LibUtilities::eFourierSingleMode;
511  if (nplanes <= 2)
512  {
513  nplanes = 4;
514  }
515  }
516  else if (btype == LibUtilities::eFourierHalfModeRe &&
517  nplanes == 1)
518  {
519  ptype = LibUtilities::ePolyEvenlySpaced;
520  }
521  }
522  else
523  {
524  m_session->LoadParameter("HomModesZ", nplanes);
525  m_session->LoadParameter("LZ", lz);
526  btype = LibUtilities::eFourier;
527  }
528  // Choose points to be at evenly spaced points at
529  // nplanes points
530  const LibUtilities::PointsKey Pkey(nplanes, ptype);
531 
532  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
533 
534  if (m_declareExpansionAsContField)
535  {
536  Exp3DH1 = MemoryManager<
537  MultiRegions::ContField3DHomogeneous1D>::
538  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
539  dealiasing, m_graph,
540  m_session->GetVariable(0),
541  Collections::eNoCollection);
542  }
543 
544  else if (m_declareExpansionAsDisContField)
545  {
546  Exp3DH1 = MemoryManager<
547  MultiRegions::DisContField3DHomogeneous1D>::
548  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
549  dealiasing, m_graph,
550  m_session->GetVariable(0),
551  Collections::eNoCollection);
552  }
553 
554  else
555  {
556  Exp3DH1 = MemoryManager<
557  MultiRegions::ExpList3DHomogeneous1D>::
558  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
559  dealiasing, m_graph, "DefaultVar",
560  Collections::eNoCollection);
561  }
562  exp = Exp3DH1;
563  }
564  else
565  {
566  MultiRegions::ExpListSharedPtr Exp2D;
567 
568  if (m_declareExpansionAsContField)
569  {
570  Exp2D = MemoryManager<MultiRegions::ContField>::
571  AllocateSharedPtr(
572  m_session, m_graph, m_session->GetVariable(0),
573  true, false, Collections::eNoCollection);
574  }
575 
576  else if (m_declareExpansionAsDisContField)
577  {
578  Exp2D = MemoryManager<MultiRegions::DisContField>::
579  AllocateSharedPtr(m_session, m_graph,
580  m_session->GetVariable(0), true,
581  true, Collections::eNoCollection);
582  }
583  else
584  {
585  Exp2D = MemoryManager<MultiRegions::ExpList>::
586  AllocateSharedPtr(m_session, m_graph, true,
587  "DefaultVar",
588  Collections::eNoCollection);
589  }
590 
591  exp = Exp2D;
592  }
593  }
594  break;
595  case 3:
596  {
597  MultiRegions::ExpListSharedPtr Exp3D;
598 
599  if (m_declareExpansionAsContField)
600  {
601  Exp3D = MemoryManager<MultiRegions::ContField>::
602  AllocateSharedPtr(m_session, m_graph,
603  m_session->GetVariable(0), true,
604  false, Collections::eNoCollection);
605  }
606  else if (m_declareExpansionAsDisContField)
607  {
608  Exp3D = MemoryManager<MultiRegions::DisContField>::
609  AllocateSharedPtr(m_session, m_graph,
610  m_session->GetVariable(0), true,
611  Collections::eNoCollection);
612  }
613  else
614  {
615  Exp3D =
616  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
617  m_session, m_graph, true, "DefaultVar",
618  Collections::eNoCollection);
619  }
620 
621  exp = Exp3D;
622  }
623  break;
624  default:
625  ASSERTL0(false, "Expansion dimension not recognised");
626  break;
627  }
628 
629  return exp;
630  };
Nektar::LibUtilities::eFourierEvenlySpaced
@ eFourierEvenlySpaced
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:76
Nektar::LibUtilities::ePolyEvenlySpaced
@ ePolyEvenlySpaced
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:75
Nektar::LibUtilities::eFourierSingleMode
@ eFourierSingleMode
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:66
Nektar::LibUtilities::eFourierHalfModeRe
@ eFourierHalfModeRe
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:68
Nektar::LibUtilities::eFourier
@ eFourier
Fourier Expansion .
Definition: BasisType.h:57

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::Collections::eNoCollection, Nektar::LibUtilities::ePolyEvenlySpaced, m_declareExpansionAsContField, m_declareExpansionAsDisContField, m_fielddef, m_graph, m_session, and m_useFFT.

Referenced by CreateExp().

Member Data Documentation

◆ m_addNormals

bool Nektar::FieldUtils::Field::m_addNormals

Definition at line 107 of file Field.hpp.

◆ m_bndRegionsToWrite

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

Definition at line 106 of file Field.hpp.

◆ m_comm

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

Definition at line 95 of file Field.hpp.

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

◆ m_data

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

Definition at line 81 of file Field.hpp.

Referenced by ClearField(), CreateExp(), and SetUpExp().

◆ m_declareExpansionAsContField

bool Nektar::FieldUtils::Field::m_declareExpansionAsContField

Definition at line 88 of file Field.hpp.

Referenced by AppendExpList(), and SetUpFirstExpList().

◆ m_declareExpansionAsDisContField

bool Nektar::FieldUtils::Field::m_declareExpansionAsDisContField

Definition at line 89 of file Field.hpp.

Referenced by AppendExpList(), and SetUpFirstExpList().

◆ m_defComm

LibUtilities::CommSharedPtr Nektar::FieldUtils::Field::m_defComm

Definition at line 96 of file Field.hpp.

◆ m_exp

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

Definition at line 82 of file Field.hpp.

Referenced by AppendExpList(), ClearField(), CreateExp(), and SetUpExp().

◆ m_fielddef

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

Definition at line 80 of file Field.hpp.

Referenced by ClearField(), CreateExp(), and SetUpFirstExpList().

◆ m_fieldMetaDataMap

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

Definition at line 111 of file Field.hpp.

◆ m_fieldPts

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

Definition at line 109 of file Field.hpp.

Referenced by ClearField().

◆ 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 988 of file Field.hpp.

Referenced by FieldIOForFile().

◆ m_graph

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

Definition at line 102 of file Field.hpp.

Referenced by AppendExpList(), ClearField(), CreateExp(), SetUpExp(), and SetUpFirstExpList().

◆ m_inputfiles

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

Definition at line 103 of file Field.hpp.

◆ m_nParts

int Nektar::FieldUtils::Field::m_nParts = 1

Definition at line 98 of file Field.hpp.

◆ m_numHomogeneousDir

int Nektar::FieldUtils::Field::m_numHomogeneousDir

Definition at line 86 of file Field.hpp.

Referenced by CreateExp().

◆ m_partComm

LibUtilities::CommSharedPtr Nektar::FieldUtils::Field::m_partComm

Definition at line 97 of file Field.hpp.

◆ m_requireBoundaryExpansion

bool Nektar::FieldUtils::Field::m_requireBoundaryExpansion

Definition at line 91 of file Field.hpp.

Referenced by AppendExpList().

◆ m_session

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

Definition at line 101 of file Field.hpp.

Referenced by AppendExpList(), ClearField(), CreateExp(), and SetUpFirstExpList().

◆ m_useFFT

bool Nektar::FieldUtils::Field::m_useFFT

Definition at line 93 of file Field.hpp.

Referenced by AppendExpList(), and SetUpFirstExpList().

◆ m_variables

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

Definition at line 84 of file Field.hpp.

Referenced by ClearField(), and CreateExp().

◆ m_verbose

bool Nektar::FieldUtils::Field::m_verbose

Definition at line 79 of file Field.hpp.

Referenced by CreateExp().

◆ m_vm

po::variables_map Nektar::FieldUtils::Field::m_vm

Definition at line 99 of file Field.hpp.

◆ m_writeBndFld

bool Nektar::FieldUtils::Field::m_writeBndFld

Definition at line 105 of file Field.hpp.

Generated on Sat Mar 25 2023 12:35:57 for Nektar++ by doxygen 1.9.1