38#include <boost/algorithm/string.hpp>
46#include <boost/math/special_functions/spherical_harmonic.hpp>
87 int shapedim =
m_fields[0]->GetShapeDimension();
89 for (
int j = 0; j < shapedim; ++j)
98 if (
m_session->DefinesSolverInfo(
"TESTTYPE"))
100 std::string TestTypeStr =
m_session->GetSolverInfo(
"TESTTYPE");
116 if (
m_session->DefinesSolverInfo(
"INITWAVETYPE"))
118 std::string InitWaveTypeStr =
m_session->GetSolverInfo(
"INITWAVETYPE");
145 for (
int k = 0; k < MFdim; ++k)
190 int nvariables = inarray.size();
200 for (
int n = 1; n < nvariables; ++n)
202 F[n] = F[n - 1] + nq;
211 for (
int i = 0; i < nvariables; ++i)
248 for (
int k = 0; k < nq; k++)
252 sin(
m_pi * x[k]) * cos(
m_pi * y[k]);
266 for (
int k = 0; k < nq; k++)
290 Vmath::Svtvp(nq, m_a, &inarray[0][0], 1, &temp[0], 1, &temp[0], 1);
295 Vmath::Svtvp(nq, m_c, &inarray[0][0], 1, &temp[0], 1, &temp[0], 1);
310 Vmath::Vmul(nq, &inarray[0][0], 1, &inarray[0][0], 1, &cube[0], 1);
311 Vmath::Vmul(nq, &inarray[1][0], 1, &cube[0], 1, &cube[0], 1);
316 Vmath::Svtvp(nq, coeff, &inarray[0][0], 1, &cube[0], 1, &tmp[0], 1);
317 Vmath::Vadd(nq, &Aonevec[0], 1, &tmp[0], 1, &outarray[0][0], 1);
320 Vmath::Svtvm(nq, B, &inarray[0][0], 1, &cube[0], 1, &outarray[1][0],
337 Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
339 Vmath::Vmul(nq, tmp, 1, inarray[0], 1, outarray[0], 1);
341 Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
344 Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
349 Vmath::Smul(nq, b, outarray[1], 1, outarray[1], 1);
364 Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
366 Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
368 Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
370 Vmath::Vmul(nq, inarray[0], 1, inarray[1], 1, tmp, 1);
372 Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
377 Vmath::Smul(nq, b, outarray[1], 1, outarray[1], 1);
394 Vmath::Smul(nq, -1.0 * c1, inarray[0], 1, outarray[0], 1);
396 Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
398 Vmath::Vmul(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
400 Vmath::Vmul(nq, inarray[0], 1, inarray[1], 1, tmp, 1);
402 Vmath::Vadd(nq, tmp, 1, outarray[0], 1, outarray[0], 1);
407 Vmath::Smul(nq, mu1, inarray[1], 1, outarray[1], 1);
409 Vmath::Vdiv(nq, outarray[1], 1, tmp, 1, outarray[1], 1);
410 Vmath::Sadd(nq, c0, outarray[1], 1, outarray[1], 1);
412 Vmath::Sadd(nq, (-a - 1.0), inarray[0], 1, tmp, 1);
418 Vmath::Vmul(nq, tmp, 1, outarray[1], 1, outarray[1], 1);
431 bool dumpInitialConditions,
432 [[maybe_unused]]
const int domain)
488 for (
int i = 0; i <
m_fields.size(); ++i)
495 if (dumpInitialConditions)
515 for (
int k = 0; k < nq; k++)
517 outfield[k] = exp(-1.0 *
m_pi *
m_pi * time) * sin(
m_pi * x[k]) *
535 for (
int k = 0; k < nq; k++)
537 outfield[k] = exp(-1.0 *
m_pi *
m_pi * time) * sin(
m_pi * x[k]) *
549 NekDouble A_mn, C_mn, theta, phi, radius;
551 std::complex<double> Spericharmonic, delta_n, temp;
552 std::complex<double> varphi0, varphi1;
553 std::complex<double> B_mn, D_mn;
557 int Maxm = 2 * Maxn - 1;
575 for (i = 0; i < Maxn; ++i)
581 Ainit[5][0] = -0.5839;
582 Ainit[5][1] = -0.8436;
583 Ainit[5][2] = -0.4764;
584 Ainit[5][3] = 0.6475;
585 Ainit[5][4] = 0.1886;
586 Ainit[5][5] = 0.8709;
587 Ainit[5][6] = -0.8338;
588 Ainit[5][7] = 0.1795;
589 Ainit[5][8] = -0.7873;
590 Ainit[5][9] = 0.8842;
591 Ainit[5][10] = 0.2943;
593 Binit[5][0] = -0.6263;
594 Binit[5][1] = 0.9803;
595 Binit[5][2] = 0.7222;
596 Binit[5][3] = 0.5945;
597 Binit[5][4] = 0.6026;
598 Binit[5][5] = -0.2076;
599 Binit[5][6] = 0.4556;
600 Binit[5][7] = 0.6024;
601 Binit[5][8] = 0.9695;
602 Binit[5][9] = -0.4936;
603 Binit[5][10] = 0.1098;
612 for (
int i = 0; i < nq; ++i)
614 radius =
sqrt(x[i] * x[i] + y[i] * y[i] +
z[i] *
z[i]);
617 theta = asin(
z[i] / radius) + 0.5 *
m_pi;
620 phi = atan2(y[i], x[i]) +
m_pi;
622 varphi0 = 0.0 * varphi0;
623 varphi1 = 0.0 * varphi1;
624 for (n = 0; n < Maxn; ++n)
627 a_n = m_a -
m_mu * (n * (n + 1) / radius / radius);
628 d_n = m_d - m_nu * (n * (n + 1) / radius / radius);
630 gamma_n = 0.5 * (a_n + d_n);
632 temp = (a_n + d_n) * (a_n + d_n) - 4.0 * (a_n * d_n - m_b * m_c);
633 delta_n = 0.5 *
sqrt(temp);
635 for (m = -n; m <= n; ++m)
638 A_mn = Ainit[n][ind];
639 C_mn = Binit[n][ind];
641 B_mn = ((a_n - gamma_n) * Ainit[n][ind] + m_b * Binit[n][ind]) /
643 D_mn = (m_c * Ainit[n][ind] + (d_n - gamma_n) * Binit[n][ind]) /
647 boost::math::spherical_harmonic(n, m, theta, phi);
648 varphi0 += exp(gamma_n * time) *
649 (A_mn * cosh(delta_n * time) +
650 B_mn * sinh(delta_n * time)) *
652 varphi1 += exp(gamma_n * time) *
653 (C_mn * cosh(delta_n * time) +
654 D_mn * sinh(delta_n * time)) *
659 u[i] = varphi0.real();
660 v[i] = varphi1.real();
697 for (
int i = 0; i < nq; i++)
708 1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff));
722 exp((
sqrt(xp * xp) - radiusofinit) / frontstiff)) +
724 exp((
sqrt(xp2 * xp2) - radiusofinit) / frontstiff));
735 1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff));
749 (1.0 + exp((
sqrt(xp * xp + yp * yp) / bs - radiusofinit) /
763 rad =
sqrt(xloc * xloc + yloc * yloc + zloc * zloc);
765 xloc = xloc / radiusofinit;
766 yloc = yloc / radiusofinit;
767 zloc = zloc / radiusofinit;
769 if (
rad < radiusofinit)
773 (xloc * xloc + yloc * yloc + zloc * zloc));
790 (1.0 / (1.0 + exp(2.0 * yp))) *
791 (1.0 / (1.0 + exp(-2.0 * xp))) *
792 (1.0 / (1.0 + exp((xp - radiusofinit) / frontstiff)));
860int main(
int argc,
char *argv[])
864 std::string vDriverModule;
870 session = LibUtilities::SessionReader::CreateInstance(argc, argv);
873 graph = SpatialDomains::MeshGraphIO::Read(session);
876 session->LoadSolverInfo(
"Driver", vDriverModule,
"Standard");
885 catch (
const std::runtime_error &e)
889 catch (
const std::string &eStr)
891 std::cout <<
"Error: " << eStr << std::endl;
int main(int argc, char *argv[])
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 DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
StdRegions::VarCoeffMap m_varcoeff
Variable diffusivity.
void v_GenerateSummary(SolverUtils::SummaryList &s) override
Prints a summary of the model parameters.
void Morphogenesis(const NekDouble time, unsigned int field, Array< OneD, NekDouble > &outfield)
static std::string className
Name of class.
void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
InitWaveType m_InitWaveType
MMFDiffusion(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Constructor.
Array< OneD, NekDouble > m_epsu
void TestCubeProblem(const NekDouble time, Array< OneD, NekDouble > &outfield)
Array< OneD, NekDouble > m_epsilon
void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
Sets a custom initial condition.
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Computes the reaction terms and .
Array< OneD, NekDouble > PlanePhiWave()
void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, NekDouble lambda)
Solve for the diffusion term.
void TestPlaneProblem(const NekDouble time, Array< OneD, NekDouble > &outfield)
void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time) override
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
int m_spacedim
Spatial dimension (>= expansion dim).
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
std::string m_sessionName
Name of the session.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
SOLVER_UTILS_EXPORT int GetTotPoints()
SOLVER_UTILS_EXPORT void SetBoundaryConditions(NekDouble time)
Evaluates the boundary conditions at the given time.
A base class for PDEs which include an advection component.
Array< OneD, Array< OneD, NekDouble > > m_DivMF
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Virtual function for generating summary information.
Array< OneD, Array< OneD, NekDouble > > m_movingframes
SOLVER_UTILS_EXPORT void MMFInitObject(const Array< OneD, const Array< OneD, NekDouble > > &Anisotropy, const int TangentXelem=-1)
Base class for unsteady solvers.
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
static NekDouble rad(NekDouble x, NekDouble y)
std::shared_ptr< SessionReader > SessionReaderSharedPtr
std::shared_ptr< Driver > DriverSharedPtr
A shared pointer to a Driver object.
std::vector< std::pair< std::string, std::string > > SummaryList
DriverFactory & GetDriverFactory()
EquationSystemFactory & GetEquationSystemFactory()
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
std::map< ConstFactorType, NekDouble > ConstFactorMap
std::vector< double > z(NPUPPER)
std::vector< double > d(NPUPPER *NPUPPER)
StdRegions::ConstFactorMap factors
const char *const InitWaveTypeMap[]
@ SIZE_TestType
Length of enum list.
const char *const TestTypeMap[]
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 Svtvm(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvm (scalar times vector minus vector): z = alpha*x - y.
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = 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 Vdiv(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 Zero(int n, T *x, const int incx)
Zero vector.
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
T Vmax(int n, const T *x, const int incx)
Return the maximum element in x – called vmax to avoid conflict with max.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
scalarT< T > sqrt(scalarT< T > in)