40using namespace LibUtilities;
54 :
Extrapolate(pSession, pFields, pPressure, pVel, advObject)
61 size_t dim =
m_fields[0]->GetCoordim(0);
64 size_t nTracePts =
m_fields[0]->GetTrace()->GetNpoints();
65 for (
size_t i = 0; i < dim; ++i)
81 ASSERTL0(
false,
"This method should not be called by Substepping routine");
89 size_t order = IntegrationScheme->GetOrder();
93 if ((IntegrationScheme->GetName() ==
"Euler" &&
94 IntegrationScheme->GetVariant() ==
"Backward") ||
96 (IntegrationScheme->GetName() ==
"BDFImplicit" &&
97 (order == 1 || order == 2)))
100 std::string vSubStepIntScheme =
"RungeKutta";
101 std::string vSubStepIntSchemeVariant =
"SSP";
102 int vSubStepIntSchemeOrder = order;
104 if (
m_session->DefinesSolverInfo(
"SubStepIntScheme"))
106 vSubStepIntScheme =
m_session->GetSolverInfo(
"SubStepIntScheme");
107 vSubStepIntSchemeVariant =
"";
108 vSubStepIntSchemeOrder = order;
113 vSubStepIntScheme, vSubStepIntSchemeVariant,
114 vSubStepIntSchemeOrder, std::vector<NekDouble>());
117 size_t ndim = order + 1;
121 int ntotpts =
m_fields[0]->GetTotPoints();
124 for (
size_t i = 1; i < ndim * nvel; ++i)
131 ASSERTL0(0,
"Integration method not suitable: Options include "
132 "BackwardEuler or BDFImplicitOrder{1,2}");
135 m_intSteps = IntegrationScheme->GetNumIntegrationPhases();
152 size_t nVariables = inarray.size();
153 size_t nQuadraturePts = inarray[0].size();
156 size_t ncoeffs =
m_fields[0]->GetNcoeffs();
161 for (i = 1; i < nVariables; ++i)
163 WeakAdv[i] = WeakAdv[i - 1] + ncoeffs;
172 Velfields[i] = Velfields[i - 1] + nQuadraturePts;
179 x->PreApply(
m_fields, Velfields, Velfields, time);
185 x->Apply(
m_fields, outarray, outarray, time);
188 for (i = 0; i < nVariables; ++i)
190 m_fields[i]->IProductWRTBase(outarray[i], WeakAdv[i]);
198 for (i = 0; i < nVariables; ++i)
204 m_fields[i]->MultiplyByElmtInvMass(WeakAdv[i], WeakAdv[i]);
207 m_fields[i]->BwdTrans(WeakAdv[i], outarray[i]);
219 ASSERTL1(inarray.size() == outarray.size(),
220 "Inarray and outarray of different sizes ");
222 for (
size_t i = 0; i < inarray.size(); ++i)
224 Vmath::Vcopy(inarray[i].size(), inarray[i], 1, outarray[i], 1);
266 int nlevels = array.size();
267 int nPts = array[0].size();
279 1, accelerationTerm, 1);
281 for (
int i = 0; i < acc_order; i++)
285 array[i + 1], 1, accelerationTerm, 1, accelerationTerm, 1);
287 array[nlevels - 1] = accelerationTerm;
298 size_t npts =
m_fields[0]->GetTotPoints();
305 for (n = 0; n < nvel; ++n)
309 for (i = nblocks - 1; i > 0; --i)
319 for (i = 0; i < nvel; ++i)
330 for (n = 0; n < nvel; ++n)
332 for (i = 1; i < nblocks; ++i)
353 static int ncalls = 1;
366 "Number of substeps has exceeded maximum");
372 std::cout <<
"Sub-integrating using " << nsubsteps
379 for (
size_t m = 0; m < nint; ++m)
382 fields = solutionVector[m];
390 for (n = 0; n < nsubsteps; ++n)
408 size_t n_element =
m_fields[0]->GetExpSize();
418 for (
size_t i = 0; i <
m_velocity.size(); ++i)
424 for (
size_t el = 0; el < n_element; ++el)
428 (ExpOrder[el] - 1) * (ExpOrder[el] - 1));
442 ASSERTL1(physfield.size() == Outarray.size(),
443 "Physfield and outarray are of different dimensions");
448 size_t nTracePts =
m_fields[0]->GetTrace()->GetNpoints();
467 for (i = 0; i < nDimensions; ++i)
469 m_fields[0]->ExtractTracePhys(velfield[i], Fwd);
473 for (i = 0; i < physfield.size(); ++i)
480 std::dynamic_pointer_cast<MultiRegions::DisContField>(
m_fields[0])
481 ->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd,
483 m_fields[i]->GetBndCondExpansions());
486 m_fields[0]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux);
489 Vmath::Vsub(nTracePts, numflux, 1, Fwd, 1, Fwd, 1);
490 Vmath::Vsub(nTracePts, numflux, 1, Bwd, 1, Bwd, 1);
497 m_fields[0]->AddFwdBwdTraceIntegral(Fwd, Bwd, Outarray[i]);
508 size_t npts =
m_fields[0]->GetTotPoints();
518 for (i = 0; i <= ord; ++i)
520 for (j = 0; j <= ord; ++j)
530 for (i = 0; i < nvel; ++i)
534 for (j = 1; j <= ord; ++j)
#define ASSERTL0(condition, msg)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
An abstract base class encapsulating the concept of advection of a vector field.
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
TimeIntegrationSchemeFactory & GetTimeIntegrationSchemeFactory()
std::shared_ptr< SessionReader > SessionReaderSharedPtr
std::shared_ptr< TimeIntegrationScheme > TimeIntegrationSchemeSharedPtr
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
std::shared_ptr< Advection > AdvectionSharedPtr
A shared pointer to an Advection object.
ExtrapolateFactory & GetExtrapolateFactory()
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.
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.
void Neg(int n, T *x, const int incx)
Negate x = -x.
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
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
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
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.