double Ti_over_Te;
double lambda; // in d_i
double pert;
double eta0;
// normalized quantities
double LLL; // lambda in d_e
double AA; // perturbation amplitude (from pert)
double Te, Ti;
};
#define to_psc_harris(psc) mrc_to_subobj(psc, struct psc_harris)
#define VAR(x) (void *)offsetof(struct psc_harris, x)
static struct param psc_harris_descr[] = {
{ "B0" , VAR(B0) , PARAM_DOUBLE(.5) },
{ "mi_over_me" , VAR(mi_over_me) , PARAM_DOUBLE(40.) },
{ "nb" , VAR(nb) , PARAM_DOUBLE(.3) },
{ "LLy" , VAR(LLy) , PARAM_DOUBLE(50.) },
{ "LLz" , VAR(LLz) , PARAM_DOUBLE(200.) },
{ "Ti_over_Te" , VAR(Ti_over_Te) , PARAM_DOUBLE(1.) },
{ "lambda" , VAR(lambda) , PARAM_DOUBLE(2.) },
{ "pert" , VAR(pert) , PARAM_DOUBLE(.025) },
{ "eta0" , VAR(eta0) , PARAM_DOUBLE(.0) },
{},
};
#undef VAR
// ----------------------------------------------------------------------
// psc_harris_create
};
#define MAX_KINDS (2)
struct psc_es1 {
// parameters
double om_pe;
double om_ce;
struct psc_es1_species species[MAX_KINDS];
};
#define to_psc_es1(psc) mrc_to_subobj(psc, struct psc_es1)
#define VAR(x) (void *)offsetof(struct psc_es1, x)
static struct param psc_es1_descr[] = {
{ "om_pe" , VAR(om_pe) , PARAM_DOUBLE(1.) },
{ "om_ce" , VAR(om_ce) , PARAM_DOUBLE(2.) },
{ "nlg_1" , VAR(species[0].nlg) , PARAM_INT(1) },
{ "q_1" , VAR(species[0].q) , PARAM_DOUBLE(-1.) },
{ "m_1" , VAR(species[0].m) , PARAM_DOUBLE(1.) },
{ "mode_1" , VAR(species[0].mode) , PARAM_DOUBLE(1.) },
{ "v0_1" , VAR(species[0].v0) , PARAM_DOUBLE(0.) },
{ "x1_1" , VAR(species[0].x1) , PARAM_DOUBLE(.001) },
{ "v1_1" , VAR(species[0].v1) , PARAM_DOUBLE(0.) },
{ "thetax_1" , VAR(species[0].thetax), PARAM_DOUBLE(0.) },
{ "thetav_1" , VAR(species[0].thetav), PARAM_DOUBLE(0.) },
{ "nlg_2" , VAR(species[1].nlg) , PARAM_INT(1) },
{ "q_2" , VAR(species[1].q) , PARAM_DOUBLE(-1.) },
{ "m_2" , VAR(species[1].m) , PARAM_DOUBLE(1.) },
double xm = sub->xm;
double s = 1 + a*(pow(x, (2.*xn)));
double sm = pow(s, xm);
double dg = d0 * (sm + xm*x*2.*xn*a*(pow(x, (2.*xn-1.))) * sm / s);
double g = d0 * x * sm - sub->xshift;
xx[i] = g;
dx[i] = dg;
}
}
// ----------------------------------------------------------------------
// mrc_crds_gen "ggcm_yz" description
#define VAR(x) (void *)offsetof(struct mrc_crds_gen_ggcm_yz, x)
static struct param mrc_crds_gen_ggcm_yz_descr[] = {
{ "center_spacing" , VAR(dx0) , PARAM_DOUBLE(.4) },
{ "center_shift" , VAR(xshift) , PARAM_DOUBLE(0.) },
{ "xn" , VAR(xn) , PARAM_DOUBLE(2.) },
{ "xm" , VAR(xm) , PARAM_DOUBLE(.5) },
{},
};
#undef VAR
// ----------------------------------------------------------------------
// mrc_crds_gen subclass "ggcm_yz"
struct mrc_crds_gen_ops mrc_crds_gen_ggcm_yz_ops = {
.name = "ggcm_yz",
.size = sizeof(struct mrc_crds_gen_ggcm_yz),
.param_descr = mrc_crds_gen_ggcm_yz_descr,
.run = mrc_crds_gen_ggcm_yz_run,
#include <mrc_params.h>
#include <math.h>
struct psc_test_microsphere {
// parameters
double radius; //< radius of spherical shell
double thickness; //< thickness of shell
double xc[3]; //< center of sphere, physical coords
double width_normal; //< pulse width normal to propagation direction
double width_parallel; //< pulse width along propagation direction
};
#define VAR(x) (void *)offsetof(struct psc_test_microsphere, x)
static struct param psc_test_microsphere_descr[] = {
{ "radius" , VAR(radius) , PARAM_DOUBLE(2.e-6) },
{ "thickness" , VAR(thickness) , PARAM_DOUBLE(.4e-6) },
{ "center" , VAR(xc) , PARAM_DOUBLE3(5e-6, 5e-6, 5e-6) },
{ "width_normal" , VAR(width_normal) , PARAM_DOUBLE(3e-6) },
{ "width_parallel", VAR(width_parallel) , PARAM_DOUBLE(2e-6) },
{},
};
#undef VAR
static void
psc_test_microsphere_create(struct psc *psc)
{
psc->prm.nicell = 10;
psc->prm.nmax = 201;
psc->domain.length[0] = 10 * 1e-6;
{
struct ggcm_mhd_ic_harris *sub = ggcm_mhd_ic_harris(ic);
double yy = crd[1];
switch (m) {
case 2: return sub->B_0_bg * yy;
default: return 0.;
}
}
// ----------------------------------------------------------------------
// ggcm_mhd_ic_harris_descr
#define VAR(x) (void *)offsetof(struct ggcm_mhd_ic_harris, x)
static struct param ggcm_mhd_ic_harris_descr[] = {
{ "n_0" , VAR(n_0) , PARAM_DOUBLE(1.0) },
{ "n_inf" , VAR(n_inf) , PARAM_DOUBLE(0.2) },
{ "B_0" , VAR(B_0) , PARAM_DOUBLE(1.0) },
{ "cs_width" , VAR(cs_width) , PARAM_DOUBLE(0.5) },
{ "pert" , VAR(pert) , PARAM_DOUBLE(0.1) },
{ "pert_halfwidth" , VAR(pert_halfwidth) , PARAM_DOUBLE(6.4) },
{ "B_0_bg" , VAR(B_0_bg) , PARAM_DOUBLE(0.) },
{},
};
#undef VAR
// ----------------------------------------------------------------------
// ggcm_mhd_ic_harris_ops
struct ggcm_mhd_ic_ops ggcm_mhd_ic_harris_ops = {
.name = "harris",
{ .val = BND_FLD_TIME , .str = "time" },
{ .val = BND_FLD_CONDUCTING_WALL, .str = "conducting_wall" },
{},
};
static struct mrc_param_select bnd_part_descr[] = {
{ .val = BND_PART_REFLECTING , .str = "reflecting" },
{ .val = BND_PART_PERIODIC , .str = "periodic" },
{ .val = BND_PART_ABSORBING , .str = "absorbing" },
{ .val = BND_PART_OPEN , .str = "open" },
{},
};
static struct param psc_descr[] = {
// psc_domain
{ "length_x" , VAR(domain.length[0]) , PARAM_DOUBLE(1e-6) },
{ "length_y" , VAR(domain.length[1]) , PARAM_DOUBLE(1e-6) },
{ "length_z" , VAR(domain.length[2]) , PARAM_DOUBLE(20e-6) },
{ "corner_x" , VAR(domain.corner[0]) , PARAM_DOUBLE(0.) },
{ "corner_y" , VAR(domain.corner[1]) , PARAM_DOUBLE(0.) },
{ "corner_z" , VAR(domain.corner[2]) , PARAM_DOUBLE(0.) },
{ "gdims_x" , VAR(domain.gdims[0]) , PARAM_INT(1) },
{ "gdims_y" , VAR(domain.gdims[1]) , PARAM_INT(1) },
{ "gdims_z" , VAR(domain.gdims[2]) , PARAM_INT(400) },
{ "np_x" , VAR(domain.np[0]) , PARAM_INT(1) },
{ "np_y" , VAR(domain.np[1]) , PARAM_INT(1) },
{ "np_z" , VAR(domain.np[2]) , PARAM_INT(1) },
{ "bnd_field_lo_x", VAR(domain.bnd_fld_lo[0]) , PARAM_SELECT(BND_FLD_PERIODIC,
bnd_fld_descr) },
{ "bnd_field_lo_y", VAR(domain.bnd_fld_lo[1]) , PARAM_SELECT(BND_FLD_PERIODIC,
