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

#include <Field.hpp>

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

Public Member Functions

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

Public Attributes

bool m_verbose
 
vector< LibUtilities::FieldDefinitionsSharedPtr > m_fielddef
 
vector< vector< double > > m_data
 
vector< MultiRegions::ExpListSharedPtr > m_exp
 
bool m_declareExpansionAsContField
 
bool m_declareExpansionAsDisContField
 
bool m_useFFT
 
LibUtilities::CommSharedPtr m_comm
 
LibUtilities::SessionReaderSharedPtr m_session
 
SpatialDomains::MeshGraphSharedPtr m_graph
 
LibUtilities::FieldIOSharedPtr m_fld
 
LibUtilities::PtsIOSharedPtr m_ptsIO
 
map< string, vector< string > > m_inputfiles
 
bool m_writeBndFld
 
vector< unsigned int > m_bndRegionsToWrite
 
bool m_fldToBnd
 
bool m_addNormals
 
bool m_setUpEquiSpacedFields
 
LibUtilities::PtsFieldSharedPtr m_fieldPts
 
MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 

Detailed Description

Definition at line 67 of file Field.hpp.

Constructor & Destructor Documentation

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

Definition at line 68 of file Field.hpp.

68  : m_verbose(false),
69  m_declareExpansionAsContField(false),
70  m_declareExpansionAsDisContField(false),
71  m_writeBndFld(false),
72  m_fldToBnd(false),
73  m_addNormals(false),
74  m_setUpEquiSpacedFields(false),
75  m_fieldPts(LibUtilities::NullPtsField){}
Nektar::Utilities::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:107
Nektar::Utilities::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:90
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:249
Nektar::Utilities::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:89
Nektar::Utilities::Field::~Field ( )
inline

Definition at line 77 of file Field.hpp.

78  {
79  if (m_session)
80  {
81  m_session->Finalise();
82  }
83  }
Nektar::Utilities::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:95

Member Function Documentation

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

Definition at line 390 of file Field.hpp.

References ASSERTL0.

393  {
394  MultiRegions::ExpListSharedPtr tmp;
395  switch (m_graph->GetMeshDimension())
396  {
397  case 1:
398  {
399  if (NumHomogeneousDir == 1)
400  {
401  ASSERTL0(m_declareExpansionAsContField ||
402  m_declareExpansionAsDisContField,
403  "ContField2DHomogeneous1D or "
404  "DisContField2DHomogenenous1D has not been "
405  "implemented");
406 
407  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
408  boost::dynamic_pointer_cast<MultiRegions::
409  ExpList2DHomogeneous1D>(m_exp[0]);
410 
411  tmp = MemoryManager<MultiRegions::
412  ExpList2DHomogeneous1D>::
413  AllocateSharedPtr(*tmp2);
414 
415  }
416  else if (NumHomogeneousDir == 2)
417  {
418  if(m_declareExpansionAsContField)
419  {
420  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
421  boost::dynamic_pointer_cast<MultiRegions::
422  ContField3DHomogeneous2D>(m_exp[0]);
423 
424  tmp = MemoryManager<MultiRegions::
425  ContField3DHomogeneous2D>::
426  AllocateSharedPtr(*tmp2);
427  }
428  else if(m_declareExpansionAsDisContField)
429  {
430  MultiRegions::DisContField3DHomogeneous2DSharedPtr tmp2 =
431  boost::dynamic_pointer_cast<MultiRegions::
432  DisContField3DHomogeneous2D>(m_exp[0]);
433 
434  tmp = MemoryManager<MultiRegions::
435  DisContField3DHomogeneous2D>::
436  AllocateSharedPtr(*tmp2);
437  }
438  else
439  {
440  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
441  boost::dynamic_pointer_cast<MultiRegions::
442  ExpList3DHomogeneous2D>(m_exp[0]);
443 
444  tmp = MemoryManager<MultiRegions::
445  ExpList3DHomogeneous2D>::
446  AllocateSharedPtr(*tmp2);
447  }
448 
449 
450  }
451  else
452  {
453  if(m_declareExpansionAsContField)
454  {
455  MultiRegions::ContField1DSharedPtr tmp2 =
456  boost::dynamic_pointer_cast<MultiRegions::
457  ContField1D>(m_exp[0]);
458 
459  tmp = MemoryManager<MultiRegions::ContField1D>::
460  AllocateSharedPtr(m_session,m_graph,var);
461  }
462  else if(m_declareExpansionAsDisContField)
463  {
464  MultiRegions::DisContField1DSharedPtr tmp2 =
465  boost::dynamic_pointer_cast<MultiRegions::
466  DisContField1D>(m_exp[0]);
467 
468  tmp = MemoryManager<MultiRegions::DisContField1D>::
469  AllocateSharedPtr(m_session,m_graph,var);
470  }
471  else
472  {
473  MultiRegions::ExpList1DSharedPtr tmp2 =
474  boost::dynamic_pointer_cast<MultiRegions::
475  ExpList1D>(m_exp[0]);
476 
477  tmp = MemoryManager<MultiRegions::ExpList1D>::
478  AllocateSharedPtr(*tmp2);
479  }
480 
481  }
482  }
483  break;
484  case 2:
485  {
486  if (NumHomogeneousDir == 1)
487  {
488  if(m_declareExpansionAsContField)
489  {
490  if(NewField)
491  {
492  bool dealiasing = false;
493 
494  tmp = MemoryManager<MultiRegions::
495  ContField3DHomogeneous1D>::AllocateSharedPtr(
496  m_session,
497  m_exp[0]->GetHomogeneousBasis()
498  ->GetBasisKey(),
499  m_exp[0]->GetHomoLen(),
500  m_useFFT, dealiasing, m_graph, var);
501  }
502  else
503  {
504  MultiRegions::ContField3DHomogeneous1DSharedPtr tmp2 =
505  boost::dynamic_pointer_cast<MultiRegions::
506  ContField3DHomogeneous1D>(m_exp[0]);
507 
508  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
509  tmp = MemoryManager<MultiRegions::
510  ContField3DHomogeneous1D>::
511  AllocateSharedPtr(*tmp2);
512  }
513  }
514  else if(m_declareExpansionAsDisContField)
515  {
516  if(NewField)
517  {
518  bool dealiasing = false;
519 
520  tmp = MemoryManager<MultiRegions::
521  DisContField3DHomogeneous1D>::AllocateSharedPtr(
522  m_session,
523  m_exp[0]->GetHomogeneousBasis()
524  ->GetBasisKey(),
525  m_exp[0]->GetHomoLen(),
526  m_useFFT, dealiasing, m_graph,var);
527  }
528  else
529  {
530  MultiRegions::DisContField3DHomogeneous1DSharedPtr tmp2 =
531  boost::dynamic_pointer_cast<MultiRegions::
532  DisContField3DHomogeneous1D>(m_exp[0]);
533  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
534 
535  tmp = MemoryManager<MultiRegions::
536  DisContField3DHomogeneous1D>::
537  AllocateSharedPtr(*tmp2);
538  }
539  }
540  else
541  {
542  if(NewField)
543  {
544  bool dealiasing = false;
545 
546  tmp = MemoryManager<MultiRegions::
547  ExpList3DHomogeneous1D>::AllocateSharedPtr(
548  m_session,
549  m_exp[0]->GetHomogeneousBasis()
550  ->GetBasisKey(),
551  m_exp[0]->GetHomoLen(),
552  m_useFFT, dealiasing, m_graph);
553  }
554  else
555  {
556  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
557  boost::dynamic_pointer_cast<MultiRegions::
558  ExpList3DHomogeneous1D>(m_exp[0]);
559  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
560 
561  tmp = MemoryManager<MultiRegions::
562  ExpList3DHomogeneous1D>::
563  AllocateSharedPtr(*tmp2);
564  }
565  }
566 
567  }
568  else
569  {
570  if(m_declareExpansionAsContField)
571  {
572  if(NewField)
573  {
574  tmp = MemoryManager<MultiRegions::ContField2D>::
575  AllocateSharedPtr(m_session,m_graph,var);
576  }
577  else // call copy constructor
578  {
579 
580  MultiRegions::ContField2DSharedPtr tmp2 =
581  boost::dynamic_pointer_cast<MultiRegions::
582  ContField2D>(m_exp[0]);
583 
584  tmp = MemoryManager<MultiRegions::ContField2D>::
585  AllocateSharedPtr(*tmp2,m_graph,var);
586  }
587  }
588  else if(m_declareExpansionAsDisContField)
589  {
590  if(NewField)
591  {
592  tmp = MemoryManager<MultiRegions::DisContField2D>::
593  AllocateSharedPtr(m_session,m_graph,var);
594  }
595  else // call copy constructor
596  {
597  MultiRegions::DisContField2DSharedPtr tmp2 =
598  boost::dynamic_pointer_cast<MultiRegions::
599  DisContField2D>(m_exp[0]);
600 
601  tmp = MemoryManager<MultiRegions::DisContField2D>::
602  AllocateSharedPtr(*tmp2,m_graph,var);
603  }
604  }
605  else
606  {
607  MultiRegions::ExpList2DSharedPtr tmp2 =
608  boost::dynamic_pointer_cast<MultiRegions::
609  ExpList2D>(m_exp[0]);
610 
611  tmp = MemoryManager<MultiRegions::ExpList2D>::
612  AllocateSharedPtr(*tmp2);
613  }
614  }
615  }
616  break;
617  case 3:
618  {
619  if(m_declareExpansionAsContField)
620  {
621  if(NewField)
622  {
623  tmp = MemoryManager<MultiRegions::ContField3D>::
624  AllocateSharedPtr(m_session,m_graph,var);
625 
626  }
627  else
628  {
629  MultiRegions::ContField3DSharedPtr tmp2 =
630  boost::dynamic_pointer_cast<MultiRegions::
631  ContField3D>(m_exp[0]);
632 
633  tmp = MemoryManager<MultiRegions::ContField3D>::
634  AllocateSharedPtr(*tmp2,m_graph,var);
635 
636  m_locToGlobalMap = tmp2->GetLocalToGlobalMap();
637  }
638  }
639  else if(m_declareExpansionAsDisContField)
640  {
641  if(NewField)
642  {
643  tmp = MemoryManager<MultiRegions::DisContField3D>::
644  AllocateSharedPtr(m_session,m_graph,var);
645  }
646  else
647  {
648  MultiRegions::DisContField3DSharedPtr tmp2 =
649  boost::dynamic_pointer_cast<MultiRegions::
650  DisContField3D>(m_exp[0]);
651 
652  tmp = MemoryManager<MultiRegions::DisContField3D>::
653  AllocateSharedPtr(*tmp2,m_graph,var);
654  }
655  }
656  else
657  {
658  MultiRegions::ExpList3DSharedPtr tmp2 =
659  boost::dynamic_pointer_cast<MultiRegions::
660  ExpList3D>(m_exp[0]);
661 
662  tmp = MemoryManager<MultiRegions::ExpList3D>::
663  AllocateSharedPtr(*tmp2);
664  }
665  }
666  break;
667  default:
668  ASSERTL0(false, "Expansion dimension not recognised");
669  break;
670  }
671 
672  return tmp;
673  }
Nektar::Utilities::Field::m_exp
vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:87
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::MultiRegions::ContField1DSharedPtr
boost::shared_ptr< ContField1D > ContField1DSharedPtr
Definition: ContField1D.h:235
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
boost::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:94
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::MemoryManager
General purpose memory allocation routines with the ability to allocate from thread specific memory p...
Definition: NekMemoryManager.hpp:102
Nektar::Utilities::Field::m_locToGlobalMap
MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap
Definition: Field.hpp:109
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
boost::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:291
Nektar::MultiRegions::ContField2DSharedPtr
boost::shared_ptr< ContField2D > ContField2DSharedPtr
Definition: ContField2D.h:291
Nektar::MultiRegions::ExpList3DHomogeneous2DSharedPtr
boost::shared_ptr< ExpList3DHomogeneous2D > ExpList3DHomogeneous2DSharedPtr
Shared pointer to an ExpList3DHomogeneous2D object.
Definition: ExpList3DHomogeneous2D.h:50
Nektar::MultiRegions::ExpList2DHomogeneous1D
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
Definition: ExpList2DHomogeneous1D.h:64
Nektar::MultiRegions::DisContField3DHomogeneous2DSharedPtr
boost::shared_ptr< DisContField3DHomogeneous2D > DisContField3DHomogeneous2DSharedPtr
Definition: DisContField3DHomogeneous2D.h:151
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
Nektar::MultiRegions::ContField3DHomogeneous2DSharedPtr
boost::shared_ptr< ContField3DHomogeneous2D > ContField3DHomogeneous2DSharedPtr
Definition: ContField3DHomogeneous2D.h:95
Nektar::MultiRegions::ExpList1DSharedPtr
boost::shared_ptr< ExpList1D > ExpList1DSharedPtr
Shared pointer to an ExpList1D object.
Definition: ExpList1D.h:50
Nektar::MultiRegions::ExpListSharedPtr
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
Definition: ExpList.h:1340
Nektar::Utilities::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:90
Nektar::MultiRegions::DisContField2DSharedPtr
boost::shared_ptr< DisContField2D > DisContField2DSharedPtr
Definition: DisContField2D.h:261
Nektar::MultiRegions::DisContField1D
This class is the abstraction of a global discontinuous two- dimensional spectral/hp element expansio...
Definition: DisContField1D.h:55
Nektar::Utilities::Field::m_graph
SpatialDomains::MeshGraphSharedPtr m_graph
Definition: Field.hpp:96
Nektar::MultiRegions::DisContField1DSharedPtr
boost::shared_ptr< DisContField1D > DisContField1DSharedPtr
Definition: DisContField1D.h:273
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:249
Nektar::MultiRegions::ExpList2DHomogeneous1DSharedPtr
boost::shared_ptr< ExpList2DHomogeneous1D > ExpList2DHomogeneous1DSharedPtr
Shared pointer to an ExpList2DHomogeneous1D object.
Definition: ExpList2DHomogeneous1D.h:50
Nektar::MultiRegions::ExpList3DSharedPtr
boost::shared_ptr< ExpList3D > ExpList3DSharedPtr
Shared pointer to an ExpList3D object.
Definition: ExpList3D.h:110
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
Nektar::MultiRegions::ExpList3D
Abstraction of a three-dimensional multi-elemental expansion which is merely a collection of local ex...
Definition: ExpList3D.h:49
Nektar::MultiRegions::ExpList3DHomogeneous1DSharedPtr
boost::shared_ptr< ExpList3DHomogeneous1D > ExpList3DHomogeneous1DSharedPtr
Shared pointer to an ExpList3DHomogeneous1D object.
Definition: ExpList3DHomogeneous1D.h:50
Nektar::Utilities::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:89
Nektar::Utilities::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:95
Nektar::MultiRegions::ContField3DSharedPtr
boost::shared_ptr< ContField3D > ContField3DSharedPtr
Definition: ContField3D.h:190
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
MultiRegions::ExpListSharedPtr Nektar::Utilities::Field::SetUpFirstExpList ( int  NumHomogeneousDir,
bool  fldfilegiven = false 
)
inline

Definition at line 113 of file Field.hpp.

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

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

Member Data Documentation

bool Nektar::Utilities::Field::m_addNormals

Definition at line 104 of file Field.hpp.

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

Definition at line 102 of file Field.hpp.

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

Definition at line 94 of file Field.hpp.

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

Definition at line 86 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsContField

Definition at line 89 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsDisContField

Definition at line 90 of file Field.hpp.

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

Definition at line 87 of file Field.hpp.

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

Definition at line 85 of file Field.hpp.

LibUtilities::FieldMetaDataMap Nektar::Utilities::Field::m_fieldMetaDataMap

Definition at line 111 of file Field.hpp.

LibUtilities::PtsFieldSharedPtr Nektar::Utilities::Field::m_fieldPts

Definition at line 107 of file Field.hpp.

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

Definition at line 97 of file Field.hpp.

bool Nektar::Utilities::Field::m_fldToBnd

Definition at line 103 of file Field.hpp.

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

Definition at line 96 of file Field.hpp.

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

Definition at line 99 of file Field.hpp.

MultiRegions::AssemblyMapCGSharedPtr Nektar::Utilities::Field::m_locToGlobalMap

Definition at line 109 of file Field.hpp.

LibUtilities::PtsIOSharedPtr Nektar::Utilities::Field::m_ptsIO

Definition at line 98 of file Field.hpp.

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

Definition at line 95 of file Field.hpp.

bool Nektar::Utilities::Field::m_setUpEquiSpacedFields

Definition at line 106 of file Field.hpp.

bool Nektar::Utilities::Field::m_useFFT

Definition at line 92 of file Field.hpp.

bool Nektar::Utilities::Field::m_verbose

Definition at line 84 of file Field.hpp.

bool Nektar::Utilities::Field::m_writeBndFld

Definition at line 101 of file Field.hpp.

Generated on Tue Dec 8 2015 23:45:42 for Nektar++ by   doxygen 1.8.9.1