Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SubSteppingExtrapolate.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File: SubSteppingExtrapolate.cpp
4 //a
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: Abstract base class for SubSteppingExtrapolate.
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
38 
39 namespace Nektar
40 {
41  /**
42  * Registers the class with the Factory.
43  */
45  "SubStepping",
47  "SubStepping");
48 
53  const Array<OneD, int> pVel,
54  const SolverUtils::AdvectionSharedPtr advObject)
55  : Extrapolate(pSession,pFields,pPressure,pVel,advObject)
56  {
57  m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
58  m_session->LoadParameter("SubStepCFL", m_cflSafetyFactor, 0.5);
59  m_session->LoadParameter("MinSubSteps", m_minsubsteps,1);
60  m_session->LoadParameter("MaxSubSteps", m_maxsubsteps,100);
61 
62  int dim = m_fields[0]->GetCoordim(0);
64 
65  int nTracePts = m_fields[0]->GetTrace()->GetNpoints();
66  for(int i = 0; i < dim; ++i)
67  {
68  m_traceNormals[i] = Array<OneD, NekDouble> (nTracePts);
69  }
70  m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
71 
72  }
73 
75  {
76  }
77 
79  {
80  ASSERTL0(false,"This method should not be called by Substepping routine");
81  }
82 
83 
85  int intMethod,
86  const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
87  {
88  int i;
89 
90  // Set to 1 for first step and it will then be increased in
91  // time advance routines
92  switch(intMethod)
93  {
96  {
97  std::string vSubStepIntScheme = "ForwardEuler";
98 
99  if(m_session->DefinesSolverInfo("SubStepIntScheme"))
100  {
101  vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
102  }
103 
105 
106  int nvel = m_velocity.num_elements();
107 
108  // Fields for linear interpolation
110  int ntotpts = m_fields[0]->GetTotPoints();
111  m_previousVelFields[0] = Array<OneD, NekDouble>(2*nvel*ntotpts);
112  for(i = 1; i < 2*nvel; ++i)
113  {
114  m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts;
115  }
116 
117  }
118  break;
120  {
121  std::string vSubStepIntScheme = "RungeKutta2_ImprovedEuler";
122 
123  if(m_session->DefinesSolverInfo("SubStepIntScheme"))
124  {
125  vSubStepIntScheme = m_session->GetSolverInfo("SubStepIntScheme");
126  }
127 
129 
130  int nvel = m_velocity.num_elements();
131 
132  // Fields for quadratic interpolation
134 
135  int ntotpts = m_fields[0]->GetTotPoints();
136  m_previousVelFields[0] = Array<OneD, NekDouble>(3*nvel*ntotpts);
137  for(i = 1; i < 3*nvel; ++i)
138  {
139  m_previousVelFields[i] = m_previousVelFields[i-1] + ntotpts;
140  }
141 
142  }
143  break;
144  default:
145  ASSERTL0(0,"Integration method not suitable: Options include BackwardEuler or BDFImplicitOrder1");
146  break;
147  }
148 
149  m_intSteps = IntegrationScheme->GetIntegrationSteps();
150 
151  // set explicit time-integration class operators
154  }
155 
156  /**
157  * Explicit Advection terms used by SubStepAdvance time integration
158  */
160  const Array<OneD, const Array<OneD, NekDouble> > &inarray,
161  Array<OneD, Array<OneD, NekDouble> > &outarray,
162  const NekDouble time)
163  {
164  int i;
165  int nVariables = inarray.num_elements();
166  int nQuadraturePts = inarray[0].num_elements();
167 
168  /// Get the number of coefficients
169  int ncoeffs = m_fields[0]->GetNcoeffs();
170 
171  /// Define an auxiliary variable to compute the RHS
172  Array<OneD, Array<OneD, NekDouble> > WeakAdv(nVariables);
173  WeakAdv[0] = Array<OneD, NekDouble> (ncoeffs*nVariables);
174  for(i = 1; i < nVariables; ++i)
175  {
176  WeakAdv[i] = WeakAdv[i-1] + ncoeffs;
177  }
178 
179  Array<OneD, Array<OneD, NekDouble> > Velfields(m_velocity.num_elements());
180  Array<OneD, int> VelIds(m_velocity.num_elements());
181 
182  Velfields[0] = Array<OneD, NekDouble> (nQuadraturePts*m_velocity.num_elements());
183 
184  for(i = 1; i < m_velocity.num_elements(); ++i)
185  {
186  Velfields[i] = Velfields[i-1] + nQuadraturePts;
187  }
188 
189  SubStepExtrapolateField(fmod(time,m_timestep), Velfields);
190 
191  m_advObject->Advect(m_velocity.num_elements(), m_fields, Velfields, inarray, outarray, time);
192 
193  for(i = 0; i < nVariables; ++i)
194  {
195  m_fields[i]->IProductWRTBase(outarray[i],WeakAdv[i]);
196  // negation requried due to sign of DoAdvection term to be consistent
197  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
198  }
199 
200  AddAdvectionPenaltyFlux(Velfields, inarray, WeakAdv);
201 
202  /// Operations to compute the RHS
203  for(i = 0; i < nVariables; ++i)
204  {
205  // Negate the RHS
206  Vmath::Neg(ncoeffs, WeakAdv[i], 1);
207 
208  /// Multiply the flux by the inverse of the mass matrix
209  m_fields[i]->MultiplyByElmtInvMass(WeakAdv[i], WeakAdv[i]);
210 
211  /// Store in outarray the physical values of the RHS
212  m_fields[i]->BwdTrans(WeakAdv[i], outarray[i]);
213  }
214  }
215 
216  /**
217  * Projection used by SubStepAdvance time integration
218  */
220  const Array<OneD, const Array<OneD, NekDouble> > &inarray,
221  Array<OneD, Array<OneD, NekDouble> > &outarray,
222  const NekDouble time)
223  {
224  ASSERTL1(inarray.num_elements() == outarray.num_elements(),"Inarray and outarray of different sizes ");
225 
226  for(int i = 0; i < inarray.num_elements(); ++i)
227  {
228  Vmath::Vcopy(inarray[i].num_elements(),inarray[i],1,outarray[i],1);
229  }
230  }
231 
232 
233  /**
234  *
235  */
237  const Array<OneD, const Array<OneD, NekDouble> > &inarray,
238  const NekDouble Aii_Dt,
239  NekDouble kinvis)
240  {
241  int nConvectiveFields =m_fields.num_elements()-1;
242  Array<OneD, Array<OneD, NekDouble> > velfields(nConvectiveFields);
243 
244  for(int i = 0; i < nConvectiveFields; ++i)
245  {
246  velfields[i] = m_fields[m_velocity[i]]->GetPhys();
247  }
248 
249  m_pressureCalls++;
250 
251  // Rotate HOPBCs storage
253 
254  // Calculate non-linear and viscous BCs at current level and
255  // put in m_pressureHBCs[0]
256  CalcNeumannPressureBCs(inarray,velfields,kinvis);
257 
258  // Extrapolate to m_pressureHBCs to n+1
260 
261  // Add (phi,Du/Dt) term to m_presureHBC
262  AddDuDt();
263 
264  // Copy m_pressureHBCs to m_PbndExp
266 
267  // Evaluate High order outflow conditiosn if required.
268  CalcOutflowBCs(inarray, kinvis);
269  }
270 
271  /**
272  *
273  */
275  {
276  int i,n;
277  int nvel = m_velocity.num_elements();
278  int npts = m_fields[0]->GetTotPoints();
279 
280  // rotate fields
281  int nblocks = m_previousVelFields.num_elements()/nvel;
283 
284  // rotate storage space
285  for(n = 0; n < nvel; ++n)
286  {
287  save = m_previousVelFields[(nblocks-1)*nvel+n];
288 
289  for(i = nblocks-1; i > 0; --i)
290  {
291  m_previousVelFields[i*nvel+n] = m_previousVelFields[(i-1)*nvel+n];
292  }
293 
294  m_previousVelFields[n] = save;
295  }
296 
297  // Put previous field
298  for(i = 0; i < nvel; ++i)
299  {
300  m_fields[m_velocity[i]]->BwdTrans(m_fields[m_velocity[i]]->GetCoeffs(),
301  m_fields[m_velocity[i]]->UpdatePhys());
302  Vmath::Vcopy(npts,m_fields[m_velocity[i]]->GetPhys(),1,
303  m_previousVelFields[i],1);
304  }
305 
306  if(nstep == 0)// initialise all levels with first field
307  {
308  for(n = 0; n < nvel; ++n)
309  {
310  for(i = 1; i < nblocks; ++i)
311  {
312  Vmath::Vcopy(npts,m_fields[m_velocity[n]]->GetPhys(),1,
313  m_previousVelFields[i*nvel+n],1);
314 
315  }
316  }
317  }
318  }
319 
320  /**
321  *
322  */
324  const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln,
325  int nstep,
326  NekDouble time)
327  {
328  int n;
329  int nsubsteps;
330 
331  NekDouble dt;
332 
333  Array<OneD, Array<OneD, NekDouble> > fields, velfields;
334 
335  static int ncalls = 1;
336  int nint = min(ncalls++, m_intSteps);
337 
338  Array<OneD, NekDouble> CFL(m_fields[0]->GetExpSize(),
340  //this needs to change
341  m_comm = m_fields[0]->GetComm()->GetRowComm();
342 
343  // Get the proper time step with CFL control
344  dt = GetSubstepTimeStep();
345 
346  nsubsteps = (m_timestep > dt)? ((int)(m_timestep/dt)+1):1;
347  nsubsteps = max(m_minsubsteps, nsubsteps);
348 
349  ASSERTL0(nsubsteps < m_maxsubsteps,"Number of substeps has exceeded maximum");
350 
351  dt = m_timestep/nsubsteps;
352 
353  if (m_infosteps && !((nstep+1)%m_infosteps) && m_comm->GetRank() == 0)
354  {
355  cout << "Sub-integrating using "<< nsubsteps
356  << " steps over Dt = " << m_timestep
357  << " (SubStep CFL=" << m_cflSafetyFactor << ")"<< endl;
358  }
359 
360  for (int m = 0; m < nint; ++m)
361  {
362  // We need to update the fields held by the m_integrationSoln
363  fields = integrationSoln->UpdateSolutionVector()[m];
364 
365  // Initialise NS solver which is set up to use a GLM method
366  // with calls to EvaluateAdvection_SetPressureBCs and
367  // SolveUnsteadyStokesSystem
369  SubIntegrationSoln = m_subStepIntegrationScheme->
370  InitializeScheme(dt, fields, time, m_subStepIntegrationOps);
371 
372  for(n = 0; n < nsubsteps; ++n)
373  {
374  fields = m_subStepIntegrationScheme->TimeIntegrate(n, dt, SubIntegrationSoln,
376  }
377 
378  // set up HBC m_acceleration field for Pressure BCs
380 
381  // Reset time integrated solution in m_integrationSoln
382  integrationSoln->SetSolVector(m,fields);
383  }
384  }
385 
386 
387  /**
388  *
389  */
391  {
392  int n_element = m_fields[0]->GetExpSize();
393 
394  const Array<OneD, int> ExpOrder=m_fields[0]->EvalBasisNumModesMaxPerExp();
395  Array<OneD, int> ExpOrderList (n_element, ExpOrder);
396 
397  const NekDouble cLambda = 0.2; // Spencer book pag. 317
398 
399  Array<OneD, NekDouble> tstep (n_element, 0.0);
400  Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
401  Array<OneD, Array<OneD, NekDouble> > velfields(m_velocity.num_elements());
402 
403  for(int i = 0; i < m_velocity.num_elements(); ++i)
404  {
405  velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
406  }
407  stdVelocity = GetMaxStdVelocity(velfields);
408 
409  for(int el = 0; el < n_element; ++el)
410  {
411  tstep[el] = m_cflSafetyFactor /
412  (stdVelocity[el] * cLambda *
413  (ExpOrder[el]-1) * (ExpOrder[el]-1));
414  }
415 
416  NekDouble TimeStep = Vmath::Vmin(n_element, tstep, 1);
417  m_comm->AllReduce(TimeStep,LibUtilities::ReduceMin);
418 
419  return TimeStep;
420  }
421 
422 
423 
424 
426  const Array<OneD, const Array<OneD, NekDouble> > &velfield,
427  const Array<OneD, const Array<OneD, NekDouble> > &physfield,
428  Array<OneD, Array<OneD, NekDouble> > &Outarray)
429  {
430  ASSERTL1(
431  physfield.num_elements() == Outarray.num_elements(),
432  "Physfield and outarray are of different dimensions");
433 
434  int i;
435 
436  /// Number of trace points
437  int nTracePts = m_fields[0]->GetTrace()->GetNpoints();
438 
439  /// Number of spatial dimensions
440  int nDimensions = m_bnd_dim;
441 
442  /// Forward state array
443  Array<OneD, NekDouble> Fwd(3*nTracePts);
444 
445  /// Backward state array
446  Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
447 
448  /// upwind numerical flux state array
449  Array<OneD, NekDouble> numflux = Bwd + nTracePts;
450 
451  /// Normal velocity array
452  Array<OneD, NekDouble> Vn (nTracePts, 0.0);
453 
454  // Extract velocity field along the trace space and multiply by trace normals
455  for(i = 0; i < nDimensions; ++i)
456  {
457  m_fields[0]->ExtractTracePhys(velfield[i], Fwd);
458  Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, Fwd, 1, Vn, 1, Vn, 1);
459  }
460 
461  for(i = 0; i < physfield.num_elements(); ++i)
462  {
463  /// Extract forwards/backwards trace spaces
464  /// Note: Needs to have correct i value to get boundary conditions
465  m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
466 
467  /// Upwind between elements
468  m_fields[0]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux);
469 
470  /// Construct difference between numflux and Fwd,Bwd
471  Vmath::Vsub(nTracePts, numflux, 1, Fwd, 1, Fwd, 1);
472  Vmath::Vsub(nTracePts, numflux, 1, Bwd, 1, Bwd, 1);
473 
474  /// Calculate the numerical fluxes multipling Fwd, Bwd and
475  /// numflux by the normal advection velocity
476  Vmath::Vmul(nTracePts, Fwd, 1, Vn, 1, Fwd, 1);
477  Vmath::Vmul(nTracePts, Bwd, 1, Vn, 1, Bwd, 1);
478 
479  m_fields[0]->AddFwdBwdTraceIntegral(Fwd,Bwd,Outarray[i]);
480  }
481  }
482 
483  /**
484  * Extrapolate field using equally time spaced field un,un-1,un-2, (at
485  * dt intervals) to time n+t at order Ord
486  */
488  NekDouble toff,
489  Array< OneD, Array<OneD, NekDouble> > &ExtVel)
490  {
491  int npts = m_fields[0]->GetTotPoints();
492  int nvel = m_velocity.num_elements();
493  int i,j;
495 
496  int ord = m_intSteps;
497 
498  // calculate Lagrange interpolants
499  Vmath::Fill(4,1.0,l,1);
500 
501  for(i = 0; i <= ord; ++i)
502  {
503  for(j = 0; j <= ord; ++j)
504  {
505  if(i != j)
506  {
507  l[i] *= (j*m_timestep+toff);
508  l[i] /= (j*m_timestep-i*m_timestep);
509  }
510  }
511  }
512 
513  for(i = 0; i < nvel; ++i)
514  {
515  Vmath::Smul(npts,l[0],m_previousVelFields[i],1,ExtVel[i],1);
516 
517  for(j = 1; j <= ord; ++j)
518  {
519  Blas::Daxpy(npts,l[j],m_previousVelFields[j*nvel+i],1,
520  ExtVel[i],1);
521  }
522  }
523  }
524 
525  /**
526  *
527  */
529  int HBCdata,
530  NekDouble kinvis,
532  Array<OneD, const NekDouble> &Advection)
533  {
534  Vmath::Smul(HBCdata,-kinvis,Q,1,Q,1);
535  }
536 
537  /**
538  *
539  */
541  {
542  int HBCPts = m_acceleration[0].num_elements();
543 
544  Array<OneD, NekDouble> accelerationTerm(HBCPts, 0.0);
545 
546  // Update velocity BF at n+1 (actually only needs doing if velocity is time dependent on HBCs)
548 
549  //Calculate acceleration term at level n based on previous steps
550  int acc_order = min(m_pressureCalls,m_intSteps);
552  m_acceleration[0], 1, accelerationTerm, 1);
553 
554  for(int i = 0; i < acc_order; i++)
555  {
556  Vmath::Svtvp(HBCPts,
557  -1*StifflyStable_Alpha_Coeffs[acc_order-1][i]/m_timestep,
558  m_acceleration[i+1], 1,
559  accelerationTerm, 1,
560  accelerationTerm, 1);
561  }
562 
563  // Subtract accleration term off m_pressureHBCs[nlevels-1]
564  int nlevels = m_pressureHBCs.num_elements();
565  Vmath::Vsub(HBCPts, m_pressureHBCs[nlevels-1],1,accelerationTerm, 1,
566  m_pressureHBCs[nlevels-1],1);
567  }
568 
570  {
571  return m_subStepIntegrationScheme->GetIntegrationMethod();
572  }
573 
574 }
575 
virtual void v_EvaluatePressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
void SubStepProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void SubStepExtrapolateField(NekDouble toff, Array< OneD, Array< OneD, NekDouble > > &ExtVel)
LibUtilities::TimeIntegrationWrapperSharedPtr m_subStepIntegrationScheme
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
void IProductNormVelocityOnHBC(const Array< OneD, const Array< OneD, NekDouble > > &Vel, Array< OneD, NekDouble > &IprodVn)
LibUtilities::SessionReaderSharedPtr m_session
Definition: Extrapolate.h:208
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: Extrapolate.h:219
BDF multi-step scheme of order 1 (implicit)
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
virtual void v_SubStepSetPressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, NekDouble Aii_Dt, NekDouble kinvis)
ExtrapolateFactory & GetExtrapolateFactory()
Definition: Extrapolate.cpp:48
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: Vmath.cpp:857
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:46
boost::shared_ptr< TimeIntegrationWrapper > TimeIntegrationWrapperSharedPtr
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:471
boost::shared_ptr< Advection > AdvectionSharedPtr
A shared pointer to an Advection object.
Definition: Advection.h:158
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:428
void RollOver(Array< OneD, Array< OneD, NekDouble > > &input)
void AddAdvectionPenaltyFlux(const Array< OneD, const Array< OneD, NekDouble > > &velfield, const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &outarray)
void CopyPressureHBCsToPbndExp(void)
void ExtrapolatePressureHBCs(void)
LibUtilities::CommSharedPtr m_comm
Definition: Extrapolate.h:210
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Definition: Extrapolate.h:212
static NekDouble StifflyStable_Gamma0_Coeffs[3]
Definition: Extrapolate.h:314
virtual void v_SubStepSaveFields(int nstep)
Array< OneD, Array< OneD, NekDouble > > m_previousVelFields
virtual void v_SubSteppingTimeIntegration(int intMethod, const LibUtilities::TimeIntegrationWrapperSharedPtr &IntegrationScheme)
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
int m_bnd_dim
bounday dimensionality
Definition: Extrapolate.h:229
static std::string className
Name of class.
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Array< OneD, Array< OneD, NekDouble > > m_acceleration
Storage for current and previous levels of the acceleration term.
Definition: Extrapolate.h:274
Array< OneD, NekDouble > GetMaxStdVelocity(const Array< OneD, Array< OneD, NekDouble > > inarray)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
int m_intSteps
Maximum points used in pressure BC evaluation.
Definition: Extrapolate.h:247
boost::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
static std::string npts
Definition: InputFld.cpp:43
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
virtual void v_SubStepAdvance(const LibUtilities::TimeIntegrationSolutionSharedPtr &integrationSoln, int nstep, NekDouble time)
double NekDouble
TimeIntegrationWrapperFactory & GetTimeIntegrationWrapperFactory()
int m_pressureCalls
number of times the high-order pressure BCs have been called
Definition: Extrapolate.h:238
SubSteppingExtrapolate(const LibUtilities::SessionReaderSharedPtr pSession, Array< OneD, MultiRegions::ExpListSharedPtr > pFields, MultiRegions::ExpListSharedPtr pPressure, const Array< OneD, int > pVel, const SolverUtils::AdvectionSharedPtr advObject)
void SubStepAdvection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void IProductNormVelocityBCOnHBC(Array< OneD, NekDouble > &IprodVn)
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
virtual void v_MountHOPBCs(int HBCdata, NekDouble kinvis, Array< OneD, NekDouble > &Q, Array< OneD, const NekDouble > &Advection)
BDF multi-step scheme of order 2 (implicit)
Array< OneD, Array< OneD, NekDouble > > m_pressureHBCs
Storage for current and previous levels of high order pressure boundary conditions.
Definition: Extrapolate.h:271
static ExtrapolateSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, MultiRegions::ExpListSharedPtr &pPressure, const Array< OneD, int > &pVel, const SolverUtils::AdvectionSharedPtr &advObject)
Creates an instance of this class.
boost::shared_ptr< TimeIntegrationSolution > TimeIntegrationSolutionSharedPtr
static NekDouble StifflyStable_Alpha_Coeffs[3][3]
Definition: Extrapolate.h:313
SolverUtils::AdvectionSharedPtr m_advObject
Definition: Extrapolate.h:221
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Definition: Extrapolate.h:288
virtual LibUtilities::TimeIntegrationMethod v_GetSubStepIntegrationMethod(void)
void CalcOutflowBCs(const Array< OneD, const Array< OneD, NekDouble > > &fields, NekDouble kinvis)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
NekDouble m_timestep
Definition: Extrapolate.h:249
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
void CalcNeumannPressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &fields, const Array< OneD, const Array< OneD, NekDouble > > &N, NekDouble kinvis)
Definition: Extrapolate.h:179
LibUtilities::TimeIntegrationSchemeOperators m_subStepIntegrationOps
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, tDescription pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:215