Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: Field converter module base classes.
33 //
34 ////////////////////////////////////////////////////////////////////////////////
35 
36 #ifndef FIELDUTILS_FIELD
37 #define FIELDUTILS_FIELD
38 
39 #include <boost/shared_ptr.hpp>
40 
41 #include <LibUtilities/BasicUtils/NekFactory.hpp>
42 #include <LibUtilities/BasicUtils/PtsField.h>
43 #include <LibUtilities/BasicUtils/PtsIO.h>
44 #include <LibUtilities/BasicUtils/SessionReader.h>
45 #include <LibUtilities/BasicUtils/SharedArray.hpp>
46 #include <SpatialDomains/MeshGraph.h>
47 
48 #include <MultiRegions/ContField1D.h>
49 #include <MultiRegions/ContField2D.h>
50 #include <MultiRegions/ContField3D.h>
51 #include <MultiRegions/ContField3DHomogeneous1D.h>
52 #include <MultiRegions/ContField3DHomogeneous2D.h>
53 #include <MultiRegions/ExpList.h>
54 #include <MultiRegions/ExpList2DHomogeneous1D.h>
55 
56 #include <MultiRegions/DisContField1D.h>
57 #include <MultiRegions/DisContField2D.h>
58 #include <MultiRegions/DisContField3D.h>
59 #include <MultiRegions/DisContField3DHomogeneous1D.h>
60 #include <MultiRegions/DisContField3DHomogeneous2D.h>
61 
62 #include "FieldUtilsDeclspec.h"
63 
64 using namespace std;
65 
66 namespace Nektar
67 {
68 namespace FieldUtils
69 {
70 
71 struct Field
72 {
73  FIELD_UTILS_EXPORT Field()
74  : m_verbose(false), m_declareExpansionAsContField(false),
75  m_declareExpansionAsDisContField(false),
76  m_requireBoundaryExpansion(false), m_writeBndFld(false),
77  m_fldToBnd(false), m_addNormals(false),
78  m_setUpEquiSpacedFields(false), m_fieldPts(LibUtilities::NullPtsField)
79  {
80  }
81 
82  FIELD_UTILS_EXPORT ~Field()
83  {
84  if (m_comm)
85  {
86  m_comm->Finalise();
87  }
88  }
89  bool m_verbose;
90  vector<LibUtilities::FieldDefinitionsSharedPtr> m_fielddef;
91  vector<vector<double> > m_data;
92  vector<MultiRegions::ExpListSharedPtr> m_exp;
93 
94  bool m_declareExpansionAsContField;
95  bool m_declareExpansionAsDisContField;
96 
97  bool m_requireBoundaryExpansion;
98 
99  bool m_useFFT;
100 
101  LibUtilities::CommSharedPtr m_comm;
102  LibUtilities::SessionReaderSharedPtr m_session;
103  SpatialDomains::MeshGraphSharedPtr m_graph;
104  LibUtilities::PtsIOSharedPtr m_ptsIO;
105  map<string, vector<string> > m_inputfiles;
106 
107  bool m_writeBndFld;
108  vector<unsigned int> m_bndRegionsToWrite;
109  bool m_fldToBnd;
110  bool m_addNormals;
111 
112  bool m_setUpEquiSpacedFields;
113 
114  LibUtilities::PtsFieldSharedPtr m_fieldPts;
115 
116  MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap;
117 
118  LibUtilities::FieldMetaDataMap m_fieldMetaDataMap;
119 
120  FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList(
121  int NumHomogeneousDir, bool fldfilegiven = false)
122  {
123 
124  MultiRegions::ExpListSharedPtr exp;
125 
126  // Set up expansion list
127  int expdim = m_graph->GetMeshDimension();
128  bool dealiasing = false;
129 
130  m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
131 
132  switch (expdim)
133  {
134  case 1:
135  {
136  ASSERTL0(NumHomogeneousDir <= 2,
137  "Quasi-3D approach is only set up for 1 or 2 "
138  "homogeneous directions");
139 
140  if (NumHomogeneousDir == 1)
141  {
142  MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
143 
144  // Define Homogeneous expansion
145  int nplanes;
146  NekDouble ly;
147  LibUtilities::BasisType btype;
148 
149  if (fldfilegiven)
150  {
151  nplanes = m_fielddef[0]->m_numModes[1];
152  ly = m_fielddef[0]->m_homogeneousLengths[0];
153  btype = m_fielddef[0]->m_basis[1];
154  }
155  else
156  {
157  m_session->LoadParameter("HomModesZ", nplanes);
158  m_session->LoadParameter("LY", ly);
159  btype = LibUtilities::eFourier;
160  }
161 
162  // Choose points to be at evenly spaced points at
163  // nplanes points
164  const LibUtilities::PointsKey Pkey(
165  nplanes, LibUtilities::eFourierEvenlySpaced);
166 
167  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
168 
169  if (m_declareExpansionAsContField ||
170  m_declareExpansionAsDisContField)
171  {
172  ASSERTL0(false, "ContField2DHomogeneous1D or "
173  "DisContField2DHomogenenous1D has "
174  "not been implemented");
175  }
176 
177  Exp2DH1 =
178  MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
179  AllocateSharedPtr(m_session, Bkey, ly, m_useFFT,
180  dealiasing, m_graph,
181  Collections::eNoCollection);
182  exp = Exp2DH1;
183  }
184  else if (NumHomogeneousDir == 2)
185  {
186  MultiRegions::ExpList3DHomogeneous2DSharedPtr Exp3DH2;
187 
188  int nylines, nzlines;
189  NekDouble ly, lz;
190  LibUtilities::BasisType btype1, btype2;
191 
192  if (fldfilegiven)
193  {
194  nylines = m_fielddef[0]->m_numModes[1];
195  nzlines = m_fielddef[0]->m_numModes[2];
196  ly = m_fielddef[0]->m_homogeneousLengths[0];
197  lz = m_fielddef[0]->m_homogeneousLengths[1];
198  btype1 = m_fielddef[0]->m_basis[1];
199  btype2 = m_fielddef[0]->m_basis[2];
200  }
201  else
202  {
203  m_session->LoadParameter("HomModesY", nylines);
204  m_session->LoadParameter("HomModesZ", nzlines);
205  m_session->LoadParameter("LY", ly);
206  m_session->LoadParameter("LZ", lz);
207  btype1 = LibUtilities::eFourier;
208  btype2 = LibUtilities::eFourier;
209  }
210 
211  // Choose points to be at evenly spaced points at
212  // nplanes points
213  const LibUtilities::PointsKey PkeyY(
214  nylines, LibUtilities::eFourierEvenlySpaced);
215  const LibUtilities::BasisKey BkeyY(btype1, nylines, PkeyY);
216 
217  const LibUtilities::PointsKey PkeyZ(
218  nzlines, LibUtilities::eFourierEvenlySpaced);
219  const LibUtilities::BasisKey BkeyZ(btype2, nzlines, PkeyZ);
220 
221  if (m_declareExpansionAsContField)
222  {
223  Exp3DH2 = MemoryManager<
224  MultiRegions::ContField3DHomogeneous2D>::
225  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
226  m_useFFT, dealiasing, m_graph,
227  m_session->GetVariable(0),
228  Collections::eNoCollection);
229  }
230  else if (m_declareExpansionAsDisContField)
231  {
232  Exp3DH2 = MemoryManager<
233  MultiRegions::DisContField3DHomogeneous2D>::
234  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
235  m_useFFT, dealiasing, m_graph,
236  m_session->GetVariable(0),
237  Collections::eNoCollection);
238  }
239  else
240  {
241  Exp3DH2 = MemoryManager<
242  MultiRegions::ExpList3DHomogeneous2D>::
243  AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
244  m_useFFT, dealiasing, m_graph,
245  Collections::eNoCollection);
246  }
247 
248  exp = Exp3DH2;
249  }
250  else
251  {
252  MultiRegions::ExpList1DSharedPtr Exp1D;
253 
254  if (m_declareExpansionAsContField)
255  {
256  Exp1D = MemoryManager<MultiRegions::ContField1D>::
257  AllocateSharedPtr(m_session, m_graph,
258  m_session->GetVariable(0),
259  Collections::eNoCollection);
260  }
261  else if (m_declareExpansionAsDisContField)
262  {
263  Exp1D = MemoryManager<MultiRegions::DisContField1D>::
264  AllocateSharedPtr(m_session, m_graph,
265  m_session->GetVariable(0),
266  true,
267  Collections::eNoCollection);
268  }
269  else
270  {
271  Exp1D = MemoryManager<MultiRegions::ExpList1D>::
272  AllocateSharedPtr(m_session, m_graph,
273  true,
274  Collections::eNoCollection);
275  }
276 
277  exp = Exp1D;
278  }
279  }
280  break;
281  case 2:
282  {
283  ASSERTL0(NumHomogeneousDir <= 1,
284  "NumHomogeneousDir is only set up for 1");
285 
286  if (NumHomogeneousDir == 1)
287  {
288  MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
289 
290  // Define Homogeneous expansion
291  int nplanes;
292  NekDouble lz;
293  LibUtilities::BasisType btype;
294  LibUtilities::PointsType ptype =
295  LibUtilities::eFourierEvenlySpaced;
296 
297  if (fldfilegiven)
298  {
299  nplanes = m_fielddef[0]->m_numModes[2];
300  lz = m_fielddef[0]->m_homogeneousLengths[0];
301  btype = m_fielddef[0]->m_basis[2];
302 
303  if (btype == LibUtilities::eFourierSingleMode)
304  {
305  btype = LibUtilities::eFourier;
306  m_fielddef[0]->m_basis[2] =
307  LibUtilities::eFourierSingleMode;
308  if (nplanes <= 2)
309  {
310  nplanes = 4;
311  }
312  }
313  else if (btype == LibUtilities::eFourierHalfModeRe &&
314  nplanes == 1)
315  {
316  ptype = LibUtilities::ePolyEvenlySpaced;
317  }
318  }
319  else
320  {
321  m_session->LoadParameter("HomModesZ", nplanes);
322  m_session->LoadParameter("LZ", lz);
323  btype = LibUtilities::eFourier;
324  }
325 
326  // Choose points to be at evenly spaced points at
327  // nplanes points
328  const LibUtilities::PointsKey Pkey(
329  nplanes, ptype);
330 
331  const LibUtilities::BasisKey Bkey(btype, nplanes, Pkey);
332 
333  if (m_declareExpansionAsContField)
334  {
335  Exp3DH1 = MemoryManager<
336  MultiRegions::ContField3DHomogeneous1D>::
337  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
338  dealiasing, m_graph,
339  m_session->GetVariable(0),
340  Collections::eNoCollection);
341  }
342  else if (m_declareExpansionAsDisContField)
343  {
344  Exp3DH1 = MemoryManager<
345  MultiRegions::DisContField3DHomogeneous1D>::
346  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
347  dealiasing, m_graph,
348  m_session->GetVariable(0),
349  Collections::eNoCollection);
350  }
351  else
352  {
353  Exp3DH1 = MemoryManager<
354  MultiRegions::ExpList3DHomogeneous1D>::
355  AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
356  dealiasing, m_graph,
357  "DefaultVar",
358  Collections::eNoCollection);
359  }
360  exp = Exp3DH1;
361  }
362  else
363  {
364  MultiRegions::ExpList2DSharedPtr Exp2D;
365 
366  if (m_declareExpansionAsContField)
367  {
368  Exp2D = MemoryManager<MultiRegions::ContField2D>::
369  AllocateSharedPtr(m_session, m_graph,
370  m_session->GetVariable(0),
371  true,false,
372  Collections::eNoCollection);
373  }
374  else if (m_declareExpansionAsDisContField)
375  {
376  Exp2D = MemoryManager<MultiRegions::DisContField2D>::
377  AllocateSharedPtr(m_session, m_graph,
378  m_session->GetVariable(0),
379  true,true,
380  Collections::eNoCollection);
381  }
382  else
383  {
384  Exp2D = MemoryManager<MultiRegions::ExpList2D>::
385  AllocateSharedPtr(m_session, m_graph,
386  true,
387  "DefaultVar",
388  Collections::eNoCollection);
389  }
390 
391  exp = Exp2D;
392  }
393  }
394  break;
395  case 3:
396  {
397  MultiRegions::ExpList3DSharedPtr Exp3D;
398 
399  if (m_declareExpansionAsContField)
400  {
401  Exp3D = MemoryManager<MultiRegions::ContField3D>::
402  AllocateSharedPtr(m_session, m_graph,
403  m_session->GetVariable(0),
404  false,
405  Collections::eNoCollection);
406  }
407  else if (m_declareExpansionAsDisContField)
408  {
409  Exp3D = MemoryManager<MultiRegions::DisContField3D>::
410  AllocateSharedPtr(m_session, m_graph,
411  m_session->GetVariable(0),
412  true,
413  Collections::eNoCollection);
414  }
415  else
416  {
417  Exp3D = MemoryManager<
418  MultiRegions::ExpList3D>::AllocateSharedPtr(
419  m_session,
420  m_graph,
421  "DefaultVar",
422  Collections::eNoCollection);
423  }
424 
425  exp = Exp3D;
426  }
427  break;
428  default:
429  ASSERTL0(false, "Expansion dimension not recognised");
430  break;
431  }
432 
433  return exp;
434  };
435 
436  /**
437  * @brief Construct a FieldIO object for the file @p filename.
438  *
439  * This routine constructs an appropriate FieldIO object for a filename
440  * through the LibUtilities::FieldIO::GetFileType function to detect the
441  * file format. The result is then cached in Field::m_fld to avoid needing
442  * to repeatedly construct the object.
443  *
444  * @param filename Filename to open.
445  * @return Reader for @p filename.
446  */
447  FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr FieldIOForFile(
448  string filename)
449  {
450  LibUtilities::CommSharedPtr c = m_session ? m_session->GetComm() :
451  LibUtilities::GetCommFactory().CreateInstance("Serial", 0, 0);
452  string fmt = LibUtilities::FieldIO::GetFileType(filename, c);
453  map<string, LibUtilities::FieldIOSharedPtr>::iterator it =
454  m_fld.find(fmt);
455 
456  if (it == m_fld.end())
457  {
458  LibUtilities::FieldIOSharedPtr fld =
459  LibUtilities::GetFieldIOFactory().CreateInstance(fmt, c, true);
460  m_fld[fmt] = fld;
461  return fld;
462  }
463  else
464  {
465  return it->second;
466  }
467  }
468 
469  FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList(
470  int NumHomogeneousDir, string var = "DefaultVar", bool NewField = false)
471  {
472  if (var.compare("DefaultVar") == 0 && m_requireBoundaryExpansion)
473  {
474  if (m_session->GetVariables().size())
475  {
476  var = m_session->GetVariables()[0];
477  }
478  }
479  MultiRegions::ExpListSharedPtr tmp;
480  switch (m_graph->GetMeshDimension())
481  {
482  case 1:
483  {
484  if (NumHomogeneousDir == 1)
485  {
486  ASSERTL0(!(m_declareExpansionAsContField ||
487  m_declareExpansionAsDisContField),
488  "ContField2DHomogeneous1D or "
489  "DisContField2DHomogenenous1D has not been "
490  "implemented");
491 
492  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
493  boost::dynamic_pointer_cast<
494  MultiRegions::ExpList2DHomogeneous1D>(m_exp[0]);
495 
496  tmp = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
497  AllocateSharedPtr(*tmp2);
498  }
499  else if (NumHomogeneousDir == 2)
500  {
501  if (m_declareExpansionAsContField)
502  {
503  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
504  boost::dynamic_pointer_cast<
505  MultiRegions::ContField3DHomogeneous2D>(
506  m_exp[0]);
507 
508  tmp = MemoryManager<
509  MultiRegions::ContField3DHomogeneous2D>::
510  AllocateSharedPtr(*tmp2);
511  }
512  else if (m_declareExpansionAsDisContField)
513  {
514  MultiRegions::DisContField3DHomogeneous2DSharedPtr
515  tmp2 = boost::dynamic_pointer_cast<
516  MultiRegions::DisContField3DHomogeneous2D>(
517  m_exp[0]);
518 
519  tmp = MemoryManager<
520  MultiRegions::DisContField3DHomogeneous2D>::
521  AllocateSharedPtr(*tmp2);
522  }
523  else
524  {
525  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
526  boost::dynamic_pointer_cast<
527  MultiRegions::ExpList3DHomogeneous2D>(m_exp[0]);
528 
529  tmp = MemoryManager<
530  MultiRegions::ExpList3DHomogeneous2D>::
531  AllocateSharedPtr(*tmp2);
532  }
533  }
534  else
535  {
536  if (m_declareExpansionAsContField)
537  {
538  MultiRegions::ContField1DSharedPtr tmp2 =
539  boost::dynamic_pointer_cast<
540  MultiRegions::ContField1D>(m_exp[0]);
541 
542  tmp = MemoryManager<MultiRegions::ContField1D>::
543  AllocateSharedPtr(m_session, m_graph, var);
544  }
545  else if (m_declareExpansionAsDisContField)
546  {
547  MultiRegions::DisContField1DSharedPtr tmp2 =
548  boost::dynamic_pointer_cast<
549  MultiRegions::DisContField1D>(m_exp[0]);
550 
551  tmp = MemoryManager<MultiRegions::DisContField1D>::
552  AllocateSharedPtr(m_session, m_graph, var);
553  }
554  else
555  {
556  MultiRegions::ExpList1DSharedPtr tmp2 =
557  boost::dynamic_pointer_cast<
558  MultiRegions::ExpList1D>(m_exp[0]);
559 
560  tmp = MemoryManager<
561  MultiRegions::ExpList1D>::AllocateSharedPtr(*tmp2);
562  }
563  }
564  }
565  break;
566  case 2:
567  {
568  if (NumHomogeneousDir == 1)
569  {
570  if (m_declareExpansionAsContField)
571  {
572  if (NewField)
573  {
574  bool dealiasing = false;
575 
576  tmp = MemoryManager<
577  MultiRegions::ContField3DHomogeneous1D>::
578  AllocateSharedPtr(
579  m_session, m_exp[0]
580  ->GetHomogeneousBasis()
581  ->GetBasisKey(),
582  m_exp[0]->GetHomoLen(), m_useFFT,
583  dealiasing, m_graph, var);
584  }
585  else
586  {
587  MultiRegions::ContField3DHomogeneous1DSharedPtr
588  tmp2 = boost::dynamic_pointer_cast<
589  MultiRegions::ContField3DHomogeneous1D>(
590  m_exp[0]);
591 
592  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
593  tmp = MemoryManager<
594  MultiRegions::ContField3DHomogeneous1D>::
595  AllocateSharedPtr(*tmp2, m_graph, var);
596  }
597  }
598  else if (m_declareExpansionAsDisContField)
599  {
600  if (NewField)
601  {
602  bool dealiasing = false;
603 
604  tmp = MemoryManager<
605  MultiRegions::DisContField3DHomogeneous1D>::
606  AllocateSharedPtr(
607  m_session, m_exp[0]
608  ->GetHomogeneousBasis()
609  ->GetBasisKey(),
610  m_exp[0]->GetHomoLen(), m_useFFT,
611  dealiasing, m_graph, var);
612  }
613  else
614  {
615  MultiRegions::DisContField3DHomogeneous1DSharedPtr
616  tmp2 = boost::dynamic_pointer_cast<
617  MultiRegions::DisContField3DHomogeneous1D>(
618  m_exp[0]);
619  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
620 
621  tmp = MemoryManager<
622  MultiRegions::DisContField3DHomogeneous1D>::
623  AllocateSharedPtr(*tmp2);
624  }
625  }
626  else
627  {
628  if (NewField)
629  {
630  bool dealiasing = false;
631 
632  tmp = MemoryManager<
633  MultiRegions::ExpList3DHomogeneous1D>::
634  AllocateSharedPtr(
635  m_session, m_exp[0]
636  ->GetHomogeneousBasis()
637  ->GetBasisKey(),
638  m_exp[0]->GetHomoLen(), m_useFFT,
639  dealiasing, m_graph);
640  }
641  else
642  {
643  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
644  boost::dynamic_pointer_cast<
645  MultiRegions::ExpList3DHomogeneous1D>(
646  m_exp[0]);
647  ASSERTL0(tmp2, "Failed to type cast m_exp[0]");
648 
649  tmp = MemoryManager<
650  MultiRegions::ExpList3DHomogeneous1D>::
651  AllocateSharedPtr(*tmp2);
652  }
653  }
654  }
655  else
656  {
657  if (m_declareExpansionAsContField)
658  {
659  if (NewField)
660  {
661  tmp = MemoryManager<MultiRegions::ContField2D>::
662  AllocateSharedPtr(m_session, m_graph, var);
663  }
664  else // call copy constructor
665  {
666 
667  MultiRegions::ContField2DSharedPtr tmp2 =
668  boost::dynamic_pointer_cast<
669  MultiRegions::ContField2D>(m_exp[0]);
670 
671  tmp = MemoryManager<MultiRegions::ContField2D>::
672  AllocateSharedPtr(*tmp2, m_graph, var);
673  }
674  }
675  else if (m_declareExpansionAsDisContField)
676  {
677  if (NewField)
678  {
679  tmp = MemoryManager<MultiRegions::DisContField2D>::
680  AllocateSharedPtr(m_session, m_graph, var);
681  }
682  else // call copy constructor
683  {
684  MultiRegions::DisContField2DSharedPtr tmp2 =
685  boost::dynamic_pointer_cast<
686  MultiRegions::DisContField2D>(m_exp[0]);
687 
688  tmp = MemoryManager<MultiRegions::DisContField2D>::
689  AllocateSharedPtr(*tmp2, m_graph, var);
690  }
691  }
692  else
693  {
694  MultiRegions::ExpList2DSharedPtr tmp2 =
695  boost::dynamic_pointer_cast<
696  MultiRegions::ExpList2D>(m_exp[0]);
697 
698  tmp = MemoryManager<
699  MultiRegions::ExpList2D>::AllocateSharedPtr(*tmp2);
700  }
701  }
702  }
703  break;
704  case 3:
705  {
706  if (m_declareExpansionAsContField)
707  {
708  if (NewField)
709  {
710  tmp = MemoryManager<MultiRegions::ContField3D>::
711  AllocateSharedPtr(m_session, m_graph, var);
712  }
713  else
714  {
715  MultiRegions::ContField3DSharedPtr tmp2 =
716  boost::dynamic_pointer_cast<
717  MultiRegions::ContField3D>(m_exp[0]);
718 
719  tmp = MemoryManager<MultiRegions::ContField3D>::
720  AllocateSharedPtr(*tmp2, m_graph, var);
721 
722  m_locToGlobalMap = tmp2->GetLocalToGlobalMap();
723  }
724  }
725  else if (m_declareExpansionAsDisContField)
726  {
727  if (NewField)
728  {
729  tmp = MemoryManager<MultiRegions::DisContField3D>::
730  AllocateSharedPtr(m_session, m_graph, var);
731  }
732  else
733  {
734  MultiRegions::DisContField3DSharedPtr tmp2 =
735  boost::dynamic_pointer_cast<
736  MultiRegions::DisContField3D>(m_exp[0]);
737 
738  tmp = MemoryManager<MultiRegions::DisContField3D>::
739  AllocateSharedPtr(*tmp2, m_graph, var);
740  }
741  }
742  else
743  {
744  MultiRegions::ExpList3DSharedPtr tmp2 =
745  boost::dynamic_pointer_cast<MultiRegions::ExpList3D>(
746  m_exp[0]);
747 
748  tmp = MemoryManager<
749  MultiRegions::ExpList3D>::AllocateSharedPtr(*tmp2);
750  }
751  }
752  break;
753  default:
754  ASSERTL0(false, "Expansion dimension not recognised");
755  break;
756  }
757 
758  return tmp;
759  }
760 
761 private:
762  /// Map to store FieldIO instances. Key is the reader type, value is the
763  /// FieldIO object.
764  map<string, LibUtilities::FieldIOSharedPtr> m_fld;
765 };
766 
767 typedef boost::shared_ptr<Field> FieldSharedPtr;
768 }
769 }
770 
771 #endif
Nektar::FieldUtils::Field::m_comm
LibUtilities::CommSharedPtr m_comm
Definition: Field.hpp:101
Nektar::FieldUtils::Field::m_exp
vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:92
ExpList2DHomogeneous1D.h
Nektar::FieldUtils::Field::SetUpFirstExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr SetUpFirstExpList(int NumHomogeneousDir, bool fldfilegiven=false)
Definition: Field.hpp:120
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
NekFactory.hpp
Nektar::MultiRegions::ContField1DSharedPtr
boost::shared_ptr< ContField1D > ContField1DSharedPtr
Definition: ContField1D.h:238
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
boost::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:108
Nektar::FieldUtils::Field::~Field
FIELD_UTILS_EXPORT ~Field()
Definition: Field.hpp:82
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
ContField3D.h
Nektar::FieldUtils::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:95
Nektar::FieldUtils::Field::FieldIOForFile
FIELD_UTILS_EXPORT LibUtilities::FieldIOSharedPtr FieldIOForFile(string filename)
Construct a FieldIO object for the file filename.
Definition: Field.hpp:447
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition: NekMemoryManager.hpp:102
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
boost::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:302
DisContField3DHomogeneous2D.h
ContField2D.h
Nektar::FieldUtils::Field::m_ptsIO
LibUtilities::PtsIOSharedPtr m_ptsIO
Definition: Field.hpp:104
DisContField2D.h
Nektar::FieldUtils::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:102
std
STL namespace.
DisContField3D.h
Nektar::MultiRegions::ContField2DSharedPtr
boost::shared_ptr< ContField2D > ContField2DSharedPtr
Definition: ContField2D.h:289
PtsField.h
Nektar::LibUtilities::eFourier
Fourier Expansion .
Definition: BasisType.h:52
Nektar::LibUtilities::GetFieldIOFactory
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
Definition: FieldIO.cpp:74
Nektar::LibUtilities::SessionReaderSharedPtr
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
Nektar::LibUtilities::FieldMetaDataMap
std::map< std::string, std::string > FieldMetaDataMap
Definition: FieldIO.h:54
Nektar::LibUtilities::GetCommFactory
CommFactory & GetCommFactory()
Definition: Comm.cpp:61
Nektar::FieldUtils::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:103
Nektar::LibUtilities::PtsFieldSharedPtr
boost::shared_ptr< PtsField > PtsFieldSharedPtr
Definition: PtsField.h:178
Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr
boost::shared_ptr< ExpList3DHomogeneous2D > ExpList3DHomogeneous2DSharedPtr
Shared pointer to an ExpList3DHomogeneous2D object.
Definition: ExpList3DHomogeneous2D.h:50
ContField3DHomogeneous2D.h
Nektar::FieldUtils::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:94
PtsIO.h
Nektar::FieldUtils::Field::AppendExpList
FIELD_UTILS_EXPORT MultiRegions::ExpListSharedPtr AppendExpList(int NumHomogeneousDir, string var="DefaultVar", bool NewField=false)
Definition: Field.hpp:469
Nektar::MultiRegions::ExpList2DHomogeneous1D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList2DHomogeneous1D.h:64
ContField3DHomogeneous1D.h
Nektar::LibUtilities::ePolyEvenlySpaced
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:65
Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr
boost::shared_ptr< DisContField3DHomogeneous2D > DisContField3DHomogeneous2DSharedPtr
Definition: DisContField3DHomogeneous2D.h:162
Nektar::LibUtilities::CommSharedPtr
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:55
Nektar::LibUtilities::eFourierEvenlySpaced
1D Evenly-spaced points using Fourier Fit
Definition: PointsType.h:66
Nektar::LibUtilities::eFourierHalfModeRe
Fourier Modified expansions with just the real part of the first mode .
Definition: BasisType.h:59
Nektar::MultiRegions::ContField2D
This class is the abstraction of a global continuous two- dimensional spectral/hp element expansion w...
Definition: ContField2D.h:56
Nektar::MultiRegions::ContField1D
Abstraction of a global continuous one-dimensional spectral/hp element expansion which approximates t...
Definition: ContField1D.h:56
ExpList.h
Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr
boost::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
Definition: ContField3DHomogeneous2D.h:103
Nektar::MultiRegions::ExpList1DSharedPtr
boost::shared_ptr< ExpList1D > ExpList1DSharedPtr
Shared pointer to an ExpList1D object.
Definition: ExpList1D.h:50
DisContField3DHomogeneous1D.h
Nektar::FieldUtils::Field::m_bndRegionsToWrite
vector< unsigned int > m_bndRegionsToWrite
Definition: Field.hpp:108
Nektar::FieldUtils::FieldSharedPtr
boost::shared_ptr< Field > FieldSharedPtr
Definition: Field.hpp:767
Nektar::FieldUtils::Field::m_data
vector< vector< double > > m_data
Definition: Field.hpp:91
Nektar::MultiRegions::ExpListSharedPtr
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: LocTraceToTraceMap.h:56
Nektar::MultiRegions::DisContField2DSharedPtr
boost::shared_ptr< DisContField2D > DisContField2DSharedPtr
Definition: DisContField2D.h:303
Nektar::MultiRegions::DisContField1D
This class is the abstraction of a global discontinuous two- dimensional spectral/hp element expansio...
Definition: DisContField1D.h:55
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition: Points.h:58
Nektar::LibUtilities::FieldIOSharedPtr
boost::shared_ptr< FieldIO > FieldIOSharedPtr
Definition: FieldIO.h:309
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::MultiRegions::DisContField1DSharedPtr
boost::shared_ptr< DisContField1D > DisContField1DSharedPtr
Definition: DisContField1D.h:281
Nektar::MultiRegions::ExpList2DSharedPtr
boost::shared_ptr< ExpList2D > ExpList2DSharedPtr
Shared pointer to an ExpList2D object.
Definition: ExpList2D.h:49
Nektar::MultiRegions::DisContField3DSharedPtr
boost::shared_ptr< DisContField3D > DisContField3DSharedPtr
Definition: DisContField3D.h:273
Nektar::FieldUtils::Field::m_fld
map< string, LibUtilities::FieldIOSharedPtr > m_fld
Map to store FieldIO instances. Key is the reader type, value is the FieldIO object.
Definition: Field.hpp:764
Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr
boost::shared_ptr< ExpList2DHomogeneous1D > ExpList2DHomogeneous1DSharedPtr
Shared pointer to an ExpList2DHomogeneous1D object.
Definition: ExpList2DHomogeneous1D.h:50
Nektar::LibUtilities::PtsIOSharedPtr
boost::shared_ptr< PtsIO > PtsIOSharedPtr
Definition: PtsIO.h:95
Nektar::MultiRegions::ExpList3DSharedPtr
boost::shared_ptr< ExpList3D > ExpList3DSharedPtr
Shared pointer to an ExpList3D object.
Definition: ExpList3D.h:112
Nektar::iterator
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
Definition: MatrixOperations.cpp:96
MeshGraph.h
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:179
FIELD_UTILS_EXPORT
#define FIELD_UTILS_EXPORT
Definition: FieldUtilsDeclspec.h:43
FieldUtilsDeclspec.h
Nektar::LibUtilities::eFourierSingleMode
Fourier ModifiedExpansion with just the first mode .
Definition: BasisType.h:58
Nektar::MultiRegions::ExpList1D
This class is the abstraction of a one-dimensional multi-elemental expansions which is merely a colle...
Definition: ExpList1D.h:61
Nektar::MultiRegions::ExpList2D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList2D.h:60
SessionReader.h
Nektar::MultiRegions::ExpList3D
Abstraction of a three-dimensional multi-elemental expansion which is merely a collection of local ex...
Definition: ExpList3D.h:49
ContField1D.h
Nektar::FieldUtils::Field::m_locToGlobalMap
MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap
Definition: Field.hpp:116
Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr
boost::shared_ptr< ExpList3DHomogeneous1D > ExpList3DHomogeneous1DSharedPtr
Shared pointer to an ExpList3DHomogeneous1D object.
Definition: ExpList3DHomogeneous1D.h:50
Nektar::FieldUtils::Field::m_inputfiles
map< string, vector< string > > m_inputfiles
Definition: Field.hpp:105
Nektar::MultiRegions::ContField3DSharedPtr
boost::shared_ptr< ContField3D > ContField3DSharedPtr
Definition: ContField3D.h:208
Nektar::MultiRegions::AssemblyMapCGSharedPtr
boost::shared_ptr< AssemblyMapCG > AssemblyMapCGSharedPtr
Definition: AssemblyMapCG.h:52
Nektar::FieldUtils::Field::m_fieldMetaDataMap
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Definition: Field.hpp:118
Nektar::FieldUtils::Field::m_fielddef
vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
Definition: Field.hpp:90
Nektar::FieldUtils::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:114
Nektar::SpatialDomains::MeshGraphSharedPtr
boost::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:442
DisContField1D.h
Nektar::MultiRegions::ExpList3DHomogeneous2D
Abstraction of a one-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList3DHomogeneous2D.h:61
Nektar::MultiRegions::ExpList3DHomogeneous1D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList3DHomogeneous1D.h:61
Nektar::LibUtilities::BasisKey
Describes the specification for a Basis.
Definition: Basis.h:50
SharedArray.hpp
Nektar::FieldUtils::Field::Field
FIELD_UTILS_EXPORT Field()
Definition: Field.hpp:73
Generated on Sat Nov 25 2017 16:18:11 for Nektar++ by   doxygen 1.8.8