Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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_declareAsNewField
 
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_declareAsNewField(false),
72  m_writeBndFld(false),
73  m_fldToBnd(false),
74  m_addNormals(false),
75  m_setUpEquiSpacedFields(false),
76  m_fieldPts(LibUtilities::NullPtsField){}
Nektar::Utilities::Field::m_fieldPts
LibUtilities::PtsFieldSharedPtr m_fieldPts
Definition: Field.hpp:110
Nektar::Utilities::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
Definition: Field.hpp:91
Nektar::LibUtilities::NullPtsField
static PtsFieldSharedPtr NullPtsField
Definition: PtsField.h:264
Nektar::Utilities::Field::m_declareExpansionAsContField
bool m_declareExpansionAsContField
Definition: Field.hpp:90
Nektar::Utilities::Field::~Field ( )
inline

Definition at line 78 of file Field.hpp.

79  {
80  if (m_comm)
81  {
82  m_comm->Finalise();
83  }
84  }
Nektar::Utilities::Field::m_comm
LibUtilities::CommSharedPtr m_comm
Definition: Field.hpp:96

Member Function Documentation

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

Definition at line 403 of file Field.hpp.

References ASSERTL0.

406  {
407  if (m_declareAsNewField)
408  {
409  NewField = true;
410  var = m_session->GetVariables()[0];
411  }
412  MultiRegions::ExpListSharedPtr tmp;
413  switch (m_graph->GetMeshDimension())
414  {
415  case 1:
416  {
417  if (NumHomogeneousDir == 1)
418  {
419  ASSERTL0( !(m_declareExpansionAsContField ||
420  m_declareExpansionAsDisContField),
421  "ContField2DHomogeneous1D or "
422  "DisContField2DHomogenenous1D has not been "
423  "implemented");
424 
425  MultiRegions::ExpList2DHomogeneous1DSharedPtr tmp2 =
426  boost::dynamic_pointer_cast<MultiRegions::
427  ExpList2DHomogeneous1D>(m_exp[0]);
428 
429  tmp = MemoryManager<MultiRegions::
430  ExpList2DHomogeneous1D>::
431  AllocateSharedPtr(*tmp2);
432 
433  }
434  else if (NumHomogeneousDir == 2)
435  {
436  if(m_declareExpansionAsContField)
437  {
438  MultiRegions::ContField3DHomogeneous2DSharedPtr tmp2 =
439  boost::dynamic_pointer_cast<MultiRegions::
440  ContField3DHomogeneous2D>(m_exp[0]);
441 
442  tmp = MemoryManager<MultiRegions::
443  ContField3DHomogeneous2D>::
444  AllocateSharedPtr(*tmp2);
445  }
446  else if(m_declareExpansionAsDisContField)
447  {
448  MultiRegions::DisContField3DHomogeneous2DSharedPtr tmp2 =
449  boost::dynamic_pointer_cast<MultiRegions::
450  DisContField3DHomogeneous2D>(m_exp[0]);
451 
452  tmp = MemoryManager<MultiRegions::
453  DisContField3DHomogeneous2D>::
454  AllocateSharedPtr(*tmp2);
455  }
456  else
457  {
458  MultiRegions::ExpList3DHomogeneous2DSharedPtr tmp2 =
459  boost::dynamic_pointer_cast<MultiRegions::
460  ExpList3DHomogeneous2D>(m_exp[0]);
461 
462  tmp = MemoryManager<MultiRegions::
463  ExpList3DHomogeneous2D>::
464  AllocateSharedPtr(*tmp2);
465  }
466 
467 
468  }
469  else
470  {
471  if(m_declareExpansionAsContField)
472  {
473  MultiRegions::ContField1DSharedPtr tmp2 =
474  boost::dynamic_pointer_cast<MultiRegions::
475  ContField1D>(m_exp[0]);
476 
477  tmp = MemoryManager<MultiRegions::ContField1D>::
478  AllocateSharedPtr(m_session,m_graph,var);
479  }
480  else if(m_declareExpansionAsDisContField)
481  {
482  MultiRegions::DisContField1DSharedPtr tmp2 =
483  boost::dynamic_pointer_cast<MultiRegions::
484  DisContField1D>(m_exp[0]);
485 
486  tmp = MemoryManager<MultiRegions::DisContField1D>::
487  AllocateSharedPtr(m_session,m_graph,var);
488  }
489  else
490  {
491  MultiRegions::ExpList1DSharedPtr tmp2 =
492  boost::dynamic_pointer_cast<MultiRegions::
493  ExpList1D>(m_exp[0]);
494 
495  tmp = MemoryManager<MultiRegions::ExpList1D>::
496  AllocateSharedPtr(*tmp2);
497  }
498 
499  }
500  }
501  break;
502  case 2:
503  {
504  if (NumHomogeneousDir == 1)
505  {
506  if(m_declareExpansionAsContField)
507  {
508  if(NewField)
509  {
510  bool dealiasing = false;
511 
512  tmp = MemoryManager<MultiRegions::
513  ContField3DHomogeneous1D>::AllocateSharedPtr(
514  m_session,
515  m_exp[0]->GetHomogeneousBasis()
516  ->GetBasisKey(),
517  m_exp[0]->GetHomoLen(),
518  m_useFFT, dealiasing, m_graph, var);
519  }
520  else
521  {
522  MultiRegions::ContField3DHomogeneous1DSharedPtr tmp2 =
523  boost::dynamic_pointer_cast<MultiRegions::
524  ContField3DHomogeneous1D>(m_exp[0]);
525 
526  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
527  tmp = MemoryManager<MultiRegions::
528  ContField3DHomogeneous1D>::
529  AllocateSharedPtr(*tmp2);
530  }
531  }
532  else if(m_declareExpansionAsDisContField)
533  {
534  if(NewField)
535  {
536  bool dealiasing = false;
537 
538  tmp = MemoryManager<MultiRegions::
539  DisContField3DHomogeneous1D>::AllocateSharedPtr(
540  m_session,
541  m_exp[0]->GetHomogeneousBasis()
542  ->GetBasisKey(),
543  m_exp[0]->GetHomoLen(),
544  m_useFFT, dealiasing, m_graph,var);
545  }
546  else
547  {
548  MultiRegions::DisContField3DHomogeneous1DSharedPtr tmp2 =
549  boost::dynamic_pointer_cast<MultiRegions::
550  DisContField3DHomogeneous1D>(m_exp[0]);
551  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
552 
553  tmp = MemoryManager<MultiRegions::
554  DisContField3DHomogeneous1D>::
555  AllocateSharedPtr(*tmp2);
556  }
557  }
558  else
559  {
560  if(NewField)
561  {
562  bool dealiasing = false;
563 
564  tmp = MemoryManager<MultiRegions::
565  ExpList3DHomogeneous1D>::AllocateSharedPtr(
566  m_session,
567  m_exp[0]->GetHomogeneousBasis()
568  ->GetBasisKey(),
569  m_exp[0]->GetHomoLen(),
570  m_useFFT, dealiasing, m_graph);
571  }
572  else
573  {
574  MultiRegions::ExpList3DHomogeneous1DSharedPtr tmp2 =
575  boost::dynamic_pointer_cast<MultiRegions::
576  ExpList3DHomogeneous1D>(m_exp[0]);
577  ASSERTL0(tmp2,"Failed to type cast m_exp[0]");
578 
579  tmp = MemoryManager<MultiRegions::
580  ExpList3DHomogeneous1D>::
581  AllocateSharedPtr(*tmp2);
582  }
583  }
584 
585  }
586  else
587  {
588  if(m_declareExpansionAsContField)
589  {
590  if(NewField)
591  {
592  tmp = MemoryManager<MultiRegions::ContField2D>::
593  AllocateSharedPtr(m_session,m_graph,var);
594  }
595  else // call copy constructor
596  {
597 
598  MultiRegions::ContField2DSharedPtr tmp2 =
599  boost::dynamic_pointer_cast<MultiRegions::
600  ContField2D>(m_exp[0]);
601 
602  tmp = MemoryManager<MultiRegions::ContField2D>::
603  AllocateSharedPtr(*tmp2,m_graph,var);
604  }
605  }
606  else if(m_declareExpansionAsDisContField)
607  {
608  if(NewField)
609  {
610  tmp = MemoryManager<MultiRegions::DisContField2D>::
611  AllocateSharedPtr(m_session,m_graph,var);
612  }
613  else // call copy constructor
614  {
615  MultiRegions::DisContField2DSharedPtr tmp2 =
616  boost::dynamic_pointer_cast<MultiRegions::
617  DisContField2D>(m_exp[0]);
618 
619  tmp = MemoryManager<MultiRegions::DisContField2D>::
620  AllocateSharedPtr(*tmp2,m_graph,var);
621  }
622  }
623  else
624  {
625  MultiRegions::ExpList2DSharedPtr tmp2 =
626  boost::dynamic_pointer_cast<MultiRegions::
627  ExpList2D>(m_exp[0]);
628 
629  tmp = MemoryManager<MultiRegions::ExpList2D>::
630  AllocateSharedPtr(*tmp2);
631  }
632  }
633  }
634  break;
635  case 3:
636  {
637  if(m_declareExpansionAsContField)
638  {
639  if(NewField)
640  {
641  tmp = MemoryManager<MultiRegions::ContField3D>::
642  AllocateSharedPtr(m_session,m_graph,var);
643 
644  }
645  else
646  {
647  MultiRegions::ContField3DSharedPtr tmp2 =
648  boost::dynamic_pointer_cast<MultiRegions::
649  ContField3D>(m_exp[0]);
650 
651  tmp = MemoryManager<MultiRegions::ContField3D>::
652  AllocateSharedPtr(*tmp2,m_graph,var);
653 
654  m_locToGlobalMap = tmp2->GetLocalToGlobalMap();
655  }
656  }
657  else if(m_declareExpansionAsDisContField)
658  {
659  if(NewField)
660  {
661  tmp = MemoryManager<MultiRegions::DisContField3D>::
662  AllocateSharedPtr(m_session,m_graph,var);
663  }
664  else
665  {
666  MultiRegions::DisContField3DSharedPtr tmp2 =
667  boost::dynamic_pointer_cast<MultiRegions::
668  DisContField3D>(m_exp[0]);
669 
670  tmp = MemoryManager<MultiRegions::DisContField3D>::
671  AllocateSharedPtr(*tmp2,m_graph,var);
672  }
673  }
674  else
675  {
676  MultiRegions::ExpList3DSharedPtr tmp2 =
677  boost::dynamic_pointer_cast<MultiRegions::
678  ExpList3D>(m_exp[0]);
679 
680  tmp = MemoryManager<MultiRegions::ExpList3D>::
681  AllocateSharedPtr(*tmp2);
682  }
683  }
684  break;
685  default:
686  ASSERTL0(false, "Expansion dimension not recognised");
687  break;
688  }
689 
690  return tmp;
691  }
Nektar::Utilities::Field::m_exp
vector< MultiRegions::ExpListSharedPtr > m_exp
Definition: Field.hpp:88
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::MultiRegions::ContField1DSharedPtr
boost::shared_ptr< ContField1D > ContField1DSharedPtr
Definition: ContField1D.h:237
Nektar::MultiRegions::ContField3DHomogeneous1DSharedPtr
boost::shared_ptr< ContField3DHomogeneous1D > ContField3DHomogeneous1DSharedPtr
Definition: ContField3DHomogeneous1D.h:98
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:112
Nektar::MultiRegions::DisContField3DHomogeneous1DSharedPtr
boost::shared_ptr< DisContField3DHomogeneous1D > DisContField3DHomogeneous1DSharedPtr
Definition: DisContField3DHomogeneous1D.h:297
Nektar::MultiRegions::ContField2DSharedPtr
boost::shared_ptr< ContField2D > ContField2DSharedPtr
Definition: ContField2D.h:293
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:154
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:98
Nektar::MultiRegions::ExpList1DSharedPtr
boost::shared_ptr< ExpList1D > ExpList1DSharedPtr
Shared pointer to an ExpList1D object.
Definition: ExpList1D.h:50
Nektar::Utilities::Field::m_declareExpansionAsDisContField
bool m_declareExpansionAsDisContField
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:298
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:98
Nektar::MultiRegions::DisContField1DSharedPtr
boost::shared_ptr< DisContField1D > DisContField1DSharedPtr
Definition: DisContField1D.h:275
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:266
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:114
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:90
Nektar::Utilities::Field::m_session
LibUtilities::SessionReaderSharedPtr m_session
Definition: Field.hpp:97
Nektar::MultiRegions::ContField3DSharedPtr
boost::shared_ptr< ContField3D > ContField3DSharedPtr
Definition: ContField3D.h:191
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 116 of file Field.hpp.

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

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

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

Definition at line 104 of file Field.hpp.

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

Definition at line 96 of file Field.hpp.

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

Definition at line 87 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareAsNewField

Definition at line 92 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsContField

Definition at line 90 of file Field.hpp.

bool Nektar::Utilities::Field::m_declareExpansionAsDisContField

Definition at line 91 of file Field.hpp.

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

Definition at line 88 of file Field.hpp.

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

Definition at line 86 of file Field.hpp.

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

Definition at line 114 of file Field.hpp.

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

Definition at line 110 of file Field.hpp.

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

Definition at line 99 of file Field.hpp.

bool Nektar::Utilities::Field::m_fldToBnd

Definition at line 105 of file Field.hpp.

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

Definition at line 98 of file Field.hpp.

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

Definition at line 101 of file Field.hpp.

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

Definition at line 112 of file Field.hpp.

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

Definition at line 100 of file Field.hpp.

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

Definition at line 97 of file Field.hpp.

bool Nektar::Utilities::Field::m_setUpEquiSpacedFields

Definition at line 108 of file Field.hpp.

bool Nektar::Utilities::Field::m_useFFT

Definition at line 94 of file Field.hpp.

bool Nektar::Utilities::Field::m_verbose

Definition at line 85 of file Field.hpp.

bool Nektar::Utilities::Field::m_writeBndFld

Definition at line 103 of file Field.hpp.

Generated on Wed Mar 23 2016 20:14:39 for Nektar++ by   doxygen 1.8.8