Skip to content

Commit

Permalink
read input parameters
Browse files Browse the repository at this point in the history
git-svn-id: https://svn.cct.lsu.edu/repos/projects/parallex/trunk/hpx@6455 5079c8e4-9419-0410-93bb-9e5ee278c886
  • Loading branch information
Matthew Anderson committed Nov 30, 2011
1 parent 32cd26f commit 7f00d87
Show file tree
Hide file tree
Showing 4 changed files with 446 additions and 0 deletions.
1 change: 1 addition & 0 deletions examples/gtc/CMakeLists.txt
Expand Up @@ -23,6 +23,7 @@ source_group("Source Files" FILES ${sources})
set(dependencies
point_component
particle_component
iostreams_component
distributing_factory_component)

# add example executable
Expand Down
232 changes: 232 additions & 0 deletions examples/gtc/gtc_client.cpp
Expand Up @@ -5,13 +5,25 @@

#include <hpx/hpx.hpp>
#include <hpx/hpx_init.hpp>
#include <hpx/include/iostreams.hpp>

#include "point/point.hpp"
#include "particle/particle.hpp"
#include "parameter.hpp"
#include <hpx/components/distributing_factory/distributing_factory.hpp>

using boost::lexical_cast;

using hpx::bad_parameter;

using hpx::applier::get_applier;
using hpx::naming::id_type;

using hpx::util::section;
using hpx::util::high_resolution_timer;

using hpx::components::gtc::parameter;

inline void
init(hpx::components::server::distributing_factory::iterator_range_type r,
std::vector<hpx::geometry::point>& accu_points)
Expand All @@ -32,12 +44,232 @@ init(hpx::components::server::distributing_factory::iterator_range_type r,
}
}

void appconfig_option(std::string const& name, section const& pars,
std::string& data)
{
if (pars.has_entry(name))
data = pars.get_entry(name);
}

template <typename T>
void appconfig_option(std::string const& name, section const& pars, T& data)
{
try {
if (pars.has_entry(name))
data = lexical_cast<T>(pars.get_entry(name));
} catch (...) {
std::string msg = boost::str(boost::format(
"\"%1%\" is not a valid value for %2%")
% pars.get_entry(name) % name);
HPX_THROW_IN_CURRENT_FUNC(bad_parameter, msg);
}
}

///////////////////////////////////////////////////////////////////////////////
int hpx_main(boost::program_options::variables_map &vm)
{
{
high_resolution_timer t;

parameter par;

// Default parameters
par->irun = false;
par->mstep = 1500;
par->msnap = 1;
par->ndiag = 4;
par->nonlinear = 1.0;
par->nhybrid = 0;
par->paranl = 0.0;
par->mode00 = true;

par->tstep = 0.2;
par->micell = 2;
par->mecell = 2;
par->mpsi = 90;
par->mthetamax = 640;
par->mzetamax = 64;
par->npartdom = 1;
par->ncycle = 5;

par->a = 0.358;
par->a0 = 0.1;
par->a1 = 0.9;
par->q0 = 0.854;
par->q1 = 0.0;
par->q2 = 2.184;
par->rc = 0.5;
par->rw = 0.35;

par->aion = 1.0;
par->qion = 1.0;
par->aelectron = 1.0/1837.0;
par->qelectron = -1.0;

par->kappati = 6.9;
par->kappate = 6.9;
par->fixed_Tprofile = 1;
par->tite = 1.0;
par->flow0 = 0.0;
par->flow1 = 0.0;
par->flow2 = 0.0;

par->r0 = 93.4;
par->b0 = 19100.0;
par->temperature = 2500.0;
par->edensity0 = 0.46e14;

par->output = 6;
par->nbound = true;
par->umax = 4.0;
par->iload = false;
par->tauii = -1.0;
par->track_particles = false;
par->nptrack = false;
par->rng_control = false;

par->nmode.push_back(5);
par->nmode.push_back(7);
par->nmode.push_back(9);
par->nmode.push_back(11);
par->nmode.push_back(13);
par->nmode.push_back(15);
par->nmode.push_back(18);
par->nmode.push_back(20);

par->mmode.push_back(7);
par->mmode.push_back(10);
par->mmode.push_back(13);
par->mmode.push_back(15);
par->mmode.push_back(18);
par->mmode.push_back(21);
par->mmode.push_back(25);
par->mmode.push_back(28);

id_type rt_id = get_applier().get_runtime_support_gid();

section root;
hpx::components::stubs::runtime_support::get_config(rt_id, root);
if (root.has_section("gtc"))
{
section pars = *(root.get_section("gtc"));

appconfig_option<bool>("irun", pars, par->irun);
appconfig_option<std::size_t>("mstep", pars, par->mstep);
appconfig_option<std::size_t>("msnap", pars, par->msnap);
appconfig_option<std::size_t>("ndiag", pars, par->ndiag);
appconfig_option<double>("nonlinear", pars, par->nonlinear);
appconfig_option<std::size_t>("nhybrid", pars, par->nhybrid);
appconfig_option<double>("paranl", pars, par->paranl);
appconfig_option<bool>("mode00", pars, par->mode00);

appconfig_option<double>("tstep", pars, par->tstep);
appconfig_option<std::size_t>("micell", pars, par->micell);
appconfig_option<std::size_t>("mecell", pars, par->mecell);
appconfig_option<std::size_t>("mpsi", pars, par->mpsi);
appconfig_option<std::size_t>("mthetamax", pars, par->mthetamax);
appconfig_option<std::size_t>("mzetamax", pars, par->mzetamax);
appconfig_option<std::size_t>("npartdom", pars, par->npartdom);
appconfig_option<std::size_t>("ncycle", pars, par->ncycle);
appconfig_option<double>("a", pars, par->a);
appconfig_option<double>("a0", pars, par->a0);
appconfig_option<double>("a1", pars, par->a1);
appconfig_option<double>("q0", pars, par->q0);
appconfig_option<double>("q1", pars, par->q1);
appconfig_option<double>("q2", pars, par->q2);
appconfig_option<double>("rc", pars, par->rc);
appconfig_option<double>("rw", pars, par->rw);
appconfig_option<double>("aion", pars, par->aion);
appconfig_option<double>("qion", pars, par->qion);
appconfig_option<double>("aelectron", pars, par->aelectron);
appconfig_option<double>("qelectron", pars, par->qelectron);
appconfig_option<double>("kappati", pars, par->kappati);
appconfig_option<double>("kappate", pars, par->kappate);
appconfig_option<bool>("fixed_Tprofile", pars, par->fixed_Tprofile);
appconfig_option<double>("tite", pars, par->tite);
appconfig_option<double>("flow0", pars, par->flow0);
appconfig_option<double>("flow1", pars, par->flow1);
appconfig_option<double>("flow2", pars, par->flow2);
appconfig_option<double>("r0", pars, par->r0);
appconfig_option<double>("b0", pars, par->b0);
appconfig_option<double>("temperature", pars, par->temperature);
appconfig_option<double>("edensity0", pars, par->edensity0);
appconfig_option<std::size_t>("output", pars, par->output);
appconfig_option<bool>("nbound", pars, par->nbound);
appconfig_option<double>("umax", pars, par->umax);
appconfig_option<bool>("iload", pars, par->iload);
appconfig_option<double>("tauii", pars, par->tauii);
appconfig_option<bool>("track_particles", pars, par->track_particles);
appconfig_option<bool>("nptrack", pars, par->nptrack);
appconfig_option<bool>("rng_control", pars, par->rng_control);
}

// Derived parameters
par->kappan = par->kappati*0.319;

// Changing the units of a0 and a1 from units of "a" to units of "R_0"
par->a0 = par->a0*par->a;
par->a1 = par->a1*par->a;

hpx::cout << ( boost::format("GTC parameters \n") ) << hpx::flush;
hpx::cout << ( boost::format("----------------------------\n") ) << hpx::flush;
hpx::cout << ( boost::format("irun : %1%\n") % par->irun) << hpx::flush;
hpx::cout << ( boost::format("mstep : %1%\n") % par->mstep) << hpx::flush;
hpx::cout << ( boost::format("msnap : %1%\n") % par->msnap) << hpx::flush;
hpx::cout << ( boost::format("ndiag : %1%\n") % par->ndiag) << hpx::flush;
hpx::cout << ( boost::format("nonlinear : %1%\n") % par->nonlinear) << hpx::flush;
hpx::cout << ( boost::format("nhybrid : %1%\n") % par->nhybrid) << hpx::flush;
hpx::cout << ( boost::format("paranl : %1%\n") % par->paranl) << hpx::flush;
hpx::cout << ( boost::format("mode00 : %1%\n") % par->mode00) << hpx::flush;
hpx::cout << ( boost::format("tstep : %1%\n") % par->tstep) << hpx::flush;
hpx::cout << ( boost::format("micell : %1%\n") % par->micell) << hpx::flush;
hpx::cout << ( boost::format("mecell : %1%\n") % par->mecell) << hpx::flush;
hpx::cout << ( boost::format("mpsi : %1%\n") % par->mpsi) << hpx::flush;
hpx::cout << ( boost::format("mthetamax : %1%\n") % par->mthetamax) << hpx::flush;
hpx::cout << ( boost::format("mzetamax : %1%\n") % par->mzetamax) << hpx::flush;
hpx::cout << ( boost::format("npartdom : %1%\n") % par->npartdom) << hpx::flush;
hpx::cout << ( boost::format("ncycle : %1%\n") % par->ncycle) << hpx::flush;
hpx::cout << ( boost::format("a : %1%\n") % par->a) << hpx::flush;
hpx::cout << ( boost::format("a0 : %1%\n") % par->a0) << hpx::flush;
hpx::cout << ( boost::format("a1 : %1%\n") % par->a1) << hpx::flush;
hpx::cout << ( boost::format("q0 : %1%\n") % par->q0) << hpx::flush;
hpx::cout << ( boost::format("q1 : %1%\n") % par->q1) << hpx::flush;
hpx::cout << ( boost::format("q2 : %1%\n") % par->q2) << hpx::flush;
hpx::cout << ( boost::format("rc : %1%\n") % par->rc) << hpx::flush;
hpx::cout << ( boost::format("rw : %1%\n") % par->rw) << hpx::flush;
hpx::cout << ( boost::format("aion : %1%\n") % par->aion) << hpx::flush;
hpx::cout << ( boost::format("qion : %1%\n") % par->qion) << hpx::flush;
hpx::cout << ( boost::format("aelectron : %1%\n") % par->aelectron) << hpx::flush;
hpx::cout << ( boost::format("qelectron : %1%\n") % par->qelectron) << hpx::flush;
hpx::cout << ( boost::format("kappati : %1%\n") % par->kappati) << hpx::flush;
hpx::cout << ( boost::format("kappate : %1%\n") % par->kappate) << hpx::flush;
hpx::cout << ( boost::format("kappan : %1%\n") % par->kappan) << hpx::flush;
hpx::cout << ( boost::format("fixed_Tprofile : %1%\n") % par->fixed_Tprofile) << hpx::flush;
hpx::cout << ( boost::format("tite : %1%\n") % par->tite) << hpx::flush;
hpx::cout << ( boost::format("flow0 : %1%\n") % par->flow0) << hpx::flush;
hpx::cout << ( boost::format("flow1 : %1%\n") % par->flow1) << hpx::flush;
hpx::cout << ( boost::format("flow2 : %1%\n") % par->flow2) << hpx::flush;
hpx::cout << ( boost::format("r0 : %1%\n") % par->r0) << hpx::flush;
hpx::cout << ( boost::format("b0 : %1%\n") % par->b0) << hpx::flush;
hpx::cout << ( boost::format("temperature : %1%\n") % par->temperature) << hpx::flush;
hpx::cout << ( boost::format("edensity0 : %1%\n") % par->edensity0) << hpx::flush;
hpx::cout << ( boost::format("output : %1%\n") % par->output) << hpx::flush;
hpx::cout << ( boost::format("nbound : %1%\n") % par->nbound) << hpx::flush;
hpx::cout << ( boost::format("umax : %1%\n") % par->umax) << hpx::flush;
hpx::cout << ( boost::format("iload : %1%\n") % par->iload) << hpx::flush;
hpx::cout << ( boost::format("tauii : %1%\n") % par->tauii) << hpx::flush;
hpx::cout << ( boost::format("track_particles: %1%\n") % par->track_particles) << hpx::flush;
hpx::cout << ( boost::format("nptrack : %1%\n") % par->nptrack) << hpx::flush;
hpx::cout << ( boost::format("rng_control : %1%\n") % par->rng_control) << hpx::flush;
BOOST_FOREACH(std::size_t i, par->nmode)
{
hpx::cout << ( boost::format("nmode : %1% \n") % i) << hpx::flush;
}
BOOST_FOREACH(std::size_t i, par->mmode)
{
hpx::cout << ( boost::format("mmode : %1% \n") % i) << hpx::flush;
}

std::size_t num_gridpoints = 5;
std::size_t num_particles = 5;
if (vm.count("n"))
Expand Down
120 changes: 120 additions & 0 deletions examples/gtc/parameter.hpp
@@ -0,0 +1,120 @@
// Copyright (c) 2009-2011 Matt Anderson
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if !defined(HPX_COMPONENTS_GTCPARAMETER_NOV_19_2011_0834AM)
#define HPX_COMPONENTS_GTCPARAMETER_NOV_19_2011_0834AM

#include <vector>

#include <boost/config.hpp>

///////////////////////////////////////////////////////////////////////////////
namespace hpx { namespace components { namespace gtc
{

namespace detail {

struct HPX_COMPONENT_EXPORT parameter
{
// Default control parameters
bool irun; // 0 for initial run, any non-zero value for restart
std::size_t mstep; // # of time steps
std::size_t msnap; // # of snapshots
std::size_t ndiag; // do diag when mod(istep,ndiag)=0
double nonlinear; // 1.0 nonlinear run, 0.0 linear run
std::size_t nhybrid; // 0: adiabatic electron, >1: kinetic electron
double paranl; // 1: keep parallel nonlinearity
bool mode00; // 1 include (0,0) mode, 0 exclude (0,0) mode

// run size
double tstep; // time step (unit=L_T/v_th), tstep*\omega_transit<0.1
std::size_t micell; // # of ions per grid cell
std::size_t mecell; // # of electrons per grid cell
std::size_t mpsi; // total # of radial grid points
std::size_t mthetamax; // poloidal grid, even and factors of 2,3,5 for FFT
std::size_t mzetamax; // total # of toroidal grid points, domain decomp.
std::size_t npartdom; // number of particle domain partitions per tor dom.
std::size_t ncycle; // subcycle electron

// run geometry
double a; // minor radius, unit=R_0
double a0; // inner boundary, unit=a
double a1; // outer boundary, unit=a
double q0; // q_profile, q=q0 + q1*r/a + q2 (r/a)^2
double q1;
double q2;
double rc; // kappa=exp{-[(r-rc)/rw]**6}
double rw; // rc in unit of (a1+a0) and rw in unit of (a1-a0)

// species information
double aion; // species isotope #
double qion; // charge state
double aelectron;
double qelectron;

// equilibrium unit: R_0=1, Omega_c=1, B_0=1, m=1, e=1
double kappati; // grad_T/T
double kappate;
double kappan; // inverse of eta_i, grad_n/grad_T
bool fixed_Tprofile; // Maintain Temperature profile (0=no, >0 =yes)
double tite; // T_i/T_e
double flow0; // d phi/dpsi=gyroradius*[flow0+flow1*r/a+flow2*(r/a)**2]
double flow1;
double flow2;

// physical unit
double r0; // major radius (unit=cm)
double b0; // on-axis vacuum field (unit=gauss)
double temperature; // electron temperature (unit=ev)
double edensity0; // electron number density (1/cm^3)

// Output
std::size_t output;
bool nbound; // 0 for periodic, >0 for zero boundary
double umax; // unit=v_th, maximum velocity in each direction
bool iload; // 0: uniform, 1: non-uniform
double tauii; // -1.0: no collisions, 1.0: collisions
bool track_particles; // 1: keep track of some particles
bool nptrack; // track nptrack particles every time step
bool rng_control; // controls seed and algorithm for random num. gen.
// rng_control>0 uses the portable random num. gen.

std::vector<std::size_t> nmode,mmode;
};

} // detail

struct HPX_COMPONENT_EXPORT parameter
{
typedef detail::parameter value_type;
typedef value_type& reference;
typedef value_type const& const_reference;
typedef value_type* pointer;
typedef value_type const* const_pointer;

boost::shared_ptr<value_type> p;

parameter() : p(new value_type) {}

pointer operator->()
{ return p.get(); }

const_pointer operator->() const
{ return p.get(); }

reference operator*()
{ return *p; }

const_reference operator*() const
{ return *p; }
};

///////////////////////////////////////////////////////////////////////////////
}}}

#include <examples/gtc/serialize_parameter.hpp>

#endif

0 comments on commit 7f00d87

Please sign in to comment.