Nektar++
Field.hpp
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // File: Field.hpp
4 //
5 // For more information, please see: http://www.nektar.info/
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a
14 // copy of this software and associated documentation files (the "Software"),
15 // to deal in the Software without restriction, including without limitation
16 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 // and/or sell copies of the Software, and to permit persons to whom the
18 // Software is furnished to do so, subject to the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be included
21 // in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 // DEALINGS IN THE SOFTWARE.
30 //
31 // Description: Field converter module base classes.
32 //
33 ////////////////////////////////////////////////////////////////////////////////
34 
35 #ifndef FIELDUTILS_FIELD
36 #define FIELDUTILS_FIELD
37 
38 #include <LibUtilities/BasicUtils/NekFactory.hpp>
39 #include <LibUtilities/BasicUtils/PtsField.h>
40 #include <LibUtilities/BasicUtils/PtsIO.h>
41 #include <LibUtilities/BasicUtils/SessionReader.h>
42 #include <LibUtilities/BasicUtils/SharedArray.hpp>
43 #include <SpatialDomains/MeshGraph.h>
44 #include <boost/program_options.hpp>
45 #include <iomanip>
46 #include <memory>
47 
48 #include <MultiRegions/ContField.h>
49 #include <MultiRegions/ContField3DHomogeneous1D.h>
50 #include <MultiRegions/ContField3DHomogeneous2D.h>
51 #include <MultiRegions/ExpList2DHomogeneous1D.h>
52 
53 #include "FieldUtilsDeclspec.h"
54 
55 namespace po = boost::program_options;
56 
57 namespace Nektar
58 {
59 namespace FieldUtils
60 {
61 
62 struct Field
63 {
64  FIELD_UTILS_EXPORT Field()
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  }
71 
72  FIELD_UTILS_EXPORT ~Field()
73  {
74  if (m_comm)
75  {
76  m_comm->Finalise();
77  }
78  }
79  bool m_verbose;
80  std::vector<LibUtilities::FieldDefinitionsSharedPtr> m_fielddef;
81  std::vector<std::vector<double>> m_data;
82  std::vector<MultiRegions::ExpListSharedPtr> m_exp;
83  std::vector<std::string> m_variables;
84 
85  int m_numHomogeneousDir;
86 
87  bool m_declareExpansionAsContField;
88  bool m_declareExpansionAsDisContField;
89 
90  bool m_requireBoundaryExpansion;
91 
92  bool m_useFFT;
93 
94  LibUtilities::CommSharedPtr m_comm;
95  LibUtilities::CommSharedPtr m_defComm;
96  LibUtilities::CommSharedPtr m_partComm;
97  int m_nParts = 1;
98  po::variables_map m_vm;
99 
100  LibUtilities::SessionReaderSharedPtr m_session;
101  SpatialDomains::MeshGraphSharedPtr m_graph;
102  std::map<std::string, std::vector<std::string>> m_inputfiles;
103 
104  bool m_writeBndFld;
105  std::vector<unsigned int> m_bndRegionsToWrite;
106  bool m_addNormals;
107 
108  LibUtilities::PtsFieldSharedPtr m_fieldPts;
109 
110  LibUtilities::FieldMetaDataMap m_fieldMetaDataMap;
111 
112  FIELD_UTILS_EXPORT void SetUpExp(boost::program_options::variables_map &vm)
113  {
114  if (m_graph && !m_exp.size())
115  {
116  CreateExp(vm, true);
117  }
118  else if (m_graph && m_data.size())
119  {
120  CreateExp(vm, false);
121  }
122  }
123 
124  FIELD_UTILS_EXPORT void CreateExp(boost::program_options::variables_map &vm,
125  bool newExp)
126  {
127 
128  bool fldfilegiven = (m_fielddef.size() != 0);
129  if (newExp)
130  {
131  LibUtilities::Timer timerpart;
132  if (m_verbose)
133  {
134  if (m_comm->TreatAsRankZero())
135  {
136  timerpart.Start();
137  }
138  }
139  // check to see if fld file defined so can use in
140  // expansion defintion if required
141 
142  bool expFromFld = fldfilegiven && !vm.count("useSessionExpansion");
143 
144  // load fielddef header if fld file is defined. This gives
145  // precedence to Homogeneous definition in fld file
146  m_numHomogeneousDir = 0;
147  if (expFromFld)
148  {
149  m_numHomogeneousDir = m_fielddef[0]->m_numHomogeneousDir;
150 
151  // Set up Expansion information to use mode order from field
152  m_graph->SetExpansionInfo(m_fielddef);
153  }
154  else
155  {
156  if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
157  {
158  std::string HomoStr =
159  m_session->GetSolverInfo("HOMOGENEOUS");
160 
161  if ((HomoStr == "HOMOGENEOUS1D") ||
162  (HomoStr == "Homogeneous1D") || (HomoStr == "1D") ||
163  (HomoStr == "Homo1D"))
164  {
165  m_numHomogeneousDir = 1;
166  }
167  if ((HomoStr == "HOMOGENEOUS2D") ||
168  (HomoStr == "Homogeneous2D") || (HomoStr == "2D") ||
169  (HomoStr == "Homo2D"))
170  {
171  m_numHomogeneousDir = 2;
172  }
173  }
174  }
175 
176  m_exp.resize(1);
177  // Check if there are any elements to process
178  std::vector<int> IDs;
179  auto domain = m_graph->GetDomain();
180  for (int d = 0; d < domain.size(); ++d)
181  {
182  for (auto &compIter : domain[d])
183  {
184  for (auto &x : compIter.second->m_geomVec)
185  {
186  IDs.push_back(x->GetGlobalID());
187  }
188  }
189  }
190  // if Range has been specified it is possible to have a
191  // partition which is empty so check this and return with empty
192  // expansion if no elements present.
193  if (!IDs.size())
194  {
195  m_exp[0] =
196  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr();
197  return;
198  }
199 
200  // Adjust number of quadrature points
201  if (vm.count("output-points"))
202  {
203  int nPointsNew = vm["output-points"].as<int>();
204  m_graph->SetExpansionInfoToPointOrder(nPointsNew);
205  }
206 
207  if (m_verbose)
208  {
209  if (m_comm->TreatAsRankZero())
210  {
211  timerpart.Stop();
212  NekDouble cpuTime = timerpart.TimePerTest(1);
213 
214  std::stringstream ss;
215  ss << cpuTime << "s";
216  std::cout << "\t CreateExp setexpansion CPU Time: "
217  << std::setw(8) << std::left << ss.str()
218  << std::endl;
219  timerpart.Start();
220  }
221  }
222  // Override number of planes with value from cmd line
223  if (m_numHomogeneousDir == 1 && vm.count("output-points-hom-z"))
224  {
225  int expdim = m_graph->GetMeshDimension();
226  m_fielddef[0]->m_numModes[expdim] =
227  vm["output-points-hom-z"].as<int>();
228  }
229  m_exp[0] = SetUpFirstExpList(m_numHomogeneousDir, expFromFld);
230  if (m_verbose)
231  {
232  if (m_comm->TreatAsRankZero())
233  {
234  timerpart.Stop();
235  NekDouble cpuTime = timerpart.TimePerTest(1);
236 
237  std::stringstream ss1;
238 
239  ss1 << cpuTime << "s";
240  std::cout << "\t CreateExp set first exp CPU Time: "
241  << std::setw(8) << std::left << ss1.str()
242  << std::endl;
243  }
244  }
245  }
246 
247  if (fldfilegiven)
248  {
249  int i, j, nfields, nstrips;
250  m_session->LoadParameter("Strip_Z", nstrips, 1);
251  std::vector<std::string> vars = m_session->GetVariables();
252 
253  if (vm.count("useSessionVariables"))
254  {
255  m_variables = vars;
256  }
257  nfields = m_variables.size();
258 
259  m_exp.resize(nfields * nstrips);
260  // declare other fields;
261  for (int s = 0; s < nstrips; ++s) // homogeneous strip varient
262  {
263  for (i = 0; i < nfields; ++i)
264  {
265  if (i < vars.size())
266  {
267  // check to see if field already defined
268  if (!m_exp[s * nfields + i])
269  {
270  m_exp[s * nfields + i] =
271  AppendExpList(m_numHomogeneousDir, vars[i]);
272  }
273  }
274  else
275  {
276  if (vars.size())
277  {
278  m_exp[s * nfields + i] =
279  AppendExpList(m_numHomogeneousDir, vars[0]);
280  }
281  else
282  {
283  m_exp[s * nfields + i] =
284  AppendExpList(m_numHomogeneousDir);
285  }
286  }
287  }
288  }
289 
290  // Extract data to coeffs and bwd transform
291  for (int s = 0; s < nstrips; ++s) // homogeneous strip varient
292  {
293  for (j = 0; j < nfields; ++j)
294  {
295  for (i = 0; i < m_data.size() / nstrips; ++i)
296  {
297  int n = i * nstrips + s;
298  // In case of multiple flds, we might not have a
299  // variable in this m_data[n] -> skip in this case
300  auto it =
301  find(m_fielddef[n]->m_fields.begin(),
302  m_fielddef[n]->m_fields.end(), m_variables[j]);
303  if (it != m_fielddef[n]->m_fields.end())
304  {
305  m_exp[s * nfields + j]->ExtractDataToCoeffs(
306  m_fielddef[n], m_data[n], m_variables[j],
307  m_exp[s * nfields + j]->UpdateCoeffs());
308  }
309  }
310  m_exp[s * nfields + j]->BwdTrans(
311  m_exp[s * nfields + j]->GetCoeffs(),
312  m_exp[s * nfields + j]->UpdatePhys());
313  }
314  }
315  // Clear fielddef and data
316  // (they should not be used after running this module)
317  m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
318  m_data = std::vector<std::vector<NekDouble>>();
319  }
320  }
321 
322  FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList(
323  int NumHomogeneousDir, bool fldfilegiven = false)
324  {
325 
326  MultiRegions::ExpListSharedPtr exp;
327 
328  // Set up expansion list
329  int expdim = m_graph->GetMeshDimension();
330  bool dealiasing = false;
331 
332  m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
333 
334  switch (expdim)
335  {
336  case 1:
337  {
338  ASSERTL0(NumHomogeneousDir <= 2,
339  "Quasi-3D approach is only set up for 1 or 2 "
340  "homogeneous directions");
341 
342  if (NumHomogeneousDir == 1)
343  {
344  MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
345 
346  // Define Homogeneous expansion
347  int nplanes;
348  NekDouble ly;
349  LibUtilities::BasisType btype;
350 
351  if (fldfilegiven)
352  {
353  nplanes = m_fielddef[0]->m_numModes[1];
354  ly = m_fielddef[0]->m_homogeneousLengths[0];
355  btype = m_fielddef[0]->m_basis[1];
356  }
357  else
358  {
359  m_session->LoadParameter("HomModesZ", nplanes);
360  m_session->LoadParameter("LY", ly);
361  btype = LibUtilities::eFourier;
362  }
363 
364  // Choose points to be at evenly spaced points at
365  // nplanes points
366  const LibUtilities::PointsKey Pkey(
367  nplanes, LibUtilities::eFourierEvenlySpaced);
368 
369  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
370 
371  if (m_declareExpansionAsContField ||
372  m_declareExpansionAsDisContField)
373  {
374  ASSERTL0(false, "ContFieldHomogeneous1D or "
375  "DisContFieldHomogenenous1D has "
376  "not been implemented");
377  }
378 
379  Exp2DH1 =
380  MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
381  AllocateSharedPtr(m_session, Bkey, ly, m_useFFT,
382  dealiasing, m_graph,
383  Collections::eNoCollection);
384  exp = Exp2DH1;
385  }
386  else if (NumHomogeneousDir == 2)
387  {
388  MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
389 
390  int nylines, nzlines;
391  NekDouble ly, lz;
392  LibUtilities::BasisType btype1, btype2;
393 
394  if (fldfilegiven)
395  {
396  nylines = m_fielddef[0]->m_numModes[1];
397  nzlines = m_fielddef[0]->m_numModes[2];
398  ly = m_fielddef[0]->m_homogeneousLengths[0];
399  lz = m_fielddef[0]->m_homogeneousLengths[1];
400  btype1 = m_fielddef[0]->m_basis[1];
401  btype2 = m_fielddef[0]->m_basis[2];
402  }
403  else
404  {
405  m_session->LoadParameter("HomModesY", nylines);
406  m_session->LoadParameter("HomModesZ", nzlines);
407  m_session->LoadParameter("LY", ly);
408  m_session->LoadParameter("LZ", lz);
409  btype1 = LibUtilities::eFourier;
410  btype2 = LibUtilities::eFourier;
411  }
412 
413  // Choose points to be at evenly spaced points at
414  // nplanes points
415  const LibUtilities::PointsKey PkeyY(
416  nylines, LibUtilities::eFourierEvenlySpaced);
417  const LibUtilities::BasisKey BkeyY(btype1, nylines, PkeyY);
418 
419  const LibUtilities::PointsKey PkeyZ(
420  nzlines, LibUtilities::eFourierEvenlySpaced);
421  const LibUtilities::BasisKey BkeyZ(btype2, nzlines, PkeyZ);
422 
423  if (m_declareExpansionAsContField)
424  {
425  Exp3DH2 = MemoryManager<
426  MultiRegions::ContField3DHomogeneous2D>::
427  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
428  m_useFFT, dealiasing, m_graph,
429  m_session->GetVariable(0),
430  Collections::eNoCollection);
431  }
432  else if (m_declareExpansionAsDisContField)
433  {
434  Exp3DH2 = MemoryManager<
435  MultiRegions::DisContField3DHomogeneous2D>::
436  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
437  m_useFFT, dealiasing, m_graph,
438  m_session->GetVariable(0),
439  Collections::eNoCollection);
440  }
441  else
442  {
443  Exp3DH2 = MemoryManager<
444  MultiRegions::ExpList3DHomogeneous2D>::
445  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
446  m_useFFT, dealiasing, m_graph,
447  Collections::eNoCollection);
448  }
449 
450  exp = Exp3DH2;
451  }
452  else
453  {
454  MultiRegions::ExpListSharedPtr Exp1D;
455 
456  if (m_declareExpansionAsContField)
457  {
458  Exp1D = MemoryManager<MultiRegions::ContField>::
459  AllocateSharedPtr(
460  m_session, m_graph, m_session->GetVariable(0),
461  true, false, Collections::eNoCollection);
462  }
463  else if (m_declareExpansionAsDisContField)
464  {
465  Exp1D = MemoryManager<MultiRegions::DisContField>::
466  AllocateSharedPtr(m_session, m_graph,
467  m_session->GetVariable(0), true,
468  Collections::eNoCollection);
469  }
470  else
471  {
472  Exp1D = MemoryManager<MultiRegions::ExpList>::
473  AllocateSharedPtr(m_session, m_graph, true,
474  "DefaultVar",
475  Collections::eNoCollection);
476  }
477 
478  exp = Exp1D;
479  }
480  }
481  break;
482  case 2:
483  {
484  ASSERTL0(NumHomogeneousDir <= 1,
485  "NumHomogeneousDir is only set up for 1");
486 
487  if (NumHomogeneousDir == 1)
488  {
489  MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
490 
491  // Define Homogeneous expansion
492  int nplanes;
493  NekDouble lz;
494  LibUtilities::BasisType btype;
495  LibUtilities::PointsType ptype =
496  LibUtilities::eFourierEvenlySpaced;
497 
498  if (fldfilegiven)
499  {
500  nplanes = m_fielddef[0]->m_numModes[2];
501  lz = m_fielddef[0]->m_homogeneousLengths[0];
502  btype = m_fielddef[0]->m_basis[2];
503 
504  if (btype == LibUtilities::eFourierSingleMode)
505  {
506  btype = LibUtilities::eFourier;
507  m_fielddef[0]->m_basis[2] =
508  LibUtilities::eFourierSingleMode;
509  if (nplanes <= 2)
510  {
511  nplanes = 4;
512  }
513  }
514  else if (btype == LibUtilities::eFourierHalfModeRe &&
515  nplanes == 1)
516  {
517  ptype = LibUtilities::ePolyEvenlySpaced;
518  }
519  }
520  else
521  {
522  m_session->LoadParameter("HomModesZ", nplanes);
523  m_session->LoadParameter("LZ", lz);
524  btype = LibUtilities::eFourier;
525  }
526  // Choose points to be at evenly spaced points at
527  // nplanes points
528  const LibUtilities::PointsKey Pkey(nplanes, ptype);
529 
530  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
531 
532  if (m_declareExpansionAsContField)
533  {
534  Exp3DH1 = MemoryManager<
535  MultiRegions::ContField3DHomogeneous1D>::
536  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
537  dealiasing, m_graph,
538  m_session->GetVariable(0),
539  Collections::eNoCollection);
540  }
541 
542  else if (m_declareExpansionAsDisContField)
543  {
544  Exp3DH1 = MemoryManager<
545  MultiRegions::DisContField3DHomogeneous1D>::
546  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
547  dealiasing, m_graph,
548  m_session->GetVariable(0),
549  Collections::eNoCollection);
550  }
551 
552  else
553  {
554  Exp3DH1 = MemoryManager<
555  MultiRegions::ExpList3DHomogeneous1D>::
556  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
557  dealiasing, m_graph, "DefaultVar",
558  Collections::eNoCollection);
559  }
560  exp = Exp3DH1;
561  }
562  else
563  {
564  MultiRegions::ExpListSharedPtr Exp2D;
565 
566  if (m_declareExpansionAsContField)
567  {
568  Exp2D = MemoryManager<MultiRegions::ContField>::
569  AllocateSharedPtr(
570  m_session, m_graph, m_session->GetVariable(0),
571  true, false, Collections::eNoCollection);
572  }
573 
574  else if (m_declareExpansionAsDisContField)
575  {
576  Exp2D = MemoryManager<MultiRegions::DisContField>::
577  AllocateSharedPtr(m_session, m_graph,
578  m_session->GetVariable(0), true,
579  true, Collections::eNoCollection);
580  }
581  else
582  {
583  Exp2D = MemoryManager<MultiRegions::ExpList>::
584  AllocateSharedPtr(m_session, m_graph, true,
585  "DefaultVar",
586  Collections::eNoCollection);
587  }
588 
589  exp = Exp2D;
590  }
591  }
592  break;
593  case 3:
594  {
595  MultiRegions::ExpListSharedPtr Exp3D;
596 
597  if (m_declareExpansionAsContField)
598  {
599  Exp3D = MemoryManager<MultiRegions::ContField>::
600  AllocateSharedPtr(m_session, m_graph,
601  m_session->GetVariable(0), true,
602  false, Collections::eNoCollection);
603  }
604  else if (m_declareExpansionAsDisContField)
605  {
606  Exp3D = MemoryManager<MultiRegions::DisContField>::
607  AllocateSharedPtr(m_session, m_graph,
608  m_session->GetVariable(0), true,
609  Collections::eNoCollection);
610  }
611  else
612  {
613  Exp3D =
614  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
615  m_session, m_graph, true, "DefaultVar",
616  Collections::eNoCollection);
617  }
618 
619  exp = Exp3D;
620  }
621  break;
622  default:
623  ASSERTL0(false, "Expansion dimension not recognised");
624  break;
625  }
626 
627  return exp;
628  };
629 
630  /**
631  * @brief Construct a FieldIO object for the file @p filename.
632  *
633  * This routine constructs an appropriate FieldIO object for a filename
634  * through the LibUtilities::FieldIO::GetFileType function to detect the
635  * file format. The result is then cached in Field::m_fld to avoid needing
636  * to repeatedly construct the object.
637  *
638  * @param filename Filename to open.
639  * @return Reader for @p filename.
640  */
641  FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr FieldIOForFile(
642  std::string filename)
643  {
644  LibUtilities::CommSharedPtr c = m_comm;
645  std::string fmt = LibUtilities::FieldIO::GetFileType(filename, c);
646 
647  auto it = m_fld.find(fmt);
648 
649  if (it == m_fld.end())
650  {
651  LibUtilities::FieldIOSharedPtr fld =
652  LibUtilities::GetFieldIOFactory().CreateInstance(fmt, c, true);
653  m_fld[fmt] = fld;
654  return fld;
655  }
656  else
657  {
658  return it->second;
659  }
660  }
661 
662  FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList(
663  int NumHomogeneousDir, std::string var = "DefaultVar",
664  bool NewField = false)
665  {
666  if (var.compare("DefaultVar") == 0 && m_requireBoundaryExpansion)
667  {
668  if (m_session->GetVariables().size())
669  {
670  var = m_session->GetVariables()[0];
671  }
672  }
673  MultiRegions::ExpListSharedPtr tmp;
674  switch (m_graph->GetMeshDimension())
675  {
676  case 1:
677  {
678  if (NumHomogeneousDir == 1)
679  {
680  ASSERTL0(!(m_declareExpansionAsContField ||
681  m_declareExpansionAsDisContField),
682  "ContFieldHomogeneous1D or "
683  "DisContFieldHomogenenous1D has not been "
684  "implemented");
685 
686  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
687  std::dynamic_pointer_cast<
688  MultiRegions::ExpList2DHomogeneous1D>(m_exp[0]);
689 
690  tmp = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
691  AllocateSharedPtr(*tmp2);
692  }
693  else if (NumHomogeneousDir == 2)
694  {
695  if (m_declareExpansionAsContField)
696  {
697  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
698  std::dynamic_pointer_cast<
699  MultiRegions::ContField3DHomogeneous2D>(
700  m_exp[0]);
701 
702  tmp = MemoryManager<
703  MultiRegions::ContField3DHomogeneous2D>::
704  AllocateSharedPtr(*tmp2);
705  }
706  else if (m_declareExpansionAsDisContField)
707  {
708  MultiRegions::DisContField3DHomogeneous2DSharedPtr
709  tmp2 = std::dynamic_pointer_cast<
710  MultiRegions::DisContField3DHomogeneous2D>(
711  m_exp[0]);
712 
713  tmp = MemoryManager<
714  MultiRegions::DisContField3DHomogeneous2D>::
715  AllocateSharedPtr(*tmp2);
716  }
717  else
718  {
719  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
720  std::dynamic_pointer_cast<
721  MultiRegions::ExpList3DHomogeneous2D>(m_exp[0]);
722 
723  tmp = MemoryManager<
724  MultiRegions::ExpList3DHomogeneous2D>::
725  AllocateSharedPtr(*tmp2);
726  }
727  }
728  else
729  {
730  if (m_declareExpansionAsContField)
731  {
732  MultiRegions::ContFieldSharedPtr tmp2 =
733  std::dynamic_pointer_cast<MultiRegions::ContField>(
734  m_exp[0]);
735 
736  tmp = MemoryManager<MultiRegions::ContField>::
737  AllocateSharedPtr(m_session, m_graph, var, true,
738  false,
739  Collections::eNoCollection);
740  }
741  else if (m_declareExpansionAsDisContField)
742  {
743  MultiRegions::DisContFieldSharedPtr tmp2 =
744  std::dynamic_pointer_cast<
745  MultiRegions::DisContField>(m_exp[0]);
746 
747  tmp = MemoryManager<MultiRegions::DisContField>::
748  AllocateSharedPtr(m_session, m_graph, var, true,
749  Collections::eNoCollection);
750  }
751  else
752  {
753  MultiRegions::ExpListSharedPtr tmp2 =
754  std::dynamic_pointer_cast<MultiRegions::ExpList>(
755  m_exp[0]);
756 
757  tmp = MemoryManager<
758  MultiRegions::ExpList>::AllocateSharedPtr(*tmp2);
759  }
760  }
761  }
762  break;
763  case 2:
764  {
765  if (NumHomogeneousDir == 1)
766  {
767  if (m_declareExpansionAsContField)
768  {
769  if (NewField)
770  {
771  bool dealiasing = false;
772 
773  tmp = MemoryManager<
774  MultiRegions::ContField3DHomogeneous1D>::
775  AllocateSharedPtr(m_session,
776  m_exp[0]
777  ->GetHomogeneousBasis()
778  ->GetBasisKey(),
779  m_exp[0]->GetHomoLen(),
780  m_useFFT, dealiasing, m_graph,
781  var,
782  Collections::eNoCollection);
783  }
784  else
785  {
786  MultiRegions::ContField3DHomogeneous1DSharedPtr
787  tmp2 = std::dynamic_pointer_cast<
788  MultiRegions::ContField3DHomogeneous1D>(
789  m_exp[0]);
790 
791  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
792  tmp = MemoryManager<
793  MultiRegions::ContField3DHomogeneous1D>::
794  AllocateSharedPtr(*tmp2, m_graph, var);
795  }
796  }
797  else if (m_declareExpansionAsDisContField)
798  {
799  if (NewField)
800  {
801  bool dealiasing = false;
802 
803  tmp = MemoryManager<
804  MultiRegions::DisContField3DHomogeneous1D>::
805  AllocateSharedPtr(m_session,
806  m_exp[0]
807  ->GetHomogeneousBasis()
808  ->GetBasisKey(),
809  m_exp[0]->GetHomoLen(),
810  m_useFFT, dealiasing, m_graph,
811  var,
812  Collections::eNoCollection);
813  }
814  else
815  {
816  MultiRegions::DisContField3DHomogeneous1DSharedPtr
817  tmp2 = std::dynamic_pointer_cast<
818  MultiRegions::DisContField3DHomogeneous1D>(
819  m_exp[0]);
820  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
821 
822  tmp = MemoryManager<
823  MultiRegions::DisContField3DHomogeneous1D>::
824  AllocateSharedPtr(*tmp2);
825  }
826  }
827  else
828  {
829  if (NewField)
830  {
831  bool dealiasing = false;
832 
833  tmp = MemoryManager<
834  MultiRegions::ExpList3DHomogeneous1D>::
835  AllocateSharedPtr(m_session,
836  m_exp[0]
837  ->GetHomogeneousBasis()
838  ->GetBasisKey(),
839  m_exp[0]->GetHomoLen(),
840  m_useFFT, dealiasing, m_graph,
841  "DefaultVar",
842  Collections::eNoCollection);
843  }
844  else
845  {
846  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
847  std::dynamic_pointer_cast<
848  MultiRegions::ExpList3DHomogeneous1D>(
849  m_exp[0]);
850  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
851 
852  tmp = MemoryManager<
853  MultiRegions::ExpList3DHomogeneous1D>::
854  AllocateSharedPtr(*tmp2);
855  }
856  }
857  }
858  else
859  {
860  if (m_declareExpansionAsContField)
861  {
862  if (NewField)
863  {
864  tmp = MemoryManager<MultiRegions::ContField>::
865  AllocateSharedPtr(m_session, m_graph, var, true,
866  false,
867  Collections::eNoCollection);
868  }
869  else // call copy constructor
870  {
871 
872  MultiRegions::ContFieldSharedPtr tmp2 =
873  std::dynamic_pointer_cast<
874  MultiRegions::ContField>(m_exp[0]);
875 
876  tmp = MemoryManager<MultiRegions::ContField>::
877  AllocateSharedPtr(*tmp2, m_graph, var);
878  }
879  }
880  else if (m_declareExpansionAsDisContField)
881  {
882  if (NewField)
883  {
884  tmp = MemoryManager<MultiRegions::DisContField>::
885  AllocateSharedPtr(m_session, m_graph, var, true,
886  true,
887  Collections::eNoCollection);
888  }
889  else // call copy constructor
890  {
891  MultiRegions::DisContFieldSharedPtr tmp2 =
892  std::dynamic_pointer_cast<
893  MultiRegions::DisContField>(m_exp[0]);
894 
895  tmp = MemoryManager<MultiRegions::DisContField>::
896  AllocateSharedPtr(*tmp2, m_graph, var);
897  }
898  }
899  else
900  {
901  MultiRegions::ExpListSharedPtr tmp2 =
902  std::dynamic_pointer_cast<MultiRegions::ExpList>(
903  m_exp[0]);
904 
905  tmp = MemoryManager<
906  MultiRegions::ExpList>::AllocateSharedPtr(*tmp2);
907  }
908  }
909  }
910  break;
911  case 3:
912  {
913  if (m_declareExpansionAsContField)
914  {
915  if (NewField)
916  {
917  tmp = MemoryManager<MultiRegions::ContField>::
918  AllocateSharedPtr(m_session, m_graph, var, true,
919  false,
920  Collections::eNoCollection);
921  }
922  else
923  {
924  MultiRegions::ContFieldSharedPtr tmp2 =
925  std::dynamic_pointer_cast<MultiRegions::ContField>(
926  m_exp[0]);
927 
928  tmp = MemoryManager<
929  MultiRegions::ContField>::AllocateSharedPtr(*tmp2,
930  m_graph,
931  var);
932  }
933  }
934  else if (m_declareExpansionAsDisContField)
935  {
936  if (NewField)
937  {
938  tmp = MemoryManager<MultiRegions::DisContField>::
939  AllocateSharedPtr(m_session, m_graph, var, true,
940  true, Collections::eNoCollection);
941  }
942  else
943  {
944  MultiRegions::DisContFieldSharedPtr tmp2 =
945  std::dynamic_pointer_cast<
946  MultiRegions::DisContField>(m_exp[0]);
947 
948  tmp = MemoryManager<MultiRegions::DisContField>::
949  AllocateSharedPtr(*tmp2, m_graph, var);
950  }
951  }
952  else
953  {
954  MultiRegions::ExpListSharedPtr tmp2 =
955  std::dynamic_pointer_cast<MultiRegions::ExpList>(
956  m_exp[0]);
957 
958  tmp =
959  MemoryManager<MultiRegions::ExpList>::AllocateSharedPtr(
960  *tmp2);
961  }
962  }
963  break;
964  default:
965  ASSERTL0(false, "Expansion dimension not recognised");
966  break;
967  }
968 
969  return tmp;
970  }
971 
972  FIELD_UTILS_EXPORT void ClearField()
973  {
974  m_session = LibUtilities::SessionReaderSharedPtr();
975  m_graph = SpatialDomains::MeshGraphSharedPtr();
976  m_fieldPts = LibUtilities::NullPtsField;
977  m_exp.clear();
978  m_fielddef = std::vector<LibUtilities::FieldDefinitionsSharedPtr>();
979  m_data = std::vector<std::vector<NekDouble>>();
980  m_variables.clear();
981  }
982 
983 private:
984  /// Map to store FieldIO instances. Key is the reader type, value is the
985  /// FieldIO object.
986  std::map<std::string, LibUtilities::FieldIOSharedPtr> m_fld;
987 };
988 
989 typedef std::shared_ptr<Field> FieldSharedPtr;
990 } // namespace FieldUtils
991 } // namespace Nektar
992 
993 #endif
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
FIELD_UTILS_EXPORT
#define FIELD_UTILS_EXPORT
Definition: FieldUtilsDeclspec.h:42
Nektar::LibUtilities::BasisKey
Describes the specification for a Basis.
Definition: Basis.h:50
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::PointsKey
Defines a specification for a set of points.
Definition: Points.h:59
Nektar::LibUtilities::Timer::TimePerTest
NekDouble TimePerTest(unsigned int n)
Returns amount of seconds per iteration in a test with n iterations.
Definition: Timer.cpp:68
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition: NekMemoryManager.hpp:83
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::ContField
This class is the abstraction of a global continuous two- dimensional spectral/hp element expansion w...
Definition: ContField.h:57
Nektar::MultiRegions::DisContField
This class is the abstractio n of a global discontinuous two- dimensional spectral/hp element expansi...
Definition: DisContField.h:56
Nektar::MultiRegions::ExpList2DHomogeneous1D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList2DHomogeneous1D.h:60
Nektar::MultiRegions::ExpList3DHomogeneous1D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList3DHomogeneous1D.h:62
Nektar::MultiRegions::ExpList3DHomogeneous2D
Abstraction of a one-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList3DHomogeneous2D.h:60
Nektar::MultiRegions::ExpList
Base class for all multi-elemental spectral/hp expansions.
Definition: ExpList.h:101
Nektar::FieldUtils::FieldSharedPtr
std::shared_ptr< Field > FieldSharedPtr
Definition: Field.hpp:989
Nektar::LibUtilities::FieldIOSharedPtr
std::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:301
Nektar::LibUtilities::FieldMetaDataMap
std::map< std::string, std::string > FieldMetaDataMap
Definition: FieldIO.h:52
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:115
Nektar::LibUtilities::PtsFieldSharedPtr
std::shared_ptr< PtsField > PtsFieldSharedPtr
Definition: PtsField.h:190
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:191
Nektar::LibUtilities::GetFieldIOFactory
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:72
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::CommSharedPtr
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:54
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
Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr
std::shared_ptr< DisContField3DHomogeneous2D > DisContField3DHomogeneous2DSharedPtr
Definition: DisContField3DHomogeneous2D.h:162
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
std::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:283
Nektar::MultiRegions::DisContFieldSharedPtr
std::shared_ptr< DisContField > DisContFieldSharedPtr
Definition: DisContField.h:377
Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr
std::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
Definition: ContField3DHomogeneous2D.h:96
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
std::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:101
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:277
Nektar::SpatialDomains::MeshGraphSharedPtr
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:172
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:327
Nektar
The above copyright notice and this permission notice shall be included.
Definition: CoupledSolver.h:1
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::FieldUtils::Field::m_partComm
LibUtilities::CommSharedPtr m_partComm
Definition: Field.hpp:96
Nektar::FieldUtils::Field::SetUpFirstExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList(int NumHomogeneousDir, bool fldfilegiven=false)
Definition: Field.hpp:322
Nektar::FieldUtils::Field::AppendExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList(int NumHomogeneousDir, std::string var="DefaultVar", bool NewField=false)
Definition: Field.hpp:662
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:88
Nektar::FieldUtils::Field::m_vm
po::variables_map m_vm
Definition: Field.hpp:98
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:101
Nektar::FieldUtils::Field::m_variables
std::vector< std::string > m_variables
Definition: Field.hpp:83
Nektar::FieldUtils::Field::m_bndRegionsToWrite
std::vector< unsigned int > m_bndRegionsToWrite
Definition: Field.hpp:105
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:100
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:986
Nektar::FieldUtils::Field::m_inputfiles
std::map< std::string, std::vector< std::string > > m_inputfiles
Definition: Field.hpp:102
Nektar::FieldUtils::Field::Field
FIELD_UTILS_EXPORT Field()
Definition: Field.hpp:64
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:87
Nektar::FieldUtils::Field::ClearField
FIELD_UTILS_EXPORT void ClearField()
Definition: Field.hpp:972
Nektar::FieldUtils::Field::m_fielddef
std::vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
Definition: Field.hpp:80
Nektar::FieldUtils::Field::SetUpExp
FIELD_UTILS_EXPORT void SetUpExp(boost::program_options::variables_map &vm)
Definition: Field.hpp:112
Nektar::FieldUtils::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:108
Nektar::FieldUtils::Field::~Field
FIELD_UTILS_EXPORT ~Field()
Definition: Field.hpp:72
Nektar::FieldUtils::Field::m_data
std::vector< std::vector< double > > m_data
Definition: Field.hpp:81
Nektar::FieldUtils::Field::m_exp
std::vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:82
Nektar::FieldUtils::Field::m_comm
LibUtilities::CommSharedPtr m_comm
Definition: Field.hpp:94
Nektar::FieldUtils::Field::m_defComm
LibUtilities::CommSharedPtr m_defComm
Definition: Field.hpp:95
Nektar::FieldUtils::Field::CreateExp
FIELD_UTILS_EXPORT void CreateExp(boost::program_options::variables_map &vm, bool newExp)
Definition: Field.hpp:124
Nektar::FieldUtils::Field::FieldIOForFile
FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr FieldIOForFile(std::string filename)
Construct a FieldIO object for the file filename.
Definition: Field.hpp:641
Nektar::FieldUtils::Field::m_fieldMetaDataMap
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Definition: Field.hpp:110
Generated on Tue Aug 23 2022 07:27:12 for Nektar++ by doxygen 1.9.1