/**
* Advection/diffusion example using an encapsulated IMEX sweeper.
*
* This example uses a vanilla SDC sweeper.
*
* @ingroup AdvectionDiffusion
*/
error_map run_vanilla_sdc(double abs_residual_tol, double rel_residual_tol=0.0)
{
SDC<> sdc;
auto const nnodes = config::get_value<size_t>("num_nodes", 3);
auto const ndofs = config::get_value<size_t>("spatial_dofs", 64);
auto const quad_type = \
config::get_value<quadrature::QuadratureType>("nodes_type", quadrature::QuadratureType::GaussLegendre);
auto quad = quadrature::quadrature_factory(nnodes, quad_type);
auto factory = make_shared<encap::VectorFactory<double>>(ndofs);
auto sweeper = make_shared<AdvectionDiffusionSweeper<>>(ndofs);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sweeper->set_residual_tolerances(abs_residual_tol, rel_residual_tol);
sdc.add_level(sweeper);
sdc.set_duration(0.0, 4*0.01, 0.01, 4);
sdc.set_options();
sdc.setup();
auto q0 = sweeper->get_start_state();
sweeper->exact(q0, 0.0);
sdc.run();
fftw_cleanup();
return sweeper->get_errors();
}
/**
* @ingroup VanDerPol
*/
double run_vdp_sdc(const size_t nsteps, const double dt, const size_t nnodes,
const size_t niters, const double nu, const double x0,
const double y0, const quadrature::QuadratureType nodetype)
{
SDC<> sdc;
auto quad = quadrature::quadrature_factory(nnodes, nodetype);
// van der Pol oscillator (as first order system) has two components
auto factory = make_shared<encap::VectorFactory<double>>(2);
// input is parameter nu and initial values for position and velocity
auto sweeper = make_shared<VdpSweeper<>>(nu, x0, y0);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sdc.add_level(sweeper);
// Final time Tend = dt*nsteps
sdc.set_duration(0.0, dt*nsteps, dt, niters);
sdc.setup();
auto q0 = sweeper->get_start_state();
sweeper->exact(q0, 0.0);
sdc.run();
return sweeper->get_errors();
}
error_map<scalar> run_boris_sdc()
{
pfasst::SDC<> sdc;
const size_t nsteps = pfasst::config::get_value<size_t>("num_steps", 10);
const double dt = pfasst::config::get_value<double>("delta_step", 0.015625);
const size_t nnodes = pfasst::config::get_value<size_t>("num_nodes", 5);
// const size_t nparticles = 1;
const size_t niters = pfasst::config::get_value<size_t>("num_iter", 7);
const double mass = 1.0;
const double charge = 1.0;
const double epsilon = pfasst::config::get_value<scalar>("epsilon", -1.0);
auto quad = pfasst::quadrature::quadrature_factory<double>(nnodes, pfasst::quadrature::QuadratureType::GaussLobatto);
auto factory = make_shared<Particle3DFactory<double, double>>(mass, charge);
typedef SimplePhysicsEnergyOperator<double, double, Particle3DEncapsulation,
IdealQuadrupolePotential, ConstantMagneticField> energy_operator_type;
energy_operator_type::e_field_type e_field(epsilon);
energy_operator_type::b_field_type b_field;
energy_operator_type e_operator(e_field, b_field, epsilon);
auto sweeper = make_shared<pfasst::examples::boris::BorisSweeper<double, double, energy_operator_type>>(e_operator, epsilon);
sweeper->set_energy_operator(e_operator);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sdc.add_level(sweeper);
sdc.set_duration(0.0, nsteps*dt, dt, niters);
sdc.setup();
auto p0 = dynamic_pointer_cast<Particle3DEncapsulation<double, double>>(sweeper->get_state(0));
p0->pos().x = 10;
p0->vel().u = 100;
p0->vel().w = 100;
sweeper->set_initial_energy();
cout << "Initial Particle: " << *(dynamic_pointer_cast<Particle3DEncapsulation<double, double>>(sweeper->get_state(0))) << endl;
sdc.run();
return sweeper->get_errors();
}
