Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
EquationSystem.h
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File EquationSystem.h
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: Base class for individual solvers.
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
36 #ifndef NEKTAR_SOLVERUTILS_EQUATIONSYSTEM_H
37 #define NEKTAR_SOLVERUTILS_EQUATIONSYSTEM_H
38 
39 #include <LibUtilities/Communication/Comm.h>
40 #include <LibUtilities/BasicUtils/SessionReader.h>
41 #include <LibUtilities/BasicUtils/NekFactory.hpp>
42 #include <LibUtilities/BasicUtils/SharedArray.hpp>
43 #include <LibUtilities/BasicUtils/FileSystem.h>
44 #include <LibUtilities/BasicUtils/FieldIO.h>
45 #include <MultiRegions/ExpList.h>
46 #include <SolverUtils/SolverUtilsDeclspec.h>
47 #include <SolverUtils/Core/Misc.h>
48 
49 namespace Nektar
50 {
51  namespace SolverUtils
52  {
53  class EquationSystem;
54 
55  /// A shared pointer to an EquationSystem object
56  typedef boost::shared_ptr<EquationSystem> EquationSystemSharedPtr;
57  /// Datatype of the NekFactory used to instantiate classes derived from
58  /// the EquationSystem class.
59  typedef LibUtilities::NekFactory<
60  std::string, EquationSystem,
61  const LibUtilities::SessionReaderSharedPtr&
62  > EquationSystemFactory;
63  SOLVER_UTILS_EXPORT EquationSystemFactory& GetEquationSystemFactory();
64 
65  /// A base class for describing how to solve specific equations.
66  class EquationSystem
67  {
68  public:
69  /// Destructor
70  SOLVER_UTILS_EXPORT virtual ~EquationSystem();
71 
72  // Set up trace normals if required
73  SOLVER_UTILS_EXPORT void SetUpTraceNormals(void);
74 
75  /// Initialises the members of this object.
76  SOLVER_UTILS_EXPORT inline void InitObject();
77 
78  /// Perform any initialisation necessary before solving the problem.
79  SOLVER_UTILS_EXPORT inline void DoInitialise();
80 
81  /// Solve the problem.
82  SOLVER_UTILS_EXPORT inline void DoSolve();
83 
84  /// Transform from coefficient to physical space.
85  SOLVER_UTILS_EXPORT inline void TransCoeffToPhys();
86 
87  /// Transform from physical to coefficient space.
88  SOLVER_UTILS_EXPORT inline void TransPhysToCoeff();
89 
90  /// Perform output operations after solve.
91  SOLVER_UTILS_EXPORT inline void Output();
92 
93  /// Linf error computation
94  SOLVER_UTILS_EXPORT inline NekDouble LinfError(unsigned int field, const Array<OneD,NekDouble> &exactsoln = NullNekDouble1DArray);
95 
96  /// Get Session name
97  SOLVER_UTILS_EXPORT std::string GetSessionName()
98  {
99  return m_sessionName;
100  }
101 
102 
103  /// Reset Session name
104  SOLVER_UTILS_EXPORT void ResetSessionName(std::string newname)
105  {
106  m_sessionName = newname;
107  }
108 
109  /// Get Session name
110  SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession()
111  {
112  return m_session;
113  }
114 
115  /// Get pressure field if available
116  SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure();
117 
118  /// Print a summary of parameters and solver characteristics.
119  SOLVER_UTILS_EXPORT inline void PrintSummary(std::ostream &out);
120 
121  /// Set parameter m_lambda
122  SOLVER_UTILS_EXPORT inline void SetLambda(NekDouble lambda);
123 
124  /// Evaluates a function as specified in the session file.
125  SOLVER_UTILS_EXPORT void EvaluateFunction(
126  Array<OneD, Array<OneD, NekDouble> >& pArray,
127  std::string pFunctionName,
128  const NekDouble pTime = 0.0,
129  const int domain = 0);
130 
131  /// Populate given fields with the function from session.
132  SOLVER_UTILS_EXPORT void EvaluateFunction(
133  std::vector<std::string> pFieldNames,
134  Array<OneD, Array<OneD, NekDouble> > &pFields,
135  const std::string& pName,
136  const int domain = 0);
137 
138  /// Populate given fields with the function from session.
139  SOLVER_UTILS_EXPORT void EvaluateFunction(
140  std::vector<std::string> pFieldNames,
141  Array<OneD, MultiRegions::ExpListSharedPtr> &pFields,
142  const std::string& pName,
143  const int domain = 0);
144 
145  // Populate an array with a function variable from session.
146  SOLVER_UTILS_EXPORT void EvaluateFunction(
147  std::string pFieldName,
148  Array<OneD, NekDouble>& pArray,
149  const std::string& pFunctionName,
150  const NekDouble& pTime = 0.0,
151  const int domain = 0);
152 
153  // Describe a function.
154  SOLVER_UTILS_EXPORT std::string DescribeFunction(
155  std::string pFieldName,
156  const std::string &pFunctionName,
157  const int domain);
158 
159  /// Perform initialisation of the base flow.
160  SOLVER_UTILS_EXPORT void InitialiseBaseFlow(
161  Array<OneD, Array<OneD, NekDouble> > &base);
162 
163  /// Initialise the data in the dependent fields.
164  SOLVER_UTILS_EXPORT inline void SetInitialConditions(
165  NekDouble initialtime = 0.0,
166  bool dumpInitialConditions = true,
167  const int domain = 0);
168 
169  /// Evaluates an exact solution
170  SOLVER_UTILS_EXPORT inline void EvaluateExactSolution(
171  int field,
172  Array<OneD, NekDouble> &outfield,
173  const NekDouble time);
174 
175  /// Compute the L2 error between fields and a given exact
176  /// solution.
177  SOLVER_UTILS_EXPORT NekDouble L2Error(
178  unsigned int field,
179  const Array<OneD,NekDouble> &exactsoln,
180  bool Normalised = false);
181 
182  /// Compute the L2 error of the fields
183  SOLVER_UTILS_EXPORT inline NekDouble L2Error(
184  unsigned int field,
185  bool Normalised = false)
186  {
187  return L2Error(field,NullNekDouble1DArray,Normalised);
188  }
189 
190  /// Compute error (L2 and L_inf) over an larger set of quadrature
191  /// points return [L2 Linf]
192  SOLVER_UTILS_EXPORT Array<OneD,NekDouble> ErrorExtraPoints(
193  unsigned int field);
194 
195  /// Compute the inner product \f$ (\nabla \phi \cdot F) \f$.
196  SOLVER_UTILS_EXPORT void WeakAdvectionGreensDivergenceForm(
197  const Array<OneD, Array<OneD, NekDouble> > &F,
198  Array<OneD, NekDouble> &outarray);
199 
200  /// Compute the inner product \f$ (\phi, \nabla \cdot F) \f$.
201  SOLVER_UTILS_EXPORT void WeakAdvectionDivergenceForm(
202  const Array<OneD, Array<OneD, NekDouble> > &F,
203  Array<OneD, NekDouble> &outarray);
204 
205  /// Compute the inner product \f$ (\phi, V\cdot \nabla u) \f$.
206  SOLVER_UTILS_EXPORT void WeakAdvectionNonConservativeForm(
207  const Array<OneD, Array<OneD, NekDouble> > &V,
208  const Array<OneD, const NekDouble> &u,
209  Array<OneD, NekDouble> &outarray,
210  bool UseContCoeffs = false);
211 
212  /// Compute the non-conservative advection \f$ (V \cdot \nabla u)
213  /// \f$.
214  SOLVER_UTILS_EXPORT void AdvectionNonConservativeForm(
215  const Array<OneD, Array<OneD, NekDouble> > &V,
216  const Array<OneD, const NekDouble> &u,
217  Array<OneD, NekDouble> &outarray,
218  Array<OneD, NekDouble> &wk = NullNekDouble1DArray);
219 
220  /// Calculate the weak discontinuous Galerkin advection.
221  SOLVER_UTILS_EXPORT void WeakDGAdvection(
222  const Array<OneD, Array<OneD, NekDouble> >& InField,
223  Array<OneD, Array<OneD, NekDouble> >& OutField,
224  bool NumericalFluxIncludesNormal = true,
225  bool InFieldIsInPhysSpace = false,
226  int nvariables = 0);
227 
228  /// Calculate weak DG Diffusion in the LDG form.
229  SOLVER_UTILS_EXPORT void WeakDGDiffusion(
230  const Array<OneD, Array<OneD, NekDouble> >& InField,
231  Array<OneD, Array<OneD, NekDouble> >& OutField,
232  bool NumericalFluxIncludesNormal = true,
233  bool InFieldIsInPhysSpace = false);
234 
235  /// Write checkpoint file of #m_fields.
236  SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n);
237 
238  /// Write checkpoint file of custom data fields.
239  SOLVER_UTILS_EXPORT void Checkpoint_Output(
240  const int n,
241  MultiRegions::ExpListSharedPtr &field,
242  std::vector<Array<OneD, NekDouble> > &fieldcoeffs,
243  std::vector<std::string> &variables);
244 
245  /// Write field data to the given filename.
246  SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname);
247 
248  /// Write input fields to the given filename.
249  SOLVER_UTILS_EXPORT void WriteFld(
250  const std::string &outname,
251  MultiRegions::ExpListSharedPtr &field,
252  std::vector<Array<OneD, NekDouble> > &fieldcoeffs,
253  std::vector<std::string> &variables);
254 
255  /// Input field data from the given file.
256  SOLVER_UTILS_EXPORT void ImportFld(
257  const std::string &infile,
258  Array<OneD, MultiRegions::ExpListSharedPtr> &pFields);
259 
260  /// Input field data from the given file to multiple domains
261  SOLVER_UTILS_EXPORT void ImportFldToMultiDomains(
262  const std::string &infile,
263  Array<OneD, MultiRegions::ExpListSharedPtr> &pFields,
264  const int ndomains);
265 
266  /// Output a field.
267  /// Input field data into array from the given file.
268  SOLVER_UTILS_EXPORT void ImportFld(
269  const std::string &infile,
270  std::vector<std::string> &fieldStr,
271  Array<OneD, Array<OneD, NekDouble> > &coeffs);
272 
273  /// Output a field.
274  /// Input field data into ExpList from the given file.
275  SOLVER_UTILS_EXPORT void ImportFld(
276  const std::string &infile,
277  MultiRegions::ExpListSharedPtr &pField,
278  std::string &pFieldName);
279 
280  /// Builds map of which element holds each history point.
281  SOLVER_UTILS_EXPORT void ScanForHistoryPoints();
282 
283  /// Probe each history point and write to file.
284  SOLVER_UTILS_EXPORT void WriteHistoryData (std::ostream &out);
285 
286  /// Write out a session summary.
287  SOLVER_UTILS_EXPORT void SessionSummary (SummaryList& vSummary);
288 
289  SOLVER_UTILS_EXPORT inline Array<
290  OneD, MultiRegions::ExpListSharedPtr> &UpdateFields();
291 
292 
293  /// Get hold of FieldInfoMap so it can be updated
294  SOLVER_UTILS_EXPORT inline LibUtilities::FieldMetaDataMap
295  &UpdateFieldMetaDataMap();
296 
297  /// Return final time
298  SOLVER_UTILS_EXPORT inline NekDouble GetFinalTime();
299 
300  SOLVER_UTILS_EXPORT inline int GetNcoeffs();
301 
302  SOLVER_UTILS_EXPORT inline int GetNcoeffs(const int eid);
303 
304  SOLVER_UTILS_EXPORT inline int GetNumExpModes();
305 
306  SOLVER_UTILS_EXPORT inline const Array<OneD,int>
307  GetNumExpModesPerExp();
308 
309  SOLVER_UTILS_EXPORT inline int GetNvariables();
310 
311  SOLVER_UTILS_EXPORT inline const std::string
312  GetVariable(unsigned int i);
313 
314  SOLVER_UTILS_EXPORT inline int GetTraceTotPoints();
315 
316  SOLVER_UTILS_EXPORT inline int GetTraceNpoints();
317 
318  SOLVER_UTILS_EXPORT inline int GetExpSize();
319 
320  SOLVER_UTILS_EXPORT inline int GetPhys_Offset(int n);
321 
322  SOLVER_UTILS_EXPORT inline int GetCoeff_Offset(int n);
323 
324  SOLVER_UTILS_EXPORT inline int GetTotPoints();
325 
326  SOLVER_UTILS_EXPORT inline int GetTotPoints(int n);
327 
328  SOLVER_UTILS_EXPORT inline int GetNpoints();
329 
330  SOLVER_UTILS_EXPORT inline int GetNumElmVelocity();
331 
332  SOLVER_UTILS_EXPORT inline int GetSteps();
333 
334  SOLVER_UTILS_EXPORT inline NekDouble GetTimeStep();
335 
336  SOLVER_UTILS_EXPORT inline void CopyFromPhysField(const int i,
337  Array<OneD, NekDouble> &output);
338 
339  SOLVER_UTILS_EXPORT inline void CopyToPhysField(const int i,
340  Array<OneD, NekDouble> &output);
341 
342  SOLVER_UTILS_EXPORT inline void SetStepsToOne();
343 
344  SOLVER_UTILS_EXPORT void ZeroPhysFields();
345 
346  SOLVER_UTILS_EXPORT void FwdTransFields();
347 
348  SOLVER_UTILS_EXPORT inline void GetFluxVector(
349  const int i,
350  Array<OneD, Array<OneD, NekDouble> >&physfield,
351  Array<OneD, Array<OneD, NekDouble> >&flux);
352 
353  SOLVER_UTILS_EXPORT inline void GetFluxVector(
354  const int i,
355  Array<OneD, Array<OneD, NekDouble> >&physfield,
356  Array<OneD, Array<OneD, NekDouble> >&fluxX,
357  Array<OneD, Array<OneD, NekDouble> > &fluxY);
358 
359  SOLVER_UTILS_EXPORT inline void GetFluxVector(
360  const int i,
361  const int j,
362  Array<OneD, Array<OneD, NekDouble> > &physfield,
363  Array<OneD, Array<OneD, NekDouble> > &flux);
364 
365  SOLVER_UTILS_EXPORT inline void NumericalFlux(
366  Array<OneD, Array<OneD, NekDouble> > &physfield,
367  Array<OneD, Array<OneD, NekDouble> > &numflux);
368 
369  SOLVER_UTILS_EXPORT inline void NumericalFlux(
370  Array<OneD, Array<OneD, NekDouble> > &physfield,
371  Array<OneD, Array<OneD, NekDouble> > &numfluxX,
372  Array<OneD, Array<OneD, NekDouble> > &numfluxY);
373 
374  SOLVER_UTILS_EXPORT inline void NumFluxforScalar(
375  const Array<OneD, Array<OneD, NekDouble> > &ufield,
376  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &uflux);
377 
378  SOLVER_UTILS_EXPORT inline void NumFluxforVector(
379  const Array<OneD, Array<OneD, NekDouble> > &ufield,
380  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &qfield,
381  Array<OneD, Array<OneD, NekDouble> > &qflux);
382 
383  SOLVER_UTILS_EXPORT inline void SetModifiedBasis(
384  const bool modbasis);
385 
386  /// Perform a case-insensitive string comparison.
387  SOLVER_UTILS_EXPORT int NoCaseStringCompare(
388  const string & s1, const string& s2) ;
389 
390  protected:
391  /// Communicator
392  LibUtilities::CommSharedPtr m_comm;
393  /// The session reader
394  LibUtilities::SessionReaderSharedPtr m_session;
395  /// Field input/output
396  LibUtilities::FieldIOSharedPtr m_fld;
397  /// Array holding all dependent variables.
398  Array<OneD, MultiRegions::ExpListSharedPtr> m_fields;
399  /// Base fields.
400  Array<OneD, MultiRegions::ExpListSharedPtr> m_base;
401  /// Array holding all dependent variables.
402  Array<OneD, MultiRegions::ExpListSharedPtr> m_derivedfields;
403  /// Pointer to boundary conditions object.
404  SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions;
405  /// Pointer to graph defining mesh.
406  SpatialDomains::MeshGraphSharedPtr m_graph;
407  /// Filename.
408  std::string m_filename;
409  /// Name of the session.
410  std::string m_sessionName;
411  /// Current time of simulation.
412  NekDouble m_time;
413  /// Finish time of the simulation.
414  NekDouble m_fintime;
415  /// Time step size
416  NekDouble m_timestep;
417  /// Lambda constant in real system if one required.
418  NekDouble m_lambda;
419  /// Time between checkpoints.
420  NekDouble m_checktime;
421  /// Number of steps to take.
422  int m_steps;
423  /// Number of steps between checkpoints.
424  int m_checksteps;
425  /// Spatial dimension (>= expansion dim).
426  int m_spacedim;
427  /// Expansion dimension.
428  int m_expdim;
429  /// Flag to determine if single homogeneous mode is used.
430  bool m_SingleMode;
431  /// Flag to determine if half homogeneous mode is used.
432  bool m_HalfMode;
433  /// Flag to determine if use multiple homogenenous modes are used.
434  bool m_MultipleModes;
435  /// Flag to determine if FFT is used for homogeneous transform.
436  bool m_useFFT;
437  /**
438  * \brief Flag to determine if dealiasing is used for
439  * homogeneous simulations.
440  */
441  bool m_homogen_dealiasing;
442  /**
443  * \brief Flag to determine if dealisising is usde for the
444  * Spectral/hp element discretisation.
445  */
446  bool m_specHP_dealiasing;
447  /// Type of projection; e.g continuous or discontinuous.
448  enum MultiRegions::ProjectionType m_projectionType;
449  /// Array holding trace normals for DG simulations in the forwards direction.
450  Array<OneD, Array<OneD, NekDouble> > m_traceNormals;
451  /// 1 x nvariable x nq
452  Array<OneD, Array<OneD, Array<OneD,NekDouble> > > m_gradtan;
453  /// 2 x m_spacedim x nq
454  Array<OneD, Array<OneD, Array<OneD,NekDouble> > > m_tanbasis;
455  /// Flag to indicate if the fields should be checked for singularity.
456  Array<OneD, bool> m_checkIfSystemSingular;
457  /// Map to identify relevant solver info to dump in output fields
458  LibUtilities::FieldMetaDataMap m_fieldMetaDataMap;
459 
460  /// Number of Quadrature points used to work out the error
461  int m_NumQuadPointsError;
462 
463  /// Parameter for homogeneous expansions
464  enum HomogeneousType
465  {
466  eHomogeneous1D,
467  eHomogeneous2D,
468  eHomogeneous3D,
469  eNotHomogeneous
470  };
471 
472 
473 
474  enum HomogeneousType m_HomogeneousType;
475 
476  NekDouble m_LhomX; ///< physical length in X direction (if homogeneous)
477  NekDouble m_LhomY; ///< physical length in Y direction (if homogeneous)
478  NekDouble m_LhomZ; ///< physical length in Z direction (if homogeneous)
479 
480  int m_npointsX; ///< number of points in X direction (if homogeneous)
481  int m_npointsY; ///< number of points in Y direction (if homogeneous)
482  int m_npointsZ; ///< number of points in Z direction (if homogeneous)
483 
484  int m_HomoDirec; ///< number of homogenous directions
485 
486  int m_NumMode; ///< Mode to use in case of single mode analysis
487 
488 
489  /// Initialises EquationSystem class members.
490  SOLVER_UTILS_EXPORT EquationSystem( const LibUtilities::SessionReaderSharedPtr& pSession);
491 
492  // Here for consistency purposes with old version
493  int nocase_cmp(const string & s1, const string& s2)
494  {
495  return NoCaseStringCompare(s1,s2);
496  }
497 
498  SOLVER_UTILS_EXPORT virtual void v_InitObject();
499 
500  /// Evaluates the boundary conditions at the given time.
501  SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time);
502 
503  /// Virtual function for initialisation implementation.
504  SOLVER_UTILS_EXPORT virtual void v_DoInitialise();
505 
506  /// Virtual function for solve implementation.
507  SOLVER_UTILS_EXPORT virtual void v_DoSolve();
508 
509  /// Virtual function for the L_inf error computation between fields and a given exact solution.
510  SOLVER_UTILS_EXPORT virtual NekDouble v_LinfError(
511  unsigned int field,
512  const Array<OneD, NekDouble> &exactsoln = NullNekDouble1DArray);
513 
514  /// Virtual function for the L_2 error computation between fields and a given exact solution.
515  SOLVER_UTILS_EXPORT virtual NekDouble v_L2Error(
516  unsigned int field,
517  const Array<OneD, NekDouble> &exactsoln = NullNekDouble1DArray,
518  bool Normalised = false);
519 
520  /// Virtual function for transformation to physical space.
521  SOLVER_UTILS_EXPORT virtual void v_TransCoeffToPhys();
522 
523  /// Virtual function for transformation to coefficient space.
524  SOLVER_UTILS_EXPORT virtual void v_TransPhysToCoeff();
525 
526  /// Virtual function for generating summary information.
527  SOLVER_UTILS_EXPORT virtual void v_GenerateSummary(SummaryList& l);
528 
529  SOLVER_UTILS_EXPORT virtual void v_SetInitialConditions(
530  NekDouble initialtime = 0.0,
531  bool dumpInitialConditions = true,
532  const int domain = 0);
533 
534  SOLVER_UTILS_EXPORT virtual void v_EvaluateExactSolution(
535  unsigned int field,
536  Array<OneD, NekDouble> &outfield,
537  const NekDouble time);
538 
539  //Initialise m_base in order to store the base flow from a file
540  SOLVER_UTILS_EXPORT void SetUpBaseFields(SpatialDomains::MeshGraphSharedPtr &mesh);
541 
542  // Fill m_base with the values stored in a fld file
543  SOLVER_UTILS_EXPORT void ImportFldBase(
544  std::string pInfile,
545  SpatialDomains::MeshGraphSharedPtr pGraph);
546 
547  // Ouptut field information
548  SOLVER_UTILS_EXPORT virtual void v_Output(void);
549 
550  // Get pressure field if available
551  SOLVER_UTILS_EXPORT virtual MultiRegions::ExpListSharedPtr v_GetPressure(void);
552 
553  SOLVER_UTILS_EXPORT virtual void v_ExtraFldOutput(
554  std::vector<Array<OneD, NekDouble> > &fieldcoeffs,
555  std::vector<std::string> &variables);
556 
557  private:
558 
559  SOLVER_UTILS_EXPORT virtual Array<OneD, bool> v_GetSystemSingularChecks();
560  SOLVER_UTILS_EXPORT virtual void v_GetFluxVector(
561  const int i, Array<OneD,
562  Array<OneD, NekDouble> >&physfield,
563  Array<OneD, Array<OneD, NekDouble> >&flux);
564 
565  SOLVER_UTILS_EXPORT virtual void v_GetFluxVector(
566  const int i, const int j,
567  Array<OneD, Array<OneD, NekDouble> >&physfield,
568  Array<OneD, Array<OneD, NekDouble> >&flux);
569 
570  SOLVER_UTILS_EXPORT virtual void v_GetFluxVector(
571  const int i, Array<OneD,
572  Array<OneD, NekDouble> >&physfield,
573  Array<OneD, Array<OneD, NekDouble> >&fluxX,
574  Array<OneD, Array<OneD, NekDouble> > &fluxY);
575 
576  SOLVER_UTILS_EXPORT virtual void v_NumericalFlux(
577  Array<OneD, Array<OneD, NekDouble> > &physfield,
578  Array<OneD, Array<OneD, NekDouble> > &numflux);
579 
580  SOLVER_UTILS_EXPORT virtual void v_NumericalFlux(
581  Array<OneD, Array<OneD, NekDouble> > &physfield,
582  Array<OneD, Array<OneD, NekDouble> > &numfluxX,
583  Array<OneD, Array<OneD, NekDouble> > &numfluxY);
584 
585  SOLVER_UTILS_EXPORT virtual void v_NumFluxforScalar(
586  const Array<OneD, Array<OneD, NekDouble> > &ufield,
587  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &uflux);
588 
589  SOLVER_UTILS_EXPORT virtual void v_NumFluxforVector(
590  const Array<OneD, Array<OneD, NekDouble> > &ufield,
591  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &qfield,
592  Array<OneD, Array<OneD, NekDouble > > &qflux);
593  };
594 
595 
596  /**
597  * This is the second part of the two-phase initialisation process.
598  * Calls to virtual functions will correctly resolve to the derived class
599  * during this phase of the construction.
600  */
601  inline void EquationSystem::InitObject()
602  {
603  v_InitObject();
604  }
605 
606 
607  /**
608  * This allows initialisation of the solver which cannot be completed
609  * during object construction (such as setting of initial conditions).
610  *
611  * Public interface routine to virtual function implementation.
612  */
613  inline void EquationSystem::DoInitialise()
614  {
615  v_DoInitialise();
616  }
617 
618 
619  /**
620  * Performs the transformation from coefficient to physical space.
621  *
622  * Public interface routine to virtual function implementation.
623  */
624  inline void EquationSystem::TransCoeffToPhys(void)
625  {
626  v_TransCoeffToPhys();
627  }
628 
629  /**
630  * Performs the transformation from physical to coefficient space.
631  *
632  * Public interface routine to virtual function implementation.
633  */
634  inline void EquationSystem::TransPhysToCoeff(void)
635  {
636  v_TransPhysToCoeff();
637  }
638 
639 
640  /**
641  * Performs the actual solve.
642  *
643  * Public interface routine to virtual function implementation.
644  */
645  inline void EquationSystem::DoSolve(void)
646  {
647  v_DoSolve();
648  }
649 
650 
651  /**
652  * Perform output operations after solve.
653  */
654  inline void EquationSystem::Output(void)
655  {
656  v_Output();
657  }
658 
659  /**
660  * L_inf Error computation
661  * Public interface routine to virtual function implementation.
662  */
663  inline NekDouble EquationSystem::LinfError(unsigned int field, const Array<OneD,NekDouble> &exactsoln)
664  {
665  return v_LinfError(field, exactsoln);
666  }
667 
668  /**
669  * L_2 Error computation
670  * Public interface routine to virtual function implementation.
671  */
672  inline NekDouble EquationSystem::L2Error(unsigned int field, const Array<OneD,NekDouble> &exactsoln, bool Normalised)
673  {
674  return v_L2Error(field, exactsoln, Normalised);
675  }
676 
677  /**
678  * Get Pressure field if available
679  */
680  inline MultiRegions::ExpListSharedPtr EquationSystem::GetPressure(void)
681  {
682  return v_GetPressure();
683  }
684 
685  /**
686  * Prints a summary of variables and problem parameters.
687  *
688  * Public interface routine to virtual function implementation.
689  *
690  * @param out The ostream object to write to.
691  */
692  inline void EquationSystem::PrintSummary(std::ostream &out)
693  {
694  if (m_session->GetComm()->GetRank() == 0)
695  {
696  std::vector<std::pair<std::string, std::string> > vSummary;
697  v_GenerateSummary(vSummary);
698 
699  out << "=======================================================================" << endl;
700  SummaryList::const_iterator x;
701  for (x = vSummary.begin(); x != vSummary.end(); ++x)
702  {
703  out << "\t";
704  out.width(20);
705  out << x->first << ": " << x->second << endl;
706  }
707  out << "=======================================================================" << endl;
708  }
709  }
710 
711  inline void EquationSystem::SetLambda(NekDouble lambda)
712  {
713  m_lambda = lambda;
714  }
715 
716  inline void EquationSystem::SetInitialConditions(NekDouble initialtime,
717  bool dumpInitialConditions,
718  const int domain)
719  {
720  v_SetInitialConditions(initialtime,dumpInitialConditions,domain);
721  }
722 
723  /// Evaluates an exact solution
724  inline void EquationSystem::EvaluateExactSolution(int field,
725  Array<OneD, NekDouble> &outfield,
726  const NekDouble time)
727  {
728  v_EvaluateExactSolution(field, outfield, time);
729  }
730 
731  inline Array<OneD, MultiRegions::ExpListSharedPtr> &EquationSystem::UpdateFields(void)
732  {
733  return m_fields;
734  }
735 
736  /// Return final time
737  inline NekDouble EquationSystem::GetFinalTime()
738  {
739  return m_time;
740  }
741 
742  inline int EquationSystem::GetNcoeffs(void)
743  {
744  return m_fields[0]->GetNcoeffs();
745  }
746 
747  inline int EquationSystem::GetNcoeffs(const int eid)
748  {
749  return m_fields[0]->GetNcoeffs(eid);
750  }
751 
752  inline int EquationSystem::GetNumExpModes(void)
753  {
754  return m_graph->GetExpansions().begin()->second->m_basisKeyVector[0]
755  .GetNumModes();
756  }
757 
758  inline const Array<OneD,int> EquationSystem::GetNumExpModesPerExp(void)
759  {
760  return m_fields[0]->EvalBasisNumModesMaxPerExp();
761  }
762 
763  inline int EquationSystem::GetNvariables(void)
764  {
765  return m_session->GetVariables().size();
766  }
767 
768  inline const std::string EquationSystem::GetVariable(unsigned int i)
769  {
770  return m_session->GetVariable(i);
771  }
772 
773  inline int EquationSystem::GetTraceTotPoints(void)
774  {
775  return GetTraceNpoints();
776  }
777 
778  inline int EquationSystem::GetTraceNpoints(void)
779  {
780  return m_fields[0]->GetTrace()->GetNpoints();
781  }
782 
783  inline int EquationSystem::GetExpSize(void)
784  {
785  return m_fields[0]->GetExpSize();
786  }
787 
788  inline int EquationSystem::GetPhys_Offset(int n)
789  {
790  return m_fields[0]->GetPhys_Offset(n);
791  }
792 
793  inline int EquationSystem::GetCoeff_Offset(int n)
794  {
795  return m_fields[0]->GetCoeff_Offset(n);
796  }
797 
798  inline int EquationSystem::GetTotPoints(void)
799  {
800  return m_fields[0]->GetNpoints();
801  }
802 
803  inline int EquationSystem::GetTotPoints(int n)
804  {
805  return m_fields[0]->GetTotPoints(n);
806  }
807 
808  inline int EquationSystem::GetNpoints(void)
809  {
810  return m_fields[0]->GetNpoints();
811  }
812 
813  inline int EquationSystem::GetNumElmVelocity(void)
814  {
815  return (m_fields.num_elements() - 1);
816  }
817 
818  inline int EquationSystem::GetSteps(void)
819  {
820  return m_steps;
821  }
822 
823  inline NekDouble EquationSystem::GetTimeStep(void)
824  {
825  return m_timestep;
826  }
827 
828  inline void EquationSystem::SetStepsToOne(void)
829  {
830  m_steps=1;
831  }
832 
833  inline void EquationSystem::CopyFromPhysField(const int i,
834  Array<OneD, NekDouble> &output)
835  {
836  Vmath::Vcopy(output.num_elements(), m_fields[i]->GetPhys(), 1, output, 1 );
837  }
838 
839  inline void EquationSystem::CopyToPhysField(const int i,
840  Array<OneD, NekDouble> &output)
841  {
842  Vmath::Vcopy(output.num_elements(), output, 1, m_fields[i]->UpdatePhys(), 1 );
843  }
844 
845  inline void EquationSystem::GetFluxVector(const int i,
846  Array<OneD, Array<OneD, NekDouble> >&physfield,
847  Array<OneD, Array<OneD, NekDouble> >&flux)
848  {
849  v_GetFluxVector(i,physfield, flux);
850  }
851 
852  inline void EquationSystem::GetFluxVector(const int i,
853  Array<OneD, Array<OneD, NekDouble> >&physfield,
854  Array<OneD, Array<OneD, NekDouble> >&fluxX,
855  Array<OneD, Array<OneD, NekDouble> > &fluxY)
856  {
857  v_GetFluxVector(i,physfield, fluxX, fluxY);
858  }
859 
860  inline void EquationSystem::GetFluxVector(const int i, const int j,
861  Array<OneD, Array<OneD, NekDouble> > &physfield,
862  Array<OneD, Array<OneD, NekDouble> > &flux)
863  {
864  v_GetFluxVector(i,j,physfield,flux);
865  }
866 
867  inline void EquationSystem::NumericalFlux(Array<OneD, Array<OneD, NekDouble> > &physfield,
868  Array<OneD, Array<OneD, NekDouble> > &numflux)
869  {
870  v_NumericalFlux(physfield, numflux);
871  }
872 
873  inline void EquationSystem::NumericalFlux(Array<OneD, Array<OneD, NekDouble> > &physfield,
874  Array<OneD, Array<OneD, NekDouble> > &numfluxX,
875  Array<OneD, Array<OneD, NekDouble> > &numfluxY)
876  {
877  v_NumericalFlux(physfield, numfluxX, numfluxY);
878  }
879 
880  inline void EquationSystem::NumFluxforScalar(
881  const Array<OneD, Array<OneD, NekDouble> > &ufield,
882  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &uflux)
883  {
884  v_NumFluxforScalar(ufield, uflux);
885  }
886 
887  inline void EquationSystem::NumFluxforVector(
888  const Array<OneD, Array<OneD, NekDouble> > &ufield,
889  Array<OneD, Array<OneD, Array<OneD, NekDouble> > > &qfield,
890  Array<OneD, Array<OneD, NekDouble> > &qflux)
891  {
892  v_NumFluxforVector(ufield, qfield, qflux);
893  }
894  }
895 }
896 
897 #endif
Generated on Sun Mar 15 2015 00:11:31 for Nektar++ by   doxygen 1.8.1.2