sim_dplangevin.cpp

Go to the documentation of this file.

 
 
#include "sim_dplangevin.hpp"

 SimDP::SimDP(
    const double linear, const double quadratic,
    const double diffusion, const double noise, 
    const double t_final, 
    const double dx, const double dt, 
    const int random_seed,
    const GridDimension grid_dimension,
    const int_vec_t grid_size,
    const gt_vec_t grid_topologies,
    const bc_vec_t boundary_conditions,
    const dbl_vec_t bc_values,
    const InitialCondition initial_condition,
    const dbl_vec_t ic_values,
    const IntegrationMethod integration_method,
    const bool do_snapshot_grid,
    const bool do_verbose
) : coefficients(linear, quadratic, diffusion, noise),
    p(
        t_final, 
        dx, 
        dt, 
        random_seed,
        grid_dimension, 
        grid_size, 
        grid_topologies,
        boundary_conditions,
        bc_values,
        initial_condition, 
        ic_values, 
        integration_method
    ),
    do_snapshot_grid(do_snapshot_grid),
    do_verbose(do_verbose)
{
    rng = new rng_t(p.random_seed); 
    dpLangevin = new DPLangevin(p);
    if (do_verbose) 
    {
        coefficients.print();
        p.print();
    }
}

bool SimDP::initialize(int n_decimals)
{
    if (not dpLangevin->construct_grid(p)) { 
        std::cout 
            << "SimDP::initialize failure: couldn't construct grid" 
            << std::endl;
        return false; 
    }
    if (not dpLangevin->initialize_grid(p, *rng)) { 
        std::cout 
            << "SimDP::initialize failure: couldn't initialize grid" 
            << std::endl;
        return false; 
    }
    dpLangevin->prepare(coefficients);
    this->n_decimals = n_decimals;
    n_epochs = count_epochs();
    t_epochs = dbl_vec_t(n_epochs, 0.0);
    mean_densities = dbl_vec_t(n_epochs, 0.0);
    // Treat epoch#0 as the initial grid state
    // So after initialization, we are nominally at epoch#1
    i_next_epoch = 1;
    t_next_epoch = p.dt;
    if (not choose_integrator())
    { 
        std::cout << "SimDP::initialize failure: unable to choose integrator" << std::endl;
        return false; 
    }        
    if (not dpLangevin->check_boundary_conditions(p))
    {
        std::cout << "SimDP::initialize failure: wrong number of boundary conditions" << std::endl;
        return false;
    }
    is_initialized = true;
    return is_initialized;
}

bool SimDP::run(const int n_next_epochs)
{
    if (not is_initialized) 
    { 
        std::cout << "SimDP::run failure: must initialize first" << std::endl;
        return false; 
    }
    did_integrate = integrate(n_next_epochs);
    return did_integrate;
}

bool SimDP::postprocess()
{
    if (not is_initialized) 
    { 
        std::cout 
            << "SimDP::postprocess failure: no data to process yet" 
            << std::endl;
        return false; 
    }
    bool did_process_grid;
    if (do_snapshot_grid) { did_process_grid = pyprep_density_grid(); }
    else { did_process_grid = true; }
    bool did_process_time_series = (
        pyprep_t_epochs() and pyprep_mean_densities() 
    ); 
    return (did_process_grid and did_process_time_series);
}