Index to C++ classes

Doxygen generates an HTML reference manual from stylized comments written into the EXP class definitions. This allows us to visualize the relationships between the various classes by providing dependency graphs, inheritance diagrams, and collaboration diagrams, which are all generated automatically.

In short, Doxygen is a development resource while this ReadTheDocs manual is a user resource. For this reason, Doxygen is optional and not built by default. You may opt-in to the Doxygen build when compiling EXP using the BUILD_DOCS feature (installing EXP). The resulting HTML directory is in source_dir/doc/html. Please see the Doxygen web site <https://www.doxygen.nl> to learn more.

A brief summary of the automatically-generated documentation is provide in the links below.

All classes, members, and utilities

• Index

Code reference with inheritance diagrams

template<typename T>
class abstract_value : public cxxopts::Value

#include <cxxopts.H>

Inheritence diagram for cxxopts::values::abstract_value:

Collaboration diagram for cxxopts::values::abstract_value:

Subclassed by cxxopts::values::standard_value< T >

Public Functions

inline abstract_value()

inline abstract_value(const abstract_value &rhs)

inline explicit abstract_value(T *t)

inline virtual std::shared_ptr<Value> default_value(const std::string &value) override

inline const T &get() const

inline virtual std::string get_default_value() const override

inline virtual std::string get_implicit_value() const override

inline virtual bool has_default() const override

inline virtual bool has_implicit() const override

inline virtual std::shared_ptr<Value> implicit_value(const std::string &value) override

inline virtual bool is_boolean() const override

inline virtual bool is_container() const override

inline virtual std::shared_ptr<Value> no_implicit_value() override

abstract_value &operator=(const abstract_value&) = default

inline virtual void parse() const override

inline virtual void parse(const std::string &text) const override

~abstract_value() override = default

Protected Attributes

bool m_default = false

std::string m_default_value = {}

bool m_implicit = false

std::string m_implicit_value = {}

std::shared_ptr<T> m_result = {}

T *m_store = {}

Private Types

using Self = abstract_value<T>

class AddDisk

#include <AddDisk.H>

Public Functions

AddDisk(std::shared_ptr<AxiSymModel> halo, std::shared_ptr<AxiSymModel> disk, double dmass)

inline std::shared_ptr<SphericalModelTable> get_model()

~AddDisk()

Public Static Attributes

static bool logarithmic

static int number

static double Rmin

static bool use_mpi

Private Members

std::vector<double> d

double dmass

std::vector<double> m

std::shared_ptr<SphericalModelTable> mod

std::vector<double> p

std::vector<double> r

class AddSpheres

#include <AddSpheres.H>

Public Functions

AddSpheres(std::shared_ptr<AxiSymModel> halo, std::shared_ptr<AxiSymModel> bulge, double bmass)

inline std::shared_ptr<SphericalModelTable> get_model()

~AddSpheres()

Public Static Attributes

static bool logarithmic

static int number

static double Rmin

static bool use_mpi

Private Members

double bmass

std::vector<double> d

std::vector<double> m

std::shared_ptr<SphericalModelTable> mod

std::vector<double> p

std::vector<double> r

struct ANGLE_GRID

#include <orbit.H>

Public Members

Eigen::MatrixXd dw1dt

Eigen::MatrixXd f

Eigen::MatrixXd fr

int num

Eigen::MatrixXd r

Eigen::MatrixXd t

Eigen::MatrixXd w1

struct ArguDesc

#include <cxxopts.H>

Public Members

std::string arg_name = ""

bool grouping = false

bool set_value = false

std::string value = ""

class argument_incorrect_type : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::argument_incorrect_type:

Collaboration diagram for cxxopts::argument_incorrect_type:

Public Functions

inline explicit argument_incorrect_type(const std::string &arg)

template<typename T = double>
class AsciiHisto

#include <AsciiHisto.H>

Process a std::vector into an ASCII histogram.

Public Functions

inline AsciiHisto(const std::vector<T> &d, int nbins = 0, bool logV = false)

Simple constructor.

inline AsciiHisto(const std::vector<T> &data, int nbins, double trim, bool logV = false)

Constructor with bin number and trim.

inline AsciiHisto(const std::vector<unsigned> &inbins, const T &inBeg, const T &inEnd, bool logV = false)

Constructor for pre-existing bins.

inline void operator()(std::ostream &out, unsigned hwid = 60)

Print the distribution.

Private Functions

inline void makeBins(const std::vector<T> &d, int nbins)

Private Members

T beg

std::vector<unsigned> bins

T dx

T end

bool logH

class AxiDisk

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL::AxiDisk:

Axisymmetric disk density function for deprojection.

Subclassed by DoubleExponential, Exponential, FEED, Ferrers, MNdisk, PyModel, Truncated, diskbulge

Public Functions

inline AxiDisk(double M = 1, std::string id = "AxiDisk")

Constructor.

inline std::string getID()

Get ID.

inline int getMass()

Get Mass.

inline std::vector<double> getParams()

Get parameters.

virtual double operator()(double R, double z, double phi = 0.) = 0

Density function.

Protected Attributes

std::string ID

double M

std::vector<double> params

class AxiSymBiorth : public Biorth

#include <biorth.H>

Inheritence diagram for AxiSymBiorth:

Collaboration diagram for AxiSymBiorth:

Subclassed by BSDisk, BSSphere, BiorthGrid, CBDisk, CBSphere, HQSphere, SphereSL

Public Functions

inline AxiSymBiorth(int DOF = 0)

virtual double d_r_to_rb(double const) = 0

virtual double dens(const int, const int, const double) = 0

virtual void dens(const int, const int, const double, Eigen::VectorXd&) = 0

double get_dens(double r, int l, const Eigen::VectorXd &coef)

inline int get_dof(void)

double get_potl(double r, int l, const Eigen::VectorXd &coef)

virtual double potl(const int, const int, const double) = 0

virtual void potl(const int, const int, const double, Eigen::VectorXd&) = 0

virtual double potlR(const int, const int, const double) = 0

virtual double potlRZ(const int, const int, const double, const double) = 0

virtual double r_to_rb(double const) = 0

virtual double rb_max(void) = 0

virtual double rb_min(void) = 0

virtual double rb_to_r(double const) = 0

inline virtual ~AxiSymBiorth()

Protected Attributes

int dof

Friends

friend class BiorthWake

class AxisymmetricBasis : public Basis

#include <AxisymmetricBasis.H>

Inheritence diagram for AxisymmetricBasis:

Collaboration diagram for AxisymmetricBasis:

Defines a basis-based potential and acceleration class.

YAML configuration

Param Lmax:

is the maximum spherical harmonic order

Param Mmax:

is the maximum cylindrical harmonic order

Param nmax:

is the maximum radial order

Param dof:

is the dimensionality of the basis

Param npca:

is the frequency for pca analyses

Param npca0:

is the number of steps to skip before the first pca analysis

Param pcavar:

boolean turns on pca analyses

Param pcaeof:

boolean turns on emperical function recomputation

Param pcadiag:

boolean turns on diagnostic pca output

Param pcavtk:

boolean prints out visualizable representations of pca info

Param hexp:

is the Hall smoothing exponent

Param samplesz:

is the number of subsamples for pca variance analysis (default: 1). Value 0 means use sqrt number of particles

Param vtkfreq:

is the frequency for printing pca variance analysis info

Param tksmooth:

is the S/N for Hall truncation for VarianceCut method

Param tkcum:

is the cumulative fraction eigenvalue power for truncation for CmululativeCut method

Param tk_type:

is the smoothing type, one of: Hall, VarianceCut, CumulativeCut, VarianceWeighted

Param subsamp:

true sets partition variance computation (default: false)

Subclassed by PolarBasis, SphericalBasis

Public Types

enum TKType

Enum listing the possible selection algorithms for coefficient selection

Values:

enumerator Hall

Tapered signal-to-noise power defined by Hall

enumerator VarianceCut

Cut all coefficients below some S/N level

enumerator CumulativeCut

Cut coefficients below some cumulative fraction

enumerator VarianceWeighted

Weight coefficients be S/N for S/N<1

enumerator None

Compute the S/N but do not modify coefficients

Public Functions

AxisymmetricBasis(Component *c0, const YAML::Node &line)

Constructor.

inline VectorP getCoefs(int l) const

Access coefficients.

inline int getLmax()

Get angular order.

inline int getMmax()

inline int getNmax()

Get radial order.

inline virtual void multistep_reset()

Reset used particle counter.

void pca_hall(bool compute)

Compute component noise suppression using PCA analysis.

void pca_hall_2d(bool compute)

void pca_hall_3d(bool compute)

TKType setTK(const std::string &tk)

Set tk_type from string.

virtual ~AxisymmetricBasis()

Destructor.

Protected Types

typedef std::shared_ptr<Eigen::MatrixXd> MatrixP

typedef std::shared_ptr<Eigen::VectorXd> VectorP

Expansion coefficients (summed over all nodes)

The vector entries store coefficients for a multistep expansion. Move pointers rather than objects for efficiency.

Protected Functions

virtual void parallel_distribute_coefficients(void)

MPI routines to distribution the expansion coefficients (expcoef) from all nodes.

virtual void parallel_gather_coef2(void)

MPI routines to sum the expansion coefficients variance moments (cc) from all nodes.

virtual void parallel_gather_coefficients(void)

MPI routines to sum the expansion coefficients (expcoef) from all nodes.

inline void swap_coefs(std::vector<VectorP> &from, std::vector<VectorP> &to)

Swap coefficients.

Protected Attributes

unsigned defSampT

std::vector<VectorP> expcoef

std::vector<VectorP> expcoef1

std::vector<std::vector<VectorP>> expcoefL

std::vector<std::vector<MatrixP>> expcoefM

std::vector<std::vector<MatrixP>> expcoefM1

std::vector<std::vector<VectorP>> expcoefN

Interpolation arrays.

std::vector<VectorP> expcoefP

std::vector<std::vector<VectorP>> expcoefT

Covariance arrays.

std::vector<std::vector<VectorP>> expcoefT1

double hexp

Hall smoothing exponent (default: 1.0)

int Lmax

Maximum angular harmonic.

std::vector<double> massT

Mass and counts for subsample covariance.

std::vector<double> massT1

int Mmax

double muse

Accumulated mass for variance computation.

int nmax

Maximum radial basis index.

Eigen::MatrixXd normM

Normalization for covariance matrix based on the biorthogonal basis norm.

int npca

Frequency of PCA computation.

int npca0

First step for PCA computation.

bool pcadiag

Output PCA diagnostics.

bool pcaeof

Compute eof decomposition.

bool pcavar

Use principal component bootstrap analysis of variance to select coefficients

bool pcavtk

Output PCA diagnostics in vtk format.

unsigned sampT

double snr

Signal-to-noise scaling parameter (default: 1.0)

Eigen::MatrixXd sqnorm

Sqr root of the normalization.

bool subsamp

Partitioned variance computation.

std::vector<MatrixP> tvar

Test for eof trim.

unsigned vtkfreq

VTK diagnostic frequency.

Protected Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

Private Members

std::vector<Eigen::VectorXd> b_Hall

Eigen::MatrixXd covar

Eigen::VectorXd cuml

Eigen::VectorXd eval

std::vector<Eigen::MatrixXd> evec

double fac02

Eigen::VectorXd inv

int L0

int Ldim

std::vector<Eigen::VectorXd> s_Hall

Eigen::VectorXd smth

std::vector<Eigen::MatrixXd> Tevec

TKType tk_type

double tkcum

double tksmooth

std::vector<Eigen::VectorXd> weight

class AxiSymModel : public MassModel, public std::enable_shared_from_this<AxiSymModel>

#include <massmodel.H>

Inheritence diagram for AxiSymModel:

Collaboration diagram for AxiSymModel:

A specification of a MassModel to the axisymmetric case.

Subclassed by CylDisk, DiskWithHalo, EmbeddedDiskModel, ExponentialDisk, GeneralizedPolytrope, HernquistSphere, HunterDisk, HunterDiskX, IsothermalSphere, KalnajsDisk, LowSingIsothermalSphere, MestelDisk, PlummerSphere, SingIsothermalSphere, SphericalModelMulti, SphericalModelTable, ToomreDisk

Public Types

using PSret = std::tuple<Eigen::VectorXd, int>

Public Functions

inline AxiSymModel(void)

Constructor.

virtual double d2fde2(double, double) = 0

virtual double dfde(double, double) = 0

virtual double dfdl(double, double) = 0

virtual double distf(double, double) = 0

inline virtual PSret gen_point()

Generate a phase-space point.

inline virtual PSret gen_point(double Emin, double Emax, double Kmin, double Kmax)

Generate a phase-space point at a particular energy and angular momentum.

inline virtual PSret gen_point(double r)

Generate a phase-space point at a particular radius.

inline virtual PSret gen_point(double r, double theta, double phi)

Generate a phase-space point at a particular radius, theta, and phi.

inline virtual PSret gen_point_iso(double r, double theta, double phi, int N, int nv, int na, double PHI, double THETA, double PSI)

Generate a phase-space point at a particular radius, theta, and phi.

inline virtual PSret gen_point_jeans()

Generate a phase-space point using Jeans’ equations.

virtual int gen_velocity(double *pos, double *vel)

Generate a the velocity variate from a position.

inline virtual double get_density(const double x1, const double x2, const double x3) override

The density at (x, y, z)

virtual double get_density(const double) = 0

virtual double get_dpot(const double) = 0

virtual double get_dpot2(const double) = 0

inline virtual double get_mass(const double x1, const double x2, const double x3) override

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

virtual double get_mass(const double) = 0

Access the profile.

virtual double get_max_radius(void) = 0

virtual double get_min_radius(void) = 0

inline virtual double get_pot(const double x1, const double x2, const double x3) override

The potential at (x, y, z)

virtual double get_pot(const double) = 0

virtual void get_pot_dpot(const double, double&, double&) = 0

inline void set_Ecut(double cut)

Set cutoff on multimass realization grid.

inline void set_itmax(int s)

Maximum number of iterations for obtaining a valid variate.

inline virtual ~AxiSymModel()

Destructor.

Public Members

bool dist_defined

The distribution is defined and computed.

Public Static Attributes

static int gen_E

static bool gen_EJ

Stuff for gen_point.

static int gen_itmax

static int gen_K

static double gen_kmin

static int gen_logr

static int gen_N

static double gen_rmin

static double gen_tolE

static double gen_tolK

static int numj

static int numr

Protected Types

typedef vector<WRgrid> wrvector

Protected Functions

PSret gen_point_2d()

PSret gen_point_2d(double r)

PSret gen_point_3d()

PSret gen_point_3d(double Emin, double Emax, double Kmin, double Kmax)

PSret gen_point_3d(double r, double theta, double phi)

PSret gen_point_3d_iso(double r, double theta, double phi, int N, int nv, int na, double PHI = 0, double THETA = 0, double PSI = 0)

PSret gen_point_jeans_3d()

Protected Attributes

double dEgrid

double dKgrid

vector<double> Egrid

vector<double> EgridMass

double Emax_grid

double Emin_grid

std::normal_distribution Gauss

double gen_ecut

bool gen_firstime

bool gen_firstime_E

bool gen_firstime_jeans

Eigen::VectorXd gen_fmax

double gen_fomax

double gen_lastr = -1.0

Eigen::VectorXd gen_mass

SphericalOrbit gen_orb

Eigen::VectorXd gen_rloc

vector<double> Jmax

vector<double> Kgrid

vector<wrvector> Rgrid

std::uniform_real_distribution Unit

Stuff for gen_point.

class BadIndexException : public EXPException

#include <EXPException.H>

Inheritence diagram for BadIndexException:

Collaboration diagram for BadIndexException:

Handle bad range related exception PartMap.

Public Functions

inline BadIndexException(int index, int num, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = true)

Constructor.

class BarrierWrapper

#include <BarrierWrapper.H>

Collaboration diagram for BarrierWrapper:

Public Functions

BarrierWrapper(const BarrierWrapper &inst)

Copy constructor.

BarrierWrapper(MPI_Comm comm, bool label = false)

Constructor.

std::vector<int> getMissing(BWPtr p)

inline double getTime()

inline void off()

inline void on()

inline void operator()(const string &label, const char *file, const int line)

inline void setHeavyWeight()

inline void setLightWeight()

~BarrierWrapper()

Destructor.

Public Static Attributes

static int cbufsz

Buffer size for checking working labels.

static bool debugging

static bool extra_verbose

static string flOper

The source file containing the call.

static bool inOper

Set to true while control is in the wrapper.

static string lbOper

The label supplied by the caller.

static int lnOper

The source file line number with the call.

static int loop_delay

Loop wait in microseconds for heavy operator mode (default: 100)

static bool verbose

Debugging output flag.

Private Types

typedef std::pair<CharPtr, ReqPtr> RecvElem

Private Functions

void finalReport(std::string&)

void heavy_operator(const string &label, const char *file, const int line)

void light_operator(const string &label, const char *file, const int line)

void listReport(const char*, std::map<std::string, BWPtr>::iterator)

void syncTest(const std::string &mesg, const std::string &label)

void updateMap(InfoPtr p)

Private Members

char *buffer

char *bufferT

bool check_label

MPI_Comm comm

int commsize

int localid

unsigned nrecv

bool onoff

std::map<std::string, BWPtr> pending

unsigned queued

std::list<RecvElem> req

Timer timer

Private Static Attributes

static bool light

Friends

friend class Info

class Basis : public PotAccel

#include <Basis.H>

Inheritence diagram for Basis:

Collaboration diagram for Basis:

Defines a basis-based potential and acceleration class.

Subclassed by AxisymmetricBasis, Cylinder

Utility functions

void legendre_R(int lmax, double x, Eigen::MatrixXd &p)

Compute Associated Legendre Polynomials, return MatrixXd type.

void dlegendre_R(int lmax, double x, Eigen::MatrixXd &p, Eigen::MatrixXd &dp)

Compute Associated Legendre Polynomials and derivitives, return Matrix type

void sinecosine_R(int mmax, double phi, Eigen::VectorXd &c, Eigen::VectorXd &s)

Compute vectors of sines and cosines by recursion.

Public Functions

Basis(Component *c0, const YAML::Node &conf)

Constructor.

virtual void determine_acceleration_and_potential(void) = 0

All derived classes must provide a method to compute the force.

virtual void determine_fields_at_point(double x, double y, double z, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotx, double *tpoty, double *tpotz) = 0

Supply density, potential and derivatives at a point in Cartesian coordinates

virtual void determine_fields_at_point_cyl(double r, double z, double phi, double *tdens0, double *dpotl0, double *tdens, double *tpotl, double *tpotr, double *tpotz, double *tpotp) = 0

Supply density, potential and derivatives at a point in cylindrical coordinates

virtual void determine_fields_at_point_sph(double r, double theta, double phi, double *tdens0, double *dpotl0, double *tdens, double *tpotl, double *tpotr, double *tpott, double *tpotp) = 0

Supply density, potential and derivatives at a point in spherical coordinates

class Basis2d

#include <EmpCyl2d.H>

Two-d basis models.

Public Functions

virtual double dens(int M, int N, double r) = 0

virtual double dpot(int M, int N, double r) = 0

virtual double norm(int N, int M) = 0

virtual double potl(int M, int N, double r) = 0

Required basis-function members.

Public Static Functions

static std::shared_ptr<Basis2d> createBasis(int mmax, int nmaxfid, double rmax, const std::string &type)

Basis creation factory.

Public Static Attributes

static bool debug

Enable orthgonality check.

class Bess

#include <Bess.H>

Generate orthonormal Bessel functions of integral order.

Public Functions

inline Bess(double order, unsigned int nroots)

Constructor: set the order and number of radial functions.

inline double eval(double &x, unsigned &m)

Evaluate the Bessel for x in [0, 1] for radial order m.

inline double getNorm(int m)

Get the norm for radial order m.

inline double operator()(double &x, const unsigned &m)

Evaluate the Bessel for x in [0, 1] for radial order m.

Private Functions

std::tuple<double, double> bracket(std::function<double(double)> B, double zmin, double z0)

std::vector<double> zeros(double Nu, int Nz, double tol = 1.0e-18)

Private Members

std::vector<double> norm

unsigned int nroots

double order

std::vector<double> roots

class Bessel : public SphericalBasis

#include <Bessel.H>

Inheritence diagram for Bessel:

Collaboration diagram for Bessel:

Computes the potential, acceleration and density using eigenfunctions of the Spherical Laplacian: spherical Bessel functions

Public Functions

Bessel(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor.

inline virtual ~Bessel()

Destructor.

Private Functions

double dens(double r, int n)

Density and potential members.

double get_dens(double r, int l, double *coef)

virtual void get_dens(int lmax, int nmax, double r, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

void get_dens_coefs(int l, double *coef, double *p)

virtual void get_dpotl(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &dp, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• dp – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

void get_pot_coefs(int l, double *coef, double *p, double *dp)

Required members for Spherical Basis.

void get_pot_coefs_safe(int l, double *coef, double *p, double *dp, double **potd1, double **dpot1)

virtual void get_potl(int lmax, int nmax, double r, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void initialize()

Initialize parameters from YAML.

void make_grid(double rmin, double rmax, int lmax, int nmax)

Make the density and potential grid.

double potl(double r, int n)

Private Members

std::vector<RGrid> dens_grid

Grid storage and parameters.

bool firstime_accel

bool firstime_coef

std::shared_ptr<Roots> p

Root database isntance.

std::vector<RGrid> potl_grid

Eigen::VectorXd r_grid

double r_grid_del

int RNUM

Number of entries in the fixed table.

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Biorth

#include <biorth.H>

Inheritence diagram for Biorth:

Subclassed by AxiSymBiorth, OneDBiorth

Public Functions

inline void bomb(const char *s)

virtual double dens(const int, const int, const double) = 0

inline const std::string &id(void)

virtual double krnl(const int, const int) = 0

virtual double norm(const int, const int) = 0

virtual double potl(const int, const int, const double) = 0

inline virtual ~Biorth()

Public Members

std::string BiorthID

class BiorthCube

#include <BiorthCube.H>

! BiorthCube grid class

Public Types

using coefType = Eigen::Tensor<std::complex<double>, 3>

Coefficient type.

Public Functions

BiorthCube(const YAML::Node &conf)

Constructor.

std::complex<double> dens(Eigen::Vector3d x, Eigen::Vector3i n)

Get density for dimensionless coord with harmonic order l and radial orer n

Eigen::Vector3cd force(Eigen::Vector3d x, Eigen::Vector3i n)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

std::complex<double> get_dens(const coefType &c, Eigen::Vector3d x)

Get density for dimensionless coord with harmonic order l and radial orer n

Eigen::Vector3cd get_force(const coefType &c, Eigen::Vector3d x)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

std::complex<double> get_pot(const coefType &c, Eigen::Vector3d x)

Get potential for dimensionless coord with harmonic order m and radial orer n.

Eigen::MatrixXcd orthoCheck()

For pyEXP.

std::complex<double> pot(Eigen::Vector3d x, Eigen::Vector3i n)

Get potential for dimensionless coord with harmonic order m and radial orer n.

inline virtual ~BiorthCube()

Destructor.

Public Static Attributes

static int mpi

Flag for MPI enabled (default: 0=off)

Protected Attributes

YAML::Node conf

std::string forceID

std::string geometry

int knots

Eigen::Vector3i nmax

Eigen::Vector3i nmin

bool verbose

Protected Static Attributes

static constexpr double dfac = 2.0 * M_PI

static constexpr std::complex<double> kfac = {0.0, dfac}

class BiorthCyl

#include <BiorthCyl.H>

Collaboration diagram for BiorthCyl:

! BiorthCyl grid class

Public Functions

BiorthCyl(const YAML::Node &conf)

Constructor.

double d_xi_to_r(double x)

Jacobian of nondimensional radial coordinate mapping.

double d_yi_to_z(double y)

Jacobian of nondimensional vertical coordinate mapping.

void dump_basis(const string &name)

Dump the basis for plotting.

inline double get_dens(double x, double y, int m, int n)

Get density for dimensionless coord with harmonic order l and radial orer n

inline void get_dens(Eigen::MatrixXd &d, double r, double z)

Get density for dimensionless coord with harmonic order l and radial orer n

inline double get_pot(double x, double y, int m, int n)

Get potential for dimensionless coord with harmonic order m and radial orer n.

inline void get_pot(Eigen::MatrixXd &p, double r, double z)

Get potential for dimensionless coord with harmonic order m and radial orer n.

void get_pot(Eigen::MatrixXd &Vc, Eigen::MatrixXd &Vs, double r, double z)

Evaluate all orders in matrices; for n-body.

inline double get_rforce(double x, double y, int m, int n)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

inline void get_rforce(Eigen::MatrixXd &f, double r, double z)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

inline double get_zforce(double x, double y, int m, int n)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

inline void get_zforce(Eigen::MatrixXd &f, double r, double z)

Get radial force for dimensionless coord with harmonic order l and radial orer n.

inline const std::string getBiorthName()

Get biorthogonal function base name.

inline const std::string getModelName()

Get model name.

inline double getRtable()

Get the table bounds.

inline double getXmax()

inline double getXmin()

Get table range bounds.

inline double getYmax()

inline double getYmin()

std::vector<Eigen::MatrixXd> orthoCheck()

For pyEXP.

double r_to_xi(double r)

Map radial coordinate to nondimensional coordinate.

double xi_to_r(double x)

Map nondimensional coordinate to radial coordinate.

double yi_to_z(double y)

Map of nondimensional coordinate to vertical coordinate.

double z_to_yi(double z)

Map of vertical coordinate to nondimesional coordinate.

inline virtual ~BiorthCyl()

Destructor.

Public Static Functions

static std::map<std::string, std::string> cacheInfo(const std::string &cachefile, bool verbose = true)

Read and print the cache and return the header parameters as a map/dictionary

static YAML::Node getHeader(const std::string &cachefile)

Read the cache and report parameters.

Public Static Attributes

static int mpi

Flag for MPI enabled (default: 0=off)

Protected Functions

void create_tables()

Build basis tables.

void initialize()

Create storage arrays.

void interp(double R, double z, const std::vector<std::vector<Eigen::MatrixXd>> &mat, Eigen::MatrixXd &ret, bool anti_symmetric = false)

Matrix interpolation on grid for coefficient composition.

double interp(int m, int n, double R, double z, const std::vector<std::vector<Eigen::MatrixXd>> &mat, bool anti_symmetric = false)

Interpolate on grid.

virtual void ReadH5Arrays(HighFive::Group &arrays)

Read the basis arrays.

virtual bool ReadH5Cache()

Read the HDF5 cache.

virtual void WriteH5Arrays(HighFive::Group &arrays)

Write the basis arrays.

virtual void WriteH5Cache()

Write the HDF5 cache.

virtual void WriteH5Params(HighFive::File &file)

Write parameter attributes (needed for derived classes)

Protected Attributes

double acylcut

double acyltbl

std::string biorth

std::string cachename

Active cache file name.

int cmapR

Grid parameters.

int cmapZ

YAML::Node conf

std::vector<std::vector<Eigen::MatrixXd>> dens

Storage for basis arrays.

YAML::Node diskconf

std::string disktype

Density target name.

double dx

double dy

EmpCyl2d emp

The 2d basis instance.

bool EVEN_M

std::string forceID

std::string geometry

int knots

bool logr

int mlim

int mmax

int mmin

double Mouter

double Ninner

int nlim

int nmax

int nmaxfid

int nmin

int NQDHT

int numr

int numx

int numy

std::vector<std::vector<Eigen::MatrixXd>> pot

double rcylmax

double rcylmin

std::vector<std::vector<Eigen::MatrixXd>> rforce

double scale

bool use_mpi

bool verbose

double xmax

double xmin

double ymax

double ymin

std::vector<std::vector<Eigen::MatrixXd>> zforce

Protected Static Attributes

static std::string Version

Cache versioning.

class BiorthGrid : public AxiSymBiorth

#include <biorth.H>

Inheritence diagram for BiorthGrid:

Collaboration diagram for BiorthGrid:

Public Functions

BiorthGrid(AxiSymBioPtr T, double RMIN = 0.0, double RMAX = 20, int NMAX = 10, int LMAX = 10, int RNUM = 400)

inline virtual double d_r_to_rb(double const r)

inline virtual void dens(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double dens(const int nn, const int l, const double rb)

inline double densR(const int nn, const int l, const double r)

inline virtual double krnl(const int n, const int l)

inline virtual double norm(const int n, const int l)

inline virtual void potl(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double potl(const int nn, const int l, const double rb)

inline virtual double potlR(const int nn, const int l, const double r)

inline virtual double potlRZ(const int nn, const int l, const double r, const double z)

inline virtual double r_to_rb(double const r)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

inline virtual double rb_to_r(double const rb)

inline virtual ~BiorthGrid()

Private Members

std::vector<Eigen::MatrixXd> dens_grid

std::vector<Eigen::MatrixXd> dens_grid2

Eigen::MatrixXd krnl_grid

int lmax

int nmax

Eigen::MatrixXd norm_grid

std::vector<Eigen::MatrixXd> potl_grid

std::vector<Eigen::MatrixXd> potl_grid2

double rmax

double rmin

int rnum

AxiSymBioPtr t

Eigen::VectorXd x_grid

double xmax

double xmin

class BiorthWake

#include <biorth_wake.H>

Collaboration diagram for BiorthWake:

Public Functions

void accumulate(double x, double y, double z, double mass)

BiorthWake(AxiSymBiorth *BIO, int LMAX, int NMAX)

double energy(std::vector<double> &params)

inline int get_amoeba_iterations(void)

void orientation(int L, int M, Eigen::VectorXd &phi, Eigen::VectorXd &theta, Eigen::VectorXd &psi, Eigen::VectorXd &cost)

void reconstruct(double r, double costh, double phi, double &dens0, double &dens, double &potl0, double &potl, int L1 = 0, int L2 = 10000)

void reset_coefs(void)

inline void set_scale(const double scl)

~BiorthWake(void)

Private Functions

void accumulate_2d(double x, double y, double mass)

void accumulate_3d(double x, double y, double z, double mass)

void amoeba(void)

double amoeba_energy(std::vector<double> &params)

double amotry(int ihi, double fac)

void bomb(const char *s)

void check_orientation(double, double, double)

void get_transform(double &phi, double &theta, double &psi, double &cost)

void modulo_param(std::vector<double> &params)

void orientation_init(void)

void reconstruct_2d(double r, double phi, double &dens0, double &dens, double &potl0, double &potl, int L1 = 0, int L2 = 10000)

void reconstruct_3d(double r, double costh, double phi, double &dens0, double &dens, double &potl0, double &potl, int L1 = 0, int L2 = 10000)

std::complex<double> test_fct(double, double)

void test_transform(void)

Private Members

std::vector<std::vector<double>> ambp

std::vector<double> amby

AxiSymBiorth *bio

bool coefs_defined

Eigen::MatrixXd expcoef

Eigen::MatrixXd factorial

std::complex<double> I

bool init_orientation

int iter

int ll

int lmax

int mm

int nfunk

int nmax

Eigen::MatrixXd norm_grid

std::vector<double> param

std::vector<double> psum

std::vector<double> ptry

double rscl

double tol

int used

Eigen::VectorXcd ylm

Private Static Attributes

static int iterDef

static int ndim

static double tolDef

class BSDisk : public AxiSymBiorth

#include <biorth2d.H>

Inheritence diagram for BSDisk:

Collaboration diagram for BSDisk:

Public Functions

BSDisk(double RMAX, int NMAX, int MMAX)

inline virtual double d_r_to_rb(double const r)

virtual double dens(const int n, const int m, const double r)

virtual void dens(const int n, const int m, const double r, Eigen::VectorXd &a)

inline double densR(const int n, const int m, const double r)

inline virtual double krnl(const int n, const int m)

virtual double norm(const int n, const int m)

virtual double potl(const int n, const int m, const double r)

virtual void potl(const int n, const int m, const double r, Eigen::VectorXd &a)

inline virtual double potlR(const int n, const int m, const double r)

virtual double potlRZ(const int n, const int m, const double r, const double z)

inline virtual double r_to_rb(double const r)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

inline virtual double rb_to_r(double const r)

~BSDisk()

Private Functions

void setup_potl_table(void)

Private Members

std::vector<Eigen::VectorXd> a

int mmax

int nmax

int numz

double rmax

Eigen::VectorXd t_dr

Eigen::MatrixXd t_f

int t_n

Eigen::MatrixXd t_y

class BSSphere : public AxiSymBiorth

#include <biorth.H>

Inheritence diagram for BSSphere:

Collaboration diagram for BSSphere:

Public Functions

BSSphere(double RMAX = 1.0, int NMAX = 10, int LMAX = 10)

inline virtual double d_r_to_rb(double const r)

virtual void dens(const int nn, const int l, const double r, Eigen::VectorXd &t)

virtual double dens(const int nn, const int l, const double rb)

inline double densR(const int nn, const int l, const double r)

inline virtual double krnl(const int nn, const int l)

inline virtual double norm(const int nn, const int l)

virtual void potl(const int nn, const int l, const double r, Eigen::VectorXd &t)

virtual double potl(const int nn, const int l, const double rb)

inline virtual double potlR(const int nn, const int l, const double r)

inline virtual double potlRZ(const int nn, const int l, const double r, const double z)

inline virtual double r_to_rb(double const r)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

inline virtual double rb_to_r(double const r)

virtual ~BSSphere()

Private Functions

void setup_potl_table(void)

Private Members

std::vector<Eigen::VectorXd> a

int lmax

int nmax

double rmax

Eigen::VectorXd t_dr

Eigen::MatrixXd t_f

Eigen::MatrixXd t_g

int t_n

Eigen::MatrixXd t_y

template<bool isConst = false>
struct BufferIterator

Public Types

typedef std::conditional<isConst, constcircular_buffer<value_type>*, circular_buffer<value_type>*>::type cbuf_pointer

typedef ptrdiff_t difference_type

typedef std::random_access_iterator_tag iterator_category

typedef std::conditional<isConst, constvalue_type*, value_type*>::type pointer

typedef std::conditional<isConst, constvalue_type&, value_type&>::type reference

typedef T value_type

Public Functions

inline BufferIterator()

inline BufferIterator(const BufferIterator<false> &it)

inline bool operator!=(const BufferIterator &other) const

inline reference operator*()

inline BufferIterator &operator++()

inline BufferIterator operator++(int)

inline BufferIterator &operator+=(difference_type n)

inline BufferIterator &operator--()

inline BufferIterator operator--(int)

inline BufferIterator &operator-=(difference_type n)

inline pointer operator->()

inline bool operator<(const BufferIterator &other) const

inline bool operator<=(const BufferIterator &other) const

inline bool operator==(const BufferIterator &other) const

inline bool operator>(const BufferIterator &other) const

inline bool operator>=(const BufferIterator &other) const

inline reference operator[](size_type index)

Friends

friend class circular_buffer< T >

inline friend BufferIterator operator+(BufferIterator lhsiter, difference_type n)

inline friend BufferIterator operator+(difference_type n, BufferIterator rhsiter)

inline friend BufferIterator operator-(BufferIterator lhsiter, difference_type n)

inline friend difference_type operator-(const BufferIterator &lhsiter, const BufferIterator &rhsiter)

class bw_struct

#include <BWHelper.H>

Public Functions

inline bw_struct(int localid, int commsize)

inline bw_struct(int owner, time_t first)

Public Members

unsigned count

time_t expire

time_t first

std::vector<bool> nd

int owner

Public Static Attributes

static int dt1

Number of seconds before first alarm.

static int dt2

Number of seconds before all sebsequent alarms.

class BWData

#include <BarrierWrapper.H>

Public Functions

void Add(InfoPtr &p)

Register node in existing entry.

BWData(InfoPtr &p, int commsize)

Full constructor.

int Owner()

Return the valid node with the lowest rank.

Public Members

unsigned count

Number of entries registered.

time_t expire

time_t first

Times: initial and next expiration.

std::list<InfoPtr> info

Cache Info shared pointers; storage reclaimed on destruction.

std::vector<bool> nd

Array of received entries.

unsigned nexpiry

Number of alarm expirations.

Public Static Attributes

static int dt1

Number of seconds before first alarm.

static int dt2

Number of seconds before all subsequent alarms.

template<typename key_t, typename value_t>
class Cache : public std::map<key_t, value_t>

#include <KDtree.H>

Inheritence diagram for KDtree::Cache:

Collaboration diagram for KDtree::Cache:

Wrapper class for std::map to keep a finite size.

Public Functions

inline void add(key_t key, value_t value)

inline Cache(int N = 1)

inline void resize(int N)

Private Members

int max_size

class CBDisk : public AxiSymBiorth, public PolarBasis

#include <biorth2d.H>

Inheritence diagram for CBDisk:

Collaboration diagram for CBDisk:

Reference implemenation of the Clutton-Brock disk basis

Parameters

Param mmax:

is the maximum azimuthal order

Param Lmax:

alias for mmax

Param Mmax:

alias for mmax

Param scale:

radius for coordinate scaling. By default, the core radius of the Clutton-Brock density is 1.

Public Functions

CBDisk(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor

Parameters:

• c0 – is the instantiating caller (Component)

• conf – passes any parameters to basis instance

• scale – is the radius for coordinate scaling

CBDisk(void)

inline virtual double d_r_to_rb(double const r)

virtual double dens(const int n, const int m, const double r)

virtual void dens(const int n, const int m, const double r, Eigen::VectorXd &a)

inline double densR(const int n, const int m, const double r)

inline virtual double krnl(const int n, const int m)

virtual double norm(const int n, const int m)

virtual double potl(const int n, const int m, const double r)

virtual void potl(const int n, const int m, const double r, Eigen::VectorXd &a)

inline virtual double potlR(const int n, const int m, const double r)

virtual double potlRZ(const int n, const int m, const double r, const double z)

inline virtual double r_to_rb(double const r)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

inline virtual double rb_to_r(double const r)

inline void set_numz(int n)

virtual ~CBDisk()

Destructor.

Protected Functions

inline virtual void get_pot(Eigen::MatrixXd &Vc, Eigen::MatrixXd &Vs, double r, double z)

Clutton-Brock potential.

Private Types

using Disk2d = std::shared_ptr<EmpCyl2d::ModelCyl>

Background instance.

Private Functions

inline virtual std::tuple<double, double, double> background(double r, double z)

Background evaluation.

void dens(const int m, const double r, Eigen::VectorXd &a)

virtual double dens(const int n, const int m, const double r)

double dphi(const int n, const int m, const double r)

double dpot(const int n, const int m, const double r)

virtual void get_dens(double r, double z, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_dpotl(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &dpr, Eigen::MatrixXd &dpz, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• dpr – will be returned array in harmonics l and radial order n for the derivative of the potential

• dpz – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl(double r, double z, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid)

Get the potential and density

Parameters:

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

inline virtual double getRtable()

Required maximum table radious (no limit here)

virtual void initialize(void)

Initialize method.

virtual double norm(const int n, const int m)

void orthoCheck()

Sanity check.

double phif(const int n, const int m, const double r)

double phif(const int n, const int m, const double r)

2D Clutton-Brock basis

void potl(const int m, const double r, Eigen::VectorXd &a)

virtual double potl(const int n, const int m, const double r)

void setBackground()

Set background from YAML.

Private Members

Disk2d disk

double fac1

Potential, force, and density scale factors.

double fac2

int mmax

string model

int numz

double scale

Parameters.

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class CBSphere : public AxiSymBiorth

#include <biorth.H>

Inheritence diagram for CBSphere:

Collaboration diagram for CBSphere:

Public Functions

CBSphere(void)

virtual double d_r_to_rb(double const)

virtual void dens(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double dens(const int nn, const int l, const double rb)

inline double densR(const int nn, const int l, const double r)

virtual double krnl(const int nn, const int l)

virtual double norm(const int nn, const int l)

virtual void potl(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double potl(const int nn, const int l, const double rb)

inline virtual double potlR(const int nn, const int l, const double r)

inline virtual double potlRZ(const int nn, const int l, const double r, const double z)

virtual double r_to_rb(double const)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

virtual double rb_to_r(double const)

inline virtual ~CBSphere()

Private Members

double rbmax

double rbmin

class CenterFile

#include <CenterFile.H>

Read a file in @Orient format and provide the center interpolated in time. The YAML node needs two key word&#8212;value pairs:

file: file name of orient-style center info type: EJ or COM

This implementation will exit for safety if it is called beyond its range.

Public Functions

CenterFile(const YAML::Node &conf)

Read in the file and cache the data.

std::array<double, 3> operator()(double T)

Interpolate and provide the desired center.

Private Members

std::vector<std::array<double, 3>> data

std::vector<double> time

class Cheb1 : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for Cheb1:

Collaboration diagram for Cheb1:

Public Functions

inline Cheb1(void)

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline virtual double h(const int n)

inline virtual double w(const double x)

class Cheb2 : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for Cheb2:

Collaboration diagram for Cheb2:

Public Functions

inline Cheb2(void)

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline virtual double h(const int n)

inline virtual double w(const double x)

class Cheby1d : public Interp1d

#include <interp.H>

Inheritence diagram for Cheby1d:

Collaboration diagram for Cheby1d:

Public Functions

void bomb(const char*, ...)

Handle error.

Cheby1d()

Null constructor.

Cheby1d(const double A, const double B, const Eigen::VectorXd &x, const Eigen::VectorXd &y, int N)

Construct with Eigen input (N is Chebyshev order)

Cheby1d(const double A, const double B, std::vector<double> &x, std::vector<double> &y, int N)

Construct with std::vector input (N is Chebyshev order)

Cheby1d(const Eigen::VectorXd &x, const Eigen::VectorXd &y, int N)

Construct with Eigen input (N is Chebyshev order) using data limits.

Cheby1d(std::vector<double> &x, std::vector<double> &y, int N)

Construct with std::vector input (N is Chebyshev order) using data limits.

inline virtual double deriv(const double &x)

Evaluate first derivative.

inline double deriv2(const double &x)

Evaluate the second derivative.

inline virtual double eval(const double &x)

Evaluate the interpolant.

inline void eval(const double &x, double &val, double &deriv)

Evaluate the interpolant and its first derivative.

inline double integral(const double &x)

Evaluate integral of interpolant.

void new_data(std::vector<double> &X, std::vector<double> &Y, int N)

Update the data.

void new_func(std::function<double(double)> func, double A, double B, int N)

Generate interpolant from a function.

void new_limits(double A, double B)

Update the data limits.

Cheby1d &operator=(const Cheby1d&)

Copy constructor.

inline virtual double xhi()

inline virtual double xlo()

Data limits.

~Cheby1d()

Destructor.

Private Functions

void chder(std::vector<double> &cin, std::vector<double> &cder)

double chebev(double x, std::vector<double> &cin)

double chebint(double x)

Private Members

double a

double b

std::vector<double> c

std::vector<double> c1

std::vector<double> c2

bool defined

int n

double xmax = 0

double xmin = 0

class CheckpointTimer

#include <chkTimer.H>

This class keeps track of time between time steps and calls for a checkpoint and signals an exit if there will not be time to reach the next checkpoint

Public Functions

CheckpointTimer()

Constructor.

bool done()

Time to quit.

void mark()

Mark the current time.

Public Static Attributes

static time_t delta

Safety time interval [Default: 10 minute warning].

static time_t diag

Diagnostic output interval [Default: 2 hours].

Private Functions

string exec(string &cmd)

Execute a command and pipe the results to string.

double time_remaining()

Get the remaining execution time.

Private Members

time_t current

time_t final

bool firstime

time_t initial

time_t last

time_t last_diag

double mean

unsigned nsteps

time_t start_time

double var

template<typename T>
class circular_buffer

#include <circular_buffer.H>

Circular buffer implementation from https://github.com/vinitjames/circularbuffer to temporarily replace the boost::circular_buffer implementation. Hopefully, this can be replaced by STL eventually.

Public Types

typedef BufferIterator<true> const_iterator

typedef BufferIterator<false> iterator

Public Functions

inline reference at(size_type index)

inline const_reference at(size_type index) const

inline reference back()

inline const_reference back() const

inline iterator begin()

inline const_iterator begin() const

inline size_type buffer_size() const

inline size_type capacity() const

inline const_iterator cbegin() const noexcept

inline const_iterator cend() const noexcept

inline circular_buffer(circular_buffer &&other) noexcept

inline circular_buffer(const circular_buffer &other)

Copy constructor.

inline explicit circular_buffer(size_t size)

Constructor.

inline void clear()

inline const_pointer data() const

inline bool empty() const

inline iterator end()

inline const_iterator end() const

inline reference front()

inline const_reference front() const

inline bool full() const

inline circular_buffer &operator=(circular_buffer &&other) noexcept

inline circular_buffer &operator=(const circular_buffer &other)

Assignment operator.

inline reference operator[](size_type index)

inline const_reference operator[](size_type index) const

inline void pop_front()

inline void push_back(const value_type &data)

inline void push_back(value_type &&data) noexcept

inline const_iterator rbegin() const noexcept

inline iterator rbegin() noexcept

inline const_iterator rend() const noexcept

inline iterator rend() noexcept

inline size_type size() const

Private Types

typedef const T *const_pointer

typedef const T &const_reference

typedef ptrdiff_t difference_type

typedef T *pointer

typedef T &reference

typedef size_t size_type

typedef T value_type

class CLin : public Disk2dHalo::CMap

Inheritence diagram for Disk2dHalo::CLin:

Collaboration diagram for Disk2dHalo::CLin:

Public Functions

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

class CLin : public DiskHalo::CMap

Inheritence diagram for DiskHalo::CLin:

Collaboration diagram for DiskHalo::CLin:

Public Functions

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

class CLog : public Disk2dHalo::CMap

Inheritence diagram for Disk2dHalo::CLog:

Collaboration diagram for Disk2dHalo::CLog:

Public Functions

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

class CLog : public DiskHalo::CMap

Inheritence diagram for DiskHalo::CLog:

Collaboration diagram for DiskHalo::CLog:

Public Functions

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

class CMap

Inheritence diagram for Disk2dHalo::CMap:

Subclassed by Disk2dHalo::CLin, Disk2dHalo::CLog, Disk2dHalo::CRat

Public Functions

virtual double r_to_x(double r) = 0

virtual double x_to_r(double x) = 0

class CMap

Inheritence diagram for DiskHalo::CMap:

Subclassed by DiskHalo::CLin, DiskHalo::CLog, DiskHalo::CRat

Public Functions

virtual double r_to_x(double r) = 0

virtual double x_to_r(double x) = 0

struct CoefMatrix : public std::vector<std::vector<MatrixM>>

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL::CoefMatrix:

Collaboration diagram for EmpCylSL::CoefMatrix:

Public Functions

inline Eigen::MatrixXd &operator()(int i, unsigned j, int m)

struct CoefMatrix : public std::vector<std::vector<MatrixM>>

#include <PolarBasis.H>

Inheritence diagram for PolarBasis::CoefMatrix:

Collaboration diagram for PolarBasis::CoefMatrix:

Public Functions

inline Eigen::MatrixXd &operator()(int i, unsigned j, int m)

struct Coefs

#include <TwoDCoefs.H>

Public Functions

bool read(std::istream &in)

Public Members

Eigen::MatrixXd data

std::string id

int Lmax

int nmax

double rmax

double scale

double time

struct CoefVector : public std::vector<std::vector<VectorM>>

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL::CoefVector:

Collaboration diagram for EmpCylSL::CoefVector:

More syntactic sugar for arrays of arrays: define an operator to the object of the main nested arrays. That is, for:

MatrixArray arr(N); for (auto & v : arr) v.resize(M);

One can use:

arr(n, m)[j][k] = …

instead of

(*arr[n][m])[j][k] = …

to access elements.

Public Functions

inline Eigen::VectorXd &operator()(int i, unsigned j, int m)

struct CoefVector : public std::vector<std::vector<VectorM>>

#include <PolarBasis.H>

Inheritence diagram for PolarBasis::CoefVector:

Collaboration diagram for PolarBasis::CoefVector:

More syntactic sugar for arrays of arrays: define an operator to the object of the main nested arrays. That is, for:

MatrixArray arr(N); for (auto & v : arr) v.resize(M);

One can use:

arr(n, m)[j][k] = …

instead of

(*arr[n][m])[j][k] = …

to access elements.

Public Functions

inline Eigen::VectorXd &operator()(int i, unsigned j, int m)

class ColorGradient

#include <ColorGradient.H>

Internal class used to store colors at different points in the gradient.

Public Functions

inline void addColorPoint(float red, float green, float blue, float value)

Inserts a new color point into its correct position:

inline void clearGradient()

Inserts a new color point into its correct position:

inline ColorGradient()

Default constructor:

inline void createDefaultGradient()

Default gradient.

inline void createFiveColorHeatMapGradient()

5 color heapmap gradient into the “color” vector:

inline void createGrayGradient()

7 color heapmap gradient into the “color” vector:

inline void createSevenColorHeatMapGradient()

7 color heapmap gradient into the “color” vector:

inline png::rgb_pixel operator()(const float value)

Inputs a (value) between 0 and 1 and outputs the (red), (green) and (blue) values representing that position in the gradient.

Private Members

std::vector<ColorPoint> color

An array of color points in ascending value.

struct ColorPoint

Public Functions

inline ColorPoint(float red, float green, float blue, float value)

Public Members

float b

float g

float r

Red, green and blue values of our color.

float val

Position of our color along the gradient (between 0 and 1).

class Component

#include <Component.H>

Collaboration diagram for Component:

Class associating the phase space with a biorthogonal basis.

The Component

provides “interactors” for specific particle fields

Each field in the

Component config file format contains four fields, each delimited by a colon (“:”), and new lines are not significant:

1. name of the potential solver (force methods) for this phase space

2. component-specific parameters [see Parameter section below]

3. file name containing phase space to be read

4. comma-delimited parameter list passed to the potential solver

Currently available force methods:

Reference frames:

1. Inertial is the rest reference frame whose coordinate system is centered at (0, 0, 0)

2. Local is the coordinate system of specific to the particles of an individual Component instance. If com_system is defined, this is defined to have its origin at the center of mass and the center of velocity of the component’s partcles at all times. If com_system is off, this is the same as Inertial

3. Centered offsets the particles coordinates using the current centering scheme for the expansion. At this point, this is the EJ method selectable by the user. The SphereTwoCenter method indirectly manipulates this to achieve two separate expansion centers.

4. keyPos is the value of the species key in the particle integer attribute vector

5. pbufsiz is the number of particles in each particle buffer sent to disk when using MPI-IO with OutPSP

6. blocking set to true chooses blocking writes when using MPI-IO with OutPSP

7. buffered set to true chooses buffered writes when using POSIX binary

8. ignore the PSP info stanza on restart (i.e. for specifying alternative parameters, using an old-style PSP file, or starting a new job with a previous output from another simulation)

bessel

Bessel function basis, see Bessel

sphereSL

Weinberg’s adaptive spherical basis derived by numerical solution to the Sturm-Liouville equation, see Sphere

cube

Trigonmetric basis with periodic boundaries, see Cube

slabSL

Trigonmetric basis with periodic boundaries the horizontal directions and vacuum boundary conditions in the vertical dirction, see Slab

slab

Trigonmetric basis with periodic boundaries the horizontal directions and vacuum boundary conditions in the vertical dirction based on a direct solution of the Sturm-Liouville equation perpendicular to the slab, see SlabSL

cylinder

Weinberg’s adaptive cylindrical basis derived by numerical solution to the Sturm-Liouville equation, see Cylinder

direct

The usual n² force calculation, see Direct

noforce

No force (presumably, you are supplying your own force)

Param EJ:

enables energy weighed center-of-mass. The paramter value is a two-bit flag: AXIS=1 and CENTER=2.

Param nEJkeep:

is the number of time steps in running box car average for EJ-determined parameters

Param nEJwant:

is the target number of particles to keep in the ensemble used to determine the paramters. The energy cutoff is dynamically adjusted to achieve this target.

Param nEJwant:

is the size of the past states used to estimate the the acceleration of the expansion frame

Param EJx0:

is the initial EJ center x-coordinate (default: 0)

Param EJy0:

is the initial EJ center y-coordinate (default: 0)

Param EJz0:

is the initial EJ center z-coordinate (default: 0)

Param EJu0:

is the initial EJ center u-velocity (default: 0)

Param EJv0:

is the initial EJ center v-velocity (default: 0)

Param EJw0:

is the initial EJ center w-velocity (default: 0)

Param EJdT:

is the spacing in time between samples (default: 0)

Param EJkinE:

set true includes kinetic energy in the energy determination, otherwise potential energy alone is used

Param EJext:

set true includes the external potential energy in the energy computation

Param EJdiag:

turns on verbose EJ reporting

Param EJdryrun:

set to true does not apply EJ centering or rotation but computes the transformation

Param EJlinear:

set true moves center with constant velocity. For testing only!! (default: false)

Param EJdamp:

multiplies the least squares slope to prevent instability (default: 1.0, no damping)

Param rmax:

is the maximum radius particle. This is determined dynamically from the initial conditions but can be overridden as a parameter.

Param rtrunc:

is the radius from the center beyond which it does not contribute to the force expansion (but does continues to be affected by it). The default value is 1.0e20.

Param rcom:

is the radius beyond which a particle is not used to compute the center of mass coordinate system

Param ton:

is the midpoint of the adiabatic turn on for this component

Param twid:

is the width for the adiabatic turn on. Unless ton or toff is specified, the component begins and remains fully on.

Center of mass system coordinates

double mtot0

System mass, center of mass, center of velocity and acceleration.

double *com0

double *cov0

double *acc0

double rcom

Maximum radius for contribution to center-of-mass computation.

double mtot

Total mass.

int dim

Dimension of the phase space.

std::vector<vector<int>> levlist

Particle list per level This will be a sorted list for each level. We use a vector rather than (e.g.) a set for the random insertion

std::vector<vector<unsigned>> mdt_ctr

Multstep dt type counter.

PotAccel *force

Points to associated force instance.

int niattrib

Attribute array dimensions for integer parameters.

int ndattrib

Attribute array dimensions for float-valued parameters.

int EJ

Binding energy orientation flag.

int nEJkeep

Number to keep in orientation stack.

int nEJwant

Target number of particles for average.

int nEJaccel

Target number of states for pseudo-acceleration estimation.

double EJx0

Initial EJ center.

x-coord

double EJy0

y-coord

double EJz0

z-coord

double EJu0

Initial EJ velocity.

x-coord

double EJv0

y-coord

double EJw0

z-coord

double EJdT

Spacing between EJ samples.

bool EJdiag

Print verbose diagnostics.

bool EJdryrun

Do not apply transformation.

bool EJkinE

Use particle KE for energy computation.

bool EJext

Use external potential for energy computation.

bool EJlinear

Move center at constant velocity specified by (EJu0, EJv0, EJw0)

double EJdamp

Damping factor for center determination (< 1.0 for damping)

bool com_system

Use center of mass coordinate system.

bool com_log

Log the center of mass coordinate system at each step.

double rtrunc

Maximum radius from center for force evaluation.

bool timers

CUDA timing info.

bool buffered

Use buffered binary writes.

Orient *orient

Orientation cache.

Timer time_so_far

Running clock on the current potential/force evaluation.

Component(YAML::Node &conf)

The constructor.

Takes the id string id and phase space file name as arguments

Component(YAML::Node&, istream *in, bool SPL)

Initialize from file.

~Component()

Destructor.

PartPtr *get_particles(int *number)

Parallel gather.

inline int particle_count(int node)

Retrieve particle count on a particular node (one node at a time)

inline vector<unsigned int> particle_count()

Retrieve particle count on a particular node (all nodes at once)

void write_binary(ostream *out, bool real4 = false)

Write binary component phase-space structure.

void write_binary_header(ostream *out, bool real4, std::string prefix, int nth = 1)

Write header for per-node writes.

void write_binary_particles(std::ostream *out, bool real4)

Write particles for per-node writes.

void write_binary_particles(std::vector<std::shared_ptr<std::ofstream>> &out, bool real4)

Write particles for per-node writes (multithreaded version)

void write_binary_particles(std::ostream *out, int threads, bool real4)

Write particles for per-node writes with multithreading.

inline void write_binary_mpi(MPI_File &out, MPI_Offset &offset, bool real4 = false)

Write binary component phase-space structure using MPI.

void write_ascii(ostream *out, bool accel = false)

Write ascii component phase-space structure.

void redistribute_particles(void)

Redestribute this component.

void fix_positions_cpu(unsigned mlevel = 0)

Compute center of mass and center of velocity (CPU version)

inline void fix_positions(unsigned mlevel = 0)

Compute center of mass and center of velocity.

void redistributeByList(vector<int> &redist)

Redistribute particle by list (deprecated?)

Serialize redistribution list into an integer array of numprocs stanzas, each with the format n &#8212; current node M &#8212; number to redistribute (may be zero) index_1 tonode_1 index_2 tonode_2 . . index_M tonode_M

so each stanza has 2(M+1) integers

void update_accel(void)

Subtract mean acceleration from each particle accel.

void get_angmom(unsigned mlevel = 0)

Update angular momentum values.

double Adiabatic(void)

Adiabatic turn on factor, range in [0, 1].

bool freeze(unsigned indx)

Is particle out of bounds?

bool escape_com(const Particle&)

Is particle beyond COM system.

inline PartMap &Particles()

Access to particle vector.

inline Particle *Part(unsigned long i)

Access to particle as a pointer.

inline PartPtr partPtr(unsigned long i)

Access to particle via the shared pointer.

inline bool partExists(unsigned long i)

Check if particle index is in the component.

Particle *GetNewPart()

Generate new particle: this adds a new particle and returns a pointer to the same particle. It is the caller’s responsbility to populate the phase space and particle attributes with sane values.

void AddPart(PartPtr p)

Add a particle to the component.

void DestroyPart(PartPtr p)

Remove a particle from the component.

inline void ErasePart(PartPtr p)

Erase a particle with no level list check.

inline unsigned Number()

Particle vector size.

inline unsigned CurTotal()

Return the last particle total (no MPI)

inline unsigned NewTotal()

Update total number of particles in component. Should be called after adding or killing particles. Uses MPI.

inline double Mass(int i)

Access to mass.

inline double Pos(int i, int j, unsigned flags = Inertial)

Access to positions.

inline std::vector<double> getCenter(unsigned flags = Inertial)

Get rectified component center.

inline double Vel(int i, int j, unsigned flags = Inertial)

Access to velocities.

inline void Pos(double *pos, int i, unsigned flags = Inertial)

Get positions.

inline void Vel(double *vel, int i, unsigned flags = Inertial)

Get velocities.

inline void ConvertPos(double *pos, unsigned flags = Local | Centered)

Convert coordinates from inertial to local.

inline void ConvertVel(double *vel, unsigned flags = Local | Centered)

Convert velocities from inertial to local.

inline void PosConvert(double *pos, unsigned flags = Local | Centered)

Convert coordinates from local to inertial.

inline void VelConvert(double *vel, unsigned flags = Local | Centered)

Convert velocities from local inertial.

inline double Acc(int i, int j, unsigned flags = Inertial)

Access to acceleration.

inline void AddPos(int i, int j, double val)

Add to position (by component)

inline void AddPos(int i, double *val)

Add to position (by array)

inline void AddPos(int i, vector<double> &val)

Add to position (by vector)

inline void AddVel(int i, int j, double val)

Add to velocity (by component)

inline void AddVel(int i, double *val)

Add to velocity (by array)

inline void AddVel(int i, vector<double> &val)

Add to velocity (by vector)

inline void AddAcc(int i, int j, double val)

Add to accerlation (by component)

inline void AddAccExt(int i, int j, double val)

Add to accerlation (by component)

inline void AddAcc(int i, double *val)

Add to acceleration (by array)

inline void AddAccExt(int i, double *val)

Add to acceleration (by array)

inline void AddAcc(int i, vector<double> &val)

Add to accerlation (by vector)

inline void AddAccExt(int i, vector<double> &val)

Add to accerlation (by vector)

inline void AddPot(int i, double val)

Add to potential.

inline void AddPotExt(int i, double val)

Add to external potential.

void reset_level_lists()

Reset the level lists.

void print_level_lists(double T)

Print out the level lists to stdout for diagnostic purposes.

inline double get_time_sofar()

Time in potential/force computation so far.

inline bool Indexing()

Check for indexing.

inline bool NoSwitch()

Check for multistep restriction (this is still a test option)

inline bool FreezeLev()

Only compute new levels on first step.

inline bool DTreset()

Compute level from minimum requested time step from last master step.

Public Types

enum PSTYPE

Describe the phase space coordinates.

Values:

enumerator Inertial

enumerator Local

enumerator Centered

Public Functions

Eigen::Vector3d &getPseudoAccel(double *pos, double *vel)

Public Members

Eigen::Vector3d accel

Pseudo-accleration (set by Orient)

double *angmom

Angular momentum vector.

YAML::Node cconf

Parameters for component.

double *center

Center (e.g. set by Orient)

double *coa

Center of acceleration.

double *com

Center of mass.

These are pointers to the center of mass, center of velocity, angular momentum and the phase-space 6 vector.

YAML::Node conf

Configuration for this component.

double *cov

Center of velocity.

bool cube

Periodic cube.

bool disk

Cylindrical geometry.

Eigen::Vector3d domdt

YAML::Node fconf

Parameters for force.

std::string id

Force method.

int keyPos

Species key position in particle integer attribute vector.

std::string name

Identify this component.

Eigen::Vector3d omega

std::string pfile

Particle file.

bool point_mass

Point masses.

double *ps

Phase space vector.

Eigen::Vector3d pseudo

double rmax

Maximum initial particle radius.

bool slab

Slab geometry.

bool sphere

Spherical geometry.

Protected Functions

void configure(void)

Set configuration and force.

void find_ctr_component()

Locagte centering component.

void initialize(void)

Initialize parameters (called by ComponentContainer after component instantiation

void initialize_cuda(void)

Enumerate and initialize cuda devices.

void restart_com_system(void)

COM restart function.

void seq_new_particles()

Update sequence number of added particles.

void set_default_values()

Set default, unset parameters in config.

void setup_distribution(void)

Setup distribution vectors.

void write_binary_mpi_b(MPI_File &out, MPI_Offset &offset, bool real4 = false)

Write binary component phase-space structure using MPI (blocking)

void write_binary_mpi_i(MPI_File &out, MPI_Offset &offset, bool real4 = false)

Write binary component phase-space structure using MPI (non-blocking)

Protected Attributes

double azcm_slab

Slab parameters.

bool binary

Binary read flag.

Component *c0

Use center from this component.

std::shared_ptr<CenterFile> CF

Center file playback.

int com_restart

COM flag.

string comfile

COM log file.

std::string ctr_name

Name of the centering component.

bool dtreset

Select level from criteria over last time step.

bool freezeLev

Compute new levels on the first step only.

unsigned modified = 0

Particle number update is needed.

unsigned int nbodies

Bodies on this node.

vector<unsigned int> nbodies_index

vector<unsigned int> nbodies_table

Vector holding current particle partition.

unsigned int nbodies_tot

Bodies on all nodes.

std::list<PartPtr> new_particles

Particles waiting for a new index.

int nlevel

Level occupation output.

bool noswitch

No multistep switching.

vector<double> orates

Vectors for holding the rates per node for load balancing.

PartMap particles

Points to associated particles using sequence number.

MPI_Datatype Particletype

Used by gather and distribution routines to define a particle structure to MPI

unsigned long top_seq

Maximum sequence value so far.

vector<double> trates

Protected Static Attributes

static const std::set<std::string> valid_keys_force

static const std::set<std::string> valid_keys_parm

static const std::set<std::string> valid_keys_top

Valid keys for YAML configurations.

Private Functions

void add_particles(int from, int to, std::vector<PartPtr> &plist)

void initialize_com_system()

void load_balance(void)

Parallel distribute and particle io.

void openNextBlob(std::ifstream &in, std::list<std::string>::iterator &fit, int &N)

Helper for split-PSP-file particle consumer.

void read_bodies_and_distribute_ascii(void)

void read_bodies_and_distribute_binary_out(istream*)

void read_bodies_and_distribute_binary_spl(istream*)

int round_up(double dnumb)

void update_indices(void)

Private Members

bool adiabatic

bool aindex

vector<double> angmom_lev

bool blocking

Using blocking writes for MPI-IO.

vector<double> coa_lev

vector<double> com_lev

vector<double> com_mas

vector<double> comE_lev

vector<double> comE_mas

bool consp

vector<double> cov_lev

vector<double> covE_lev

bool indexing

Internal data for sequence checking.

vector<loadb_datum> loadb

std::vector<PartPtr> pbuf

int pBufSiz

Particle buffer count for MPI-IO writing.

ParticleFerryPtr pf

unsigned rsize

int seq_beg

int seq_cur

int seq_end

int tidal

double toff

double ton

double twid

bool umagic

Private Static Attributes

static const unsigned long magic = 0xadbfabc0

For magic number checking.

static const unsigned long mmask = 0xf

static const unsigned long nmask = ~mmask

Friends

friend class ComponentContainer

friend class OrbTrace

friend class ScatterMFP

class ComponentContainer

#include <ComponentContainer.H>

Collaboration diagram for ComponentContainer:

A container for all phase-space components.

There are two parameters affecting ComponentContainter, which may be specified in the global stanza:

Restarting:

If the infile parameter contains a valid PSP file name, the simulation will resume using the file as an PSP body file. If the infile begins with or contains the string ‘SPL’, a split-PSP format will be assumed.

Param restart:

set to 1 instructs all the components and force methods to restart the simulation from phase space checkpoints and log files

Public Types

enum State

For timers in PotAcc to hook the type of acceleration.

Values:

enumerator NONE

enumerator SELF

enumerator INTERACTION

enumerator EXTERNAL

Public Functions

bool bad_values()

Debug for bad phase space values.

ComponentContainer()

Constructor.

void compute_expansion(unsigned mlevel = 0)

Compute the expansion for all components in the container Those without expansions, should return without working

void compute_potential(unsigned mlevel = 0)

Compute the acceleration for all components in the container.

void fix_acceleration()

Remove the center of mass accelration from the overall phase space.

void fix_positions()

Recompute the center of mass and centers of velocity for all components. These may be used (if flagged) to center the phase space on each grid either globally or per component

void initialize()

Read database and construct indvidual components.

void load_balance()

Compute duty for each processor and initiate load balancing.

void multistep_debug()

Print debug info.

void multistep_reset()

Reset data before a multistep step.

void print_level_list_header()

Print column explanation for level lists output.

void print_level_lists(double T)

Print out the level lists for all components to stdout for diagnostic purposes

void read_rates()

Read initial processor rates.

void report_numbers()

Diagnostic report of number from each component and process.

~ComponentContainer()

Destructor.

Public Members

std::list<Component*> components

List of components.

std::list<std::shared_ptr<Interaction>> interaction

List of interactions.

int ncomp

Number of components.

int ntot

Total number of bodies.

std::vector<double> rates

Processor rates.

enum ComponentContainer::State state

bool thread_timing

Timer timer_accel

Timer timer_angmom

Timer timer_clock

Timer timer_cuda

Timer timer_expand

Timer timer_extrn

Timer timer_fixp

Timer timer_force

Timer timer_gcom

Timer timer_inter

Timer timer_orient

Timer timer_posn

Performance timers (enabled with VERBOSE>3)

vector<pair<string, Timer>> timer_sext

vector<pair<string, Timer>> timer_sntr

Timer timer_thr_acc

Timer timer_thr_ext

Timer timer_thr_int

Timer timer_wait

Timer timer_zero

bool timing

Timing in use.

Public Static Attributes

static long tinterval

Seconds between timer dumps.

Private Members

bool binary

double *gcom1

double *gcov1

bool gottapot

int ifile

vector<unsigned> levcnt

Counts steps at each level for timing output.

double time0

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

Friends

friend class Component

class ComponentHeader

#include <header.H>

Describe a component in a phase space dump.

Public Functions

inline ComponentHeader()

Default constructor: uses defaultInfoSize by default.

inline ComponentHeader(int n)

Construct component with info field of length n.

inline int getSize()

Get header size.

bool read(istream *in)

Read binary header from input stream.

bool write(ostream *out)

Write binary header to output stream.

bool write_mpi(MPI_File &out, MPI_Offset &offset)

Write binary header to MPI.

Public Members

std::shared_ptr<char> info

Info string.

int nbod

Number of bodies in the component.

int ndatr

Number of real (double) attributes per particle.

int niatr

Number of integer attributes per particle.

int ninfochar

Size of info string.

Public Static Attributes

static int defaultInfoSize

Default size of info string (if not specified explicitly or read)

Friends

inline friend std::ostream &operator<<(std::ostream &os, const ComponentHeader &p)

class CoordMap

Inheritence diagram for SLGridSlab::CoordMap:

The base class for all coordinate maps.

Subclassed by SLGridSlab::LinearMap, SLGridSlab::SechMap, SLGridSlab::TanhMap

Public Functions

inline CoordMap(double H)

Constructor.

virtual double d_xi_to_z(double z) = 0

Jacobian of the transformation.

virtual double xi_to_z(double z) = 0

Convert from mapped coordinate back to vertical.

virtual double z_to_xi(double z) = 0

Convert from vertical to mapped coordinate.

inline virtual ~CoordMap()

Destructor.

Public Static Functions

static std::unique_ptr<CoordMap> factory(CoordMapTypes type, double H)

Coordinate map factory.

Protected Attributes

double H

Scale parameter.

class coulombSelect

#include <BN.H>

Cumulative angle scattering from Bobylev and Nanbu (2000)

Public Functions

inline coulombSelect()

Constructor.

inline double eval(double tau)

Evaluate A given tau.

inline double operator()(double tau, double U)

Select tau given random number U in [0,1)

Private Functions

inline double deriv(double x)

inline double f(double x)

inline double func(double tau, double x)

Private Members

std::vector<double> cA

std::vector<double> cT

Array grids.

const int numT = 2000

Tau evaluation grid.

const double tau_f = 4.0

const double tau_i = 0.0001

Limiting values for tau evaluation for asymptotic and extreme values

const double tau_m = 1.0e-8

const double tau_z = 40.0

class CPoly : public Eigen::VectorXcd

#include <cpoly.H>

Inheritence diagram for CPoly:

Collaboration diagram for CPoly:

Public Functions

CPoly(const CPoly&)

CPoly(const Eigen::VectorXcd&)

CPoly(const int)

CPoly(const Poly&)

CPoly(int, double*)

CPoly(void)

std::complex<double> deriv(std::complex<double> z)

std::complex<double> eval(std::complex<double> z)

inline const int getorder(void)

CPoly &operator%=(const CPoly&)

CPoly &operator&=(const CPoly&)

inline CPoly operator+()

CPoly &operator+=(const CPoly&)

CPoly operator-()

CPoly &operator-=(const CPoly&)

CPoly &operator=(const CPoly&)

inline void Pop(int i)

void print(ostream&)

Private Functions

void reduce_order(void)

Private Members

int order

Friends

friend CPoly operator%(const CPoly&, const CPoly&)

friend CPoly operator&(const CPoly&, const CPoly&)

friend CPoly operator+(const CPoly&, const CPoly&)

friend CPoly operator-(const CPoly&, const CPoly&)

class CRat : public Disk2dHalo::CMap

Inheritence diagram for Disk2dHalo::CRat:

Collaboration diagram for Disk2dHalo::CRat:

Public Functions

inline CRat(const CRat &p)

inline CRat(double scale)

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

Public Members

double scale

class CRat : public DiskHalo::CMap

Inheritence diagram for DiskHalo::CRat:

Collaboration diagram for DiskHalo::CRat:

Public Functions

inline CRat(const CRat &p)

inline CRat(double scale)

inline virtual double r_to_x(double r)

inline virtual double x_to_r(double x)

Public Members

double scale

template<typename X, typename Y>
class Cspline

#include <Cspline.H>

A cubic spline evaluator templated on data types X, Y. Types X and Y must have operator +, -, *, Y must have defined a constructor that takes a scalar.

Public Functions

inline Cspline()

Null constructor.

inline Cspline(const std::vector<X> &x, const std::vector<Y> &y)

Constructor for spline with x and y vectors.

inline std::vector<Y> interpolate(const std::vector<X> &xx) const

Evaluation function for vector input, assuming xx is sorted ascending.

inline Y interpolate(const X &x) const

Evaluation function.

inline std::vector<Y> operator()(const std::vector<X> &xx) const

Evaluation operator for vector input, assuming xx is sorted ascending.

inline Y operator()(const X &x) const

Evaluation opterator.

inline virtual ~Cspline()

Destructor.

Protected Types

typedef Element element_type

Protected Attributes

std::vector<element_type> elems

class Cube : public PotAccel

#include <Cube.H>

Inheritence diagram for Cube:

Collaboration diagram for Cube:

Periodic cube basis.

YAML configuration

Param nminx:

is the minimum absoulte value of the wave number in the x direction (default: 0)

Param nminy:

is the minimum absoulte value of the wave number in the y direction (default: 0)

Param nminz:

is the minimum absoulte value of the wave number in the z direction (default: 0)

Param nmaxx:

is the maximum absoulte value of the wave number in the x direction (default: 16)

Param nmaxy:

is the maximum absoulte value of the wave number in the y direction (default: 16)

Param nmaxz:

is the maximum absoulte value of the wave number in the z direction (default: 16)

Param method:

string sets the evaluation method for the CUDA kernel. Available methods are: all, full, 3d which compute all dimensions at once and planes, axes, and 1d which compute wave vectors by plane. This may be extended to specific algorithms in the future. This does nothing for the CPU-only computation.

Public Functions

Cube(Component *c0, const YAML::Node &conf)

Constructor.

virtual void determine_coefficients(void)

Compute the coefficients.

virtual void dump_coefs_h5(const std::string &file)

Coefficient output.

virtual void get_acceleration_and_potential(Component*)

Compute the force.

virtual ~Cube()

Destructor.

Public Members

std::string id

Id string.

Private Types

using coefType = Eigen::Tensor<std::complex<double>, 3>

Coefficients are a 3-tensor.

using coefTypePtr = std::shared_ptr<coefType>

Interpolation arrays.

Private Functions

void compute_multistep_coefficients()

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

void determine_acceleration_and_potential()

Do the work.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

virtual void *determine_coefficients_thread(void *arg)

Threading.

virtual void initialize(void)

Parameter and storage initialization.

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

virtual void multistep_update_begin()

Update the multi time step coefficient table when moving particle i from level cur to level next

virtual void multistep_update_finish()

Execute to finish level shifts for particles.

inline void swap_coefs(std::vector<coefType> &from, std::vector<coefType> &to)

Swap coefficients.

Private Members

bool byPlanes

Plane method (default: true)

CoefClasses::CubeCoefs cubeCoefs

Coefficient container instance for writing HDF5.

std::string cuMethod

Cuda batch method (string, default: planes.

double dfac

std::vector<std::vector<coefType>> differ1

For updating levels.

std::vector<coefType> expcoef

Current coefficient tensor.

std::vector<coefTypePtr> expcoefL

std::vector<coefTypePtr> expcoefN

std::vector<coefType> expcoefP

int imx

Variables.

int imy

int imz

std::complex<double> kfac

int nmaxx

Minimum wave numbers in each dimesion.

int nmaxy

int nmaxz

int nminx

Maximum wave numbers in each dimesion.

int nminy

int nminz

int osize

std::vector<std::complex<double>> pack

std::vector<std::complex<double>> unpack

int use0

int use1

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Cubic_Table

#include <cubic.H>

Public Functions

void build(Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&)

inline Cubic_Table(Cubic_Table &c)

Cubic_Table(void)

inline Cubic_Table &operator*=(double x)

inline Cubic_Table &operator+=(Cubic_Table &c)

inline Cubic_Table &operator-=(Cubic_Table &c)

inline Cubic_Table &operator/=(double x)

inline Cubic_Table &operator=(Cubic_Table &c)

double value(double, double*)

~Cubic_Table(void)

Protected Attributes

Eigen::MatrixXd a

Eigen::VectorXd dx

Eigen::VectorXd xgrid

Friends

friend Cubic_Table operator*(Cubic_Table &c, double x)

friend Cubic_Table operator*(double x, Cubic_Table &c)

friend Cubic_Table operator+(Cubic_Table &c1, Cubic_Table &c2)

friend Cubic_Table operator-(Cubic_Table &c1, Cubic_Table &c2)

friend Cubic_Table operator/(Cubic_Table &c, double x)

template<typename T, typename Iterator>
class CyclicIterator

#include <Circular.H>

Collaboration diagram for CyclicIterator:

Public Types

using difference_type = std::ptrdiff_t

using iterator_category = std::bidirectional_iterator_tag

Add typedefs for std::iterator_traits.

using pointer = T*

using reference = T&

using value_type = T

Public Functions

inline CyclicIterator(const Iterator &i, const Iterator &j)

Create using positions i through j.

inline bool operator!=(const CyclicIterator &x) const

Test for inequality.

inline T operator*() const

Return current data.

inline CyclicIterator &operator++()

Pre-increment operator.

inline CyclicIterator operator++(int)

Post-increment operator.

inline CyclicIterator &operator--()

Pre-decrement operator.

inline CyclicIterator operator--(int)

Post-decrement operator.

inline Iterator operator->() const

Return current iterator.

inline bool operator==(const CyclicIterator &x) const

Test for equality.

Private Members

Iterator begin

Iterator cursor

Iterator end

struct CylCoefHeader

#include <coef.H>

Header structure for cylindrical expansion.

Public Members

int mmax

Number of azimuthal orders kept.

int nmax

Number of functions per azimuthal order.

double time

Time for this dump.

struct CylCoefs

#include <Coefs.H>

Public Functions

bool read(std::istream &in, bool verbose = false)

Public Members

std::shared_ptr<char[]> buf

std::vector<std::vector<double>> cos_c

int mmax

int nmax

std::vector<std::vector<double>> sin_c

double time

class CylDisk : public AxiSymModel

#include <CylDisk.H>

Inheritence diagram for CylDisk:

Collaboration diagram for CylDisk:

Public Functions

inline CylDisk(EmpCylSL *D, double Rmin, double Rmax)

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

Public Static Attributes

static int NUMR

static bool RLOG

Private Functions

void setup_model(double rmin, double rmax)

Private Members

EmpCylSL *d

vector<double> dd

double dr

vector<double> mm

vector<double> pp

bool rlog

double rmax

double rmin

vector<double> rr

class CylEXP : public EmpCylSL

#include <CylEXP.H>

Inheritence diagram for CylEXP:

Collaboration diagram for CylEXP:

Encapsulatates a SLGridSph (Sturm-Liouville basis) for use as force method.

This provides the extra routines needed for n-body integration. See EmpCylSL in the exputils directory.

Public Functions

void compute_multistep_coefficients(unsigned mlevel)

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

inline CylEXP()

CylEXP(int numr, int lmax, int mmax, int nord, double ascale, double hscale, int Nodd = -1, std::string cachename = "")

Constructor with parameters

Parameters:

Parameters:

• multistep – is the number of coefficient levels for n-body

• numr – is the spherical radial order of the input basis

• lmax – is the spherical angular order of the input basis

• mmax – is the output aximuthal order for the EOF basis

• nord – is the output radial order for the EOF basis

• ascale – is the target disk scale LENGTH

• hscale – is the target disk scale HEIGHT

• nodd – is the number of vertically odd parity basis functions. If unspecified, you get eigenvalue order.

void multistep_debug()

Print debug info.

virtual void multistep_reset()

virtual void multistep_update(int from, int to, double r, double z, double phi, double mass, int id)

virtual void multistep_update_begin()

Update the multi time step coefficient table when moving particle i from level cur to level next

virtual void multistep_update_finish()

Protected Attributes

std::vector<std::vector<Eigen::MatrixXd>> differC1

std::vector<std::vector<Eigen::MatrixXd>> differS1

For updating levels.

std::vector<double> workC

std::vector<double> workC1

std::vector<double> workS

std::vector<double> workS1

Friends

friend class Cylinder

class Cylinder : public Basis

#include <Cylinder.H>

Inheritence diagram for Cylinder:

Collaboration diagram for Cylinder:

This routine computes the potential, acceleration and density using the Cylindrical biorthogonal expansion.

YAML parameters

Param rcylmin:

is the minimum cylindrical grid radius in scale-length units

Param rcylmax:

is the maximum cylindrical grid radius in scale-length units

Param acyl:

is the scale length

Param hcyl:

is the scale height

Param lmaxfid:

is the maximum spherical harmonic index for EOF construction

Param nmaxfid:

is the maximum radial index for EOF construction

Param mmax:

is the maximum azimuthal order for the resulting basis

Param mlim:

applies a limit <= mmax without basis reconstruction

Param ncylnx:

is the grid size for the cylindrical radius axis

Param ncylny:

is the grid size for the vertical axis

Param ncylr:

radial grid size for basis computation (NUMR in EmpCylSL)

Param ncylorder:

is the maximum order in for each harmonic m for the new basis

Param ncylodd:

is the number of vertically antisymmetric basis functions out of the total ncylorder

Param ncylrecomp:

is the frequency of basis recompution during a running simulation

Param npca:

is the number steps between PCA variance/error analyses

Param npca0:

is the number steps to skip before the first PCA variance/error analysis

Param nvtk:

is the number steps between vtk visualization output for the PCA variance/error analyses

Param cachename:

is the name of the basis cache file

Param samplesz:

is the default particle number in PCA subsampling partitions (default is 1). The value 0 sets the sample size to sqrt(N).

Param rnum:

if the size of the radial quadrature grid for analytic EOF computation

Param pnum:

if the size of the azimuthal quadrature grid for analytic EOF computation (set to 1 if model is axisymmetric)

Param tnum:

is the size of the equitorial quadrature grid for analytic EOF computation

Param ashift:

offsets the center of the analytic model for basis function computation

Param precond:

boolean true turns on analytic basis function preconditioning (default: true)

Param logr:

boolean turns on logarithmic radial basis gridding in EmpCylSL

Param pcavar:

turns on variance analysis

Param pcaeof:

turns on basis conditioning based on variance analysis

Param pcadiag:

logs diagnostic output for variance analysis

Param pcavtk:

turns on VTK visualization diagnostic output for variance analysis

Param hexp:

is the Hall sharpness parameter

Param snr:

is the signal-to-noise prefactor for sharpness computation

Param evcut:

is the cumulative trim remainder on the covariance eigenvalues (default: -1, which implies no trimming). Set to small positive value for trimming.

Param try_cache:

false suppresses cache reading on restart (default: true)

Param EVEN_M:

true uses even harmonic orders only

Param cmap:

is the coordinate mapping type (deprecated but kept for backward consistency)

Param cmapr:

is the radial coordinate mapping type

Param cmapz:

is the vertical coordinate mapping type

Param self_consistent:

set to false turns off potential expansion; only performed the first time

Param playback:

file reads a coefficient file and uses it to compute the basis function output for resimiulation

Param pyname:

is the file name of Python module which supplies the ‘disk_density’ function for conditioning the cylindrical basis. A non-null string triggers the use of the Python interpreter to evaluate the target density function.

Param dumpbasis:

set to true dumps the basis to a file for diagnostic examination (default: false)

Public Functions

Cylinder(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor

Parameters settable in the configuration line include:

Parameters:

• c0 – is the instantiating caller (a Component)

• conf – contains the parameters passed to the method

• m – is the MixtureBasis for a multicenter expansion

• acyl – is the disk scale length for the basis

• hcyl – is the disk scale height for the basis

• nmaxfid – is the radial order for the underlying spherical basis

• lmaxfid – is the harmonic order for the underlying spherical basis

• mmax – is the azimuthal harmonic order for final cylindrical expansion

• mlim – restricts the azimuthal harmonic order for testing

• ncylnx – is the radial grid in the basis function table

• ncylny – is the vertical grid in the basis function table

• ncylr – is the size of the spherical radial grid used to construct the cylindrical basis

• nmax – is the order of the radial expansion

• ncylodd – is the number of terms with vertically antisymmetric parity out of ncylorder. If unspecified, you will get the original variance order.

• ncylrecomp – is the number of steps between basis recomputation (default: -1 which means NEVER)

• npca – is the number of steps between Hall coefficient recomputaton

• npca0 – is the first step for Hall coefficient computaton

• nvtk – is the number of step VTK output

• pcadiag – set to true enables PCA output diagnostics (default: false)

• cachename – is the file for the EOF basis

• vflag – sets verbosity (see EmpCylSL.cc)

• rnum – is the number of Legendre radial knots for numerical basis computation

• pnum – is the number of azimuthal knots for numerical basis computation

• tnum – is the number of Legendre polar knots for numerical basis computation

• ashift – is the shift applied in the x-axis relative to the original for basis conditioning

• self_consistent – set to false for fixed potential

• precond – set to true for analytic basis function conditioning (default: true)

• logr – tabulate basis in logarithmic coordinates (default: false)

• pcavar – set to true for real-time Hall analysis (default: false)

• samplesz – is the default particle number in PCA subsampling partitions (default is 1). The value 0 sets the sample size to sqrt(N).

• pcavtk – set to true dumps PCA functions in VTK format for diagnostics (default: false)

• try_cache – set to true means try to read basis from cache (default: true)

• dump_basis – set to true outputs basis into file

• cmapR – selects the radial coordinate mapping (default: 2, power mapping)

• cmapZ – selects the vertical coordinate mapping (default: 1, sinh mapping)

virtual void determine_fields_at_point(double x, double y, double z, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotx, double *tpoty, double *tpotz)

Return the value for the fields in Cartesian coordinates.

virtual void determine_fields_at_point_cyl(double r, double z, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpotz, double *tpotp)

Return the value for the fields in cylindrical coordinates.

inline void determine_fields_at_point_cyl(double r, double z, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpotz, double *tpotp, int mmin, int mlim)

Return the value for the fields in cylindrical coordinates with limits.

virtual void determine_fields_at_point_sph(double r, double theta, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpott, double *tpotp)

Return the value for the fields in spherical polar coordinates.

virtual void dump_coefs(ostream &out)

Save coefficients to file (need type marker to id dump, component id?)

virtual void dump_coefs_h5(const std::string &file)

Save coefficients to named HDF5 file.

void dump_mzero(const string &name, int step)

Sanity check on grid: dumps SM-style images of initial field.

virtual void get_acceleration_and_potential(Component*)

The main force call.

inline virtual void multistep_add_debug(const std::vector<std::vector<std::pair<unsigned, unsigned>>> &data)

Multistep accumulate debugging info.

virtual void multistep_debug()

Print debug info.

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

inline virtual void multistep_update_begin()

Update the multi time step coefficient table when moving particle i from level cur to level next.

inline virtual void multistep_update_finish()

Execute to finish level shifts for particles.

virtual ~Cylinder()

Destructor.

Public Static Attributes

static pthread_mutex_t cos_coef_lock

static pthread_mutex_t sin_coef_lock

static pthread_mutex_t used_lock

Mutexes for multithreading.

Protected Functions

inline void getCoefs(Eigen::MatrixXcd &C)

Store coefficients from EmpCylSL.

void occt_output()

Print deep debugging data.

inline void setCoefs(Eigen::MatrixXcd &C)

Installed stored coefficients in EmpCylSL.

Protected Attributes

bool coefMaster

Master node ships coefficients to hosts. True (default) implies that only the master node caches the coefficients for playback to save core memory. This is set in the config input using the ‘coefMaster: bool’ parameter. Once I am sure that there are no algorithmic issues, I will remove this as an option.

CoefClasses::CylCoefs cylCoefs

Coefficient container instance for writing HDF5.

int defSampT

double lastPlayTime

Last playback coefficient evaluation time.

std::vector<std::vector<unsigned>> occt

CUDA method for coefficient accumulation.

Test change level counts for deep debugging enabled by setting CYL_UPDATE_TABLE at the top of this header file or the command line

Eigen::MatrixXcd P

Save data pointers.

Eigen::MatrixXcd P1

std::shared_ptr<CoefClasses::CylCoefs> playback

Coefficient playback instance. Using shared_ptr to avoid constructing a simple pointer or null instance

int sampT

For variance subsampling.

Protected Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

Private Functions

void compute_grid_mass()

Manual computation of on-grid mass.

void compute_multistep_coefficients()

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

virtual void determine_acceleration_and_potential()

All derived classes must provide a method to compute the force.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

virtual void determine_coefficients()

Used by get_acceleration_and_potential to request that the expansion be performed.

void determine_coefficients_eof()

void determine_coefficients_particles()

void determine_coefficients_playback()

virtual void *determine_coefficients_thread(void *arg)

Multithreading implementation of the expansion computation.

virtual void initialize(void)

Used by derived class to initialize any storage and parameters.

virtual void multistep_reset()

Reset used particle counter and mass registers.

Private Members

double acyl

double ashift

std::string cachename

int cmapR

int cmapZ

bool compute

double cylmass

std::vector<double> cylmass0

bool dump_basis

int eof

bool EVEN_M

bool firstime

bool firstime_coef

std::vector<Eigen::Vector3d> frc

double hcyl

double hexp

int lmaxfid

bool logarithmic

MixtureBasis *mix

For massive satellite simulations.

int mlim

int mmax

int ncompcyl

int ncylnx

int ncylny

int ncylodd

int ncylr

int ncylrecomp

int nmax

int nmaxfid

int npca

int npca0

int nvtk

std::vector<int> offgrid

std::shared_ptr<CylEXP> ortho

bool pcadiag

bool pcaeof

bool pcainit

bool pcavar

bool pcavtk

int pnum

std::vector<Eigen::Vector3d> pos

bool precond

std::string pyname

double rcylmax

double rcylmin

double rem

double resetT

int rnum

bool self_consistent

double snr

bool subsamp

int tnum

bool try_cache

unsigned int vflag

double zmax

struct dark_particle

#include <tipsydefs.h>

Tipsy particle structure for a dark particle.

Public Members

Real eps

Smoothing.

Real mass

Mass.

Real phi

Gravitational potential.

Real pos[MAXDIM]

Position vector.

Real vel[MAXDIM]

Velocity vector.

struct dark_particle

#include <tipsy.H>

Public Functions

inline int ID() const

Convert phi to index.

Public Members

Real eps

Real mass

Particle data.

Real phi

Real pos[MAXDIM]

Real vel[MAXDIM]

class DataGrid : public ThreeDGrid

#include <DataGrid.H>

Inheritence diagram for DataGrid:

Collaboration diagram for DataGrid:

This implementation of ThreeDGrid instantiates at VtkGrid if VTK is available and TableGrid if not.

This is really syntactic glue that allows one call without checking for VTK in application codes.

Public Functions

inline virtual void Add(const std::vector<double> &data, const std::string &name)

Add data.

inline DataGrid(int nx, int ny, int nz, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, std::string type = "VTK")

Constructor.

inline virtual void Write(const std::string &name)

Write output file.

Private Members

ThreeDGridPtr ptr

class Direct : public PotAccel

#include <Direct.H>

Inheritence diagram for Direct:

Collaboration diagram for Direct:

Computes the potential, acceleration and density using the direct summation

Positions are passed from node to node on a ring. Accelerations computed on requested particles array due to particles in component associated with the Direct force.

Settable parameters:

Param soft_indx:

is the index in the particle double array for the softening value.

Param soft:

is a fixed softening value for all particles. This can be used even if a value is specified in the particle attribute array.

Param mn_model:

uses a Miyamoto-Nagi model for the distributed gravity. E.g. a disk model particle. Default: false.

Param a:

is the scale length of the Miyamoto-Nagai model for the distributed gravity. Default: 0.01

Param b:

is the scale height of the Miyamoto-Nagai model for the distributed gravity. Default: 0.002

Param pm_model:

uses a spherical model for the distributed gravity. E.g. a substructure halo profile. Default: false.

Param pmmodel_file:

is the file containing the substructure halo profile (default: SLGridSph.model)

Param type:

is the softening type. Current types: Plummer or Spline. Default type is Spline.

Public Functions

Direct(Component *c0, const YAML::Node &conf)

The constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• conf – passes in any explicit parameters

virtual void get_acceleration_and_potential(Component*)

The main force call.

virtual ~Direct()

The constructor.

Private Functions

void determine_acceleration_and_potential(void)

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

virtual void determine_coefficients(void)

Used by get_acceleration_and_potential to request that the expansion be performed.

virtual void *determine_coefficients_thread(void *arg)

Multithreading implementation of the expansion computation.

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

double a

MN disk scale length.

double b

MN disk scale height.

double *bod_buffer

int diverge

double diverge_rfac

bool fixed_soft

int from_proc

std::shared_ptr<SoftKernel> kernel

Smoothing kernel isntance.

int max_bodies

bool mn_model

Use Miyamoto-Nagai disk.

int ndim

int ninteract

bool pm_model

Use point-mass profile.

SphericalModelTable *pmmodel

string pmmodel_file

const double rtol = 1.0e-16

Separations smaller than this are assumed to be zero (same particle)

double soft

int soft_indx

double *tmp_buffer

int to_proc

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Disk2d

#include <Disk2d.H>

Computes the potential, acceleration and density using an empirical function analysis for a flat Bessel basis and a target density

Param acyltbl:

is the scale length of target density (default is 0.6)

Param rcylmin:

is the minimum value in the table for the radial basis functions (default is 0.0)

Param rcylmax:

is the maximum value in the table for the radial basis functions in acyltbl units (default is 10.0)

Param numr:

is the number radial coordinate knots in the table (default is 1000)

Param knots:

is the number quadrature points for integrals in basis construction

Param logr:

scales the EmpCyl2d grid logarithmically

Param model:

name for EmpCyl2d (default: expon)

Param biorth:

set for EmpCyl2d (default: bess)

Param Mmax:

is the azimuthal order

Param nmaxfid:

is the radial order for the Bessel basis used to construct the EOF

Param nmax:

is the radial order

Param numx:

is the number of grid points in the scaled radial direction

Param numy:

is the number of grid points in the scaled vertical direction

Param NQDHT:

is the number of Bessel knots in the underlying Hankel transform used to get the vertical potential

Param cmapR:

is the scaling method for radius (0=none, 1=rational) in the grid mapping

Param cmapZ:

is the scaling method for vertical height (0=none, 1=sinh, 2=rational) in the grid mapping

Param scale:

is the expansion factor to get the physical scale from the internal scale (default is 0.01)

Param cachename:

is the file cache for the 2d EOF basis

Param verbose:

set to true turns on some additional diagnostic info in BiorthCyl

Param mmin:

changes the minimum harmonic order for evaluation to some value >=0

Param mlim:

changes the maximum harmonic order for evaluation to some value <=mmax

Param nmin:

changes the minimum radial order for evaluation to some value >=0

Param nlim:

changes the maximum radial order for evaluation to some value <=nmax

Param EVEN_M:

evaluates the expansion for even azimuthal harmonics only

Public Functions

void accumulate(double r, double phi, double mass)

Add single particle to coefficients.

void accumulate(std::vector<Particle> &part)

Accumulate coefficients from particle distribution.

std::tuple<double, double, double, double, double, double, double> accumulated_eval(double R, double z, double phi)

Evaluation of field. Returns: den0, den1, pot0, pot1, Fr, Fz, Fp.

Disk2d(const YAML::Node &conf)

Constructor.

inline Eigen::MatrixXd get_coefs()

Get coefficient matrix.

void inner_product(std::function<double(int, double)> dens, int numr, int nlim = std::numeric_limits<int>::max())

Compute the m=0 coefficients for the provided density profile.

void make_coefficients()

Finish making the coefficients after accumulation.

void setup_accumulation()

Set up for accumulations by zeroing counters, allocated storage, etc.

void write_coefficients(const std::string &outfile)

Write coefficients to a file for debugging.

virtual ~Disk2d()

Destructor.

Protected Functions

inline void get_pot(Eigen::MatrixXd &Vc, Eigen::MatrixXd &Vs, double r, double z)

Use BiorthCyl to evaluate the basis at r, z.

void setup_accum()

Setup accumulation arrays.

Protected Attributes

double cylmass

std::vector<double> cylmass1

Mass tally.

Eigen::MatrixXd dend

Field evaluation.

Eigen::MatrixXd expcoef

Final coefficiet set.

std::vector<Eigen::MatrixXd> expcoef0

Matrices per thread for obtaining expansion coefficients.

std::vector<Eigen::MatrixXd> potd

Potential coefficient computation.

Eigen::MatrixXd potl

Eigen::MatrixXd potr

Eigen::MatrixXd potz

Private Functions

void get_dens(double r, double z, Eigen::MatrixXd &p, int tid)

void get_dpotl(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &dpr, Eigen::MatrixXd &dpz, int tid)

Field evaluation members.

void get_potl(double r, double z, Eigen::MatrixXd &p, int tid)

void get_potl_dens(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid)

inline virtual double getRtable()

void initialize(void)

Initialize parameters.

Private Members

bool accum_setup

double acyltbl

Parameters.

string biorth

bool coefs_made

YAML::Node conf

Config db.

int knots

bool logr

int mmax

string model

int nmax

int nthrds

Internal state variables.

int numr

CylPtr ortho

Basis instance.

double rcylmax

double rcylmin

double scale

Private Static Attributes

static std::set<std::string> valid_keys

Valid key set for parameter name checking.

class Disk2dHalo

#include <Disk2dHalo.H>

Public Types

enum DiskGenType

Values:

enumerator Jeans

enumerator Asymmetric

enumerator Epicyclic

Public Functions

double a_drift(double xp, double yp, double zp)

double deri_pot(double xp, double yp, double zp, int n)

double deri_pot_disk(double xp, double yp, double zp, int n)

double deri_pot_halo(double xp, double yp, double zp, int n)

Disk2dHalo()

Dummy Constructor.

Disk2dHalo(const Disk2dHalo&)

Copy constructor.

Disk2dHalo(SphericalSLptr expandh, std::shared_ptr<Disk2d> expandd, double A, double DMass, std::string maptype, string &filename, int DF = 0, int DIVERGE = 0, double DIVERGE_RFAC = 1.0, DiskGenType type = Asymmetric)

Constructor: equal mass.

Disk2dHalo(SphericalSLptr haloexp, std::shared_ptr<Disk2d> diskexp, double A, double DMass, std::string maptype, string &filename1, int DIVERGE, double DIVERGE_RFAC, string &filename2, int DIVERGE2, double DIVERGE_RFAC2, DiskGenType type = Asymmetric)

Constructor: multi mass.

void disk_eval(double R, double z, double phi, double &p, double &fr, double &fz, double &fp)

void disk_model(const std::string &modfile)

double epi(double xp, double yp, double zp)

double get_ddpot(double xp, double yp, double zp)

double get_disp(double xp, double yp, double zp)

double get_dpot(double xp, double yp, double zp)

double get_hdpot(double xp, double yp, double zp)

double get_hpot(double xp, double yp, double zp)

void profile(std::ostream &rotfile, vector<Particle> &dpart, double rmin, double rmax, int numr)

void set_disk_coordinates(vector<Particle> &pdisk, int ndisk, int npart)

void set_halo(vector<Particle> &phalo, int nhalo, int npart)

void set_halo_coordinates(vector<Particle> &phalo, int nhalo, int npart)

void set_halo_table_multi(vector<Particle> &phalo)

void set_halo_table_single(vector<Particle> &phalo)

inline void set_pos_origin(double &x, double &y, double &z)

void set_vel_disk(vector<Particle> &part)

void set_vel_halo(vector<Particle> &part)

inline void set_vel_origin(double &x, double &y, double &z)

void table_disk(vector<Particle> &part)

void table_halo(vector<Particle> &part)

double v_circ(double xp, double yp, double zp)

void virial_ratio(const char*, const char*)

void virial_ratio(vector<Particle> &hpart, vector<Particle> &dpart)

double vp_disp2(double xp, double yp, double zp)

double vr_disp2(double xp, double yp, double zp)

void write_file(ostream &fou, vector<Particle> &part)

inline void zero_com(bool val)

inline void zero_cov(bool val)

~Disk2dHalo()

Destructor.

Public Static Attributes

static bool ALLOW

static double AMPL

static bool CHEBY

static double COMPRESSION

static double DR_DF

static std::map<std::string, DiskGenType> getDiskGenType

static int ITMAX

static bool LOGR

static int MPERT

static unsigned NBUF

static int NCHEB

static int NDP

static int NDR

static int NDZ

static int NHR

static int NHT

static int NUMDF

static double Q

static double R_DF

static double RA

static double RDMAX

static double RDMIN

static double RHMAX

static double RHMIN

static int RNUM

static string RUNTAG

static int SEED

static double SHFACTOR

static double SIG0

static double TOLE

static bool use_mono

static unsigned VFLAG

static double XI

Private Functions

double disk_surface_density(double R)

void flush_buffer(ostream &out)

inline std::shared_ptr<CMap> make_cmap(std::string type, double scale)

void table_halo_disp()

inline void write_record(ostream &out, Particle &p)

void write_record(ostream &out, SParticle &p)

Private Members

Eigen::MatrixXd asytable

int bufcnt

std::ostringstream bufout

const int bunchcnt = 16384

double center_pos[3]

double center_vel[3]

std::shared_ptr<CMap> cmap

bool com

bool cov

double dc

bool DF

std::shared_ptr<ExponentialDisk> disk

double dmass

double dP

double dR

double dr

double dRh

Eigen::MatrixXd dv2table

double dZ

Eigen::MatrixXd epitable

std::shared_ptr<Disk2d> expandd

SphericalSLptr expandh

std::mt19937 gen

std::shared_ptr<SphericalModelTable> halo

std::shared_ptr<SphericalModelTable> halo2

std::shared_ptr<SphericalModelTable> halo3

Eigen::MatrixXd halotable

double hDmax

double hDmin

std::string mtype

std::shared_ptr<SphericalModelMulti> multi

bool MULTI

std::shared_ptr<AddDisk> newmod

vector<double> nhD

vector<double> nhM

vector<unsigned> nhN

int nzepi

int nzero

std::normal_distribution rndN

std::uniform_real_distribution rndU

double scalelength

double sigma0

DiskGenType type

double Xmax

double Xmin

Private Static Attributes

static const unsigned mh = 5

static const unsigned nh = 50

static const int use_spline = 0

class Disk2dHaloException : public std::runtime_error

#include <Disk2dHalo.H>

Inheritence diagram for Disk2dHaloException:

Collaboration diagram for Disk2dHaloException:

Public Functions

inline Disk2dHaloException(const string message, const string sourcefilename, const int sourcelinenumber)

class diskbulge : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for diskbulge:

Collaboration diagram for diskbulge:

The usual exponential disk + a Hernquist bulge.

Public Functions

inline diskbulge(double a, double h, double as, double Mfac, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double as

double d1

double d2

double h

double Mfac

class DiskEval

#include <DiskEval.H>

Compute the axisymmetric force of a three-dimensional disk density using the multipole expansion

Using the standard multipole formula

\[ \Phi(\mathbf{r}) = -4\pi G \sum_{lm} Y_{lm}(\mathbf{\Omega}) \left[ \frac{1}{r^{l+1}}\int_0^r da a^{l+2}\rho_{lm}(a) + r^l\int_r^{\infty} da \frac{\rho_{lm}(a)}{a^{l-1}} \right] \]

where

\[ \rho_{lm} = \int d\mathbf{\Omega}Y_{lm}(\mathbf{\Omega}) \rho(\mathbf{r}). \]

The forces follow by analytic differentiation. Specifically, the forces follows by differentiation of \(\Phi(\mathbf{r})\) with respect to \(r\) and \(\theta\) where:

\[ F_R = -\frac{\partial\Phi}{\partial r} \frac{R}{r} - \frac{\partial\Phi}{\partial\theta} \frac{z}{r^2} \]

and

\[ F_z = -\frac{\partial\Phi}{\partial r} \frac{z}{r} + \frac{\partial\Phi}{\partial\theta} \frac{R}{r^2} \]

Note

{Mathematics}

Param model:

is the target model for potential computation

Param rmin:

is the minimum radius for potential evaluation

Param rmax:

is the maximum radius for potential evaluation

Param ascl:

is the scale radius for maping r to the unit interval. This is only used if ascl>0, otherwise it is linear if rmin=0 or logarithmic if rmin>0.

Param lmax:

is the maximum order of the spherical harmonics

Param numr:

is the number of grid points in the radial table

Param nint:

is the number of quadrature knots for the x=cos(theta) integral @parm progress set to true prints a progress bar

Public Functions

DiskEval(EmpCylSL::AxiDiskPtr model, double rmin, double rmax, double ascl, int lmax, int numr, int nint, bool progress = true, int mmax = 1, int nump = 1, bool cache = true)

Constructor.

std::tuple<double, double, double, double> operator()(double R, double z, double phi = 0)

Evaluation where the return tuple is potential, dPhi/dR, dPhi/dz, dPhi/dphi.

inline void setPrenorm(bool b)

Set prenorm (true) standard (false) evaluation.

Private Functions

inline double dr_to_dx(double x)

inline double Nlm(int l, int m)

Ylm angular factors.

inline double r_to_x(double r)

Coordinate scaling: physical to scaled.

bool read_cache()

void write_cache()

inline double x_to_r(double x)

Coordinate scaling: scaled to physical.

inline double Ylm(int l, int m, double cosx)

Ylm evaluation.

inline double Ylm_prenorm(int L, int m, double x)

Prenormalized Ylm evaluation.

inline double Ylm_standard(int l, int m, double cosx)

Standard recursion CAUTION: this will fail at l>150 owing to double precision issues.

inline double Zlm(int l, int m, double cosx)

Ylm derivative.

inline double Zlm_prenorm(int L, int m, double x)

Derivative of Ylm prenormalized.

inline double Zlm_standard(int l, int m, double cosx)

Partial derivative of Ylm in theta Standard version

Private Members

double ascl

double dx

const unsigned hmagic = 0x57ee1ed

int lmax

bool logr

EmpCylSL::AxiDiskPtr model

int numr

bool prenorm = true

std::vector<std::vector<std::vector<double>>> rho

Rho(l, r), Term1(l, r), Term2(l, r)

Rho(l, m, r), Term1(l, m, r), Term2(l, m, r)

std::vector<std::vector<std::vector<double>>> T1

std::vector<std::vector<std::vector<double>>> T2

double xmax

double xmin

bool xscl

Private Static Attributes

static const std::string cachefile

class DiskHalo

#include <DiskHalo.H>

Public Types

enum DiskGenType

Values:

enumerator Jeans

enumerator Asymmetric

enumerator Epicyclic

Public Functions

double a_drift(double xp, double yp, double zp)

double deri_pot(double xp, double yp, double zp, int n)

double deri_pot_disk(double xp, double yp, double zp, int n)

double deri_pot_halo(double xp, double yp, double zp, int n)

void disk_eval(double R, double z, double phi, double &p, double &fr, double &fz, double &fp)

void disk_model(const std::string &modfile)

DiskHalo()

Dummy Constructor.

DiskHalo(const DiskHalo&)

Copy constructor.

DiskHalo(SphericalSLptr expandh, EmpCylSLptr expandd, double H, double A, double DMass, std::string maptype, string &filename, int DF = 0, int DIVERGE = 0, double DIVERGE_RFAC = 1.0, DiskGenType type = Asymmetric)

Constructor: equal mass.

DiskHalo(SphericalSLptr haloexp, EmpCylSLptr diskexp, double H, double A, double DMass, std::string maptype, string &filename1, int DIVERGE, double DIVERGE_RFAC, string &filename2, int DIVERGE2, double DIVERGE_RFAC2, DiskGenType type = Asymmetric)

Constructor: multi mass.

double epi(double xp, double yp, double zp)

double get_ddpot(double xp, double yp, double zp)

double get_disp(double xp, double yp, double zp)

double get_dpot(double xp, double yp, double zp)

double get_hdpot(double xp, double yp, double zp)

double get_hpot(double xp, double yp, double zp)

void profile(std::ostream &rotfile, vector<Particle> &dpart, double rmin, double rmax, int numr)

void set_disk_coordinates(vector<Particle> &pdisk, int ndisk, int npart)

void set_halo(vector<Particle> &phalo, int nhalo, int npart)

void set_halo_coordinates(vector<Particle> &phalo, int nhalo, int npart)

void set_halo_table_multi(vector<Particle> &phalo)

void set_halo_table_single(vector<Particle> &phalo)

inline void set_pos_origin(double &x, double &y, double &z)

void set_vel_disk(vector<Particle> &part)

void set_vel_halo(vector<Particle> &part)

inline void set_vel_origin(double &x, double &y, double &z)

void table_disk(vector<Particle> &part)

void table_halo(vector<Particle> &part)

double v_circ(double xp, double yp, double zp)

void virial_ratio(const char*, const char*)

void virial_ratio(vector<Particle> &hpart, vector<Particle> &dpart)

double vp_disp2(double xp, double yp, double zp)

double vr_disp2(double xp, double yp, double zp)

double vz_disp2(double xp, double yp, double zp)

void write_file(ostream &fou, vector<Particle> &part)

inline void zero_com(bool val)

inline void zero_cov(bool val)

~DiskHalo()

Destructor.

Public Static Attributes

static bool ALLOW

static bool CHEBY

static double COMPRESSION

static double DR_DF

static std::map<std::string, DiskGenType> getDiskGenType

static int ITMAX

static bool LOGR

static unsigned NBUF

static int NCHEB

static int NDP

static int NDR

static int NDZ

static int NHR

static int NHT

static int NUMDF

static double Q

static double R_DF

static double RA

static double RDMAX

static double RDMIN

static double RHMAX

static double RHMIN

static int RNUM

static string RUNTAG

static int SEED

static double SHFACTOR

static double SIG0

static double TOLE

static bool use_mono

static unsigned VFLAG

static double XI

Private Functions

double disk_density(double R, double z)

double disk_surface_density(double R)

void flush_buffer(ostream &out)

inline std::shared_ptr<CMap> make_cmap(std::string type, double scale)

void table_halo_disp()

inline void write_record(ostream &out, Particle &p)

void write_record(ostream &out, SParticle &p)

Private Members

Eigen::MatrixXd asytable

int bufcnt

std::ostringstream bufout

const int bunchcnt = 16384

double center_pos[3]

double center_vel[3]

std::shared_ptr<CMap> cmap

bool com

bool cov

double dc

bool DF

std::shared_ptr<ExponentialDisk> disk

std::vector<Eigen::MatrixXd> disktableN

std::vector<Eigen::MatrixXd> disktableP

double dmass

double dP

double dR

double dr

double dRh

Eigen::MatrixXd dv2table

double dZ

Eigen::MatrixXd epitable

EmpCylSLptr expandd

SphericalSLptr expandh

std::mt19937 gen

std::shared_ptr<SphericalModelTable> halo

std::shared_ptr<SphericalModelTable> halo2

std::shared_ptr<SphericalModelTable> halo3

Eigen::MatrixXd halotable

double hDmax

double hDmin

std::string mtype

std::shared_ptr<SphericalModelMulti> multi

bool MULTI

std::shared_ptr<AddDisk> newmod

vector<double> nhD

vector<double> nhM

vector<unsigned> nhN

int nzepi

int nzero

std::normal_distribution rndN

std::uniform_real_distribution rndU

double scaleheight

double scalelength

double sigma0

DiskGenType type

double Xmax

double Xmin

Private Static Attributes

static const unsigned mh = 5

static const unsigned nh = 50

static const int use_spline = 0

class DiskHaloException : public std::runtime_error

#include <DiskHalo.H>

Inheritence diagram for DiskHaloException:

Collaboration diagram for DiskHaloException:

Public Functions

inline DiskHaloException(const string message, const string sourcefilename, const int sourcelinenumber)

class DiskWithHalo : public AxiSymModel

#include <DiskWithHalo.H>

Inheritence diagram for DiskWithHalo:

Collaboration diagram for DiskWithHalo:

Public Functions

inline virtual double d2fde2(double E, double L) override

inline virtual double dfde(double E, double L) override

inline virtual double dfdl(double E, double L) override

inline DiskWithHalo()

inline DiskWithHalo(const DiskWithHalo &t)

inline DiskWithHalo(std::shared_ptr<AxiSymModel> D, std::shared_ptr<AxiSymModel> H)

inline virtual double distf(double E, double L) override

inline virtual double get_density(const double r) override

inline virtual double get_density(const double x1, const double x2, const double x3) override

The density at (x, y, z)

inline virtual double get_dpot(const double r) override

inline virtual double get_dpot2(const double r) override

inline virtual double get_mass(const double r) override

Access the profile.

inline virtual double get_mass(const double x1, const double x2, const double x3) override

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

inline virtual double get_max_radius(void) override

inline virtual double get_min_radius(void) override

inline virtual double get_pot(const double r) override

inline virtual double get_pot(const double x1, const double x2, const double x3) override

The potential at (x, y, z)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur) override

Private Members

std::shared_ptr<AxiSymModel> d

std::shared_ptr<AxiSymModel> h

class DoubleExponential : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for DoubleExponential:

Collaboration diagram for DoubleExponential:

A mixture of two exponential disks.

Public Functions

inline DoubleExponential(double a, double h, double a2, double h2, double Mfac, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double a2

double d1

double d2

double h

double h2

double Mfac

struct dump

#include <tipsydefs.h>

Tipsy file header.

Public Members

int nbodies

Total number of bodies.

int ndark

Number of Dark particles.

int ndim

Dimensions.

int nsph

Number of Gas particles.

int nstar

Number of Star particles.

double time

Dump time.

template<typename T>
class Dynamic2dArray

#include <ThreeDGrid.H>

Make a two-d wrapper for nested std::vectors.

Public Functions

inline Dynamic2dArray()

Default constructor.

inline Dynamic2dArray(int rows, int cols)

Allocation constructor.

inline std::vector<T> &operator[](int i)

Get reference to second dimension.

inline const std::vector<T> &operator[](int i) const

Get reference to second dimension (const version)

inline void resize(int rows, int cols)

Resize the two dimentional array.

Private Members

std::vector<std::vector<T>> dArray

template<typename T>
class Dynamic3dArray

#include <ThreeDGrid.H>

Make a three-d wrapper for nested std::vectors.

Public Functions

inline Dynamic3dArray()

Default constructor.

inline Dynamic3dArray(int rows, int cols, int levs)

Allocation constructor.

inline Dynamic2dArray<T> &operator[](int i)

Return a Dynamic2DArray reference for first index.

inline const Dynamic2dArray<T> &operator[](int i) const

Return a Dynamic2DArray reference for first index (constant version)

inline void resize(int rows, int cols, int levs)

Resize the three dimentional array .

Private Members

std::vector<Dynamic2dArray<T>> tArray

class EJcom : public TwoCenter

#include <EJcom.H>

Inheritence diagram for EJcom:

Collaboration diagram for EJcom:

Computes the potential, acceleration and density using basis expansion solutions fitting to peak potential and COM. This implements a TwoCenter class by providing a mixture function.

The mixture function is:

\[ f({\bf r}) = \hbox{erf}\left(C\left[{|{\bf r} - {\bf r}_{peak}|\over |{\bf r}_{COM} - {\bf r}_{peak}|}\right]^\alpha\right) \]

On evaluation, the acceleration from the grid centered on \({\bf r}_{COM}\) is multiplied by \(f({\bf r})\) and the the acceleration from the grid centered on \({\bf r}_{peak}\) is multiplied by \(1-f({\bf r})\)

See SphereTwoCenter for other parameters controlling the spherical expansion.

Param cfac:

is a prefactor \(C\) for the erf ramp above

Param alpha:

is the exponent in the argument of the erf ( \(\alpha\))

Public Functions

EJcom(Component *c0, const YAML::Node &conf)

Constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• line – passes any parameters (rsphSL, rmin and numr)

virtual double mixture(double *p)

Mixture function for the two expansions.

Private Functions

virtual void initialize()

Initialize the force.

Private Members

double alpha

exponent in the argument of the erf

double cfac

Prefactor for the erf ramp.

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class EL3

#include <Orient.H>

Class to hold energy and angular momentum for use in centering a component. Helper class for class Orient.

Public Functions

void debug() const

Debug output.

inline EL3()

Constructor.

inline bool operator<(const EL3 &x) const

Comparison member for ordering energy.

Public Members

double E

Binding energy.

Eigen::Vector3d L

Angular momentum.

double M

Mass.

Eigen::Vector3d R

Position.

double T

Time.

class Element

#include <Cspline.H>

A cubic spline fit for an interval.

Public Functions

inline Element(X _x)

Define the ordinate only.

inline Element(X _x, Y _a, Y _b, Y _c, Y _d)

The ordinate and the cubic coefficients.

inline Y eval(const X &xx) const

Evaluate the fit.

inline bool operator<(const Element &e) const

Sorting operators.

inline bool operator<(const X &xx) const

Public Members

Y a

Cubic coefficients.

Y b

Y c

Y d

X x

The ordinate.

class EllipForce

#include <EllipForce.H>

Public Functions

EllipForce(double a, double b, double c, double mass, int num = 100, int numr = 100)

double getMass(double x)

double getPot(double x)

void PrintModel(const string&)

void PrintTable()

void TestTable()

~EllipForce()

Public Static Attributes

static string cache_file

Private Functions

bool read_cache()

void write_cache()

Private Members

double a

double b

double c

std::shared_ptr<LegeQuad> lq

std::vector<double> m

double mass

int num

int numr

std::vector<double> p

std::vector<double> r

class EllipsoidForce

#include <EllipsoidForce.H>

Defines potential and force for ellipsoid models

Internal potential has the form (Chandra pg. 52, eqn. 93)

\[ V = \pi G a_1 a_2 a_3 \int^\infty_0\frac{du}{\Delta} \left[\Psi(1) - \Psi(m^2(u))\right] \]

where

\[ m^2(u) = \sum_{i=1}^3\frac{x_i^2}{a_i^2 + u} \]

and

\[ \Psi(m^2) = \int_1^{m^2} dm^2\,\rho(m^2). \]

The external potential has the form (Cha ndra pg. 51, eqn. 89)

\[ V = \pi G a_1 a_2 a_3 \int^\infty_\lambda\frac{du}{\Delta} \left[\Psi(1) - \Psi(m^2(u))\right]. \]

Note

{Mathematics}

Param a:

is the major axis

Param b:

is the submajor (middle) axis

Param c:

is the minor axis

Param mass:

is the total mass for the ellipsoid

Param num:

is the number of integration knots

Param numr:

is the number of grid points in the radial table

Public Types

enum BarType

Values:

enumerator powerlaw

enumerator ferrers

enumerator expon

Public Functions

EllipsoidForce(double a, double b, double c, double mass, double rmin, double rmax, BarType bartype, bool quad, double param = 0.0, int num = 100, int numr = 100)

Constructor.

double getDens(vector<double> x)

Returns the density at position x.

double getPotl(double r)

Returns the radial part of quadrupole potential.

double getPotl(vector<double> x)

Returns the potential at position x.

double getSurfDens(double r)

Compute the surface density along the major axis.

void MakeTable(int n1, int n2, int n3)

Tabulate the potential and force.

void MassInertia(double &M, vector<double> &I)

Returns the total mass and moment of inertia vector.

bool quadpot(double r, double &f, double &fr, double &M)

Get the quadrupole components at the radius r.

double RhoBar(double r)

Quadrupole bar density for radius r.

void TableEval(vector<double> x, vector<double> &forcepot)

Evaluate the force (indices 0,1,2) potential (index 3) on the table.

double U22(double r)

Quadrupole potential term for radius r.

~EllipsoidForce()

Destructor.

Public Static Attributes

static string cache_file

Interpolation grid cache name.

static double dfrac

Fraction of grid step for numerical derivatives.

static int n

Number of points for the monopole/quadrupole computation.

Private Functions

bool nindx(Eigen::Vector3d &x, Eigen::Vector3i &n)

bool read_cache()

double solve(vector<double> x, double m2)

void write_cache()

Private Members

vector<double> a

BarType bartype

vector<double> dX

std::shared_ptr<LegeQuad> gq

std::shared_ptr<LegeQuad> gt

std::shared_ptr<LegeQuad> gz

double ldr

double lrmax

double lrmin

double mass

vector<double> mm

int N

vector<int> ntab

int num

int numr

double param

vector<double> pp

bool quadr

double rho0

double rmax

double rmin

vector<double> rr

double rtmax

double rtmin

vector<double> table

bool tlog

bool tmade

vector<double> uu

class EmbeddedDiskModel : public AxiSymModel

#include <massmodel.H>

Inheritence diagram for EmbeddedDiskModel:

Collaboration diagram for EmbeddedDiskModel:

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

EmbeddedDiskModel(std::vector<std::shared_ptr<AxiSymModel>> &T, std::vector<double> &M_scale, std::vector<double> &R_scale, int NUMBER)

inline virtual double get_density(const double x1, const double x2, const double x3)

The density at (x, y, z)

virtual double get_density(const double)

virtual double get_dpot(const double)

virtual double get_dpot2(const double)

inline virtual double get_mass(const double x1, const double x2, const double x3)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

virtual double get_mass(const double)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double x1, const double x2, const double x3)

The potential at (x, y, z)

virtual double get_pot(const double)

virtual void get_pot_dpot(const double, double&, double&)

void save_df(string &file)

void setup_df(int egrid = 10, int kgrid = 5, int mgrid = 20, double lambda = 0.0, double alpha = -6.0, double beta = 1.0, double gama = 1.0, double sigma = 2.0, double rmmax = -1, double roff = 0.05, double eoff = 0.5, double koff = 0.5, double kmin = 0.0, double kmax = 1.0, int nint = 20, int numt = 20)

void setup_df(string &file)

void verbose_df(void)

virtual ~EmbeddedDiskModel()

Private Members

std::shared_ptr<QPDistF> df

std::vector<double> m_scale

int number

std::vector<double> r_scale

double rmax

double rmin

std::vector<std::shared_ptr<AxiSymModel>> t

class EmpCyl2d

#include <EmpCyl2d.H>

Collaboration diagram for EmpCyl2d:

A class that implements most of the members for an Exp force routine

Public Functions

inline void basisTest(bool which)

Use underlying basis for testing? Default: false.

void checkCoefs()

Check the coefficients of the EOF basis against the zeroth-order model

inline EmpCyl2d()

Null constructor (for copy construct)

EmpCyl2d(int mmax, int nmaxfid, int nmax, int knots, int numr, double rmin, double rmax, double scale, bool cmap, bool logr, const YAML::Node &P, const std::string biorth, const std::string cache = "")

Constructor.

EmpCyl2d(int mmax, int nmaxfid, int nmax, int knots, int numr, double rmin, double rmax, double scale, bool cmap, bool logr, std::shared_ptr<ModelCyl> disk, const std::string biorth, const std::string cache = "")

Constructor with user-supplied target model.

double get_dens(double r, int M, int N)

Linear interpolate on grid to get density value.

void get_dens(Eigen::MatrixXd &mat, double r)

double get_dpot(double r, int M, int N)

Linear interpolate on grid to get potential gradient (-force) value.

void get_force(Eigen::MatrixXd &mat, double r)

void get_pot(Eigen::MatrixXd &mat, double r)

Matrix evaluation members.

double get_potl(double r, int M, int N)

Linear interpolate on grid to get potential value.

inline const std::string getBiorthName()

Get biorthogonal function base name.

inline Mapping getMapping()

Get coordinate mapping object.

inline const std::string getModelName()

Get model name.

inline double getRmax()

Access the maximum radius.

inline double getRmin()

Access the minimum radius.

inline bool operator()()

Check for configuration.

std::vector<Eigen::MatrixXd> orthoCheck()

Return an array of inner-product matrices for the EOF basis.

void orthoCheck(int M, const std::string &file)

Write the inner-product matrix for the EOF basis for a particular azimuthal M value to a file

void writeBasis(int M, const std::string &file)

Write the basis for a partcular azimuthal M value to a file.

void writeTrans(int M, const std::string &file)

Write the eigenvector rotation matrix for a partcular azimuthal M value to a file

Protected Functions

void checkMN(int &M, int &N, const std::string &member)

void create_tables()

std::shared_ptr<ModelCyl> createModel()

std::tuple<int, int, double, double> linear_interp(double r)

Interpolation helpers.

bool ReadH5Cache()

void WriteH5Cache()

Protected Attributes

std::shared_ptr<Basis2d> basis

bool basis_test

std::string biorth

std::string cache_name_2d

The cache file name.

bool cmap

bool configured

std::vector<Eigen::MatrixXd> dens_array

std::shared_ptr<ModelCyl> disk

std::vector<Eigen::MatrixXd> dpot_array

double dxi

int knots

bool logr

Mapping map

Mapping instance.

int mmax

std::string model

int nmax

int nmaxfid

int numr

YAML::Node Params

Contains parameter database.

std::vector<Eigen::MatrixXd> potl_array

double rmax

double rmin

std::vector<Eigen::MatrixXd> rot_matrix

double scale

std::vector<double> xgrid

double xmax

double xmin

Protected Static Attributes

static const std::string default_cache_name

Default cache name.

static const unsigned int hmagic = 0xc0a57a1

Basis magic number.

static const std::string Version = "1.0"

Cache versioning.

class EmpCylSL

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL:

Collaboration diagram for EmpCylSL:

Encapsulatates a SLGridSph (Sturm-Liouville basis) for use as force method

This version breaks the spherical basis computation into even and odd subspaces if Nodd is selected. This gives the user more control over the vertical parity, is numerically more accurate, and more efficient.

Subclassed by CylEXP

Utility functions

using TableArray = std::vector<Eigen::MatrixXd>

TKType tk_type

void legendre_R(int lmax, double x, Eigen::MatrixXd &p)

Compute Associated Legendre Polynomials, return Matrix type.

void dlegendre_R(int lmax, double x, Eigen::MatrixXd &p, Eigen::MatrixXd &dp)

Compute Associated Legendre Polynomials and derivitives, return Matrix type

void sinecosine_R(int mmax, double phi, Eigen::VectorXd &c, Eigen::VectorXd &s)

Compute vectors of sines and cosines by recursion.

double xi_to_r(double)

Convert from non-dimensional to dimensional radial coordinate.

double r_to_xi(double)

Convert from dimension to non-dimension radial coordinate.

double d_xi_to_r(double)

Jacobian.

inline double get_ascale(void)

Return current value of disk scale length.

inline double get_hscale(void)

Return current value of disk scale height.

inline double get_rtable(void)

Return current table radius.

inline void setEven(bool even = true)

Set even modes only.

inline void setHall(std::string file, unsigned tot)

Set file name for EOF analysis and sample size for subsample computation

inline void AllowOldCache(bool allow = true)

Cache versioning override. Allow read of old cache files without triggering a cache recomputation.

void getPotSC(int m, int j, double R, double z, double &pC, double &pS)

Get potential grid interpolated entries.

void getDensSC(int m, int j, double R, double z, double &dC, double &dS)

Get density grid interpolated entries.

inline TableArray getDensC()

Return density and potential matrices Indexed (M, n) pair as id = M*NORDER + n

inline TableArray getDensS()

inline TableArray getPotlC()

Return density and potential matrices.

inline TableArray getPotlS()

void getPotParticle(double x, double y, double z, ContribArray &vc, ContribArray &vs)

void get_trimmed(double snr, std::vector<Eigen::VectorXd> &ac_cos, std::vector<Eigen::VectorXd> &ac_sin, std::vector<Eigen::VectorXd> *rt_cos = 0, std::vector<Eigen::VectorXd> *rt_sin = 0, std::vector<Eigen::VectorXd> *sn_rat = 0)

Get the coefficients trimmed by a SNR value using the defined algorithm.

void set_trimmed(double snr, double rem)

Set the coefficients trimmed by a SNR value using the defined algorithm.

inline void setTotal(unsigned tot)

Set number of bodies for subsample computation.

inline void setTK(const std::string &tk)

inline vector<double> sanity()

void ortho_check(std::ostream &out)

Check orthogonality for basis (debugging)

std::vector<Eigen::MatrixXd> orthoCheck()

Check orthogonality for basis (pyEXP style)

static std::map<std::string, std::string> cacheInfo(const std::string &cachefile, bool verbose = true)

Read and print the cache and return the header parameters as a map/dictionary

Public Types

typedef std::shared_ptr<AxiDisk> AxiDiskPtr

using ContribArray = std::vector<Eigen::VectorXd>

enum EmpModel

Type of density model to use.

Values:

enumerator Exponential

enumerator Gaussian

enumerator Plummer

enumerator Power

enumerator Deproject

using MatrixM = std::vector<Eigen::MatrixXd>

using SLGridSphPtr = std::shared_ptr<SLGridSph>

using SphModTblPtr = std::shared_ptr<SphericalModelTable>

enum TKType

Enum listing the possible selection algorithms for coefficient selection

Values:

enumerator Hall

Tapered signal-to-noise as defined by Hall

enumerator Truncate

Truncated signal-to-noise

enumerator None

Compute the S/N but do not modify coefficients

using VectorM = std::vector<Eigen::VectorXd>

Public Functions

void accumulate(double r, double z, double phi, double mass, unsigned long seq, int id, int mlev = 0, bool compute = false)

Add single particle to coefficients.

void accumulate(vector<Particle> &p, int mlev = 0, bool verbose = false, bool compute = false)

Accumulate coefficients from particle distribution.

void accumulate_eof(double r, double z, double phi, double mass, int id, int mlev = 0)

Add single particle to EOF coefficients.

void accumulate_eof(vector<Particle> &p, bool verbose = false)

Make EOF from particle distribution.

void accumulate_eof_thread(vector<Particle> &p, bool verbose = false)

Make EOF from particle distribution by thread. Used by external applications.

void accumulate_thread(vector<Particle> &p, int mlev = 0, bool verbose = false)

Accumulate coefficients from particle distribution by thread. Used by external applications.

double accumulated_dens_eval(double r, double z, double phi, double &d0)

Evaluate density field.

void accumulated_eval(double r, double z, double phi, double &p0, double &p, double &fr, double &fz, double &fp)

Evaluate potential and force field.

double accumulated_midplane_eval(double r, double zmin, double zmax, double phi, int num = 40)

Evaluate peak density height within two limits.

inline bool coefs_made_all()

True if coefficients are made at all levels.

void compare_basis(const EmpCylSL *p)

Compare current basis with another for debugging.

void create_deprojection(double H, double Rfactor, int numR, int numI, AxiDiskPtr func)

Compute deprojection of axisymmetric disk for and use this generate the EOF spherical basis. The scale length must be O(1) with scale height H in scale length units.

double d_y_to_z(double y)

For measure transformation.

inline void determine_acceleration_and_potential()

Necessary member function currently unused (change design?)

inline void determine_coefficients()

Necessary member function currently unused (change design?)

void dump_basis(const std::string &name, int step, double Rmax = -1.0)

Plot basis.

void dump_coefs(std::ostream &out)

Dump out coefficients to output stream.

void dump_coefs_binary(std::ostream &out, double time)

Dump out coefficients to stream in bianry format.

void dump_eof_file(const std::string &eof_file, const std::string &dump_file)

Dump the EOF basis in ascii format.

void dump_images(const std::string &OUTFILE, double XYOUT, double ZOUT, int OUTR, int OUTZ, bool logscale)

Plot full fields for debugging.

void dump_images_basis(const std::string &OUTFILE, double XYOUT, double ZOUT, int OUTR, int OUTZ, bool logscale, int M1, int M2, int N1, int N2)

Plot basis images for debugging.

void dump_images_basis_eof(const std::string &runtag, double XYOUT, double ZOUT, int OUTR, int OUTZ, int M, int N, int cnt, const Eigen::VectorXd &tp)

Plot EOF basis images for debugging.

void dump_images_basis_pca(const std::string &runtag, double XYOUT, double ZOUT, int OUTR, int OUTZ, int M, int N, int cnt)

Plot PCA basis images for debugging.

EmpCylSL()

Constructor (reset must called later)

EmpCylSL(int mlim, const std::string cache)

Construct from cache file.

EmpCylSL(int numr, int lmax, int mmax, int nord, double ascale, double hscale, int Nodd, std::string cachename)

Constructor with parameters

Parameters:

Parameters:

• multistep – is the number of coefficient levels for n-body

• numr – is the spherical radial order of the input basis

• lmax – is the spherical angular order of the input basis

• mmax – is the output aximuthal order for the EOF basis

• nord – is the output radial order for the EOF basis

• ascale – is the target disk scale LENGTH

• hscale – is the target disk scale HEIGHT

• nodd – is the number of vertically odd parity basis functions. If unspecified, you get eigenvalue order.

void generate_eof(int numr, int nump, int numt, std::function<double(double, double, double, int)> f)

Generate EOF by direct integration conditioned on a user supplied function

If func is axisymmetric, you may use nump=1 to save computation time.

Parameters:

• numr – is the number of radial knots

• nump – is the number of azimuthal knots

• numt – is the number of inclination knots

• func – is the user-supplied density target function

void get_all(int m, int n, double r, double z, double phi, double &p, double &d, double &fr, double &fz, double &fp)

Get a single basis function values for a phase-space point.

void get_coefs(int mm, Eigen::VectorXd &cos1, Eigen::VectorXd &sin1)

Get coefficients from Vectors.

void get_coefs(int mm, std::vector<double> &cos1, std::vector<double> &sin1)

Get coefficients from std::vectors.

inline int get_mlim()

Get limit to mmax for testing.

inline int get_mmax(void)

Parameter access: get mmax.

inline int get_mmin()

Get limit to mmax for testing.

inline int get_order(void)

Parameter access: get norder.

inline double getMaxSNR(void)

Maximum SNR coefficient value.

inline double getMinSNR(void)

Minimum SNR coefficient value.

void init_pca()

Initialize PCA work space.

void make_coefficients(bool compute = false)

Make coefficients from accumulated data.

All levels

void make_coefficients(unsigned mlevel, bool compute = false)

Single level.

void make_eof(void)

Make empirical orthgonal functions.

void pca_hall(bool compute, bool subsamp)

Compute PCA.

int read_cache(void)

Read basis from cache file.

int read_eof_file(const std::string &eof_file)

Read EOF basis from saved file.

int read_eof_header(const std::string &eof_file)

Read EOF basis header from saved file.

void reset(int numr, int lmax, int mmax, int nord, double ascale, double hscale, int Nodd, std::string cachename)

Reconstruct basis with new parameters.

void reset_mass(void)

Clear mass counter.

void restrict_order(int n)

Restrict order.

void set_coefs(int mm, const Eigen::VectorXd &cos1, const Eigen::VectorXd &sin1, bool zero = true)

Set coefficients from Vectors.

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

void set_coefs(int mm, const std::vector<double> &cos1, const std::vector<double> &sin1, bool zero = true)

Set coefficients from std::vectors.

inline void set_mass(double mass)

Set cylmass manually.

inline void set_mlim(int mlim)

Set limit to mmax for testing.

inline void set_mmin(int mmin)

Set limit to mmax for testing.

inline void set_mrange(int mmin, int mmax)

Set azimuthal order range for evaluation.

inline void set_nrange(int nmin, int nmax)

Set radial order range for evaluation.

inline void setSampT(int N)

For PCAVAR: set subsample size.

void setup_accumulation(int toplev = 0)

Setup for accumulated coefficients.

void setup_eof(void)

For EOF computation.

void setup_table(void)

For EOF.

double y_to_z(double y)

Compute Z from non-dbimensional vertical coordinate.

double z_to_y(double z)

Compute non-dimensional vertical coordinate from Z.

~EmpCylSL(void)

Destructor.

Public Static Attributes

static int CMAPR

TRUE if we are using coordinate mapping (0=no, 1 rational-function mapping (default)

static int CMAPZ

TRUE if we are using coordinate mapping (0=no, 1 for vertical hyberbolic mapping (default), 2 for power mampping)

static std::map<EmpModel, std::string> EmpModelLabs

Convert EmpModel to ascii label.

static bool enforce_limits

No extrapolating beyond grid (default: false)

static int HALLFREQ

Selector output freq (this only affects diagnostic output). Current default is to perform Hall on every step when selected

static double HEXP

Hall smoothing exponent (default: 1.0)

static double HFAC

Fraction of table range for basis images (for debug)

static bool logarithmic

TRUE if mapping is logarithmic (default: false)

static EmpModel mtype

Density model type.

static bool NewCoefs

Use YAML header in coefficient file.

static int NOUT

Number of bases to print (for debug)

static int NUMR

Number of entries in radial basis table.

static int NUMX

Radial basis grid in radial direction.

static int NUMY

Radial basis grid in vertical direction.

static bool PCADRY

Compute taper but to not apply to coefficients (default: true)

static bool PCAEOF

TRUE if EOF diagnostics are on (default: false)

static bool PCAVAR

TRUE if signal-to-noise methods are on (default: false)

static bool PCAVTK

TRUE if VTK diagnostics are on (default: false)

static double PPOW

Power exponent for EOF conditioning density function.

static double RMAX

Maximum radial value for basis.

static double RMIN

Minimum radial value for basis.

static unsigned VFLAG

Verbose level flags bit Action

0 = quiet 1 = SL model output 2 = EOF diagnostics 4 = Accumulation, PCA Hall, and all other diagnostics 8 = Debug-level communication details 16 = Timing info

static unsigned VTKFRQ

VTK diagnostic frequency (default: false)

Protected Types

typedef std::shared_ptr<PCAbasis> PCAbasisPtr

typedef std::shared_ptr<PCAelement> PCAelemPtr

using VarMat = std::vector<std::vector<std::vector<std::vector<double>>>>

EOF variance computation.

typedef std::vector<std::vector<Eigen::VectorXd>> VectorD2

typedef std::shared_ptr<VectorD2> VectorD2ptr

Protected Functions

void accumulate_eof_thread_call(int id, std::vector<Particle> *p, bool verbose)

Thread body for eof accumulation.

void accumulate_thread_call(int id, std::vector<Particle> *p, int mlevel, bool verbose)

Thread body for coef accumulation.

int cache_grid(int, std::string file)

void compute_eof_grid(int request_id, int m)

void compute_even_odd(int request_id, int m)

double densR(double R)

void eigen_problem(int request_id, int M, Timer &timer)

void get_pot(Eigen::MatrixXd&, Eigen::MatrixXd&, double, double)

double integral(int, int, int, int)

void make_grid()

SphModTblPtr make_sl()

double massR(double R)

void parityCheck(const std::string &prefix)

bool ReadH5Cache()

Read HDF5 cache.

void receive_eof(int request_id, int m)

void send_eof_grid()

void setup_eof_grid(void)

void WriteH5Cache()

Write HDF5 cache.

Protected Attributes

std::vector<Eigen::VectorXd> accum_cos

std::vector<Eigen::VectorXd> accum_sin

bool allow_old_cache = false

Allow older cache files with the Eigen3 row-major bug to be read with the new Eigen3 API

double ASCALE

std::string cachefile

The cache file name.

struct CylCoefHeader coefheadercyl

std::vector<short> coefs_made

MstepArray cosL

std::vector<Eigen::VectorXd> cosm

MstepArray cosN

CoefMatrix covM

CoefVector covV

double cylmass

std::vector<double> cylmass1

bool cylmass_made

std::vector<double> d

unsigned defSampT

Eigen::MatrixXd dend

std::vector<std::vector<Eigen::MatrixXd>> densC

Linear1d densRg

std::vector<std::vector<Eigen::MatrixXd>> densS

double dfac

std::vector<Eigen::MatrixXd> dlegs

Eigen::MatrixXd dpot

double dX

double dY

Eigen::MatrixXd ef

Eigen::MatrixXd efE

Eigen::MatrixXd efO

bool eof_made

Eigen::VectorXd ev

Eigen::VectorXd evE

bool EVEN_M

Suppress odd modes.

bool EvenOdd

Use EvenOdd partition.

Eigen::VectorXd evO

std::vector<Eigen::MatrixXd> facC

std::vector<Eigen::MatrixXd> facS

double ffac

std::string hallfile

std::vector<unsigned> howmany

std::vector<std::vector<unsigned>> howmany1

double HSCALE

std::vector<std::vector<int>> lE

std::vector<Eigen::MatrixXd> legs

int LMAX

std::vector<std::vector<int>> lO

int M

std::vector<double> m

Linear1d massRg

std::vector<double> massT

std::vector<std::vector<double>> massT1

double maxSNR

double minSNR

int MLIM

int MMAX

int MMIN

std::vector<double> mpi_double_buf2

std::vector<double> mpi_double_buf3

int MPIbufsz

std::vector<double> MPIin

Storage buffers for MPI.

std::vector<double> MPIin2

std::vector<double> MPIin_eof

std::vector<double> MPIout

std::vector<double> MPIout2

std::vector<double> MPIout_eof

int MPItable

unsigned nbodstot

int Neven

Number of even and odd terms per subspace.

int NKEEP

int NLIM

int NMAX

int NMIN

int Nodd

int NORDER

std::vector<unsigned> numbT

std::vector<std::vector<unsigned>> numbT1

SLGridSphPtr ortho

std::vector<double> p

PCAbasisPtr pb

Cache PCA information between calls.

double pfac

std::vector<std::vector<Eigen::MatrixXd>> potC

Eigen::MatrixXd potd

std::vector<std::vector<Eigen::MatrixXd>> potS

std::vector<double> r

int rank2

int rank3

std::vector<std::vector<Eigen::MatrixXd>> rforceC

std::vector<std::vector<Eigen::MatrixXd>> rforceS

double Rtable

unsigned sampT

VarMat SC

VarMat SCe

VarMat SCo

MstepArray sinL

std::vector<Eigen::VectorXd> sinm

MstepArray sinN

VarMat SS

VarMat SSe

VarMat SSo

MPI_Status status

Eigen::MatrixXd tabd

Eigen::MatrixXd tabf

std::vector<Eigen::MatrixXd> table

Eigen::MatrixXd tabp

std::vector<Eigen::MatrixXd> tdens

std::vector<Eigen::MatrixXd> tpot

std::vector<Eigen::MatrixXd> trforce

std::vector<std::vector<Eigen::MatrixXd>> tvar

std::vector<Eigen::MatrixXd> tzforce

bool use_mpi

MPI is active.

pthread_mutex_t used_lock

std::vector<Eigen::MatrixXd> var

std::vector<Eigen::MatrixXd> varE

std::vector<Eigen::MatrixXd> varO

std::vector<Eigen::MatrixXd> vc

std::vector<Eigen::MatrixXd> vs

double XMAX

double XMIN

double YMAX

double YMIN

std::vector<std::vector<Eigen::MatrixXd>> zforceC

std::vector<std::vector<Eigen::MatrixXd>> zforceS

Protected Static Functions

static YAML::Node getHeader(const std::string &cachefile)

Read the cache and return YAML db.

static YAML::Node getHeader_binary(const std::string &cachefile)

static YAML::Node getHeader_hdf5(const std::string &cachefile)

Protected Static Attributes

static const unsigned int cmagic = 0xc0a57a3

Coefficient magic number.

static const unsigned int hmagic = 0xc0a57a1

Basis magic number.

static const std::string Version = "1.0"

Cache versioning.

class Ensemble

#include <phase.H>

Public Functions

void binread(std::istream &fp)

void binwrite(std::ostream &fp)

Eigen::Vector3d CM_Position(void)

Eigen::Vector3d CM_Velocity(void)

Ensemble(Ensemble&)

Ensemble(int)

Ensemble(void)

inline int get_Nstars(void)

Eigen::Matrix3d Inertia_Tensor(double)

Ensemble integrate_to(double)

Ensemble integrate_to(double, freezing_function)

Eigen::Matrix3d Moment_Tensor(double)

Ensemble &operator=(Ensemble&)

Phase &operator[](int)

Eigen::Vector3d Principal_Axes(double, Eigen::Matrix3d&)

void read_orbits(std::istream&)

void read_snapshot(std::istream&)

void read_tidesfile(std::istream&)

void rotate_frame(double)

void rotate_view(double)

void scale_masses(double)

void scale_positions(double)

void scale_speeds(double)

void set_masses(double)

void setsize(int)

void settime(double)

Eigen::Vector3d Solid_Body_Frequency(double)

Ensemble Step_Positions(double)

Ensemble Step_Velocities(double, Eigen::Vector3d*)

Eigen::Vector3d total_Angular_Momentum(void)

double total_Energy(void)

double total_Kinetic(void)

double total_Potential(void)

void translate(Eigen::Vector3d&)

double Virial(void)

void write_log(std::ostream&)

void write_orbits(std::ostream&)

void write_snapshot(std::ostream&)

~Ensemble(void)

Protected Attributes

int Nstars

std::vector<Phase> stars

double t

template<typename T>
class EnumBitset

#include <EnumBitset.H>

Wrap the bitset according to the provided EnumTraits class. The class allows fields in a bit set to be accessed by members of the enum.

Public Functions

inline EnumBitset()

Constructor.

inline EnumBitset &flip(T pos)

Flip the flag.

inline bool operator[](size_t i) const

operator version of the test

inline bool operator[](T pos) const

operator version of the test

inline void reset()

Reset all flags.

inline EnumBitset &reset(T pos)

Reset the flag.

inline EnumBitset &set(T pos)

Set the flag.

inline size_t size()

Return size of bitset.

inline bool test(T pos) const

Test the flag.

Private Functions

inline std::underlying_type<T>::type get_value(T v) const

Private Members

std::bitset<static_cast<typename std::underlying_type<T>::type>(EnumTraits<T>::max)> s

The underlying bitset.

template<typename T>
struct EnumTraits

EnumTraits must define a max data member to set the bitset size and wraps an enum class

class exeTimer

Collaboration diagram for Cube::exeTimer:

Time routines.

Public Functions

inline exeTimer(Cube *c, const std::string &name)

inline void Start1()

inline void Stop1()

inline ~exeTimer()

Private Members

Cube *c

std::chrono::high_resolution_clock::time_point finish0

std::chrono::high_resolution_clock::time_point finish1

std::string routine

std::chrono::high_resolution_clock::time_point start0

std::chrono::high_resolution_clock::time_point start1

class EXPException : public std::exception

#include <EXPException.H>

Inheritence diagram for EXPException:

Collaboration diagram for EXPException:

Defines an error handler base class EXPException to handle exceptions

Subclassed by BadIndexException, FileCreateError, FileOpenError, GenericError, InternalError, YamlConfigError

Public Functions

inline EXPException(const std::string exceptionname, const std::string message, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor for base

Parameters:

• exceptionname – Human-readable identifier for the error

• message – Error details for the user

• sourcefilename – File where the thrower resides

• sourcelinenumber – Line number in the source for the thrower

• errorcode – Error code to report at top-level catch

• deadlock – Exception may break MPI synchronization

inline bool getDeadlock()

Get deadlock status.

inline int getErrorcode()

Get errorcode.

inline std::string getErrorMessage()

Returns an error message suitable for printing to the user. Also called by derived classes to assemble the error message for std::exception::what()

inline virtual const char *what() const

std::exception member returns a pointer to the error message

The std::string “buffer” used for assembling and passing the message to std::exception will be deleted when the exception is deleted.

Returns:

A pointer to a const char*.

inline virtual ~EXPException()

Destructor for base. Virtual to permit derived classes.

Protected Functions

inline EXPException(const std::string sourcefile, int linenumber, int errorcode = -1, bool deadlock = false)

Protected so it is only called by properly implemented classes.

Protected Attributes

bool deadlock

Possible deadlock?

int errorcode

Return code.

std::string errormessage

Error message describing the error in more detail.

std::string exceptionname

Friendly name of the exception.

std::string msg_

Message buffer.

Private Members

std::string sourcefilename

Source file where throw occured.

int sourcelinenumber

Line number of throw.

class ExponCyl : public EmpCyl2d::ModelCyl

#include <EmpCyl2d.H>

Inheritence diagram for EmpCyl2d::ExponCyl:

Collaboration diagram for EmpCyl2d::ExponCyl:

Public Functions

inline virtual double dens(double r)

inline virtual double dpot(double r)

inline ExponCyl(const YAML::Node &par)

inline virtual double pot(double r)

Private Functions

inline virtual void parse(const YAML::Node &conf)

Private Members

double acyl

double sigma0

class Exponential : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for Exponential:

Collaboration diagram for Exponential:

The usual exponential disk.

Public Functions

inline Exponential(double a, double h, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double h

class ExponentialDisk : public AxiSymModel

#include <exponential.H>

Inheritence diagram for ExponentialDisk:

Collaboration diagram for ExponentialDisk:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline ExponentialDisk(double RSCALE = 1.0, double RMAX = 20.0, double DMASS = 1.0)

inline virtual double get_density(const double r)

virtual double get_dpot(const double r)

virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

virtual double get_pot(const double r)

virtual void get_pot_dpot(const double r, double &ur, double &dur)

Private Members

double a

double den0

double m

double rmax

double rmin

class ExternalCollection

#include <ExternalCollection.H>

Container class for external force types.

These are supplied as a file with one type to a line. The constructor does “hand coded” reflection to make a chain of these. Therefore, the external forces will be applied in order of their listing (in case this matters).

Format: single line per force, parameters separated from name by “:”

Public Functions

ExternalCollection()

Constructor.

void finish()

Call the finish member for all external forces.

void get_acceleration_and_potential(vector<Particle>*)

Provides the same interface to compute acceleration as ExternalForce.

void initialize()

Reads configuration database and initializes requested external forces.

~ExternalCollection()

Destructor.

Public Members

list<ExternalForce*> force_list

List of forces we create.

Private Functions

void dynamicload(void)

vector<string> getlibs(void)

Private Members

list<void*> dl_list

list<void*>::iterator itr

list<ExternalForce*>::iterator sitr

class ExternalForce : public PotAccel

#include <ExternalForce.H>

Inheritence diagram for ExternalForce:

Collaboration diagram for ExternalForce:

External force PotAccel members.

This does little but make sure that user is not loading a class that is not designed to be an external force.

Subclassed by HaloBulge, PeriodicBC, ScatterMFP, UserBar, UserDisk, UserHalo, UserLogPot, UserMNdisk, UserMW, UserTest, UserTestCuda, externalShock, generateRelaxation, tidalField

Public Functions

virtual void *determine_acceleration_and_potential_thread(void *arg) = 0

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

ExternalForce(const YAML::Node &config)

Constructor.

Parameters:

line – passes any parameters to the method

inline virtual void finish()

Finish and clean-up (caching data necessary for restart)

virtual void get_acceleration_and_potential(Component *compIn)

Will be called by clients to evaluate force.

inline virtual ~ExternalForce()

Destructor.

Public Members

string id

Name of external force (mnemonic)

Protected Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

void print_divider(void)

User info divider Make demarcation in output log

Private Functions

virtual void determine_coefficients(void)

Used by get_acceleration_and_potential to request that the expansion be performed.

virtual void *determine_coefficients_thread(void *arg)

Multithreading implementation of the expansion computation.

class externalShock : public ExternalForce

#include <externalShock.H>

Inheritence diagram for externalShock:

Collaboration diagram for externalShock:

Compute shock perturbation.

Public Functions

externalShock(const YAML::Node &conf)

Constructor.

~externalShock()

Destructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

double get_tidal_shock(double T)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

double AMPL

double E

string INFILE

double K

std::shared_ptr<SphericalModelTable> model

double PER

std::shared_ptr<SphericalOrbit> t

class FDIST

#include <massmodel.H>

A one-dimensional Merritt-Osipkov distribution.

Public Functions

inline FDIST()

Simple constructor. Use value of num to check for initialization.

Public Members

Eigen::VectorXd ffQ

Eigen::VectorXd ffQ2

Eigen::VectorXd fQ

Eigen::VectorXd fQ2

int num

double off

Eigen::VectorXd Q

double ra2

class FDISTC

#include <massmodel.H>

Collaboration diagram for FDISTC:

Chebyshev version.

Public Functions

inline FDISTC()

Simple constructor. Use value of num to check for initialization.

Public Members

Cheby1d FF

Eigen::VectorXd ffQ

Eigen::VectorXd fQ

Cheby1d GG

int num

double off

Eigen::VectorXd Q

double ra2

class FEED : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for FEED:

Collaboration diagram for FEED:

A Ferrers Ellipsoid + Evacuated Exponential Disc (semi-realistic bar+disk model)

Public Functions

inline FEED(double a, double b, double c, double r0, double z0, double fbar, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double b

double c

double fbar

double r0

double z0

class Ferrers : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for Ferrers:

Collaboration diagram for Ferrers:

An n=2 Ferrers Ellipsoid.

Public Functions

inline Ferrers(double a, double b, double c, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double b

double c

class FileCreateError : public EXPException

#include <EXPException.H>

Inheritence diagram for FileCreateError:

Collaboration diagram for FileCreateError:

File creation error.

Public Functions

inline FileCreateError(const std::string filename, const std::string method, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor with method string.

inline FileCreateError(const std::string filename, std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor.

class FileOpenError : public EXPException

#include <EXPException.H>

Inheritence diagram for FileOpenError:

Collaboration diagram for FileOpenError:

File open error.

Public Functions

inline FileOpenError(const std::string filename, const std::string method, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor with method string.

inline FileOpenError(const std::string filename, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor.

class FindOrb : public std::function<double(std::vector<double>&)>

#include <FindOrb.H>

Inheritence diagram for FindOrb:

Collaboration diagram for FindOrb:

Public Functions

OrbValues Anneal()

Do the work!

FindOrb(std::shared_ptr<AxiSymModel> mod, double PERI, double APO)

Constructor.

inline SphericalOrbit &Orb()

Return the orbit instance (presumably now at minimum)

~FindOrb()

Destructor.

Public Static Attributes

static double EFAC

static double KMAX

static double KMIN

Defaults.

static int MAXIT

static bool MELT

static double RATE

static double T0

Private Functions

void mapvars(std::vector<double>&, double &ee, double &kk)

double operator()(std::vector<double> &ek)

Private Members

double apo

double Emax

double Emin

std::shared_ptr<AxiSymModel> halo_model

double Kmax

double Kmin

int maxit

double melt

std::shared_ptr<SphericalOrbit> orb

double peri

double rate

class FlatDisk : public PolarBasis

#include <FlatDisk.H>

Inheritence diagram for FlatDisk:

Collaboration diagram for FlatDisk:

Computes the potential, acceleration and density using an empirical function analysis for a flat Bessel basis and a target density.

YAML configuration

Param rcylmin:

is the minimum value in the table for the radial basis functions (default is 0.0)

Param rcylmax:

is the maximum value in the table for the radial basis functions in acyltbl units (default is 10.0)

Param scale:

is the expansion factor to get the physical scale from the internal scale (default is 0.01)

Param mmax:

is the maximum azimuthal order

Param numx:

is the number of grid points in the scaled radial direction

Param numy:

is the number of grid points in the scaled vertical direction

Param knots:

is the number of quadrature points for EmpCyl2d

Param logr:

scales the EmpCyl2d grid logarithmically

Param model:

name for conditioning the new basis using EmpCyl2d (default: expon)

Param biorth:

is the biorthogonal basis set used by EmpCyl2d for conditioning (default: bess)

Param background:

sets a fixed monopole potential and force for the model. Used for stability analysis of disks with active and inactive tapers, following Zang

Param nmaxfid:

is the maximum radial order for the basis used by EmpCyl2d for conditioning

Param numr:

is the number of grid points in the radial direction for the numerical basis in EmpCyl2d

Param NQDHT:

is the number of grid points for the numerical Hankel transform

Param diskconf:

is a YAML configuration for the target disk model in EmpCyl2d

Param cachename:

is the name of the cache file for the newly constructed basis

Param dumpbasis:

provides the user with a ascii table of the basis potential-density pairs

Public Functions

FlatDisk(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor

Input line parameters include:

Parameters:

• c0 – is the instantiating caller (Component)

• conf – passes any parameters to basis instance (rsphSL, rmin and numr

• m – allows the spherical basis to be used for multiple center expansions

• rs – is the radius for coordinate scaling

• numr – is the number of radial grid points

• cmap – set to true for scaling coordinates from the semi-infinite to finite segment

• diverge – set to true means assume a cuspy profile

• dfac – is the power of the “divergent” cusp

• modelname – is the file containing the input background model profile

• dtime – is the interval between basis recomputations (<=0 for never)

virtual ~FlatDisk()

Destructor.

Protected Functions

inline virtual void get_pot(Eigen::MatrixXd &Vc, Eigen::MatrixXd &Vs, double r, double z)

Use BiorthCyl to evaluate the basis at r, z.

Private Types

using Disk2d = std::shared_ptr<EmpCyl2d::ModelCyl>

Background instance.

Private Functions

inline virtual std::tuple<double, double, double> background(double r, double z)

Background evaluation.

virtual void get_dens(double r, double z, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_dpotl(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &dpr, Eigen::MatrixXd &dpz, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• dpr – will be returned array in harmonics l and radial order n for the derivative of the potential

• dpz – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl(double r, double z, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid)

Get the potential and density

Parameters:

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

inline virtual double getRtable()

Get table scale.

virtual void initialize(void)

Initialize method.

void setBackground()

Set background from YAML.

Private Members

double acyltbl

string biorth

Disk2d disk

bool dump_basis

int knots

bool logr

int mmax

string model

int numr

CylPtr ortho

double rcylmax

double rcylmin

double scale

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class foarray

#include <foarray.H>

Public Functions

inline foarray(vector<string> &names, bool append = false)

inline ofstream &operator[](int n)

inline ~foarray()

Private Members

unsigned fnum

vector<ofstream*> fo

class Frame_Rotation

#include <phase.H>

Public Functions

inline void set_corotation(double rc)

inline void set_omega(double w)

Public Members

double omega

double omega2

double omegasq

class Func1d

#include <Func1d.H>

Public Functions

virtual double CostFunction(double*) = 0

inline virtual ~Func1d()

struct gadget_header

#include <gadget.H>

Public Members

double BoxSize

box-size of simulation in case periodic boundaries were used

char fill[64]

int flag_cooling

flags whether cooling was included

int flag_feedback

flags whether feedback was included (obsolete)

int flag_metals

flags whether the file contains metallicity values for gas and star particles

int flag_sfr

flags whether the simulation was including star formation */

int flag_stellarage

flags whether the file contains formation times of star particles

double HubbleParam

Hubble parameter in units of 100 km/sec/Mpc.

double mass[6]

mass of particles of each type. If 0, then the masses are explicitly stored in the mass-block of the snapshot file, otherwise they are omitted

int npart[6]

number of particles of each type in this file

unsigned int npartTotal[6]

total number of particles of each type in this snapshot. This can be different from npart if one is dealing with a multi-file snapshot.

unsigned int npartTotalHighWord[6]

High word of the total number of particles of each type.

int num_files

number of files in multi-file snapshot

double Omega0

matter density in units of critical density

double OmegaLambda

cosmological constant parameter

double redshift

redshift of snapshot file */

double time

time of snapshot file

class GadgetHDF5 : public PR::ParticleReader

#include <ParticleReader.H>

Inheritence diagram for PR::GadgetHDF5:

Collaboration diagram for PR::GadgetHDF5:

Public Functions

inline virtual unsigned long CurrentNumber()

Number of particles in the chosen type.

inline virtual double CurrentTime()

Get current time.

virtual const Particle *firstParticle()

Reset to beginning of particles for this component.

GadgetHDF5(const std::vector<std::string> &file, bool verbose = false)

Constructor.

inline virtual std::vector<std::string> GetTypes()

Return list of particle types.

virtual const Particle *nextParticle()

Get the next particle.

inline virtual void SelectType(const std::string &type)

Select a particular particle type and reset the iterator.

Protected Functions

void getNumbers()

bool nextFile()

void packParticle()

void read_and_load()

Protected Attributes

std::vector<std::string>::iterator curfile

Current file.

double mass[6]

int npart[6]

int nptot[6]

std::vector<Particle> particles

unsigned pcount

std::vector<std::string> Pfound

int ptype

double time

unsigned long totalCount

Protected Static Attributes

static std::unordered_map<std::string, int> findP

static std::vector<std::string> Ptypes

class GadgetNative : public PR::ParticleReader

#include <ParticleReader.H>

Inheritence diagram for PR::GadgetNative:

Collaboration diagram for PR::GadgetNative:

Public Functions

inline virtual unsigned long CurrentNumber()

Number of particles in the chosen type.

inline virtual double CurrentTime()

Get current time.

virtual const Particle *firstParticle()

Reset to beginning of particles for this component.

GadgetNative(const std::vector<std::string> &file, bool verbose = false)

Constructor.

inline virtual std::vector<std::string> GetTypes()

Return list of particle types.

virtual const Particle *nextParticle()

Get the next particle.

inline virtual void SelectType(const std::string &type)

Select a particular particle type and reset the iterator.

Private Functions

void getNumbers()

bool nextFile()

void packParticle()

void read_and_load()

Private Members

std::vector<std::string>::iterator curfile

Current file.

gadget_header header

double mass[6]

int npart[6]

int nptot[6]

std::vector<Particle> particles

unsigned pcount

std::vector<std::string> Pfound

int ptype

double time

unsigned long totalCount

Private Static Attributes

static std::unordered_map<std::string, int> findP

static std::vector<std::string> Ptypes

struct gas_particle

#include <tipsydefs.h>

Tipsy particle structure for a gas particle.

Public Members

Real hsmooth

Smoothing scale.

Real mass

particle mass

Real metals

Metal value.

Real phi

Gravitational potential.

Real pos[MAXDIM]

particle position vector

Real rho

Density.

Real temp

Temperature.

Real vel[MAXDIM]

particle velociy vector

struct gas_particle

#include <tipsy.H>

Public Functions

inline int ID() const

Convert phi to index.

Public Members

Real hsmooth

Real mass

Particle data.

Real metals

Real phi

Real pos[MAXDIM]

Real rho

Real temp

Real vel[MAXDIM]

struct GAUSS

#include <gknots.h>

Public Members

int n

double *w

double *x

class GaussQuad

#include <gaussQ.H>

Inheritence diagram for GaussQuad:

Subclassed by HermQuad, JacoQuad, LaguQuad

Public Functions

inline int bomb(const char *s)

inline GaussQuad()

inline double get_alpha(void)

inline double get_beta(void)

inline int get_n(void)

inline double knot(const int i)

inline std::vector<double> &kV(void)

inline double weight(const int i)

inline std::vector<double> &wV(void)

Public Members

double alpha

double beta

std::string FunctionID

int n

std::vector<double> r

std::vector<double> w

class GeneralizedPolytrope : public AxiSymModel

#include <GenPoly.H>

Inheritence diagram for GeneralizedPolytrope:

Collaboration diagram for GeneralizedPolytrope:

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

void dump_model(ostream *out)

GeneralizedPolytrope(int num, double n, double m, double eps0 = 1.0e-5, double step = 1.0e-5)

GeneralizedPolytrope(void)

virtual double get_density(const double)

virtual double get_dpot(const double)

virtual double get_dpot2(const double)

virtual double get_mass(const double)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

virtual double get_pot(const double)

virtual void get_pot_dpot(const double, double&, double&)

Private Members

RUN dens

double KF

double m

RUN mass

double n

RUN pot

class generateRelaxation : public ExternalForce

#include <generateRelaxation.H>

Inheritence diagram for generateRelaxation:

Collaboration diagram for generateRelaxation:

Compute relaxation diagnoistics.

Public Functions

generateRelaxation(const YAML::Node &conf)

Constructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

int done

int epos

class GenericError : public EXPException

#include <EXPException.H>

Inheritence diagram for GenericError:

Collaboration diagram for GenericError:

Used for explicit detailed messages.

Public Functions

inline GenericError(const std::string msg, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Use this for reporting an error with a specific message.

class GenLagu : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for GenLagu:

Collaboration diagram for GenLagu:

Public Functions

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline GenLagu(double A)

inline virtual double h(const int n)

inline virtual double w(const double x)

Private Members

double alpha

class GenPhi

Public Functions

inline double Angle(double r)

inline GenPhi(double scale, double amp, int m)

inline std::tuple<unsigned, unsigned, std::vector<unsigned>> getStats()

Private Members

double baramp

std::vector<unsigned> counts

std::random_device dev

std::uniform_real_distribution dist

int m

unsigned numbar

unsigned numtot

std::mt19937 rng

double scale

Private Static Attributes

static constexpr int numcnt = 32

class Grid2D

#include <Grid2D.H>

Create, store, and restore a two-dimensional binned grid

Public Functions

inline void addPoint(double mass, double x, double y)

Add.

inline Grid2D(double Rmax, int num, double t)

Constructor.

inline Grid2D(std::istream &in)

Constructor from istream (restore from cache file)

inline double operator()(double x, double y)

Get density.

inline void read(std::istream &in)

Read from file.

inline void sync()

Synchonize arrays.

inline double Time()

Get time.

inline void write(std::ostream &out)

Write to file.

Private Members

std::vector<double> dens

Data store (flattened into a single vector)

double dr

int N

double R

Parameters.

double T

class HaloBulge : public ExternalForce

#include <HaloBulge.H>

Inheritence diagram for HaloBulge:

Collaboration diagram for HaloBulge:

Compute halo + bulge external force.

Public Functions

HaloBulge(const YAML::Node &conf)

Constructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

AxiSymModPtr bmodel

int HMODEL

Halo model type (default: file)

string INFILE

Halo model file (default: w05)

double MBULGE

Bulge mass scale factor (default: 1.0)

double MHALO

Halo mass scale factor (default: 1.0)

AxiSymModPtr model

double RBCORE

Bulge core/scale size (default: 1.0)

double RBMOD

Bulge maximum model radius (default: 20.0)

double RBMODMIN

Bulge miniimum model radius (default: 1.0e-3)

double RBULGE

Bulge radius scale factor (default: 1.0)

double RHALO

Halo radius scale factor (default: 1.0)

double RMOD

Halo maximum model radius (default: 20.0)

double RMODMIN

Halo minimum model radius (default: 1.0e-3)

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class HankelTransform

#include <Hankel.H>

Hankel transform based on the Ogata quadrature formulae from:

Ogata, H, 2005, “A Numerical Integration Formula Based on the

Bessel Functions”, Publ. Res. Inst. Math. Sci. 41 (4) (2005) 949–970.

Public Functions

inline HankelTransform()

Null constructor.

HankelTransform(double h, double nu, int N = 20)

Constructor.

double operator()(std::function<double(double)> f, double q)

Perform the transform F(q)=int(f(x)*Jn(x*q))

inline void setLinear()

Set to unmapped Ogata formula.

inline ~HankelTransform()

Destructor.

Private Functions

inline double fk_trans(double x, std::function<double(double)> f, double q)

Variable change.

double get_psi(double t)

Ogata mapping formula.

double get_psip(double t)

Derivative of the Ogata mapping formula.

double ogata_linear(std::function<double(double)> f, double q, double h)

The unmapped algorithm.

double ogata_transformed(std::function<double(double)> f, double q, double h)

The mapping transformation algorithm (default)

Private Members

double h

the h scaling value for the Ogata mapping

bool mapped

True for mapping transformation algorithm (default)

int N

N is number of function calls.

double nu

nu is Bessel function order

std::vector<double> w

Ogata weights; Bessel functions of the second kind divided by the first kind for nu+1 evaluated at the zeros

std::vector<double> xi

Zeros divided by 2*pi for Ogata.

std::vector<double> zeros

Will contain the zeros of the Bessel function of order nu.

struct Header

#include <tipsy.H>

Public Members

int nbodies

int ndark

int ndim

int nsph

int nstar

double time

struct HelpGroupDetails

#include <cxxopts.H>

Public Members

std::string description = {}

std::string name = {}

std::vector<HelpOptionDetails> options = {}

struct HelpOptionDetails

#include <cxxopts.H>

Public Members

std::string arg_help

std::string default_value

String desc

bool has_default

bool has_implicit

std::string implicit_value

bool is_boolean

bool is_container

std::string l

std::string s

class Hermite : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for Hermite:

Collaboration diagram for Hermite:

Public Functions

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline virtual double h(const int n)

inline Hermite(void)

inline virtual double w(const double x)

class HermQuad : public GaussQuad

#include <gaussQ.H>

Inheritence diagram for HermQuad:

Collaboration diagram for HermQuad:

Public Functions

HermQuad(int N = 10, double ALPHA = 0.0)

class Hernquist

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

double potential(Eigen::Vector3d&)

inline void set_Hernquist(double r0init, double Ginit, double Minit)

Protected Attributes

double G

double GM

double M

double r0

class HernquistSphere : public AxiSymModel

#include <hernquist_model.H>

Inheritence diagram for HernquistSphere:

Collaboration diagram for HernquistSphere:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

inline HernquistSphere(double RSCL = 1.0, double RMIN = 1.0e-6, double RMAX = 1.0e6, double TOLE = 1.0e-5)

Private Members

double rmax

double rmin

double rot

double rscl

double tolE

class HQSphere : public AxiSymBiorth

#include <biorth.H>

Inheritence diagram for HQSphere:

Collaboration diagram for HQSphere:

Public Functions

virtual double d_r_to_rb(double const)

virtual void dens(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double dens(const int nn, const int l, const double rb)

inline double densR(const int nn, const int l, const double r)

HQSphere(void)

virtual double krnl(const int nn, const int l)

virtual double norm(const int nn, const int l)

virtual void potl(const int nn, const int l, const double r, Eigen::VectorXd &a)

virtual double potl(const int nn, const int l, const double rb)

inline virtual double potlR(const int nn, const int l, const double r)

inline virtual double potlRZ(const int nn, const int l, const double r, const double z)

virtual double r_to_rb(double const)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

virtual double rb_to_r(double const)

inline virtual ~HQSphere()

Private Members

double rbmax

double rbmin

class HunterDisk : public AxiSymModel

#include <hunter.H>

Inheritence diagram for HunterDisk:

Collaboration diagram for HunterDisk:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

virtual double get_density(const double r)

virtual double get_dpot(const double r)

double get_dpot(const double r, const double z)

virtual double get_dpot2(const double r)

double get_dpot2(const double r, const double z)

virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

virtual double get_pot(const double r)

double get_pot(const double r, const double z)

void get_pot_dpot(const double r, const double z, double &ur, double &dur)

virtual void get_pot_dpot(const double r, double &ur, double &dur)

HunterDisk(int N, double RMAX = 1.0, double MASS = 1.0)

void set_params(const double KMAX = 20.0, const double RCUT = 8.0, const int NINT = 200, const int MGRID = 200, const int NHANK = 400)

Private Functions

Vector d2vplgndr(double)

Vector dvplgndr(double)

void setup_mass(void)

void setup_model(void)

void tabulate_hankel(void)

Vector vplgndr(double)

Private Members

Vector cvec

Vector gam

Logic hankel_setup

Vector K

double kfac

double kmax

Vector m_mass

double mass

Logic mass_setup

int mgrid

Logic model_setup

int n

int nhank

int nint

double offset_dp

double offset_dp2

double offset_p

double omfac

double pfac

Vector r_mass

double rcut

double rmax

Vector S_K

double sfac

Private Static Attributes

static const double defKMAX = 20.0

static const int defMGRID = 200

static const int defNHANK = 400

static const int defNINT = 200

static const double defRCUT = 8.0

class HunterDiskX : public AxiSymModel

#include <HunterX.H>

Inheritence diagram for HunterDiskX:

Collaboration diagram for HunterDiskX:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

virtual double get_density(const double r)

virtual double get_dpot(const double r)

double get_dpot(const double r, const double z)

virtual double get_dpot2(const double r)

double get_dpot2(const double r, const double z)

virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

virtual double get_pot(const double r)

double get_pot(const double r, const double z)

void get_pot_dpot(const double r, const double z, double &ur, double &dur)

virtual void get_pot_dpot(const double r, double &ur, double &dur)

HunterDiskX(int N, double RMAX = 1.0, double MASS = 1.0)

void set_params(const double KMAX = 20.0, const double RCUT = 8.0, const int NINT = 200, const int MGRID = 200, const int NHANK = 400)

~HunterDiskX()

Private Members

HunterDisk *disk1

HunterDisk *diskN

double factor

double rmax

template<template<class, class, class...> class C, typename K, typename V, typename ...Args>
class Icont : public C<K, V, Args...>

#include <InitContainer.H>

Inheritence diagram for Icont:

Collaboration diagram for Icont:

This does the same thing as the non-invasive templates above using inheritance to wrap the container

Public Functions

inline virtual V Default()

Default value is zero for simple arithmetic types, but may be specialized as necessary. If it fails to compile, it probably needs to be specialized.

inline V &operator[](const K &key)

Initializer.

class Info

#include <BarrierWrapper.H>

Public Functions

inline Info()

Null constructor for assignment.

Info(CharPtr p)

Construct from MPI-passed char buffer.

Info(int own, time_t ctm, const std::string &s)

Full constructor.

void sendInfo(int myid, MPI_Comm comm, int commsize)

Send the Info to all processes in the communicator.

Public Members

CharPtr c

Character buffer for string.

time_t ctm

Creation time.

int own

Owning process.

std::string s

Label.

unsigned siz

Label size.

Public Static Attributes

static const size_t bufsz = 512

Buffer size (1 block)

static const int tag = 232395

Tag.

Private Functions

void pack()

Helper to translate buffer.

Private Members

CharPtr blob

MPI buffer.

size_t charsz

Space for character string.

std::list<ReqPtr> req

Request handle.

class Input

Input class to adaptively handle various EXP output formats.

inputs
---------------
filename : str
    the input filename to be read
comp     : str, optional
    the name of the component for which to extract data. If None, will read primary header and exit.
legacy   : bool, default=True
    if True, return attributes rather than a dictionary of particle data
verbose  : int, default 0
    verbosity flag.

returns
---------------
self        : Input instance
  .header   : dict, all header values pulled from the file
    the .keys() are the names of each component
    each component has a dictionary of values, including 'parameters'
    the details of the force calculation are in 'force'
  .filename : str, the filename that was read
  .comp     : str, name of the component
  .time     : float, the time in the output file
  .data     : dictionary, with keys:
    x       : float, the x position
    y       : float, the y position
    z       : float, the z position
    vx      : float, the x velocity
    vy      : float, the y velocity
    vz      : float, the z velocity
    mass    : float, the mass of the particle
    index   : int, the integer index of the particle
    potE    : float, the potential energy value

  ---or, if legacy=True---
  
  .xpos     : float, the x position
  .ypos     : float, the y position
  .zpos     : float, the z position
  .xvel     : float, the x velocity
  .yvel     : float, the y velocity
  .zvel     : float, the z velocity
  .mass     : float, the mass of the particle
  .indx     : int, the integer index of the particle
  .pote     : float, the potential energy value

Public Members

comp

data

filename

header

indx

mass

pote

style

time

xpos

xvel

ypos

yvel

zpos

zvel

struct IntegerDesc

#include <cxxopts.H>

Public Members

std::string base = ""

std::string negative = ""

std::string value = ""

class Interaction

#include <ComponentContainer.H>

Collaboration diagram for Interaction:

Class to keep track of the interactions between components.

Maintains a list of component that feel the force from the given component. Every pair of interactions must be explicitly be listed in the [interaction] stanza of the input file. Example: halo : disk will tell the code to apply the force from halo particles on the disk particles. The fully self-consistent simulation with a disk and halo component would have the lines: halo : disk disk : halo

Public Functions

inline Interaction(Component *c)

Constructor.

Public Members

Component *c

Fiducial component with whom force interactions are desired.

std::list<Component*> l

List of components whose particles will feel the force from *c.

class InternalError : public EXPException

#include <EXPException.H>

Inheritence diagram for InternalError:

Collaboration diagram for InternalError:

Used when execution reaches a point it should not reach.

Public Functions

inline InternalError(const std::string msg, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = true)

inline InternalError(const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = true)

Use this when you reach an unexpected state.

class Interp1d

#include <interp.H>

Inheritence diagram for Interp1d:

Subclassed by Cheby1d, Linear1d, Spline1d

Public Functions

virtual double deriv(const double &x) = 0

Evaluate first derivative.

virtual double eval(const double &x) = 0

Evaluate the interpolant.

virtual double xhi() = 0

virtual double xlo() = 0

Data limits.

virtual ~Interp1d() = 0

Destructor.

class invalid_option_format_error : public cxxopts::OptionSpecException

#include <cxxopts.H>

Inheritence diagram for cxxopts::invalid_option_format_error:

Collaboration diagram for cxxopts::invalid_option_format_error:

Public Functions

inline explicit invalid_option_format_error(const std::string &format)

class Isothermal

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

double potential(Eigen::Vector3d&)

inline void set_Isothermal(double r0init, double vcinit)

Protected Attributes

double r0

double vc

double vcsq

class IsothermalSphere : public AxiSymModel

#include <isothermal.H>

Inheritence diagram for IsothermalSphere:

Collaboration diagram for IsothermalSphere:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double R)

inline virtual double get_dpot(const double R)

inline virtual double get_dpot2(const double R)

inline virtual double get_mass(const double R)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double R)

inline virtual void get_pot_dpot(const double R, double &ur, double &dur)

IsothermalSphere(double RCORE = 1.0, double RMAX = 20.0, double VROT = 1.0, int NUM = 2000, int dN = 20)

Private Members

Eigen::VectorXd d

Eigen::VectorXd d2

double F

Eigen::VectorXd m

Eigen::VectorXd m2

int num

Eigen::VectorXd p

Eigen::VectorXd p2

Eigen::VectorXd r

double ret1

double ret2

double rmax

double rscale

double sigma

double vrot

template<typename T>
class Iterable : public Iterator<T>

#include <Iterable.H>

Inheritence diagram for Iterable:

Collaboration diagram for Iterable:

Public Functions

inline explicit Iterable(T *_ptr)

inline bool operator!=(Iterable other) const

inline T *operator*() const

inline Iterable &operator++()

inline Iterable operator++(int)

inline bool operator==(Iterable other) const

Private Members

T *ptr

class Iterator

#include <cxxopts.H>

Collaboration diagram for cxxopts::ParseResult::Iterator:

Public Types

using difference_type = void

using iterator_category = std::forward_iterator_tag

using pointer = const KeyValue*

using reference = const KeyValue&

using value_type = KeyValue

Public Functions

Iterator() = default

Iterator(const Iterator&) = default

inline Iterator(const ParseResult *pr, bool end = false)

inline bool operator!=(const Iterator &other) const

inline const KeyValue &operator*()

inline Iterator &operator++()

inline Iterator operator++(int)

inline const KeyValue *operator->()

inline bool operator==(const Iterator &other) const

Private Members

std::vector<KeyValue>::const_iterator m_iter

const ParseResult *m_pr

template<typename T>
struct Iterator

#include <Iterable.H>

Inheritence diagram for Iterator:

Subclassed by Iterable< T >

Public Types

using difference_type = std::ptrdiff_t

using iterator_category = std::forward_iterator_tag

using pointer = T*

using reference = T&

using value_type = T

class JacoQuad : public GaussQuad

#include <gaussQ.H>

Inheritence diagram for JacoQuad:

Collaboration diagram for JacoQuad:

Subclassed by LegeQuad

Public Functions

JacoQuad(int N = 10, double ALPHA = 0.0, double BETA = 0.0)

class KalnajsDisk : public AxiSymModel

#include <kalnajs.H>

Inheritence diagram for KalnajsDisk:

Collaboration diagram for KalnajsDisk:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

inline KalnajsDisk(double RMOD = 1.0, double MASS = 1.0)

inline void setup_df(double frac)

Private Members

double F

double fac0

double mmax

double omega

double omega0

double potfac1

double potfac2

double rhofac

double rmax

class KDE2d

#include <KDE2d.H>

Class for 2D kernel density estimation

Public Functions

inline KDE2d(int numx, int numy, double xmin, double xmax, double ymin, double ymax, double sigmax, double sigmay)

Constructor.

inline const Eigen::MatrixXd &operator()(const Eigen::MatrixXd &GRID)

Get the smoothed density from an input grid.

inline const Eigen::MatrixXd &operator()(const std::vector<double> &x, const std::vector<double> &y)

Get the smoothed density from an input data arrays.

inline const Eigen::MatrixXd &operator()(const std::vector<std::pair<double, double>> &data)

Get the smoothed density from an input data pairs.

inline void setDebug()

Set debug mode.

Protected Functions

std::vector<double> gaussian_kernel_2d(int xsize, int ysize)

Create a smooth 2D gaussian kernel.

void grid_array(const std::vector<double> &x, const std::vector<double> &y)

void grid_pairs(const std::vector<std::pair<double, double>> &data)

Make 2D grid.

void kde_fft_2d()

Do the FFT convolution.

Protected Attributes

bool debug = false

Parameters.

double delx

double dely

Eigen::MatrixXd grid

Eigen matrices.

const int minKsize = 7

int numx

int numy

double sigmax

double sigmay

Eigen::MatrixXd smooth

double xmax

double xmin

double ymax

double ymin

template<typename coordinate_type, size_t dimensions>
class kdtree

#include <KDtree.H>

Collaboration diagram for KDtree::kdtree:

k-d tree implementation

Public Types

using cache = Cache<double, node*>

using point_type = point<coordinate_type, dimensions>

Public Functions

inline double distance(cache &best_) const

Returns the distance between the input point and return value from the last call to nearest().

inline bool empty() const

Returns true if the tree is empty, false otherwise.

inline std::vector<double> getDist(cache &best_)

inline std::vector<std::vector<unsigned long>> getPartition(unsigned level)

kdtree(const kdtree&) = delete

Copy constructor2.

template<typename func>
inline kdtree(func &&f, size_t n)

Constructor taking a function object that generates points. The function object will be called n times to populate the tree.

Parameters:

• f – function that returns a point

• n – number of points to add

template<typename iterator>
inline kdtree(iterator begin, iterator end)

Constructor taking a pair of iterators. Adds each point in the range [begin, end) to the tree.

Parameters:

• begin – start of range

• end – end of range

inline std::tuple<std::vector<point_type>, double, cache> nearestList(const point_type &pt, int N)

Finds the nearest N points in the tree to the given point. It is not valid to call this function if the tree is empty.

Returns: tuple of the nearest point list and the radius of the Nth point

Parameters:

• pt – a point

• N – is the number of nearest points

inline std::tuple<point_type, double, double, cache> nearestN(const point_type &pt, int N)

Finds the nearest N points in the tree to the given point. It is not valid to call this function if the tree is empty.

Returns: tuple of the first points, summed weight, and the radius of the Nth point

Parameters:

• pt – a point

• N – is the number of nearest points

kdtree &operator=(const kdtree&) = delete

inline size_t visited() const

Returns the number of nodes visited by the last call to nearest().

Private Functions

inline void accum(node *root, std::vector<std::vector<unsigned long>> &ret, unsigned cur)

inline node *make_tree(size_t begin, size_t end, size_t index)

inline void nearestN(node *root, const point_type &point, size_t index, int N, cache &best_)

inline void walk(node *root, std::vector<std::vector<unsigned long>> &ret, unsigned int cur, unsigned int lev, unsigned int level)

Private Members

std::vector<node> nodes_

node *root_

size_t visited_

class KeyConvert

#include <Species.H>

Wrap a union for converting a speciesKey to an int

Public Functions

inline unsigned short C()

Get C.

inline int getInt()

Get the converted int.

inline speciesKey getKey()

Get the converter speciesKey.

inline KeyConvert()

Null constructor.

inline KeyConvert(const int i)

Constructor taking a converted int (enter value into the union)

inline KeyConvert(const KeyConvert &p)

Copy constructor.

inline KeyConvert(const speciesKey &k)

Constructor taking a speciesKey (enter values into the union)

inline int updateC(short unsigned C)

Update C and return int.

inline unsigned short Z()

Get Z.

Public Members

int i

unsigned short us[2]

Private Members

union KeyConvert c

class KeyValue

#include <cxxopts.H>

Public Functions

template<typename T>
inline T as() const

inline CXXOPTS_NODISCARD const std::string & key () const

inline KeyValue(std::string key_, std::string value_)

inline CXXOPTS_NODISCARD const std::string & value () const

Private Members

std::string m_key

std::string m_value

class KingSphere : public SphericalModelTable

#include <king.H>

Inheritence diagram for KingSphere:

Collaboration diagram for KingSphere:

Public Functions

inline double d2fde2(double E)

inline double dfde(double E)

inline double distf(double E)

inline KingSphere(string filename)

inline void setup_df(void)

Private Members

double betaK

double E0K

double kingK

class KuzminCyl : public EmpCyl2d::ModelCyl

#include <EmpCyl2d.H>

Inheritence diagram for EmpCyl2d::KuzminCyl:

Collaboration diagram for EmpCyl2d::KuzminCyl:

Public Functions

inline virtual double dens(double R)

inline virtual double dpot(double R)

inline KuzminCyl(const YAML::Node &par)

inline virtual double pot(double R)

Private Functions

inline virtual void parse(const YAML::Node &conf)

Private Members

double acyl

class LaguQuad : public GaussQuad

#include <gaussQ.H>

Inheritence diagram for LaguQuad:

Collaboration diagram for LaguQuad:

Public Functions

LaguQuad(int N = 10, double ALPHA = 0.0)

template<class U>
class largestValues

#include <largest.H>

Public Functions

inline void clear()

Empty the queue.

inline std::vector<U> getValues()

Get the current list of values.

inline largestValues(int size)

Construtor: size is the desired size of the heap.

inline void operator()(U data)

Add a new value set.

Private Members

int maxSize

std::priority_queue<U, std::vector<U>, std::greater<U>> pq

class Legendre : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for Legendre:

Collaboration diagram for Legendre:

Subclassed by PVQuad

Public Functions

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline virtual double h(const int n)

inline Legendre(void)

inline virtual double w(const double x)

class LegeQuad : public JacoQuad

#include <gaussQ.H>

Inheritence diagram for LegeQuad:

Collaboration diagram for LegeQuad:

Public Functions

inline LegeQuad(int N = 10)

class Linear1d : public Interp1d

#include <interp.H>

Inheritence diagram for Linear1d:

Collaboration diagram for Linear1d:

Public Functions

virtual double deriv(const double &x)

Evaluate first derivative.

virtual double eval(const double &x)

Evaluate the interpolant.

Linear1d()

Null constructor.

Linear1d(const Eigen::VectorXd &x, const Eigen::VectorXd &y)

Construct from Eigen input.

Linear1d(const std::vector<double> &x, const std::vector<double> &y)

Construct from std::vector input.

Linear1d &operator=(const Linear1d&)

Copy constructor.

inline virtual double xhi()

inline virtual double xlo()

Data limits.

~Linear1d()

Destructor.

Private Members

Eigen::VectorXd x

Eigen::VectorXd y

class LinearMap : public SLGridSlab::CoordMap

Inheritence diagram for SLGridSlab::LinearMap:

Collaboration diagram for SLGridSlab::LinearMap:

x = z

Public Functions

virtual double d_xi_to_z(double z)

Jacobian of the transformation.

inline LinearMap(double H)

virtual double xi_to_z(double z)

Convert from mapped coordinate back to vertical.

virtual double z_to_xi(double z)

Convert from vertical to mapped coordinate.

struct loadb_datum

#include <Component.H>

Structure used to sort old & new indices for load balancing.

Public Members

int indx

Process ID.

unsigned short s

0–>Old partiion, 1–>New partiion

int top

Top particle index for this process.

class Logarithmic

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

inline double get_r0(void)

inline double get_vc(void)

double potential(Eigen::Vector3d&)

inline void set_Logarithmic(double r0init, double vcinit, double qyinit, double qzinit)

inline void set_r0(double r)

inline void set_vc(double v)

Protected Attributes

double qy

double qz

double r0

double vc

double vcsq

class LowIso : public OneDModelTable

#include <massmodel1d.H>

Inheritence diagram for LowIso:

Collaboration diagram for LowIso:

Public Functions

virtual double dfde(const double E, const double V = 0.0)

virtual double dfdv(const double E, const double V = 0.0)

virtual double distf(const double E, const double V = 0.0)

virtual double get_dpot(const double)

virtual double get_dpot2(const double)

virtual double get_pot(const double)

virtual tuple<double, double> get_pot_dpot(const double)

inline LowIso(string filename, double DISPX = 0.159154943091895335768)

Private Functions

void setup_model(void)

Private Members

double betak

double Bfac

double dispx

double gammak

double normx

double w0

class LowSingIsothermalSphere : public AxiSymModel

#include <isothermal.H>

Inheritence diagram for LowSingIsothermalSphere:

Collaboration diagram for LowSingIsothermalSphere:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double R)

inline virtual double get_dpot(const double R)

inline virtual double get_dpot2(const double R)

inline virtual double get_mass(const double R)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double R)

inline virtual void get_pot_dpot(const double R, double &ur, double &dur)

LowSingIsothermalSphere(double RMIN = 1.0e-3, double RMAX = 20.0, int NUM = 2000, int dN = 20)

Private Members

Eigen::VectorXd d

Eigen::VectorXd d2

double F

double Fconst

Eigen::VectorXd m

Eigen::VectorXd m2

int num

Eigen::VectorXd p

Eigen::VectorXd p2

double ret1

double ret2

double rmax

double rmin

double sigma

Eigen::VectorXd u

struct ltEL3

#include <Orient.H>

Comparsion function for set<>

Public Functions

inline bool operator()(const EL3 &s1, const EL3 &s2) const

class MakeModel

#include <MakeModel.H>

Public Functions

void AddPoint(double r, double mass)

std::shared_ptr<SphericalModelTable> Compute()

MakeModel(int N, double Rmin, double Rmax, bool logr = true)

void WriteModel(string &filename)

Private Members

Eigen::VectorXd d

std::vector<Eigen::VectorXd> dm

double dr

bool logr

Eigen::VectorXd m

int num

Eigen::VectorXd p

Eigen::VectorXd p1

Eigen::VectorXd r

double rmax

double rmin

class Mapping

#include <EmpCyl2d.H>

Map the radius.

Public Functions

double d_xi_to_r(double xi)

Jacobian.

inline Mapping()

Null constructor (for copy construct)

inline Mapping(double scale, bool cmap)

Main constructor.

double r_to_xi(double r)

From semi-infinite radius to [-1, 1].

double xi_to_r(double xi)

From [-1, 1] to semi-infinite radius.

Protected Attributes

bool cmap

double scale

class MassModel

#include <massmodel.H>

Inheritence diagram for MassModel:

A three-dimensional density-potential model.

Subclassed by AxiSymModel, OneDModel

Public Functions

inline void bomb(const char *s)

Exception handling using std::exception.

inline int dof()

Return the number of dimensions (degrees of freedom)

virtual double get_density(const double, const double, const double) = 0

The density at (x, y, z)

virtual double get_mass(const double, const double, const double) = 0

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

virtual double get_pot(const double, const double, const double) = 0

The potential at (x, y, z)

inline virtual ~MassModel()

Destructor.

Public Members

bool defined

True if model is assigned.

int dim

The number of dimensions (degrees of freedom)

string ModelID

Model identifier.

class MasterHeader

#include <header.H>

Describe the phase space dump.

Public Members

int ncomp

Number of individual components.

int ntot

Number of particles in entire phase space.

double time

Current time for phase space.

Friends

inline friend std::ostream &operator<<(std::ostream &os, const MasterHeader &p)

class MestelCyl : public EmpCyl2d::ModelCyl

#include <EmpCyl2d.H>

Inheritence diagram for EmpCyl2d::MestelCyl:

Collaboration diagram for EmpCyl2d::MestelCyl:

Subclassed by EmpCyl2d::ZangCyl

Public Functions

inline virtual double dens(double R)

inline virtual double dpot(double R)

inline MestelCyl(const YAML::Node &par)

inline virtual double pot(double R)

Protected Functions

inline virtual void parse(const YAML::Node &conf)

Protected Attributes

double rot

double vrot

class MestelDisk : public AxiSymModel

#include <mestel.H>

Inheritence diagram for MestelDisk:

Collaboration diagram for MestelDisk:

Infiinte Mestel Disk.

Subclassed by TaperedMestelDisk

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

virtual double get_density(const double R)

virtual double get_dpot(const double R)

virtual double get_dpot2(const double R)

virtual double get_mass(const double R)

Required member functions.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

Addiional member functions.

virtual double get_pot(const double R)

virtual void get_pot_dpot(const double R, double &ur, double &dur)

MestelDisk(double VROT = 1.0, double RMIN = 1.0e-6, double RMAX = 1.0e6)

Constructor.

virtual void setup_df(double sigma)

Protected Attributes

double F

double q

double rmax

double rmin

double rot

double sig2

double vrot

class missing_argument_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::missing_argument_exception:

Collaboration diagram for cxxopts::missing_argument_exception:

Public Functions

inline explicit missing_argument_exception(const std::string &option)

class MixtureBasis

#include <MixtureBasis.H>

Collaboration diagram for MixtureBasis:

Public Functions

inline void getCenter(vector<double> &c)

inline double Mixture(double *pos)

inline MixtureBasis(TwoCenter &instance, vector<double> *c, string ID, mixFunc func)

Private Types

typedef double (TwoCenter::* mixFunc)(double *p)

Private Members

vector<double> *ctr

mixFunc f

string id

TwoCenter *p

class Miyamoto

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

inline double get_a(void)

inline double get_b(void)

inline double get_M(void)

double potential(Eigen::Vector3d&)

inline void set_a(double aa)

inline void set_b(double bb)

inline void set_M(double m)

inline void set_Miyamoto(double ainit, double binit, double Ginit, double Minit)

Protected Attributes

double a

double b

double G

double GM

double M

class Miyamoto_Needle

#include <models.H>

Public Functions

double density(Eigen::Vector3d&)

Eigen::Vector3d force(Eigen::Vector3d&)

Vector force(Vector&)

inline double get_a(void)

inline double get_b(void)

inline double get_c(void)

inline double get_M(void)

double potential(Eigen::Vector3d&)

double potential(Vector&)

inline void set_a(double aa)

inline void set_b(double bb)

inline void set_c(double cc)

inline void set_M(double m)

inline void set_Miyamoto_Needle(double aa, double bb, double cc, double gg, double mm)

inline void set_Miyamoto_Needle(double aa, double bb, double cc, double gg, double mm)

Protected Attributes

double a

double b

double c

double G

double k

double kf

double M

class MNdisk : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for MNdisk:

Collaboration diagram for MNdisk:

Miyamoto-Nagai disk.

Public Functions

inline MNdisk(double a, double h, double M = 1)

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

Private Members

double a

double h

class ModelCyl

#include <EmpCyl2d.H>

Inheritence diagram for EmpCyl2d::ModelCyl:

A two-dimensional disk model for computing the EOF.

Subclassed by EmpCyl2d::ExponCyl, EmpCyl2d::KuzminCyl, EmpCyl2d::MestelCyl

Public Functions

virtual double dens(double r) = 0

virtual double dpot(double r) = 0

inline virtual std::string ID()

virtual double pot(double r) = 0

Protected Functions

virtual void parse(const YAML::Node&) = 0

Protected Attributes

std::string id

class Modified_Hubble

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

inline double get_Gravity(void)

inline double get_Ms(void)

inline double get_rs(void)

double potential(Eigen::Vector3d&)

inline void set_Gravity(double g)

inline void set_Modified_Hubble(double r, double m, double G)

inline void set_Ms(double m)

inline void set_rs(double r)

Protected Attributes

double Gravity

double Ms

double rs

class MonotCubicInterpolator

#include <MonotCubicInterpolator.H>

Represents one dimensional function f with single valued argument x that can be interpolated using monotone cubic interpolation.

Class to represent a one-dimensional function f with single-valued argument x. The function is represented by a table of function values. Interpolation between table values is cubic and monotonicity preserving if input values are monotonous.

Outside x_min and x_max, the class will extrapolate using the constant f(x_min) or f(x_max).

Extra functionality:

• Can return (x_1+x_2)/2 where x_1 and x_2 are such that abs(f(x_1) - f(x_2)) is maximized. This is used to determine where one should calculate a new value for increased accuracy in the current function

Monotonicity preserving cubic interpolation algorithm is taken from Fritsch and Carlson, “Monotone piecewise cubic interpolation”, SIAM J. Numer. Anal. 17, 238&#8212;246, no. 2,

$Id$

Algorithm also described here: http://en.wikipedia.org/wiki/Monotone_cubic_interpolation

Author

Håvard Berland <havb (at) statoil.com>, December 2006, Updated for >=C++ 11 by M. Weinberg

Public Functions

void addPair(double newx, double newf)

Adds a new datapoint to the function.

This causes all the derivatives at all points of the functions to be recomputed and then adjusted for monotone cubic interpolation. If this function ever enters a critical part of any code, the locality of the algorithm for monotone adjustment must be exploited.

Parameters:

• newx – New x point

• newf – New f(x) point

inline void chopFlatEndpoints()

Wrapper function for chopFlatEndpoints(const double) providing a default epsilon parameter

void chopFlatEndpoints(const double)

Checks if the function curve is flat at the endpoints, chop off endpoint data points if that is the case.

The notion of “flat” is determined by the input parameter “epsilon” Values whose difference are less than epsilon are regarded as equal.

This is implemented to be able to obtain a strictly monotone curve from a data set that is strictly monotone except at the endpoints.

Example: The data points (1,3), (2,3), (3,4), (4,5), (5,5), (6,5) will become (2,3), (3,4), (4,5)

Assumes at least 3 datapoints. If less than three, this function is a noop.

double evaluate(double x) const

Returns f(x) for given x (input). Interpolates (monotone cubic or linearly) if necessary.

Extrapolates using the constants f(x_min) or f(x_max) if input x is outside (x_min, x_max)

Parameters:

x – x value

Returns:

f(x) for a given x

double evaluate(double x, double &errorestimate_output) const

Returns f(x) and an error estimate for given x (input).

Interpolates (linearly) if necessary.

Throws an exception if extrapolation would be necessary for evaluation. We do not want to do extrapolation (yet).

The error estimate for x1 < x < x2 is (x2 - x1)^2/8 * f’’(x) where f’’(x) is evaluated using the stencil (1 -2 1) using either (x0, x1, x2) or (x1, x2, x3);

Throws an exception if the table contains only two x-values.

NOT IMPLEMENTED YET!

Parameters:

• x – x value

• errorestimate_output –

std::vector<double> get_fVector() const

Provide a copy of tghe function data as a vector

Unspecified order, but corresponds to get_xVector

Returns:

f values as a vector

std::vector<double> get_xVector() const

Provide a copy of the x-data as a vector

Unspecified order, but corresponds to get_fVector.

Returns:

x values as a vector

std::pair<double, double> getMaximumF() const

Maximum f-value, returns both x and f in a pair.

Returns:

x value corresponding to maximum f value

Returns:

maximum f value

inline std::pair<double, double> getMaximumX() const

Maximum x-value, returns both x and f in a pair.

Returns:

maximum x value

Returns:

f(maximum x value)

std::pair<double, double> getMinimumF() const

Minimum f-value, returns both x and f in a pair

Returns:

x value corresponding to minimal f value

Returns:

minimum f value

inline std::pair<double, double> getMinimumX() const

Minimum x-value, returns both x and f in a pair.

Returns:

minimum x value

Returns:

f(minimum x value)

std::pair<double, double> getMissingX() const

Returns an x-value that is believed to yield the best improvement in global accuracy for the interpolation if computed.

Searches for the largest jump in f-values, and returns a x value being the average of the two x-values representing the f-value-jump.

Returns:

New x value beleived to yield the best improvement in global accuracy

Returns:

Maximal difference

inline int getSize() const

Returns:

Number of datapoint pairs in this object

inline bool isMonotone() const

Determines if the current function-value-data is monotone.

Returns:

True if f(x) is monotone, else False

inline bool isMonotoneDecreasing() const

Determines if the current function-value-data is monotone and decreasing

Returns:

True if f(x) is monotone and decreasing, else False

inline bool isMonotoneIncreasing() const

Determines if the current function-value-data is monotone and increasing.

Returns:

True if f(x) is monotone and increasing, else False

inline bool isStrictlyDecreasing()

Determines if the current function-value-data is strictly decreasing. This is a utility function for outsiders if they want to invert the data for example.

Returns:

True if f(x) is strictly decreasing, else False

inline bool isStrictlyIncreasing()

Determines if the current function-value-data is strictly increasing. This is a utility function for outsiders if they want to invert the data for example.

Returns:

True if f(x) is strictly increasing, else False

inline bool isStrictlyMonotone()

Determines if the current function-value-data is strictly monotone. This is a utility function for outsiders if they want to invert the data for example.

Returns:

True if f(x) is strictly monotone, else False

inline MonotCubicInterpolator()

No input, an empty function object is created.

This object must be treated with care until populated.

inline MonotCubicInterpolator(const char *datafilename)

Accepts a filename as input and parses this file for two-column floating point data, interpreting the data as representing function values x and f(x).

Ignores all lines not conforming to <whitespace><float><whitespace><float><whatever><newline>

All commas in the file will be treated as spaces when parsing.

Parameters:

datafilename – A datafile with the x values and the corresponding f(x) values

inline MonotCubicInterpolator(const char *datafilename, int xColumn, int fColumn)

Accepts a filename as input, and parses the chosen columns in that file.

Parameters:

• datafilename – data file

• XColumn – x values

• fColumn – f values

inline MonotCubicInterpolator(const std::string &datafilename)

Accepts a filename as input and parses this file for two-column floating point data, interpreting the data as representing function values x and f(x).

Ignores all lines not conforming to <whitespace><float><whitespace><float><whatever><newline>

Parameters:

datafilename – A datafile with the x values and the corresponding f(x) values

inline MonotCubicInterpolator(const std::string &datafilename, int xColumn, int fColumn)

Accepts a filename as input, and parses the chosen columns in that file.

Parameters:

• datafilename – data file

• XColumn – x values

• fColumn – f values

MonotCubicInterpolator(const std::vector<double> &x, const std::vector<double> &f)

Accepts two equal-length vectors as input for constructing the interpolation object. First vector is the x-values, the second vector is the function values

Parameters:

• x – vector of x values

• f – vector of corresponding f values

inline double operator()(double x) const

Returns f(x) for given x (input). Interpolates (monotone cubic or linearly) if necessary.

Extrapolates using the constants f(x_min) or f(x_max) if input x is outside (x_min, x_max)

Parameters:

x – x value

Returns:

f(x) for a given x

inline bool read(const std::string &datafilename)

Accepts a filename as input and parses this file for two-column floating point data, interpreting the data as representing function values x and f(x).

returns true on success

All commas in file will be treated as spaces when parsing

Ignores all lines not conforming to <whitespace><float><whitespace><float><whatever><newline>

Parameters:

datafilename – A datafile with the x values and the corresponding f(x) values

bool read(const std::string &datafilename, int xColumn, int fColumn)

Accepts a filename as input, and parses the chosen columns in that file.

Parameters:

• datafilename – data file

• XColumn – x values

• fColumn – f values

void scaleData(double factor)

Scale all the function value data by a constant

Parameters:

factor – Scaling constant

inline void shrinkFlatAreas()

Wrapper function for shrinkFlatAreas(const double) providing a default epsilon parameter

void shrinkFlatAreas(const double)

If function is monotone, but not strictly monotone, this function will remove datapoints from intervals with zero derivative so that the curve become strictly monotone.

Example The data points (1,2), (2,3), (3,4), (4,4), (5,5), (6,6) will become (1,2), (2,3), (3,4), (5,5), (6,6)

Assumes at least two datapoints, if one or zero datapoint, this is a noop.

std::string toString() const

Constructs a string containing the data in a table

Returns:

a string containing the data in a table

Private Functions

void adjustDerivativesForMonotoneness() const

Adjusts the derivative values (ddata) so that we can guarantee that the resulting piecewise Hermite polymial is monotone. This is done according to the algorithm of Fritsch and Carlsson 1980, see Section 4, especially the two last lines.

void computeInternalFunctionData() const

void computeSimpleDerivatives() const

Computes initial derivative values using centered (second order) difference for internal datapoints, and one-sided derivative for endpoints

The internal datastructure map<double,double> ddata is populated by this method.

inline double H00(double t) const

inline double H01(double t) const

inline double H10(double t) const

inline double H11(double t) const

inline bool isMonotoneCoeff(double alpha, double beta) const

Checks if the coefficient alpha and beta is in the region that guarantees monotoneness of the derivative values they represent

See Fritsch and Carlson 1980, Lemma 2, alternatively Step 5 in Wikipedia’s article on Monotone cubic interpolation.

Private Members

std::map<double, double> data

mutable std::map<double, double> ddata

mutable bool decreasing

mutable bool increasing

mutable bool monotone

mutable bool monotoneCached

mutable bool strictlyDecreasing

mutable bool strictlyIncreasing

mutable bool strictlyMonotone

mutable bool strictlyMonotoneCached

struct MstepArray : public std::vector<VectorD2ptr>

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL::MstepArray:

Collaboration diagram for EmpCylSL::MstepArray:

Some syntactic sugar for array of shared pointers: define an operator to the object of the shared pointer. That is, for:

MstepArray step(N);

One can use:

step(n)[j][k] = …

instead of

(*step[n])[j][k] = …

to access elements.

Public Functions

inline VectorD2 &operator()(int M)

struct NData

#include <PotAccel.H>

For timing data.

Public Members

string name

int node

int tid

class Needle

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

Vector force(Vector&)

inline double get_a(void)

inline double get_b(void)

inline double get_M(void)

double potential(Eigen::Vector3d&)

double potential(Vector&)

inline void set_a(double aa)

inline void set_b(double bb)

inline void set_M(double m)

inline void set_Needle(double aa, double bb, double gg, double mm)

inline void set_Needle(double aa, double bb, double gg, double mm)

Protected Attributes

double a

double b

double G

double k

double kf

double M

struct node

#include <KDtree.H>

Collaboration diagram for KDtree::kdtree::node:

Public Functions

inline double distance(const point_type &pt) const

inline coordinate_type get(size_t index) const

inline node(const point_type &pt)

Public Members

node *left_

point_type point_

node *right_

struct node_cmp

Public Functions

inline node_cmp(size_t index)

inline bool operator()(const node &n1, const node &n2) const

Public Members

size_t index_

class NoForce : public PotAccel

#include <NoForce.H>

Inheritence diagram for NoForce:

Collaboration diagram for NoForce:

A NULL force method

Applies no acceleration to the particles whatsoever. This allows the user to supply an alternative as an external force.

Public Functions

inline virtual void get_acceleration_and_potential(Component*)

The main force call.

NoForce(Component *c0, const YAML::Node &conf)

The constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• conf – is ignored here

virtual ~NoForce()

The constructor.

Private Functions

inline void determine_acceleration_and_potential(void)

inline virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

inline virtual void determine_coefficients(void)

Used by get_acceleration_and_potential to request that the expansion be performed.

inline virtual void *determine_coefficients_thread(void *arg)

Multithreading implementation of the expansion computation.

inline virtual void initialize()

Used by derived class to initialize any storage and parameters.

class nvTracer

#include <NVTX.H>

Public Functions

inline nvTracer(const char *name)

inline ~nvTracer()

class OneDBiorth : public Biorth

#include <biorth1d.H>

Inheritence diagram for OneDBiorth:

Collaboration diagram for OneDBiorth:

One-dimensional biorthgonal basis.

Subclassed by OneDTrig

Public Functions

virtual double d_r_to_rb(double const) = 0

Jacobian of mapping.

virtual double dens(const int, const int, const double) = 0

Get density basis value.

virtual void dens(const int, const int, const double, Eigen::VectorXd&) = 0

Write density basis into a vetor.

virtual double get_dens(double r, int l, Eigen::VectorXd &coef) = 0

Return value of density for given coefficient vector.

inline int get_dof(void)

Number of degrees of freedom.

virtual double get_potl(double r, int l, Eigen::VectorXd &coef) = 0

Return value of poential for given coefficient vector.

inline OneDBiorth(void)

Constructor.

virtual double potl(const int, const int, const double) = 0

Get potential basis value.

virtual void potl(const int, const int, const double, Eigen::VectorXd&) = 0

Write potential basis into a vetor.

virtual double r_to_rb(double const) = 0

Dimensional to non-dimensional coordinate map.

virtual double rb_max(void) = 0

Maximum value in non-dimensional mapping.

virtual double rb_min(void) = 0

Minimum value in non-dimensional mapping.

virtual double rb_to_r(double const) = 0

Non-dimensional to dimensional coordinate map.

inline void reset_kx(double KX)

Reset vertical wave number.

Public Members

double kx

Vertical wave number.

Private Members

int dof

class OneDModel : public MassModel

#include <massmodel1d.H>

Inheritence diagram for OneDModel:

Collaboration diagram for OneDModel:

Subclassed by OneDModelTable, Sech2, Sech2mu

Public Functions

virtual double dfde(const double, const double V = 0.0) = 0

virtual double dfdv(const double, const double V = 0.0) = 0

virtual double distf(const double, const double V = 0.0) = 0

inline virtual double get_density(const double x, const double y, const double z)

The density at (x, y, z)

virtual double get_density(const double) = 0

virtual double get_dpot(const double) = 0

virtual double get_dpot2(const double) = 0

inline virtual double get_mass(const double x, const double y, const double z)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

virtual double get_mass(const double) = 0

virtual double get_max_radius(void) = 0

virtual double get_min_radius(void) = 0

inline virtual double get_pot(const double x, const double y, const double z)

The potential at (x, y, z)

virtual double get_pot(const double) = 0

virtual tuple<double, double> get_pot_dpot(const double) = 0

virtual double get_scale_height(void) = 0

Public Members

bool dist_defined

class OneDModelTable : public OneDModel

#include <massmodel1d.H>

Inheritence diagram for OneDModelTable:

Collaboration diagram for OneDModelTable:

Subclassed by LowIso, Sech2Halo

Public Functions

virtual double get_density(const double)

virtual double get_dpot(const double)

virtual double get_dpot2(const double)

virtual double get_mass(const double)

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline const int get_num_param(void)

inline const double get_param(int i)

virtual double get_pot(const double)

virtual tuple<double, double> get_pot_dpot(const double)

inline virtual double get_scale_height(void)

inline int grid_size(void)

inline OneDModelTable()

OneDModelTable(int num, double *r, double *d, double *m, double *p, string ID = "")

OneDModelTable(string filename, int PARM = 0)

Protected Attributes

Spline1d dens

int even

double half_height

Spline1d mass

int num

int numdf

std::vector<double> params

Spline1d pot

class OneDTrig : public OneDBiorth

#include <biorth1d.H>

Inheritence diagram for OneDTrig:

Collaboration diagram for OneDTrig:

Basis based on trigonometric functions in vertical direction.

Public Functions

inline virtual double d_r_to_rb(double const x)

Jacobian for non-dimensional mapping.

virtual double dens(const int n, const int tmp, const double z)

Get density value for basis.

virtual void dens(const int n, const int tmp, const double z, Eigen::VectorXd &vec)

Return density basis in a vector.

double force(const int n, const int tmp, const double z)

Get force value for basis.

void force(const int n, const int tmp, const double z, Eigen::VectorXd &vec)

Return force basis in a vector.

virtual double get_dens(double r, int l, Eigen::VectorXd &coef)

Return density field for given coefficient vector.

double get_force(double r, int l, Eigen::VectorXd &coef)

Return force field for given coefficient vector.

virtual double get_potl(double r, int l, Eigen::VectorXd &coef)

Return potential field for given coefficient vector.

inline virtual double krnl(int n, int k = 0)

Kernel value.

inline virtual double norm(int n, int k = 0)

Norm value.

OneDTrig(double kx)

Constructor.

OneDTrig(double kx, double ZMAX)

Constructor.

OneDTrig(void)

Constructor.

virtual double potl(const int n, const int tmp, const double z)

Get potential value for basis.

virtual void potl(const int n, const int tmp, const double z, Eigen::VectorXd &vec)

Return potential basis in a vector.

inline virtual double r_to_rb(double const x)

Dimensional to non-dimensional mapping.

inline virtual double rb_max(void)

Maximum value in non-dimensional mapping.

inline virtual double rb_min(void)

Minimum value in non-dimensional mapping.

inline virtual double rb_to_r(double const x)

Non-dimensional to dimensional mapping.

void reset(double KX, double ZMAX)

Reset grid with new parameters.

Public Static Attributes

static double KSTOL

Enpoint offset for root finding (small)

static double KSZTOL

Root finding tolerance (small)

Private Functions

void compute_kstar(int n)

void compute_norm(void)

Private Members

Eigen::VectorXd cnorm

Eigen::VectorXd kbstar

Eigen::VectorXd kstar

int nrmax

double zmax

struct Option

#include <cxxopts.H>

Public Functions

inline Option(std::string opts, std::string desc, std::shared_ptr<const Value> value = ::cxxopts::value<bool>(), std::string arg_help = "")

Public Members

std::string arg_help_

std::string desc_

std::string opts_

std::shared_ptr<const Value> value_

class option_exists_error : public cxxopts::OptionSpecException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_exists_error:

Collaboration diagram for cxxopts::option_exists_error:

Public Functions

inline explicit option_exists_error(const std::string &option)

class option_has_no_value_exception : public cxxopts::OptionException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_has_no_value_exception:

Collaboration diagram for cxxopts::option_has_no_value_exception:

Public Functions

inline explicit option_has_no_value_exception(const std::string &option)

class option_not_exists_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_not_exists_exception:

Collaboration diagram for cxxopts::option_not_exists_exception:

Public Functions

inline explicit option_not_exists_exception(const std::string &option)

class option_not_has_argument_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_not_has_argument_exception:

Collaboration diagram for cxxopts::option_not_has_argument_exception:

Public Functions

inline option_not_has_argument_exception(const std::string &option, const std::string &arg)

class option_not_present_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_not_present_exception:

Collaboration diagram for cxxopts::option_not_present_exception:

Public Functions

inline explicit option_not_present_exception(const std::string &option)

class option_required_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_required_exception:

Collaboration diagram for cxxopts::option_required_exception:

Public Functions

inline explicit option_required_exception(const std::string &option)

class option_requires_argument_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_requires_argument_exception:

Collaboration diagram for cxxopts::option_requires_argument_exception:

Public Functions

inline explicit option_requires_argument_exception(const std::string &option)

class option_syntax_exception : public cxxopts::OptionParseException

#include <cxxopts.H>

Inheritence diagram for cxxopts::option_syntax_exception:

Collaboration diagram for cxxopts::option_syntax_exception:

Public Functions

inline explicit option_syntax_exception(const std::string &text)

class OptionAdder

#include <cxxopts.H>

Collaboration diagram for cxxopts::OptionAdder:

Public Functions

inline OptionAdder &operator()(const std::string &opts, const std::string &desc, const std::shared_ptr<const Value> &value = ::cxxopts::value<bool>(), std::string arg_help = "")

inline OptionAdder(Options &options, std::string group)

Private Members

std::string m_group

Options &m_options

class OptionDetails

#include <cxxopts.H>

Public Functions

inline CXXOPTS_NODISCARD const String & description () const

inline size_t hash() const

inline CXXOPTS_NODISCARD const std::string & long_name () const

inline CXXOPTS_NODISCARD std::shared_ptr< Value > make_storage () const

inline OptionDetails(const OptionDetails &rhs)

OptionDetails(OptionDetails &&rhs) = default

inline OptionDetails(std::string short_, std::string long_, String desc, std::shared_ptr<const Value> val)

inline CXXOPTS_NODISCARD const std::string & short_name () const

inline CXXOPTS_NODISCARD const Value & value () const

Private Members

int m_count

String m_desc = {}

size_t m_hash = {}

std::string m_long = {}

std::string m_short = {}

std::shared_ptr<const Value> m_value = {}

class OptionException : public std::exception

#include <cxxopts.H>

Inheritence diagram for cxxopts::OptionException:

Collaboration diagram for cxxopts::OptionException:

Subclassed by cxxopts::OptionParseException, cxxopts::OptionSpecException, cxxopts::option_has_no_value_exception

Public Functions

inline explicit OptionException(std::string message)

inline CXXOPTS_NODISCARD const char * what () const noexcept override

Private Members

std::string m_message

class OptionParseException : public cxxopts::OptionException

#include <cxxopts.H>

Inheritence diagram for cxxopts::OptionParseException:

Collaboration diagram for cxxopts::OptionParseException:

Subclassed by cxxopts::argument_incorrect_type, cxxopts::missing_argument_exception, cxxopts::option_not_exists_exception, cxxopts::option_not_has_argument_exception, cxxopts::option_not_present_exception, cxxopts::option_required_exception, cxxopts::option_requires_argument_exception, cxxopts::option_syntax_exception

Public Functions

inline explicit OptionParseException(const std::string &message)

class OptionParser

#include <cxxopts.H>

Public Functions

inline void add_to_option(OptionMap::const_iterator iter, const std::string &option, const std::string &arg)

inline void checked_parse_arg(int argc, const char *const *argv, int &current, const std::shared_ptr<OptionDetails> &value, const std::string &name)

inline bool consume_positional(const std::string &a, PositionalListIterator &next)

inline OptionParser(const OptionMap &options, const PositionalList &positional, bool allow_unrecognised)

inline ParseResult parse(int argc, const char *const *argv)

inline void parse_default(const std::shared_ptr<OptionDetails> &details)

inline void parse_no_value(const std::shared_ptr<OptionDetails> &details)

inline void parse_option(const std::shared_ptr<OptionDetails> &value, const std::string &name, const std::string &arg = "")

Private Functions

inline void finalise_aliases()

Private Members

bool m_allow_unrecognised

std::vector<KeyValue> m_defaults = {}

NameHashMap m_keys = {}

const OptionMap &m_options

ParsedHashMap m_parsed = {}

const PositionalList &m_positional

std::vector<KeyValue> m_sequential = {}

class Options

#include <cxxopts.H>

Public Functions

inline void add_option(const std::string &group, const Option &option)

inline void add_option(const std::string &group, const std::string &s, const std::string &l, std::string desc, const std::shared_ptr<const Value> &value, std::string arg_help)

inline void add_options(const std::string &group, std::initializer_list<Option> options)

inline OptionAdder add_options(std::string group = "")

inline Options &allow_unrecognised_options()

inline Options &custom_help(std::string help_text)

inline const HelpGroupDetails &group_help(const std::string &group) const

inline std::vector<std::string> groups() const

inline std::string help(const std::vector<std::string> &groups = {}) const

inline explicit Options(std::string program, std::string help_string = "")

inline ParseResult parse(int argc, const char *const *argv)

template<typename Iterator>
inline void parse_positional(Iterator begin, Iterator end)

inline void parse_positional(std::initializer_list<std::string> options)

inline void parse_positional(std::string option)

inline void parse_positional(std::vector<std::string> options)

inline Options &positional_help(std::string help_text)

inline Options &set_tab_expansion(bool expansion = true)

inline Options &set_width(size_t width)

inline Options &show_positional_help()

Private Functions

inline void add_one_option(const std::string &option, const std::shared_ptr<OptionDetails> &details)

inline void generate_all_groups_help(String &result) const

inline void generate_group_help(String &result, const std::vector<std::string> &groups) const

inline String help_one_group(const std::string &group) const

Private Members

bool m_allow_unrecognised

std::string m_custom_help = {}

std::map<std::string, HelpGroupDetails> m_help = {}

String m_help_string = {}

std::list<OptionDetails> m_option_list = {}

std::unordered_map< std::string, decltype(m_option_list)::iterator > m_option_map   = {}

std::shared_ptr<OptionMap> m_options

std::vector<std::string> m_positional = {}

std::string m_positional_help = {}

std::unordered_set<std::string> m_positional_set = {}

std::string m_program = {}

bool m_show_positional

bool m_tab_expansion

size_t m_width

class OptionSpecException : public cxxopts::OptionException

#include <cxxopts.H>

Inheritence diagram for cxxopts::OptionSpecException:

Collaboration diagram for cxxopts::OptionSpecException:

Subclassed by cxxopts::invalid_option_format_error, cxxopts::option_exists_error

Public Functions

inline explicit OptionSpecException(const std::string &message)

class OptionValue

#include <cxxopts.H>

Public Functions

template<typename T>
inline const T &as() const

inline CXXOPTS_NODISCARD size_t count () const noexcept

inline CXXOPTS_NODISCARD bool has_default () const noexcept

inline void parse(const std::shared_ptr<const OptionDetails> &details, const std::string &text)

inline void parse_default(const std::shared_ptr<const OptionDetails> &details)

inline void parse_no_value(const std::shared_ptr<const OptionDetails> &details)

Private Functions

inline void ensure_value(const std::shared_ptr<const OptionDetails> &details)

Private Members

size_t m_count = 0

bool m_default = false

const std::string *m_long_name = nullptr

std::shared_ptr<Value> m_value = {}

class OrbTrace : public Output

#include <OrbTrace.H>

Inheritence diagram for OrbTrace:

Collaboration diagram for OrbTrace:

Log norb orbits at each interval

For best efficiency, particles to be traced should be on the root process.

Param norb:

is the number of orbits per node to follow

Param nbeg:

is the offset in the bodies list for the first particle to trace.

Param nskip:

is the interval between orbits beginning with nskip. If nskip is unspecified, nskip=nbodies/norb.

Param nint:

is the frequency between file updates

Param use_acc:

to output the acceleration

Param use_pot:

to output the potential

Param use_lev:

to output the multistep level

Param orbitlist:

is the list of particle numbers to trace

Param name:

of the component to trace

Public Functions

OrbTrace(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

int flags

bool local

int nbeg

int nbuf

int norb

int nskip

std::string orbitlist

std::vector<int> orblist

std::vector<double> pbuf

double prev = -std::numeric_limits<double>::max()

Last output time.

Component *tcomp

bool use_acc

bool use_lev

bool use_pot

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

struct OrbValues

#include <FindOrb.H>

Public Members

double apo

double azimuthal_period

double Boltzmann

double energy

double kappa

double peri

double radial_period

double rate

double t0

double tf

double value

class Orient

#include <Orient.H>

Collaboration diagram for Orient:

Class to keep track of orientation

Log file contents:

1. Time

2. Energy

3. Particles used

4. Current Axis(x) from regression

5. Current Axis(y)

6. Current Axis(z)

7. Last Axis(x) from particles

8. Last Axis(y)

9. Last Axis(z)

10. Current Center(x) from regression

11. Current Center(y)

12. Current Center(z)

13. Current Center(x) from analytic approx

14. Current Center(y)

15. Current Center(z)

16. Last Center(x) from particles

17. Last Center(y)

18. Last Center(z)

19. COM(x)

20. COM(y)

21. COM(z)

22. System COM(x)

23. System COM(y)

24. System COM(z)

Public Types

enum ControlFlags

Mask flags for Orient behavior.

Values:

enumerator DIAG

enumerator KE

enumerator EXTERNAL

enum OrientFlags

Mask flags for Orient type.

Values:

enumerator AXIS

enumerator CENTER

Public Functions

void accumulate(double time, Component *c)

Register phase space of num particles and store angular momentum vector for the lowest many binding energies.

inline const std::tuple<Eigen::Vector3d&, Eigen::Vector3d&, Eigen::Vector3d&> currentAccel(void)

Return current pseudo force, angular velocity, and angular velocity derivative

inline Eigen::Vector3d &currentAxis(void)

Return current axis.

inline double currentAxisVar(void)

Return variance of axis determination (linear least squares solution)

inline Eigen::Vector3d &currentCenter(void)

Return current center.

inline double currentCenterVar(void)

Return variance for center determination (linear least squares solution)

inline double currentCenterVarZ(void)

Return variance for center determination for z component alone.

inline double currentE(void)

Return energy for disk ang mom.

inline int currentUsed(void)

Return number of particles used.

void logEntry(double time, Component *c)

Write log entry.

Orient(int number_to_keep, int target, int Naccel, unsigned orient_flags, unsigned control_flags, string logfile, double dt = 0.0, double damping = 1.0)

Constructor.

inline void set_center(double x, double y, double z)

Set initial center (zero by default)

inline void set_cenvel(double u, double v, double w)

Set initial center velocity (zero by default)

inline void set_linear()

Set center to move at constant velocity.

inline Eigen::Matrix3d &transformBody(void)

Return transformation to new body axes.

inline Eigen::Matrix3d &transformOrig(void)

Return transformation to original coordinates.

~Orient()

Destructor.

Private Types

typedef pair<double, Eigen::VectorXd> DV

Private Functions

void accumulate_cpu(double time, Component *c)

Private Members

std::shared_ptr<PseudoAccel> accel

set<EL3, ltEL3> angm

Eigen::Vector3d axis

Eigen::Vector3d axis1

Eigen::Matrix3d body

Eigen::Vector3d center

Eigen::Vector3d center0

Eigen::Vector3d center1

Eigen::Vector3d cenvel0

unsigned int cflags

int current

double damp

double deltaT

Eigen::Vector3d domdt = Eigen::Vector3d::Zero()

double Ecurr

double Elast

Eigen::Vector3d intercept

int keep

double lasttime

bool linear

string logfile

int many

int Nlast

unsigned int oflags

Eigen::Vector3d omega = Eigen::Vector3d::Zero()

Eigen::Matrix3d orig

std::vector<double> pos

std::vector<double> psa

Eigen::Vector3d pseudo = Eigen::Vector3d::Zero()

double sigA

double sigC

double sigCz

Eigen::Vector3d slope

deque<DV> sumsA

deque<DV> sumsC

double sumX

double sumX2

Eigen::Vector3d sumXY

Eigen::Vector3d sumY

Eigen::Vector3d sumY2

EL3 t

int used

std::vector<double> vel

class OrthoFunction

#include <OrthoFunction.H>

Compute orthogonal functions whose lowest-order member is the background density using the Stieltjes procedure for generating 3-term recursion

Public Types

using DensFunc = std::function<double(double)>

Public Functions

void dumpOrtho(const std::string &filename)

Dump the orthogonal function table

Parameters:

filename – Filename for output

Eigen::VectorXd operator()(double r)

Evaluate orthogonal functions at r

Parameters:

r – Radial coordinate

Returns:

A vector of the orthogonal functions

OrthoFunction(int norder, DensFunc W, double rmin, double rmax, double scale, int dof)

Constructor

Parameters:

• norder – Order of the orthogonal polynomial

• W – Density weight function

• rmin – Inner radial bound

• rmax – Outer radial bound

• scale – Mapping scale

• dof – Degrees of freedom (2 or 3)

inline void setKnots(int N)

Reset Legendre knots and weights for inner product

Parameters:

N – Number of Legendre knots

Eigen::MatrixXd testOrtho()

Test orthogonality.

inline virtual ~OrthoFunction()

Destructor.

Private Functions

inline double d_r_to_x(double x)

void generate()

Generate the recursion for the orthogonal polynomials.

Eigen::VectorXd poly_eval(double t, int n)

Polynomial evaluation at t for orders j=0,…,n.

inline double r_to_x(double r)

Coordinate scaling.

double scalar_prod(int n, int m)

Inner product polynomial of order n with moment m.

inline double x_to_r(double x)

Private Members

Eigen::VectorXd alph

Recursion coefficients and norm.

Eigen::VectorXd beta

int dof

Degrees of freedom.

double dx

int knots = 400

Legendre knots.

std::shared_ptr<LegeQuad> lq

Gaussian quadrature.

int nmax

Polynomial order.

Eigen::VectorXd norm

double rmax

double rmin

Radial boundaries.

double scale

Mapping scale.

DensFunc W

Sqrt root weight function.

double xmax

double xmin

Mapped radial boundaries and range.

class OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for OrthoPoly:

Subclassed by Cheb1, Cheb2, GenLagu, Hermite, Legendre, Ultra

Public Functions

virtual double coef1(const int n) = 0

virtual double coef2(const int n) = 0

virtual double coef3(const int n) = 0

virtual double coef4(const int n) = 0

double f(const double x, const int n)

virtual double f0(const double x) = 0

virtual double f1(const double x) = 0

Eigen::VectorXd fv(const double x, const int n)

inline double get_a(void)

inline double get_b(void)

virtual double h(const int n) = 0

virtual double w(const double x) = 0

Protected Attributes

double a

double b

double *param

Private Members

double coefs[4]

class OutAscii : public Output

#include <OutAscii.H>

Inheritence diagram for OutAscii:

Collaboration diagram for OutAscii:

Write phase-space dumps for a single component at regular intervals in ascii format. Each line contains: mass, pos[3], vel[3], acc[3], pot, potext, ival[niattr], dval[ndattr]

Each dump is written into a new file label as filename.n where is begins at nbeg and incremented by 1 after each file is written.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param nintsub:

is the substep number to perform outputs

Param nbeg:

is suffix of the first phase space dump

Param name:

of the desired component

Param accel:

set to 1 means print out accelerations

Public Functions

OutAscii(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

bool accel

Component *c0

std::string filename

std::string name

int nbeg

double prev = -std::numeric_limits<double>::max()

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutCalbr : public Output

#include <OutCalbr.H>

Inheritence diagram for OutCalbr:

Collaboration diagram for OutCalbr:

Compute changes in energy and angular momentum per orbit and provide rms changes as a function of energy

The routine assumes that the input file is defined with four double attributes to hold the energy and angular momentum vector.

Param filename:

of the output file

Param name:

of the component to dump

Param nint:

is the frequency between file updates

Param N:

are the number of energy bins

Public Functions

OutCalbr(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

void set_energies(void)

Private Members

double dE

std::vector<double> deltaE

std::vector<double> deltaE1

std::vector<double> deltaLx

std::vector<double> deltaLx1

std::vector<double> deltaLy

std::vector<double> deltaLy1

std::vector<double> deltaLz

std::vector<double> deltaLz1

std::vector<double> Ec

double Emax

double Emin

std::string filename

std::vector<unsigned> ncnt

std::vector<unsigned> ncnt1

int num

double prev = -std::numeric_limits<double>::max()

Component *tcomp

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutCHKPT : public Output

#include <OutCHKPT.H>

Inheritence diagram for OutCHKPT:

Collaboration diagram for OutCHKPT:

Writes a checkpoint file at regular intervals

Previously written checkpoint file will be rename to <filename>.bak

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, or OutCHKPT in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param mpio:

set to true uses MPI-IO output with arbitrarily sequenced particles

Param nagg:

is the number of MPI-IO aggregators

Public Functions

OutCHKPT(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

bool mpio

std::string nagg

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutCHKPTQ : public Output

#include <OutCHKPTQ.H>

Inheritence diagram for OutCHKPTQ:

Collaboration diagram for OutCHKPTQ:

Writes a checkpoint file at regular intervals from each node in component pieces. These pieces may be reassembled from the info in an “instruction” file.

Previously written checkpoint file will be rename to <filename>.bak

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, OutCHKPT, or OutCHKPTQ in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param mpio:

set to true uses MPI-IO output with arbitrarily sequenced particles

Param nagg:

is the number of MPI-IO aggregators

Public Functions

OutCHKPTQ(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

bool mpio

std::string nagg

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutCoef : public Output

#include <OutCoef.H>

Inheritence diagram for OutCoef:

Collaboration diagram for OutCoef:

Dump coefficients at each interval

Param filename:

of the coefficient file

Param name:

of the component to dump

Param nint:

is the frequency between file updates

Param native:

set to true uses old-style native coefficient format

Public Functions

OutCoef(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

bool native

double prev = -std::numeric_limits<double>::max()

Component *tcomp

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutDiag : public Output

#include <OutDiag.H>

Inheritence diagram for OutDiag:

Collaboration diagram for OutDiag:

Print field quantities for spherical and cylindrical bases.

Public Functions

OutDiag(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

void header(ostream &out)

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

std::list<Component*> lcomp

std::vector<std::string> names

int NUM

double PHI

double prev = -std::numeric_limits<double>::max()

double RMAX

double RMIN

double THETA

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutFrac : public Output

#include <OutFrac.H>

Inheritence diagram for OutFrac:

Collaboration diagram for OutFrac:

Dump mass fractions at each interval

Param filename:

of the fraction file

Param name:

of the component to dump

Param nint:

is the frequency between file updates

Param frac(n):

are the quantiles

Public Functions

OutFrac(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

int numQuant

double prev = -std::numeric_limits<double>::max()

vector<double> Quant

Component *tcomp

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OUTInput

Input class to adaptively handle OUT. format specifically

inputs
---------------
filename : str
    the input filename to be read
comp     : str, optional
    the name of the component for which to extract data. If None, will read primary header and exit.
verbose  : int, default 0
    verbosity flag.

returns
---------------
self        : Input instance
  .header   : dict, all header values pulled from the file
    the .keys() are the names of each component
    each component has a dictionary of values, including 'parameters'
    the details of the force calculation are in 'force'
  .filename : str, the filename that was read
  .comp     : str, name of the component
  .time     : float, the time in the output file
  .data     : dictionary, with keys:
    x       : float, the x position
    y       : float, the y position
    z       : float, the z position
    vx      : float, the x velocity
    vy      : float, the y velocity
    vz      : float, the z velocity
    mass    : float, the mass of the particle
    index   : int, the integer index of the particle
    potE    : float, the potential energy value

Public Members

comp

comp_map

data

f

filename

header

indexing

primary_header

time

verbose

class OutLog : public Output

#include <OutLog.H>

Inheritence diagram for OutLog:

Collaboration diagram for OutLog:

Log vital statistics every n steps.

New version of log file puts all entries on a single line. This makes for difficult human reading but great for machines.

Centers of mass, Centers of velocity, Virial of Clausius and 2T/VC will be computed for each component

NB: the “Virial of Clausius” is a better indicatator of the true potential energy for multiple components or external forces

Current ordering (will be labeled in the file):

• Global statistics

  1. Current time

Total mass

1. Number of bodies

2. COM (x, y, z)

3. COV (x, y, z)

4. Ang mom (x, y, z)

5. Total KE

6. Total PE

7. Total E

8. Virial of Clausius (VC)

9. 2T/VC

10. Time per step

11. Total particles used

For each component in succession

1. Total mass

Number of bodies

1. COM (x, y, z)

2. COV (x, y, z)

3. Ang mom (x, y, z)

4. Total KE

5. Total PE

6. Total E

7. Virial of Clausius (VC)

8. 2T/VC

9. Particles used

Public Functions

OutLog(const YAML::Node &conf)

Constructor.

Parameters:

line – token list of specific parameters

virtual void Run(int nstep, int mstep, bool last)

Generate output.

Parameters:

• nstep – the current step number (used e.g. to decide whether or not to write output

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – if true, output is generated independent of the step number

Public Static Attributes

static char lab_component[][20]

Per-component column labels.

static char lab_global[][19]

Global column labels.

static const int num_component = 20

Number of per-component entries.

static const int num_global = 19

Number of global entries.

Private Types

typedef vector<double> dvector

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

vector<dvector> angm

vector<double> angm0

vector<dvector> angm1

vector<double> angmG

vector<double> clausius

vector<double> clausius1

vector<dvector> com

vector<double> com0

vector<dvector> com1

vector<double> comG

vector<double> comL

vector<dvector> cov

vector<double> cov0

vector<dvector> cov1

vector<double> covG

vector<double> covL

vector<dvector> ctr

double curwtime

vector<double> ektot

vector<double> ektot1

double ektotxy

vector<double> eptot

vector<double> eptot1

vector<double> eptotx

vector<double> eptotx1

std::string filename

bool firstime

int laststep

double lastwtime

vector<double> mtot

vector<double> mtot1

vector<int> nbodies

vector<int> nbodies1

int nfreq

vector<double> pos0

vector<double> posL

int precision

vector<int> used

vector<int> used1

vector<double> vel0

vector<double> velL

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutMulti : public Output

#include <OutMulti.H>

Inheritence diagram for OutMulti:

Collaboration diagram for OutMulti:

Dump histogram of multistep levels to file in GNUPLOT format

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Public Functions

OutMulti(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

double prev = -std::numeric_limits<double>::max()

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutPS : public Output

#include <OutPS.H>

Inheritence diagram for OutPS:

Collaboration diagram for OutPS:

Append phase space dumps to specified file at regular intervals

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, OutCHKPT, or OutCHKPTQ in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param timer:

set to true turns on wall-clock timer for PS output

Public Functions

OutPS(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

• timer – set to true turns on wall-clock timer for PS output

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutPSN : public Output

#include <OutPSN.H>

Inheritence diagram for OutPSN:

Collaboration diagram for OutPSN:

Write phase-space dumps at regular intervals. Each dump is written into a new file label as filename.n where is begins at nbeg and incremented by 1 after each file is written.

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, OutCHKPT, or OutCHKPTQ in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param nbeg:

is suffix of the first phase space dump

Param real4:

indicates floats for real PS quantities

Param timer:

set to true turns on wall-clock timer for PS output

Public Functions

OutPSN(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

• timer – set to true turns on wall-clock timer for PS output

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

int nbeg

bool real4

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutPSP : public Output

#include <OutPSP.H>

Inheritence diagram for OutPSP:

Collaboration diagram for OutPSP:

Write phase-space dumps at regular intervals using MPI-IO

Each dump is written into a new file label as filename.n where is begins at nbeg and incremented by 1 after each file is written. This implementation bunches particles into memory and uses a collective MPI_File write to push the bunch to disk at the appropriate offset. The MPI-IO implementation does not maintain the particle sequence so indexing=1 needs to be added as a Component option if the particle index is needed for post processing. This version is much faster than OutPSN and OutCHKPT which uses MPI gather to the root node before writing. This is the newest version for PSP output and has not be extensively tested as of 10/2018.

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, OutCHKPT, or OutCHKPTQ in the output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param nbeg:

is suffix of the first phase space dump

Param real4:

indicates floats for real PS quantities

Param nagg:

is the number of MPI-IO aggregators

Public Functions

OutPSP(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

std::string nagg

int nbeg

bool real4

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutPSQ : public Output

#include <OutPSQ.H>

Inheritence diagram for OutPSQ:

Collaboration diagram for OutPSQ:

Write phase-space dumps at regular intervals from each node in component pieces. These pieces may be reassembled from the info in an “instruction” file.

The assembly instructions for each dump is written into a new file label as filename.n where is begins at nbeg and incremented by 1 after each file is written.

The component pieces are indexed from 0 onward.

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSQ, OutCHKPT, or OutCHKPTQ in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param nbeg:

is suffix of the first phase space dump

Param timer:

set to true turns on wall-clock timer for PS output

Param threads:

number of threads for binary writes

Public Functions

OutPSQ(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

• timer – set to true turns on wall-clock timer for PS output

• threads – is the thread count for binary writes

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

std::string filename

int nbeg

bool real4

int threads

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutPSR : public Output

#include <OutPSR.H>

Inheritence diagram for OutPSR:

Collaboration diagram for OutPSR:

Write phase-space dumps at regular intervals from each node in component pieces. These pieces may be reassembled from the info in an “instruction” file.

The assembly instructions for each dump is written into a new file label as filename.n where is begins at nbeg and incremented by 1 after each file is written.

The component pieces are indexed from 0 onward.

Sending the root process a SIGHUP will cause the first of OutPS, OutPSP, OutPSN, OutPSR, OutCHKPT, or OutCHKPTQ in the Output list to execute. This may not always be possible to signal for batch scheduled jobs.

Param filename:

is the name of the output file

Param nint:

is the number of steps between dumps

Param nbeg:

is suffix of the first phase space dump

Param timer:

set to true turns on wall-clock timer for PS output

Param threads:

number of threads for binary writes

Public Functions

OutPSR(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Provided by derived class to generate some output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• mstep – is the current multistep level to decide whether or not to dump multisteps

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

• timer – set to true turns on wall-clock timer for PS output

• threads – is the thread count for binary writes

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

void write_thread(void)

Private Members

std::string filename

std::string fname

int nbeg

bool real4

int threads

bool timer

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Output

#include <Output.H>

Inheritence diagram for Output:

Collaboration diagram for Output:

Output routines.

These are designed to be run in a chain at each step. Each Output class is responsible for determining when to run. Initialization parameters are parsed on construction and available to the contructor for initializing control variables.

The class is also responsible for cycling through the component list and operating on each phase space accordingly. NB: the alternative would be to allow each component to define an output method. However, this can easily result in a chaos of specialized output streams and so I rejected this approach.

The stopWatch Timer is implemented in the base class but can be used by any derived class to time the output event. See OutPS for an example.

Subclassed by OrbTrace, OutAscii, OutCHKPT, OutCHKPTQ, OutCalbr, OutCoef, OutDiag, OutFrac, OutLog, OutMulti, OutPS, OutPSN, OutPSP, OutPSQ, OutPSR, OutRelaxation, OutVel

Public Functions

Output(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool final) = 0

Provided by derived class to generate some output.

inline std::set<std::string> unmatched()

Return unmatched parameters.

inline virtual ~Output()

Destructor.

Public Members

string id

Id string.

Protected Functions

virtual void initialize(void) = 0

Used to assign additional specific parameters, create storage, etc.

inline void nintsub_warning(const std::string &name)

nintsub warning message

Protected Attributes

const YAML::Node &conf

Configuration.

std::set<std::string> current_keys

Current YAML keys to check configuration.

int nint

Output frequency (should be used by derived classes)

int nintsub

Multistep output frequency (also used by derived classes)

Timer stopWatch

Output timer.

bool timer

Use output timer.

class OutputContainer

#include <OutputContainer.H>

Container class to hold the output chain of container methods.

Public Functions

void initialize()

Will read configuration stanza and initialize requested output methods.

OutputContainer()

Constructor.

void Run(int nstep, int mstep = std::numeric_limits<int>::max(), bool final = false)

Execute the all methods in the container.

~OutputContainer()

Destructor.

Public Members

std::list<std::shared_ptr<std::thread>> cproc

A list of concurrent threads for asychronous processing.

std::list<Output*> out

List of output methods currently active.

Private Members

double last

Last run time.

class OutRelaxation : public Output

#include <OutRelaxation.H>

Inheritence diagram for OutRelaxation:

Collaboration diagram for OutRelaxation:

Output routine for generateRelaxation (“external force”) module.

Public Functions

OutRelaxation(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool final = false)

Do some output.

Parameters:

• nstep – is the current time step index

• mstep – is the current multistep level to decide whether or not to dump multisteps

• final – should be true on last step to force output

inline virtual ~OutRelaxation()

Destructor.

Private Functions

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

Private Members

int epos

std::string fname

std::string suffix

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class OutVel : public Output

#include <OutVel.H>

Inheritence diagram for OutVel:

Collaboration diagram for OutVel:

Dump velocity flow coefficients at each interval

Param modelname:

is the file specifying the density model

Param name:

of the component to dump

Param nint:

is the frequency between file updates

Param dof:

is the number of degrees of freedom. 2=polar, 3 =spherical

Param lmax:

is the maximum harmonic order

Param nmax:

is the maximum radial order

Param rmapping:

is the coordinate mapping parameter for the expansion

Param rmin:

is the minimum radius for the density field

Param rmax:

is the maximum radius for the density field

Param ascl:

is the exponential scale length used for the “expon” density

Param delta:

is the cutoff radius used for the “expon” density

Param model:

defines the density for the orthogonal functions

Public Functions

OutVel(const YAML::Node &conf)

Constructor.

virtual void Run(int nstep, int mstep, bool last)

Generate the output.

Parameters:

• nstep – is the current time step used to decide whether or not to dump

• last – should be true on final step to force phase space dump indepentently of whether or not the frequency criterion is met

Private Types

using CoefType = Eigen::TensorMap<Eigen::Tensor<std::complex<double>, 3>>

Private Functions

void ExtendH5Coefs()

Extend the HDF5 file.

virtual void initialize(void)

Used to assign additional specific parameters, create storage, etc.

void WriteH5Coefs()

Initialize and write the HDF5 file.

void WriteH5Params(HighFive::File &file)

Write the parameters to the HDF5 file.

unsigned WriteH5Times(HighFive::Group &snaps, unsigned count)

Write the coefficient data to the HDF5 file.

Private Members

std::shared_ptr<BasisClasses::VelocityBasis> basis

The basis isntance.

CoefClasses::CoefsPtr coefs

int dof

std::string model

std::string modelname

std::string outfile

double prev = -std::numeric_limits<double>::max()

Component *tcomp

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class P2Quantile

#include <P2Quantile.H>

Implementation of the quantile estimator from:

Jain, Raj, and Imrich Chlamtac. “The P² algorithm for dynamic calculation of quantiles and histograms without storing observations.” Communications of the ACM 28, no. 10 (1985): 1076-1085.

Public Functions

inline void addValue(double x)

Add a new value.

inline double getQuantile()

Get the current quantile value.

inline P2Quantile(double prob = 0.5)

Quantile constructor where.

Parameters:

prob – is the quantile

inline void reset(double prob)

Change the probability value and reset.

Private Functions

inline double Linear(int i, int d)

inline double Parabolic(int i, double d)

Private Members

size_t count

Update count so far.

std::array<double, 5> dns

Marker updates.

std::array<int, 5> n

Marker indices.

std::array<double, 5> ns

Desired marker positions.

double p

Probability.

std::array<double, 5> q

Marker heights.

class ParseResult

#include <cxxopts.H>

Public Functions

inline const std::vector<KeyValue> &arguments() const

inline const std::string arguments_string() const

inline Iterator begin() const

inline size_t count(const std::string &o) const

inline const std::vector<KeyValue> &defaults() const

inline Iterator end() const

ParseResult &operator=(const ParseResult&) = default

ParseResult &operator=(ParseResult&&) = default

inline const OptionValue &operator[](const std::string &option) const

ParseResult() = default

ParseResult(const ParseResult&) = default

inline ParseResult(NameHashMap &&keys, ParsedHashMap &&values, std::vector<KeyValue> sequential, std::vector<KeyValue> default_opts, std::vector<std::string> &&unmatched_args)

inline const std::vector<std::string> &unmatched() const

Private Members

std::vector<KeyValue> m_defaults = {}

NameHashMap m_keys = {}

std::vector<KeyValue> m_sequential = {}

std::vector<std::string> m_unmatched = {}

ParsedHashMap m_values = {}

class Particle

#include <Particle.H>

Inheritence diagram for Particle:

Keeps track of all info for one particle.

The iattrib and dattrib vectors are used by individual components to carry additional parameters specific to different particle types.

Subclassed by PR::PParticle< float >, PR::PParticle< double >, PR::PParticle< real >

Public Types

typedef std::pair<unsigned short, unsigned short> speciesKey

Public Functions

inline unsigned getMPIBufSize(unsigned rsize, bool indexing)

Particle buffer size.

Particle()

Constructor.

Particle()

Particle(const Particle&)

Copy constructor.

Particle(const Particle &p)

Particle(unsigned niatr, unsigned ndatr)

Constructor with presized attribute lists.

void readAscii(bool indexing, int seq, std::istream *fin)

Read particles from file.

void readBinary(unsigned rsize, bool indexing, int seq, std::istream *in)

Read particles from file.

void writeAscii(bool indexing, bool accel, std::ostream *out)

Write a particle in ascii format.

void writeBinary(unsigned rsize, bool indexing, std::ostream *out) const

Write a particle in binary format (PSP)

void writeBinaryBuffered(unsigned rsize, bool indexing, std::ostream *out, ParticleBuffer &buf) const

Write a particle in binary format (PSP)

int writeBinaryMPI(char *buf, unsigned rsize, bool indexing)

Write a particle in binary format (PSP) to buffer for MPI.

void writeBinaryThreaded(unsigned rsize, bool indexing, ParticleBuffer &buf, int count) const

Write a particle in binary format (PSP), threaded version.

Public Members

double acc[3]

Acceleration vector.

vector<double> dattrib

Real (double) attributes.

float dtreq

Internal process time step (<0 means ignore)

float effort

Scale factor for partitioning work.

vector<int> iattrib

Integer attributes.

unsigned long indx

Index for ordering.

unsigned long key

Hash key.

unsigned level

Multistep level.

double mass

Mass of particle.

double pos[3]

Position vector.

double pot

Gravitational potential due to particles

double potext

Gravitational potential from external forces.

float scale

Internal size scale (<0 means ignore)

speciesKey skey

Species key (this is a cache value to prevent endless on-the-fly reconstruction of the species key)

unsigned tree

Tree key.

double vel[3]

Velocity vector.

Public Static Attributes

static const speciesKey defaultKey

static float effort_default

Default effort value.

Private Members

std::vector<char> buffer

MPI buffer.

class ParticleBuffer

#include <Particle.H>

Helper class for writing a buffer of particles.

Public Functions

inline char *operator()()

Raw access to particle buffer.

inline void operator++(int)

Increment the particle counter.

ParticleBuffer(unsigned rsize, bool indexing, const Particle *p)

Constructor.

inline unsigned pMemSize()

Get memory per particle.

inline void setLocation(int n)

Set location to the nth particle.

void writeBuffer(std::ostream *out, bool finish = false)

Write buffer.

Public Members

char *Loc

Buffer location.

const unsigned maxBufCount = 1048576

Buffer maximum particle count.

Protected Attributes

unsigned bufCount

Buffer particle count.

unsigned bufSize

Buffer size.

std::vector<char> charBuffer

Write buffer.

unsigned parSize

Particle size.

class ParticleFerry

#include <ParticleFerry.H>

For interprocess communication, need static structure for MPI mapping

Public Functions

inline size_t getBufsize()

Size needed for a single particle.

ParticleFerry(int nimax, int ndmax)

Constructor.

void particlePack(PartPtr in, char *buffer)

Pack particle into buffer. Caller provides buffer.

void particleUnpack(PartPtr out, char *buffer)

Unpack buffer into particle. Caller provides buffer.

PartPtr RecvParticle()

void SendParticle(PartPtr part)

Send and receive particles. Uses ParticleFerry internally maintained buffer

void ShipParticles(unsigned to, unsigned from, unsigned &total)

Send message to receiver: get ready for bulk shipment of particles.

~ParticleFerry()

Destructor.

Private Functions

void BufferRecv()

void BufferSend()

void particleBufInit()

Determine size of buffer needed.

Private Members

std::vector<char> buf

unsigned bufpos

size_t bufsiz

unsigned ibufcount

int idxpos

unsigned itotcount

int keypos

int ndmax

int nimax

int treepos

class ParticleReader

#include <ParticleReader.H>

Inheritence diagram for PR::ParticleReader:

Base class for reading particle phase space from any simulation.

Subclassed by PR::GadgetHDF5, PR::GadgetNative, PR::PSP, PR::Tipsy

Public Functions

virtual unsigned long CurrentNumber() = 0

Number of particles in the chosen type.

virtual double CurrentTime() = 0

Get current time.

virtual const Particle *firstParticle() = 0

Reset to beginning of particles for this component.

virtual std::vector<std::string> GetTypes() = 0

Return list of particle types.

virtual const Particle *nextParticle() = 0

Get the next particle.

inline ParticleReader()

Constructor: check for and set up MPI.

virtual void PrintSummary(std::ostream &out, bool stats = false, bool timeonly = false)

Print summary phase-space info.

virtual void SelectType(const std::string &type) = 0

Select a particular particle type and reset the iterator.

inline virtual ~ParticleReader()

Destructor.

Public Static Functions

static std::shared_ptr<ParticleReader> createReader(const std::string &type, const std::vector<std::string> &file, int myid = 0, bool verbose = false)

Create a shared pointer to derived instance of the desired type and return it.

static std::vector<std::vector<std::string>> parseFileList(const std::string &file, const std::string &delimit)

Order file list into batches at single times from file.

static std::vector<std::vector<std::string>> parseStringList(const std::vector<std::string> &file, const std::string &delimit)

Order file list into batches at single times from vector of strings.

Protected Attributes

int myid

int numprocs

bool use_mpi

Protected Static Attributes

static std::vector<std::string> readerTypes

class PCAbasis : public std::map<int, PCAelemPtr>

#include <EmpCylSL.H>

Inheritence diagram for EmpCylSL::PCAbasis:

Collaboration diagram for EmpCylSL::PCAbasis:

PCA basis structure for caching and diagnostics.

Public Functions

inline PCAbasis(int M, int n)

Constructor.

inline void reset()

Reset all variables to zero for accumulation.

Public Members

double Tmass

Mass in the accumulation.

unsigned Tnumb

Total number in accumulation.

class PCAelement

#include <EmpCylSL.H>

Data for each harmonic subspace.

Public Functions

inline PCAelement(int n)

Constructor.

inline void reset()

Zero all data.

Public Members

Eigen::MatrixXd covrJK

Eigen::VectorXd evalJK

All the public data.

Eigen::MatrixXd evecJK

Eigen::VectorXd meanJK

Eigen::VectorXd ratio

class Perfect

#include <staeckel.H>

Public Functions

double dFlambda(double)

double dFmu(double)

double Feff_lambda(double, double)

double Feff_mu(double, double)

double Flambda(double)

double Fmu(double)

Eigen::Vector3d force(Eigen::Vector3d&)

void Integrals(Phase&, double*, double*, double*)

void meridional_force(double, double, double*, double*)

double potential(Eigen::Vector3d&)

double second_integral(double, double, double, double, double)

inline void set_Perfect(double aa, double bb, double g, double m)

void to_ellipsoidal(double, double, double*, double*)

Protected Attributes

double a

double alpha

double b

double beta

double G

double M

double rho0

double W0

class PeriodicBC : public ExternalForce

#include <PeriodicBC.H>

Inheritence diagram for PeriodicBC:

Collaboration diagram for PeriodicBC:

Enforce periodic boundary conditions in a rectangular prism (box)

Param ctrname:

is the name of the component whose particles will be subject to the boundary condition

Param sx:

is the edge size in the x-direction

Param sy:

is the edge size in the y-direction

Param sz:

is the edge size in the z-direction

Param cx:

is the center offset in the x-direction

Param cy:

is the center offset in the y-direction

Param cz:

is the center offset in the z-direction

Param btype:

is a string of length that defines the type of boundary condition for each dimension (‘r’ for reflection bc, ‘p’ for periodic bc, ‘v’ is vacuum)

Public Functions

PeriodicBC(const YAML::Node &conf)

Constructor.

~PeriodicBC()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void userinfo()

Private Members

std::vector<double> atomic_weights

std::string bc

Component *c0

std::string comp_name

std::vector<double> L

double munit

std::normal_distribution norm

Pseudorandom generation.

std::vector<double> offset

double temp

double vunit

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class permutation

#include <permutation.H>

Make a permutation index. Share will MPI nodes if MPI is active.

This implementation should fall back politely to single processor use.

Public Functions

inline size_t operator[](size_t n) const

The permutation operator.

inline permutation(unsigned n, bool full = false)

Initialize and generate the identity permutation

Parameters:

Parameters:

• n – is the vecctor rank

• full – set to true will seed every value in the mt19937 state. This will produce better randomness at higher startup cost.

inline void shuffle()

Create and share the random permutation.

Private Functions

inline void seed19937()

Seed the Mersenne Twister from the random device.

Private Members

std::mt19937 g

std::vector<size_t> perm

class Phase

#include <phase.H>

Public Functions

double Accuracy(Phase&)

Phase advance(double&)

Phase advance_symplectic(double&)

inline Eigen::Vector3d Angular_Momentum(void)

void binread(std::istream &fp)

void binwrite(std::ostream &fp)

inline double Energy(void)

char *get_Integrator(void)

inline double get_Tolerance(void)

inline double get_Vscale(void)

inline double get_Xscale(void)

Phase integrate_to(double)

Phase integrate_to_symplectic(double, double)

double Jacobi(void)

inline double &Mass(void)

Phase &operator=(const Phase&)

Phase PC_advance(double)

Phase(const Phase&)

Phase(void)

inline double &Position(int i)

inline Eigen::Vector3d &Position(void)

void print(std::ostream &out)

Phase rotate_frame(double)

Phase rotate_view(double)

void set_Integrator(char*)

void set_PC(double, int)

inline void set_Tolerance(double tol)

inline void set_Vscale(double vv)

inline void set_Xscale(double xx)

inline double Speed(void)

inline double &Time(void)

inline double &Velocity(int i)

inline Eigen::Vector3d &Velocity(void)

inline double &Work(void)

Phase x_return_map(void)

Public Static Functions

static Eigen::Vector3d Default_Force(double, Eigen::Vector3d&, Eigen::Vector3d&)

static double Default_Potential(double, Eigen::Vector3d&)

static inline void Register_Potential(pot_func_ptr p, force_func_ptr f)

Public Static Attributes

static force_func_ptr Force

static pot_func_ptr Potential

Protected Attributes

double m

double t

Eigen::Vector3d v

double work

Eigen::Vector3d x

Protected Static Attributes

static ode_integrator integrator

static char integrator_name[8]

static symp_integrator mapping

static int potential_defined

static char symp_integrator_name[8]

static double tolerance

static double vscale

static double xscale

Friends

friend class Ensemble

class Plummer

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

inline double get_M(void)

inline double get_r0(void)

double potential(Eigen::Vector3d&)

inline void set_M(double m)

inline void set_Plummer(double r, double g, double m)

inline void set_r0(double r)

Protected Attributes

double G

double GM

double M

double r0

double r2

double r3

class PlummerSoft : public SoftKernel

#include <GravKernel.H>

Inheritence diagram for PlummerSoft:

Collaboration diagram for PlummerSoft:

Plummer softened gravity (infinite support)

Public Functions

virtual std::pair<double, double> operator()(double r, double eps)

Main operator returning enclosed mass and gravitational potential

class PlummerSphere : public AxiSymModel

#include <plummer.H>

Inheritence diagram for PlummerSphere:

Collaboration diagram for PlummerSphere:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

inline PlummerSphere(double RSCL = 1.0, double RMIN = 1.0e-6, double RMAX = 1.0e6, double MASS = 1.0)

Private Members

double dfac

double ffac

double mass

double rmax

double rmin

double rscl

template<typename coordinate_type, size_t dimensions>
class point

#include <KDtree.H>

Class for representing a point Coordinate_type must be a numeric type Field (weight) is a double

Public Functions

inline double distance(const point &pt) const

Returns the distance squared from this point to another point.

Parameters:

pt – another point

Returns:

distance squared from this point to the other point

inline coordinate_type get(size_t index) const

Returns the coordinate in the given dimension.

Parameters:

index – dimension index (zero based)

Returns:

coordinate in the given dimension

inline unsigned long indx() const

inline double mass() const

inline point()

Null initializer.

inline point(const point &p)

Copy constructor.

inline point(std::array<coordinate_type, dimensions> c, double m = 1, unsigned long indx = 0)

Constructor.

inline point(std::array<coordinate_type, dimensions> c, std::array<coordinate_type, dimensions> v, double m = 1, unsigned long indx = 0)

inline point(std::initializer_list<coordinate_type> list, double m = 1, unsigned long indx = 0)

List constructor.

inline point(std::initializer_list<coordinate_type> list, std::initializer_list<coordinate_type> vlst, double m = 1, unsigned long indx = 0)

inline double speed(const point &pt) const

Returns the squared velocity between this point to another point.

Parameters:

pt – another point

Returns:

squared speed between this point and the other point

inline coordinate_type vel(size_t index) const

Private Members

std::array<coordinate_type, dimensions> coords_

unsigned long indx_

double mass_

std::array<coordinate_type, dimensions> vels_

class Point_Quadrupole

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

double potential(Eigen::Vector3d&)

inline void set_Point_Quadrupole(double q)

Protected Attributes

double Q

class PolarBasis : public AxisymmetricBasis

#include <PolarBasis.H>

Inheritence diagram for PolarBasis:

Collaboration diagram for PolarBasis:

Defines a cylindrical basis with members specific to polar symmetry

Configurable parameters:

Other parameters may be defined and passed to any derived classes in addition to these.

Param scale:

is the characterisic scale of the basis

Param rmin:

is the minimum radius of the basis

Param rmax:

is the maximum radius of the basis

Param self_consistent:

true for updating the the coefficients at time steps

Param NO_M0:

true to omit the m=0 harmonic (default: false)

Param NO_M1:

true to omit the m=1 harmonic (default: false)

Param NO_MONO:

true to omit the monopole off-grid force algorithm (default: false)

Param EVEN_M:

true to include only even m harmonics (default: false)

Param M0_ONLY:

true to include only the m=0 harmonic (default: false)

Param M0_BACK:

true includes fixed m=0 harmonic (default: false)

Param ssfrac:

set > 0.0 to compute a fraction of particles only

Param playback:

true to replay from a coefficient file

Param coefMaster:

true to have only the root node read and distribute the coefficients

Subclassed by CBDisk, FlatDisk

Public Types

using ContribArray = std::vector<Eigen::VectorXd>

using MatrixM = std::vector<Eigen::MatrixXd>

using VectorM = std::vector<Eigen::VectorXd>

Public Functions

virtual void determine_acceleration_and_potential(void)

Required member to compute accleration and potential with threading.

The thread member must be supplied by the derived class

inline virtual void determine_coefficients(Component *c)

Compute coefficients with threading using the provided component.

virtual void determine_coefficients(void)

Required member to compute coeifficients with threading.

The thread member must be supplied by the derived class

virtual void determine_fields_at_point(double x, double y, double z, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotx, double *tpoty, double *tpotz)

Return the value for the fields in Cartesian coordinates.

virtual void determine_fields_at_point_cyl(double r, double z, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpotz, double *tpotp)

Returns the potential, its derivatives & density in cylindrical coords.

virtual void determine_fields_at_point_sph(double r, double theta, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpott, double *tpotp)

Returns the potential, its derivatives & density in spherical coords.

virtual void dump_coefs(ostream&)

Dump current coefficients.

virtual void dump_coefs_h5(const std::string &file)

Dump current coefficients into named HDF5 file.

virtual void get_acceleration_and_potential(Component *cC)

Required member to compute accelration and potential.

This implemenation should be fine for most cases

virtual void get_dens(double r, double z, Eigen::MatrixXd &d, int tid) = 0

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_dpotl(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &dpr, Eigen::MatrixXd &dpz, int tid) = 0

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• dpr – will be returned array in harmonics l and radial order n for the derivative of the potential

• dpz – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl(double r, double z, Eigen::MatrixXd &p, int tid) = 0

Get derivative of potential

Parameters:

• r – is the evaluation radius

• z – is the evaluation height

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(double r, double z, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid) = 0

Get the potential and density

Parameters:

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

inline virtual double knl(int, int)

Kernel value for recursion relation basis.

virtual void multistep_reset()

Update the multi time step coefficient table when moving particle i from level cur to level next

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

virtual void multistep_update_begin()

Execute to begin level shifts for particles.

Update the multi time step force algorithm when moving particle i from level cur to level next

virtual void multistep_update_finish()

Execute to finish level shifts for particles.

PolarBasis(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor (line contains the paramter list)

PolarBasis(const PolarBasis &p)

Copy constructor.

virtual ~PolarBasis()

Destructor.

Public Static Attributes

static bool NewCoefs

Use YAML header in coefficient file.

Protected Types

typedef std::shared_ptr<Eigen::VectorXd> VectorXdP

Matrices per thread for obtaining expansion coefficients.

Protected Functions

inline virtual std::tuple<double, double, double> background(double r, double z)

CUDA method for coefficient accumulation.

Background evaluation

virtual void check_range()

Provided by derived classes to check consistency.

void compute_multistep_coefficients()

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

virtual void *determine_acceleration_and_potential_thread(void *arg)

Thread method for accerlation compuation.

virtual void determine_coefficients_particles(void)

Compute the coefficients from particles.

virtual void determine_coefficients_playback(void)

Compute the coefficients from an table.

virtual void *determine_coefficients_thread(void *arg)

Thread method for coefficient accumulation.

void dump_coefs_all(ostream&)

Dump current coefficients (all multistep levels) For debugging …

void get_dens_coefs(int m, Eigen::VectorXd &coef, double &p)

Get density from coefficient vector.

virtual void get_pot(Eigen::MatrixXd &Vc, Eigen::MatrixXd &Vs, double r, double z) = 0

void get_pot_coefs(int m, const Eigen::VectorXd &coef, double &p, double &dpr, double &dprz)

Get potential and accel field values from coefficients.

void get_pot_coefs_safe(int m, const Eigen::VectorXd &coef, double &p, double &dpr, double &dprz, Eigen::MatrixXd &potd1, Eigen::MatrixXd &dpotr1, Eigen::MatrixXd &dpotz1)

Get potential and field values from coefficients (provide workspace for thread safety)

virtual double getRtable() = 0

Get table scale.

void init_pca()

Initialize for PCA variance computation.

virtual void initialize()

Initialize method.

inline void setup()

Should be called by derived classes after initialization (does nothing here)

void setup_accumulation(int mlevel)

Clear arrays for accumulation.

Protected Attributes

const unsigned int cmagic = 0xc0a57a2

Coefficient magic number.

bool coefMaster

Master node ships coefficients to hosts. True (default) implies that only the master node caches the coefficients for playback to save core memory. This is set in the config input using the ‘coefMaster: bool’ parameter. Once I am sure that there are no algorithmic issues, I will remove this as an option.

std::vector<Eigen::VectorXd> cosm

Work vectors for cosines for all values m

CoefMatrix covM

CoefVector covV

CoefClasses::CylCoefs cylCoefs

Coefficient container instance for writing HDF5.

double cylmass

std::vector<double> cylmass1

unsigned defSampT

Eigen::MatrixXd dend

Work matrix.

vector<vector<Eigen::MatrixXd>> differ1

For updating levels.

std::vector<std::vector<Eigen::MatrixXd>> differC1

std::vector<std::vector<Eigen::MatrixXd>> differS1

For updating levels.

std::vector<Eigen::MatrixXd> dpotR

Matrices per thread for obtaining derivative of potential field.

std::vector<Eigen::MatrixXd> dpotZ

bool EVEN_M

Flag use of even m harmonics only.

std::vector<std::vector<VectorXdP>> expcoef0

bool firstime_accel

Flag whether or not work space has been initialized for acceleration.

bool firstime_coef

Flag whether or not work space has been initialized for coefficients.

std::vector<unsigned> howmany

std::vector<std::vector<unsigned>> howmany1

bool is_flat

Model is flat.

double lastPlayTime

Last playback coefficient evaluation time.

bool M0_back

Flag fixed monopole.

bool M0_only

Use axisymmetric terms.

std::vector<double> massT

std::vector<std::vector<double>> massT1

double maxSNR

Eigen::VectorXd meanC

Expected coefficient values for RMS noise computation.

double minSNR

MixtureBasis *mix

For massive satellite simulations.

int mlim

Maximum harmonic order restriction.

double muse0

vector<double> muse1

Mass accumulation for PCA.

bool NO_M0

Omit monopole.

bool NO_M1

Flag drop m=1 term.

bool NO_MONO

Omit off-grid force algorithm.

std::normal_distribution nrand

std::vector<unsigned> numbT

std::vector<std::vector<unsigned>> numbT1

vector<double> pack

std::shared_ptr<CoefClasses::CylCoefs> playback

Coefficient playback instance. Using shared_ptr to avoid constructing a simple pointer or null instance

std::vector<Eigen::MatrixXd> potd

Matrices per thread for obtaining potential field.

double resetT

Time at last multistep reset.

std::mt19937 rgen

double rmax

The maximum radius.

double rmin

The minimum radius.

Eigen::MatrixXd rmsC

Expected squared coefficient values for RMS noise computation.

unsigned sampT

double scale

Basis linear scale for mapping.

unsigned int seedN

Pseudorandom generation.

bool self_consistent

Flag self_consitency.

std::vector<Eigen::VectorXd> sinm

Work vectors for sines for all values m

double ssfrac

Subsample fraction of particles.

bool subset

Flag to use subset.

std::vector<std::vector<Eigen::MatrixXd>> tvar

std::vector<Eigen::VectorXd> u

Work vectors to make recursion evaluations thread safe.

vector<double> unpack

std::vector<Eigen::MatrixXd> vc

std::vector<Eigen::MatrixXd> vs

std::vector<double> workC

std::vector<double> workC1

std::vector<double> workS

std::vector<double> workS1

Protected Static Attributes

static pthread_mutex_t cos_coef_lock

static pthread_mutex_t sin_coef_lock

static pthread_mutex_t used_lock

Mutexes for multithreading.

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Poly : public Eigen::VectorXd

#include <poly.H>

Inheritence diagram for Poly:

Collaboration diagram for Poly:

Public Functions

double deriv(double z)

double eval(double z)

inline int getorder(void) const

Poly &operator%=(Poly&)

Poly &operator&=(Poly&)

inline Poly operator+()

Poly &operator+=(Poly&)

Poly operator-()

Poly &operator-=(Poly&)

Poly &operator=(Poly&)

Poly(const Eigen::VectorXd&)

Poly(const Poly&)

Poly(int)

Poly(int, double*)

Poly(void)

void print(ostream&)

~Poly(void)

Private Functions

void reduce_order(void)

Private Members

int order

Friends

friend Poly operator%(Poly&, Poly&)

friend Poly operator&(Poly&, Poly&)

friend Poly operator+(Poly&, Poly&)

friend Poly operator-(Poly&, Poly&)

class PotAccel

#include <PotAccel.H>

Inheritence diagram for PotAccel:

Collaboration diagram for PotAccel:

Defines the basic components of the Force class.

This class provides the threading members. Derived classes must provide the per thread members for evaluating coeffients (if any) and acceleration.

Subclassed by Basis, Cube, Direct, ExternalForce, NoForce, Shells, SlabSL, TwoCenter

Public Types

enum Geometry

Possible geometries.

Values:

enumerator sphere

enumerator cylinder

enumerator cube

enumerator slab

enumerator table

enumerator other

typedef std::vector<std::time_t> TList

For timing.

Public Functions

inline bool atol(string &val)

For parameter parsing.

inline void ClearExternal()

Clear external flag.

inline bool cudaAware()

Cuda aware.

virtual void *determine_acceleration_and_potential_thread(void *arg) = 0

Multithreading implementation of the force computation.

inline virtual void determine_coefficients(Component *c)

virtual void determine_coefficients(void) = 0

Used by get_acceleration_and_potential to request that the expansion be performed.

virtual void *determine_coefficients_thread(void *arg) = 0

Multithreading implementation of the expansion computation.

inline virtual void dump_coefs(ostream &out)

Dump current coefficients.

inline virtual void dump_coefs_h5(const std::string &file)

void exp_thread_fork(bool coef)

Make some threads.

virtual void get_acceleration_and_potential(Component *c) = 0

The main force evaluation routine to be called by clients.

inline virtual double getScale()

Get current length scale.

inline bool HaveCoefDump()

Dump coefficients for this force?

void kill_mutex(pthread_mutex_t *m, const char *caller, const char *name)

Kill a mutex.

void make_mutex(pthread_mutex_t *m, const char *caller, const char *name)

Make a mutex.

inline virtual void multistep_debug()

Print debug info.

inline virtual void multistep_reset()

Reset data for multistep.

inline virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

inline virtual void multistep_update_begin()

Execute to begin level shifts for particles.

Update the multi time step force algorithm when moving particle i from level cur to level next

inline virtual void multistep_update_finish()

Execute to finish level shifts for particles.

inline bool NoCoefs()

Check whether coeffcients are not available.

PotAccel(Component *c0, const YAML::Node &conf)

Constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• line – is parsed and info is made available to derived classes on request

void print_timings(const string&, TList &tlist)

For timing the fraction spent in threaded force methods.

void print_timings(const string &label)

inline virtual void RegisterComponent(Component *c)

For access to parent component.

inline virtual void set_multistep_level(unsigned n)

Set the level for evaluating acceleration at level n.

inline void SetExternal()

Set external flag for current force call.

inline virtual void setScale(double s)

Set new length scale (default: 1.0)

void thread_timing_beg(int id)

void thread_timing_end(int id)

inline std::set<std::string> unmatched()

Get unaccounted keys.

inline int Used()

Return umber of particles used on last coefficient evaluation.

virtual ~PotAccel()

Destructor.

Public Members

bool compute

Flag to indicate that PCA variance matrix should be recomputed.

int dof

Dimension of the force vector (degrees of freedom)

Geometry geometry

sphere, cylinder, cube, slab, other

string id

Id string.

std::vector<int> use

Thread particle counter.

Public Static Attributes

static pthread_mutex_t cc_lock

Mutex used to be used in the threading implementations to lock PCA variance matrix for updating

static std::map<Geometry, std::string> geoname

Map from enum to string.

Protected Functions

virtual void initialize(void) = 0

Used by derived class to initialize any storage and parameters.

Protected Attributes

Component *cC

Current component pointer.

bool coef_dump

Coefficient dump flag (true if a useful dump_coefs member is defined)

Component *component

“Back” pointer to component that instantiated this force

const YAML::Node &conf

Contains parameter database.

bool cuda_aware

Cuda implementation is available for this source method. Otherwise, particle structures will be copied between the GPU and CPU at significant expanse

std::set<std::string> current_keys

Current YAML keys to check configuration.

unsigned mlevel

Current level for multistepping.

int nbodies

Number of bodies.

Call to return value for requested parameter name

bool play_back

Coefficient play back flag (true cached coefficients in use)

bool play_cnew

Compute new coefficients during play back (false by default)

double scale

Length scaling (not used for all methods)

TList timer_list

For thread timing.

int use_external

Set flag to add to external potential field.

int used

Number of particles used on last coefficient evaluation.

Private Members

pthread_t *t

thrd_pass_PotAccel *td

class PotRZ

#include <PotRZ.H>

Collaboration diagram for PotRZ:

Compute the inverse Hankel transform using the quasi-discrete Hankel transform to get the potential based on Gauss’ Law applied to the cylindrical Laplacian. The user supplies a functor containing the surface density. E.g. B&T equations 2.184-2.185.

Public Types

enum class Field

Which field.

Values:

enumerator potential

enumerator rforce

enumerator zforce

Public Functions

inline std::tuple<Eigen::VectorXd, Eigen::VectorXd> getKT(std::function<double(double)> func)

Evalute the forward transform: Sk.

inline double operator()(double r, double z, std::function<double(double)> dens, Field f = Field::potential)

Perform the evaluation at a particular r.

inline std::tuple<Eigen::VectorXd, Eigen::VectorXd> operator()(double z, std::function<double(double)> dens, Field f = Field::potential)

Perform the evaluation.

inline PotRZ(double R, int N, int M)

The gravitational potential by Hankel transform

Constructor

Protected Attributes

std::function<double(double)> mass

Sigma(R) functor instance stored by the constructor.

Private Members

int M

Sk u

QDHT v

QDHT vm

QDHT vp

template<typename real>
class PParticle

#include <PSP2.H>

Public Functions

inline void read(std::istream &in, int pcount, list<PSPstanza>::iterator spos)

inline void read(std::istream &in, int pcount, std::list<PSPstanza>::iterator spos)

Public Members

vector<real> datr

std::vector<real> datr

vector<int> iatr

std::vector<int> iatr

unsigned long indx

real mass

real phi

real pos[3]

real vel[3]

template<typename real>
class PParticle : public Particle

#include <ParticleReader.H>

Inheritence diagram for PR::PParticle:

Collaboration diagram for PR::PParticle:

Public Functions

inline void read(std::istream &in, int pcount, list<PSPstanza>::iterator spos)

inline void skip(std::istream &in, int pcount, list<PSPstanza>::iterator spos)

class progress_display

#include <Progress.H>

Public Functions

inline unsigned long count() const

inline unsigned long expected_count() const

inline unsigned long operator++()

inline unsigned long operator+=(unsigned long increment)

inline explicit progress_display(unsigned long expected_count_, std::ostream &os = std::cout, const std::string &s1 = "\n", const std::string &s2 = "", const std::string &s3 = "")

inline void restart(unsigned long expected_count_)

Private Functions

inline void display_tic()

Private Members

std::ostream &m_os

const std::string m_s1

const std::string m_s2

const std::string m_s3

class PseudoAccel

#include <PseudoAccel.H>

Public Functions

inline void add(double t, const Eigen::Vector3d &c, const Eigen::Vector3d &a)

Add a center element to the pseudo accelration estimator.

inline std::tuple<Eigen::Vector3d&, Eigen::Vector3d&, Eigen::Vector3d&> operator()()

inline PseudoAccel(unsigned int Nsize, bool center, bool axis)

Construct a pseudo acceleration estimator.

Private Types

using Elem = std::array<double, 7>

Queue of elements.

Private Members

Eigen::Vector3d accel = Eigen::Vector3d::Zero()

Storage.

bool AXIS = false

bool CENTER = false

Type flags.

Eigen::Vector3d domdt = Eigen::Vector3d::Zero()

unsigned int Nsize

Maximum number of time points.

Eigen::Vector3d omega = Eigen::Vector3d::Zero()

std::deque<Elem> queue

class PSP : public PR::ParticleReader

#include <ParticleReader.H>

Inheritence diagram for PR::PSP:

Collaboration diagram for PR::PSP:

Subclassed by PR::PSPout, PR::PSPspl

Public Functions

inline virtual unsigned long CurrentNumber()

Number of particles in current type.

inline virtual double CurrentTime()

Get snapshot time.

virtual const Particle *firstParticle() = 0

Particle access.

inline virtual PSPstanza *GetNamed(const std::string &name)

Set stanza to name.

virtual PSPstanza *GetStanza()

Reset to beginning of stanza list and return null if no stanzas.

inline virtual std::vector<std::string> GetTypes()

Return list of particle types.

virtual const Particle *nextParticle() = 0

Get the next particle.

virtual PSPstanza *NextStanza()

Get next stanza in list and return null at end;.

void PrintSummary(ostream &out, bool stats = false, bool timeonly = false)

Print summary phase-space info.

inline PSP(bool verbose)

Default constructor.

inline virtual void SelectType(const std::string &name)

Set to type.

void writePSP(std::ostream &out, bool real4)

Write a new PSP file.

inline virtual ~PSP()

Destructor.

Protected Functions

void ComputeStats()

inline void init()

Stream init.

void write_binary(std::ostream &out, list<PSPstanza>::iterator its, bool real4)

Protected Attributes

PSPstanza *cur

PParticle<double> dpart

PParticle<float> fpart

MasterHeader header

std::ifstream in

float mtot

Temporaries for stanza statistics.

int pcount

std::vector<double> pmax

std::vector<double> pmed

std::vector<double> pmin

std::list<PSPstanza>::iterator spos

std::list<PSPstanza> stanzas

bool VERBOSE

std::vector<double> vmax

std::vector<double> vmed

std::vector<double> vmin

Protected Static Attributes

static const unsigned long magic = 0xadbfabc0

static const unsigned long mmask = 0xf

static const unsigned long nmask = ~mmask

class PSP

#include <PSP2.H>

Inheritence diagram for PSP:

Collaboration diagram for PSP:

Subclassed by PSPout, PSPout, PSPspl, PSPspl

Public Functions

inline virtual SParticle *begin()

Define necessary member functions to be a valid container iterator

inline double CurrentTime()

Get snapshot time.

inline double CurrentTime()

Get snapshot time.

inline virtual SParticle *end()

inline virtual PSPstanza *GetNamed(const std::string &name)

Set stanza to name.

inline virtual PSPstanza *GetNamed(const std::string &name)

Set stanza to name.

virtual SParticle *GetParticle() = 0

Reset to beginning of particles for this component.

virtual SParticle *GetParticle() = 0

Reset to beginning of particles for this component.

virtual PSPstanza *GetStanza()

Reset to beginning of stanza list and return null if no stanzas.

virtual PSPstanza *GetStanza()

Reset to beginning of stanza list and return null if no stanzas.

virtual SParticle *NextParticle() = 0

Get next particle and return null at end.

virtual SParticle *NextParticle() = 0

Get next particle and return null at end.

virtual PSPstanza *NextStanza()

Get next stanza in list and return null at end;.

virtual PSPstanza *NextStanza()

Get next stanza in list and return null at end;.

inline virtual bool operator!=(SParticle *const &other)

inline virtual SParticle *operator++()

inline virtual bool operator==(SParticle *const &other)

void PrintSummary(ostream &out, bool stats = false, bool timeonly = false)

Print summary phase-space info.

void PrintSummary(std::ostream &out, bool stats = false, bool timeonly = false)

Print summary phase-space info.

inline PSP(bool verbose)

Default constructor.

inline PSP(bool verbose)

Default constructor.

inline PSP(bool verbose, std::string new_dir)

Constructor specifying current working data directory.

inline PSP(bool verbose, std::string new_dir)

Constructor specifying current working data directory.

void writePSP(std::ostream &out, bool real4)

Write a new PSP file.

void writePSP(std::ostream &out, bool real4)

Write a new PSP file.

inline virtual ~PSP()

Destructor.

inline virtual ~PSP()

Destructor.

Public Static Functions

static std::shared_ptr<PSP> getPSP(const std::string &file, const std::string dir = "", bool verbose = false)

PSP factory: choose type based on file name.

Protected Functions

void check_dirname()

Append ‘/’ if necessary.

void check_dirname()

Append ‘/’ if necessary.

void ComputeStats()

void ComputeStats()

inline void init()

Stream init.

inline void init()

Stream init.

void write_binary(std::ostream &out, list<PSPstanza>::iterator its, bool real4)

void write_binary(std::ostream &out, std::list<PSPstanza>::iterator its, bool real4)

Protected Attributes

PSPstanza *cur

MasterHeader header

std::ifstream in

float mtot

Temporaries for stanza statistics.

std::string new_dir

SParticle part

int pcount

std::vector<float> pmax

std::vector<float> pmed

std::vector<float> pmin

list<PSPstanza>::iterator spos

std::list<PSPstanza>::iterator spos

list<PSPstanza> stanzas

std::list<PSPstanza> stanzas

bool VERBOSE

std::vector<float> vmax

std::vector<float> vmed

std::vector<float> vmin

Protected Static Attributes

static const unsigned long magic = 0xadbfabc0

static const unsigned long mmask = 0xf

static const unsigned long nmask = ~mmask

class PSPout : public PR::PSP

#include <ParticleReader.H>

Inheritence diagram for PR::PSPout:

Collaboration diagram for PR::PSPout:

Class to access a full PSP file (OUT)

Public Functions

virtual const Particle *firstParticle()

Particle access.

virtual const Particle *nextParticle()

Get the next particle.

PSPout(const std::vector<std::string> &file, bool verbose = false)

Constructor.

inline virtual ~PSPout()

Destructor.

Private Members

streampos pos

class PSPout : public PSP, public PSP

#include <PSP2.H>

Inheritence diagram for PSPout:

Collaboration diagram for PSPout:

Class to access a full PSP file (OUT)

Public Functions

virtual SParticle *GetParticle()

Reset to beginning of particles for this component.

virtual SParticle *GetParticle()

Iterators.

virtual SParticle *NextParticle()

Get next particle and return null at end.

virtual SParticle *NextParticle()

Get next particle and return null at end.

PSPout(const std::string &file, bool verbose = false)

PSPout(const std::string &file, bool verbose = false)

inline virtual ~PSPout()

Destructor.

inline virtual ~PSPout()

Destructor.

Private Members

streampos pos

std::streampos pos

class PSPspl : public PR::PSP

#include <ParticleReader.H>

Inheritence diagram for PR::PSPspl:

Collaboration diagram for PR::PSPspl:

Class to access a SPLIT PSP file (SPL)

Public Functions

virtual const Particle *firstParticle()

Particle access.

virtual const Particle *nextParticle()

Get the next particle.

PSPspl(const std::vector<std::string> &file, bool verbose = false)

Constuctors.

inline virtual ~PSPspl()

Destructor.

Private Functions

void openNextBlob()

Open next file part.

Private Members

unsigned int fcount

std::vector<std::string>::iterator fit

unsigned int N

class PSPspl : public PSP, public PSP

#include <PSP2.H>

Inheritence diagram for PSPspl:

Collaboration diagram for PSPspl:

Class to access a SPLIT PSP file (SPL)

Public Functions

virtual SParticle *GetParticle()

Reset to beginning of particles for this component.

virtual SParticle *GetParticle()

Reset to beginning of particles for this component.

virtual SParticle *NextParticle()

Get next particle and return null at end.

virtual SParticle *NextParticle()

Get next particle and return null at end.

PSPspl(const std::string &file, const std::string dir = "", bool verbose = false)

Constuctors.

PSPspl(const std::string &file, const std::string dir = "", bool verbose = false)

Constuctors.

inline virtual ~PSPspl()

Destructor.

inline virtual ~PSPspl()

Destructor.

Private Functions

void openNextBlob()

Open next file part.

void openNextBlob()

Open next file part.

Private Members

unsigned int fcount

std::vector<std::string>::iterator fit

unsigned int N

class PSPstanza

#include <ParticleReader.H>

Collaboration diagram for PR::PSPstanza:

Public Functions

inline bool operator==(const PSPstanza &x) const

Public Members

ComponentHeader comp

std::string cparam

std::string fparam

std::string id

size_t index_size

std::string name

std::vector<std::string> nparts

streampos pos

streampos pspos

size_t r_size

class PSPstanza

#include <PSP2.H>

Collaboration diagram for PSPstanza:

Public Functions

inline bool operator==(const PSPstanza &x) const

inline bool operator==(const PSPstanza &x) const

Public Members

ComponentHeader comp

std::string cparam

std::string fparam

std::string id

size_t index_size

std::string name

std::vector<std::string> nparts

streampos pos

std::streampos pos

streampos pspos

std::streampos pspos

size_t r_size

class PVQuad : public Legendre

#include <CauchyPV.H>

Inheritence diagram for PVQuad:

Collaboration diagram for PVQuad:

Public Functions

inline double mu(int i)

inline double norm(int i)

inline Eigen::VectorXd &ovec(int i)

PVQuad(int N = 10)

inline Eigen::VectorXd &return_coefs(Eigen::VectorXd &input)

Eigen::VectorXd &return_coefs(std::function<double(double)> func)

inline double return_pv(double lambda)

inline double return_pv(double lambda, Eigen::VectorXd &input)

inline double return_pv(double lambda, std::function<double(double)> func)

inline double root(int i)

Private Functions

Eigen::VectorXd &get_coefs(Eigen::VectorXd&)

void get_eigenvalues(void)

double get_integral(double)

void get_orthopolies(void)

inline double q0(double x)

Private Members

Eigen::VectorXd chrs

Eigen::VectorXd coefs

Eigen::VectorXd eign

int n

Eigen::VectorXd nrml

std::vector<Eigen::VectorXd> poly

class PyModel : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for PyModel:

Collaboration diagram for PyModel:

A user-defined Python model.

Public Functions

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

inline PyModel(std::string &pyname)

Private Members

std::shared_ptr<DiskDensityFunc> pyDens

class QDHT

#include <QDHT.H>

Hankel transform based on the QDHT algorithm

See: “Computation of quasi-discrete Hankel transforms of the integer

order for propagating optical wave fields” Manuel Guizar-Sicairos and Julio C. Guitierrez-Vega J. Opt. Soc. Am. A 21 (1) 53-58 (2004)

Public Functions

void check()

Check solution.

inline const Eigen::VectorXd &getK()

Compute the transform coordinates (e.g. spatial frequencies)

inline const Eigen::VectorXd &getR()

Compute the input coordinates (e.g. radii)

double operator()(double r, Eigen::VectorXd &v)

Inverse Hankel transform at r.

Eigen::VectorXd operator()(Eigen::VectorXd &v, bool forward = true)

Compute the forward or backward Hankel transform.

inline QDHT()

Null constructor.

QDHT(int M, int N, double R)

Constructor

Parameters:

• M – is the harmonic order

• N – is the number of knots

• R – is the radius at which the input function is zero

inline ~QDHT()

Destructor.

Public Static Attributes

static bool debug

For checking unitarity (default: false)

Private Members

Eigen::VectorXd Jp

Jp vector.

Eigen::VectorXd k

int N

N is number of knots.

double nu

nu is Bessel function order

double R

Dimension 1 scale.

Eigen::VectorXd r

R and K vectors.

double S

Total bandwidth.

Eigen::MatrixXd T

Transform matrix.

double V

Dimension 2 scale.

Eigen::VectorXd zeros

Will contain the zeros of the Bessel function of order nu.

class QPDistF

#include <QPDistF.H>

Compute distribution function for axisymmetric models using quadratic programming techniques

Public Functions

void compute_distribution(void)

double d2fdE2(double E, double L)

double d2fdE2_EK(double E, double K)

double d2fdEK_EK(double E, double K)

double d2fdK2_EK(double E, double K)

double dfdE(double E, double L)

double dfdE_EK(double E, double K)

double dfdK_EK(double E, double K)

double dfdL(double E, double L)

double distf(double E, double L)

double distf_EK(double E, double K)

void dump_cdf(const string &file)

pair<double, double> gen_EK(double r1, double r2)

inline void get_objective(double *OBJ0, double *OBJ, int *IFLG)

void make_cdf(int ENUM, int KNUM, double KTOL = 1.0e-3)

QPDistF(AxiSymModPtr T, AxiSymModPtr H, double rmmax, double remax, int egrid, int kgrid, int mgrid, double sigma = 2.0, double lambda = 0.0, double alpha = -4.0, double beta = 1.0, double gama = 1.0, double roff = 0.01, double eoff = 0.5, double koff = 0.5, double kmin = 0.0, double kmax = 1.0, int nint = 80, int numt = 40)

Constructor

Parameters:

• T – is a pointer to an axisymmetric model (2 or 3 dim)

• H – is a pointer to an axisymmetric model (3-d halo)

• rmmax – is the maximum radius for the radial QP grid

• remax – determines the maximum energy Phi(remax) for the energy grid

• egrid – is the number of energy knots for Gaussian kernels

• kgrid – is the number of kappa knots for Gaussian kernels

• mgrid – is the number of radial knots for density evaluation

• sigma – is the fraction over the spacing for the kernel width

• lambda – is the penalty coefficient in powers of kappa

• alpha – is the exponent for powers of kappa

• beta – is the power law exponent for radial-grid spacing in mass fraction

• gama – is the power law exponent for energy-grid spacing

• roff – is the offset of the mass zero point

• eoff – is the offset of the energy grid from Emin

• koff – is the offset of the energy grid from Kmin

• kmin – is the minimum value of kappa

• kmax – is the maximum value of kappa

• nint – is the number of knots in the velocity magnitude integral

• numt – is the number of knots in the velocity angular integral

QPDistF(AxiSymModPtr T, double rmmax, double remax, int egrid, int kgrid, int mgrid, double sigma = 2.0, double lambda = 0.0, double alpha = -4.0, double beta = 1.0, double gama = 1.0, double roff = 0.01, double eoff = 0.5, double koff = 0.5, double kmin = 0.0, double kmax = 1.0, int nint = 80, int numt = 40)

QPDistF(AxiSymModPtr T, string file)

void read_state(string &name)

void set_verbose(int verbosity)

void set_verbose(void)

void write_state(string &name)

~QPDistF(void)

Public Static Attributes

static double FSIGE

static double FSIGK

static int ITERMAX

static double ITERTOL

static bool MassEGrid

static bool MassLinear

Private Types

typedef pair<double, ip> elem

typedef pair<int, int> ip

Private Functions

inline void bomb(char *s)

double kernel(double x, double y, double x0, double y0, double sx, double sy)

double kernel_x(double x, double y, double x0, double y0, double sx, double sy)

double kernel_x2(double x, double y, double x0, double y0, double sx, double sy)

double kernel_xy(double x, double y, double x0, double y0, double sx, double sy)

double kernel_y(double x, double y, double x0, double y0, double sx, double sy)

double kernel_y2(double x, double y, double x0, double y0, double sx, double sy)

Private Members

double ALPHA

double BETA

vector<double> cdf

bool df_computed

int EGRID

Eigen::VectorXd Egrid

double Emax

double Emin

double EOFF

double GAMA

int IFAIL

Eigen::VectorXd JMAX

Eigen::VectorXd JMAX2

Eigen::VectorXd JMAXE

int KGRID

Eigen::VectorXd Kgrid

double KMAX

double KMIN

double KOFF

double LAMBDA

int MGRID

int NINT

int NJMAX

bool nt

int NUME

int NUMK

int NUMT

double obj

double obj0

std::shared_ptr<SphericalOrbit> orb

vector<double> pdf

multimap<double, ip> realz

double REMAX

double RMMAX

double ROFF

double SIGMA

Eigen::VectorXd sigma_E

Eigen::VectorXd sigma_K

std::shared_ptr<AxiSymModel> t

double TOLE

double TOLK

int verbose

Eigen::VectorXd X

template<typename T>
class QuadLS

#include <QuadLS.H>

Public Functions

inline std::tuple<double, double, double> coefs() const

Access coefficients.

inline double operator()(const double x) const

Evaluate the quadratic function.

inline QuadLS()

Null constructor.

inline QuadLS(const T &x, const T &y)

Constructor.

inline virtual ~QuadLS()

Destructor.

Private Functions

inline void fit(const T &x, const T &y)

class Quadrupole_Bar

#include <models.H>

Public Functions

Eigen::Vector3d force(Eigen::Vector3d&)

double potential(Eigen::Vector3d&)

inline void set_Quadrupole_Bar(double G, double Q, double length)

Protected Attributes

double a2

double GQ

class RegularOrbit

#include <orbit.H>

Inheritence diagram for RegularOrbit:

Subclassed by SphericalOrbit

Public Functions

void bomb(const char *s)

void bomb(const string &s)

virtual double get_action(const int) = 0

virtual double get_angle(const int, const double) = 0

virtual double get_freq(const int) = 0

void warn(const string &fct, const string &msg)

inline virtual ~RegularOrbit()

Public Members

Eigen::Vector3d action

bool action_defined

bool angle_defined

bool biorth_defined

int dof

Eigen::Vector3d freq

bool freq_defined

bool model_defined

std::string OrbitID

class RGrid

Grid to hold tabulated basis.

Public Members

int nmax

Eigen::MatrixXd rw

Eigen::MatrixXd rw2

template<typename T, typename Container = std::vector<T>, typename Iterator = typename Container::iterator>
class RingIterator

#include <Circular.H>

Public Types

using difference_type = std::ptrdiff_t

using iterator_category = std::bidirectional_iterator_tag

Add typedefs for std::iterator_traits.

using pointer = T*

using reference = T&

using value_type = T

Public Functions

inline RingIterator erase()

Erase the current element.

inline RingIterator insert(const T &x)

Insert a new element at the current position.

inline bool operator!=(const RingIterator &x) const

Test for inequality.

inline T operator*() const

Return current data element.

inline RingIterator &operator++()

Pre-increment operator.

inline RingIterator operator++(int)

Post-increment operator.

inline RingIterator &operator--()

Pre-decrement operator.

inline RingIterator operator--(int)

Post-decrement operator.

inline Iterator operator->() const

Return current iterator.

inline bool operator==(const RingIterator &x) const

Test for equality.

inline RingIterator(Container &v)

Create from v and position at the beginning.

inline RingIterator(Container &v, const Iterator &i)

Create from v and begin at iterator i.

inline RingIterator(Container &v, const Iterator &i, const Iterator &j)

Create from v using positions i through j.

inline RingIterator(Container &v, size_t i)

Create from v and begin at position i.

Private Members

Iterator begin

Iterator cursor

Container &data

Iterator end

class RK4

#include <RK4.H>

RK4 takes one 4th-order Runge-Kutta step.

Public Types

using Force = std::function<Vref(double, Vref)>

Functoid defintion for the force.

using Vref = Eigen::Ref<Eigen::VectorXd>

Reference to an Eigen vector.

Public Functions

inline RK4(Force force)

Constructor defining the force function.

inline double step(Vref x, double t, double dt)

Take a single RK4 step.

Private Members

Force force

Force instance.

class Roots

Cache roots for spherical Bessel functions.

Public Functions

inline Roots(int L, int nmax)

inline ~Roots()

Public Members

Eigen::VectorXd a

int l

int n

class RUN

#include <massmodel.H>

A one-dimensional profile.

Public Functions

inline void resize(int N)

inline RUN()

Simple constructor. Use value of num to check for initialization.

Public Members

int num

Eigen::VectorXd x

Eigen::VectorXd y

Eigen::VectorXd y2

class RunningTime

#include <RunningTime.H>

Collaboration diagram for RunningTime:

Public Functions

inline double getLast()

inline double getTavg()

inline double getTime()

inline RunningTime()

inline RunningTime(unsigned n)

inline void Start()

inline void Stop(bool final = true)

Private Functions

inline void append()

inline void initialize(unsigned n)

inline void lap()

Private Members

double accum

std::deque<double> boxcar

double current

double last

unsigned nkeep

Timer timer

double value

class ScatterMFP : public ExternalForce

#include <ScatterMFP.H>

Inheritence diagram for ScatterMFP:

Collaboration diagram for ScatterMFP:

Compute acceleration based on mean free path (dark matter pressure)

Will probably never use this again …

Public Functions

ScatterMFP(const YAML::Node &conf)

Constructor.

~ScatterMFP()

Destructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void get_acceleration_and_potential(Component *C)

Will be called by clients to evaluate force.

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

Component *c

int cntacc

vector<int> cntr

string comp_id

double dr

double *dtau

double *dtau1

int mfp_index

std::normal_distribution norm

int nscat

double rmax

vector<rpair> rr2

double tau

double tauscat

int tautab

std::uniform_real_distribution unif

Pseudorandom generation.

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Sech2 : public OneDModel

#include <massmodel1d.H>

Inheritence diagram for Sech2:

Collaboration diagram for Sech2:

Public Functions

inline virtual double dfde(const double E, const double p)

inline virtual double dfdv(const double E, const double p)

inline virtual double distf(const double E, const double p)

inline virtual double get_density(const double x, const double y, const double z)

The density at (x, y, z)

inline virtual double get_density(const double z)

inline virtual double get_dpot(const double z)

inline virtual double get_dpot2(const double z)

inline virtual double get_mass(const double x, const double y, const double z)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

inline virtual double get_mass(const double z)

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double x, const double y, const double z)

The potential at (x, y, z)

inline virtual double get_pot(const double z)

inline virtual tuple<double, double> get_pot_dpot(const double z)

inline virtual double get_scale_height(void)

inline Sech2(const double DISPZ, const double DISPX = 1.0)

inline Sech2(void)

Public Static Functions

static inline void set_hmax(double hmax)

Private Members

double dispx

double dispz

double h

double norm

Private Static Attributes

static double HMAX

class Sech2Halo : public OneDModelTable

#include <massmodel1d.H>

Inheritence diagram for Sech2Halo:

Collaboration diagram for Sech2Halo:

Public Functions

inline virtual double dfde(const double E, const double p = 0.0)

inline virtual double dfdv(const double E, const double p = 0.0)

inline virtual double distf(const double E, const double p = 0.0)

inline virtual double get_dpot(const double z)

inline virtual double get_dpot2(const double z)

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double z)

inline virtual std::tuple<double, double> get_pot_dpot(const double z)

inline double get_rho0(void)

inline double get_rho0_halo(void)

inline virtual double get_scale_height(void)

inline double get_scale_height_halo(void)

Sech2Halo(const double DISPZ, const double DRATIO, const double HRATIO, const double DISPX = 1.0)

inline Sech2Halo(void)

Public Static Functions

static inline void set_hmax(double hmax)

Public Static Attributes

static bool MU

static int NTABLE

static double OFFSET

Private Functions

void reset()

Private Members

double dispx

double dispz

double dratio

double h

double hh

double hmax

double hratio

bool model_computed

double norm

double rho0

double rho0h

Private Static Attributes

static double HMAX

class Sech2mu : public OneDModel

#include <massmodel1d.H>

Inheritence diagram for Sech2mu:

Collaboration diagram for Sech2mu:

Public Functions

inline virtual double dfde(const double E, const double p)

inline virtual double dfdv(const double E, const double p)

inline virtual double distf(const double E, const double p)

inline virtual double get_density(const double x, const double y, const double z)

The density at (x, y, z)

inline virtual double get_density(const double z)

inline virtual double get_dpot(const double z)

inline virtual double get_dpot2(const double z)

inline virtual double get_mass(const double x, const double y, const double z)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

inline virtual double get_mass(const double z)

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double x, const double y, const double z)

The potential at (x, y, z)

inline virtual double get_pot(const double z)

inline void get_pot_dpot(const double z, double &p, double &dp)

inline virtual double get_scale_height(void)

inline Sech2mu(const double DISPZ, const double H, const double DISPX = 1.0)

inline Sech2mu(void)

inline void setMu(double Sigma0)

Public Static Functions

static inline void set_hmax(double hmax)

Private Members

double dispx

double dispz

double dnorm

double fnorm

double h

double knorm

double mu

Private Static Attributes

static double HMAX

class SechMap : public SLGridSlab::CoordMap

Inheritence diagram for SLGridSlab::SechMap:

Collaboration diagram for SLGridSlab::SechMap:

x = z/sqrt(z^2 + H^2)

Public Functions

virtual double d_xi_to_z(double z)

Jacobian of the transformation.

inline SechMap(double H)

virtual double xi_to_z(double z)

Convert from mapped coordinate back to vertical.

virtual double z_to_xi(double z)

Convert from vertical to mapped coordinate.

class Shells : public PotAccel

#include <Shells.H>

Inheritence diagram for Shells:

Collaboration diagram for Shells:

Computes the potential, acceleration and density using spherical, Lagrangian shells

Settable parameters:

Param nsample:

is the number of particles per sample for the shell boundary computation.

Param nselect:

is the number of particle intervals in computing the cumulative distribution

Public Functions

virtual void get_acceleration_and_potential(Component*)

The main force call.

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

virtual void multistep_update_begin()

Execute to begin level shifts for particles.

virtual void multistep_update_finish()

Execute to finish level shifts for particles.

Shells(Component *c0, const YAML::Node &conf)

The constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• conf – passes in any explicit parameters

virtual ~Shells()

The constructor.

Private Types

typedef pair<double, double> Dpair

Private Functions

void determine_acceleration_and_potential(void)

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

virtual void determine_coefficients(void)

Used by get_acceleration_and_potential to request that the expansion be performed.

virtual void *determine_coefficients_thread(void *arg)

Multithreading implementation of the expansion computation.

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

bool firstime_accel

vector<Dpair> grid

std::vector<std::vector<int>> igrid

std::vector<int> igrid1

std::vector<std::vector<int>> igridT

std::vector<std::map<int, double>> mgrid

vector<double> mgrid0

vector<double> mgrid1

std::vector<std::vector<double>> mgridT

int nsample

int nselect

vector<double> pgrid0

vector<int> rcvcts

vector<int> rdispl

std::vector<std::map<int, double>> rgrid

vector<double> rgrid0

vector<double> rgrid1

std::vector<std::vector<double>> rgridT

vector<int> rnumbr

vector<int> sdispl

bool self_consistent

vector<int> sndcts

vector<int> snumbr

std::vector<std::vector<int>> update_fr

std::vector<std::vector<int>> update_ii

std::vector<std::vector<int>> update_to

int used1

vector<int> usedT

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

template<typename T, bool B>
struct SignedCheck

template<typename T>
struct SignedCheck<T, false>

#include <cxxopts.H>

Public Functions

template<typename U>
inline void operator()(bool, U, const std::string&) const

template<typename T>
struct SignedCheck<T, true>

#include <cxxopts.H>

Public Functions

template<typename U>
inline void operator()(bool negative, U u, const std::string &text)

class SimAnn

#include <SimAnn.H>

Public Functions

double anneal(const int iters = -1)

Perform the annealing.

inline double Boltzmann(const double k = -1.0)

inline std::vector<double> current()

inline int dwell(const int d = -1)

inline void initial(std::vector<double> &xi)

inline int iterations(const int m = -1)

inline double jump(const double j = -1.0)

inline double learning_rate(const double r = -1.0)

double melt(const int iters = -1)

Look for the melting temprature.

inline std::vector<double> optimum()

inline double range(const double r = -1.0)

inline void report_states(std::ostream &out)

inline void save_states(const std::string &name)

inline void set_map(FuncMap f)

Set map function.

void set_up(Func1d f, const int seed = 10)

Set the objective function.

inline SimAnn()

SimAnn(std::function<double(std::vector<double>&)> f, const int d = 1)

inline double temperature(const double t = -1.0)

inline ~SimAnn()

Private Types

typedef std::function<double(std::vector<double>&)> Func1d

typedef std::function<std::vector<double>(std::vector<double>&)> FuncMap

Private Functions

int equilibrate(const double t, const int n)

void log_state(int)

Private Members

double c_jump

int ddwell

double dt

double dy

int err

std::string fname

int fsave

Func1d func

std::mt19937 gen

double K

int maxit

std::uniform_real_distribution<double> number_01

std::uniform_real_distribution<double> number_range

FuncMap pmap

double rho

double rrange

std::ostream *str

double t0

double tscale

std::vector<double> x

std::vector<double> xbest

std::vector<double> xnew

double y

double ybest

class SingIsothermalSphere : public AxiSymModel

#include <isothermal.H>

Inheritence diagram for SingIsothermalSphere:

Collaboration diagram for SingIsothermalSphere:

Public Functions

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Required member functions.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

Addiional member functions.

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

inline SingIsothermalSphere(double VROT = 1.0, double RMIN = 1.0e-6, double RMAX = 1.0e6)

Constructor.

Private Members

double F

double rmax

double rmin

double rot

class Sk

#include <PotRZ.H>

Collaboration diagram for PotRZ::Sk:

Compute the Hankel transform of the target density.

Public Functions

inline std::tuple<Eigen::VectorXd, Eigen::VectorXd> operator()(std::function<double(double)> dens)

Perform the transform.

inline Sk()

Null constructor.

inline Sk(double R, int N, int M)

Constructor with R=cutoff, N=number of knots, M=harmonic order, and a=parameter vector

Protected Attributes

int N

QDHT v

class SlabModel

#include <SLGridMP2.H>

Target density models for slabs.

Public Functions

virtual double dens(double z) = 0

Return the surface density.

virtual double dpot(double z) = 0

Return the derivative of the potential.

inline std::string ID() const

Get model ID.

virtual double pot(double z) = 0

Return the potential.

Public Static Functions

static std::shared_ptr<SlabModel> createModel(const std::string type)

Factory constructor.

Protected Attributes

std::string id

For cache identification.

class SlabSL : public PotAccel

#include <SlabSL.H>

Inheritence diagram for SlabSL:

Collaboration diagram for SlabSL:

This routine computes the potential, acceleration and density using expansion periodic in X & Y and outgoing vacuum boundary condtions in Z

Public Functions

virtual void dump_coefs_h5(const std::string &file)

Coefficient output.

SlabSL(Component *c0, const YAML::Node &conf)

Constructor.

virtual ~SlabSL()

Destructor.

Public Members

std::string id

Id string.

Protected Functions

virtual void initialize(void)

Parse parameters and initialize on first call.

Protected Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

Private Types

using coefType = Eigen::Tensor<std::complex<double>, 3>

Coefficients are a 3-tensor.

using coefTypePtr = std::shared_ptr<coefType>

Interpolation arrays.

Private Functions

void compute_multistep_coefficients()

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

virtual void determine_coefficients(void)

Usual evaluation interface.

virtual void *determine_coefficients_thread(void *arg)

Threading.

virtual void get_acceleration_and_potential(Component*)

The main force evaluation routine to be called by clients.

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

virtual void multistep_update_begin()

Update the multi time step coefficient table when moving particle i from level cur to level next

virtual void multistep_update_finish()

Execute to finish level shifts for particles.

inline void swap_coefs(std::vector<coefType> &from, std::vector<coefType> &to)

Swap coefficients.

Private Members

SlabSLCoefHeader coefheader

double dfac

std::vector<std::vector<coefType>> differ1

For updating levels.

std::vector<coefType> expccof

Current coefficient tensor.

std::vector<coefTypePtr> expccofL

std::vector<coefTypePtr> expccofN

std::vector<coefType> expccofP

std::shared_ptr<SLGridSlab> grid

double hslab

int imx

int imy

int imz

int jmax

std::complex<double> kfac

int ngrid = 1000

Default number of grid points for SLGridSlab.

int nmaxx

int nmaxy

int nmaxz

int nminx

int nminy

int nnmax

std::vector<std::complex<double>> pack

CoefClasses::SlabCoefs slabCoefs

Coefficient container instance for writing HDF5.

std::string type = "isothermal"

Default slab type (must be “isothermal”, “parabolic”, or “constant”)

std::vector<std::complex<double>> unpack

std::vector<Eigen::VectorXd> zfrc

double zmax

std::vector<Eigen::VectorXd> zpot

Private Static Attributes

static const int ID = 1

struct SlabSLCoefHeader

Header structure for Sturm-Liouville slab expansion Used for deprecated native coefficient files

Public Members

double h

int jmax

int nmaxx

int nmaxy

int nmaxz

double time

int type

double zmax

class SLGridSlab

#include <SLGridMP2.H>

Slab (one-dimensional) SL grid class.

Public Functions

inline double d_xi_to_z(double x)

Jacobian of coordinate mapping.

double eigenvalue(int kx, int ky, int n)

Members.

Get n^th eigenvalue for given wave number indices

double get_dens(double x, int kx, int ky, int n, int which = 1)

Get density for dimensionless coord with given wave numbers and index.

void get_dens(Eigen::MatrixXd &tab, double x, int which = 1)

Get density for dimensionless coord with given wave numbers Return Matrix with first dimension containing x and y wavenumbers packed with y index varying most quicly, second index is vertical order.

void get_dens(Eigen::VectorXd &vec, double x, int kx, int ky, int which = 1)

Get density for dimensionless coord with given wave numbers Return Vector for all indices

double get_force(double x, int kx, int ky, int n, int which = 1)

Get force for dimensionless coord with given wave numbers and index.

void get_force(Eigen::MatrixXd &tab, double x, int which = 1)

Get force for dimensionless coord with given wave numbers Return Matrix with first dimension containing x and y wavenumbers packed with y index varying most quicly, second index is vertical order.

void get_force(Eigen::VectorXd &vec, double x, int kx, int ky, int which = 1)

Get force for dimensionless coord with given wave numbers Return Vector for all indices

double get_pot(double x, int kx, int ky, int n, int which = 1)

Get potential for dimensionless coord with given wave numbers and index.

void get_pot(Eigen::MatrixXd &tab, double x, int which = 1)

Get potential for dimensionless coord with given wave numbers Return Matrix with first dimension containing x and y wavenumbers packed with y index varying most quicly, second index is vertical order.

void get_pot(Eigen::VectorXd &vec, double x, int kx, int ky, int which = 1)

Get potential for member for dimensionless coord with given wave numbers Return Vector for all indices

std::vector<Eigen::MatrixXd> orthoCheck(int knots = 40)

Compute the orthogonality of the basis by returning inner produce matrices

SLGridSlab(int kmax, int nmax, int numz, double zmax, const std::string type = "isothermal", bool Verbose = false)

Constructor.

inline double xi_to_z(double x)

Map from dimensionless coordinate to vertical coordinate.

inline double z_to_xi(double z)

Map from vertical coordinate to dimensionless coordinate.

~SLGridSlab()

Destructor.

Public Static Attributes

static int cache

Check for cached table, default: 1=yes.

static double H

Scale height, default=0.1.

static double L

Periodic box size, default=1.0.

static int mpi

Global MPI flag, default: 0=off.

static double ZBEG

Offset from origin, default=1.0e-4.

static double ZEND

Potential offset, default=1.0e-5.

Private Types

enum CoordMapTypes

This defines a class providing selectable maps from the infinite to finite interval

Values:

enumerator Tanh

enumerator Sech

enumerator Linear

using table_ptr_1D = std::shared_ptr<TableSlab[]>

using table_ptr_2D = std::shared_ptr<table_ptr_1D[]>

Private Functions

void bomb(string oops)

void compute_table(TableSlab *table, int kx, int ky)

void compute_table_worker(void)

void init_table(void)

int mpi_pack_table(TableSlab *table, int kx, int ky)

void mpi_setup(void)

void mpi_unpack_table(void)

bool ReadH5Cache(void)

void WriteH5Cache(void)

Private Members

Eigen::VectorXd d0

double dxi

std::unique_ptr<CoordMap> mM

The current map created by the SLGridSlab constructor.

std::shared_ptr<char[]> mpi_buf

int mpi_bufsz

int mpi_myid

int mpi_numprocs

int nmax

int numk

int numz

Eigen::VectorXd p0

table_ptr_2D table

bool tbdbg

For deep debugging.

std::string type

Model type.

Eigen::VectorXd xi

double xmax

double xmin

Eigen::VectorXd z

double zmax

class SLGridSph

#include <SLGridMP2.H>

! Spherical SL grid class

Public Functions

double d_xi_to_r(double x)

Jacobian of nondimensional coordinate mapping.

double eigenvalue(int l, int n)

Eigenvalue for index and harmonic order l.

double get_dens(double x, int l, int n, int which = 1)

Get density for dimensionless coord with harmonic order l and radial orer n

void get_dens(Eigen::MatrixXd &tab, double x, int which = 1)

Get density for dimensionless coord with harmonic order l and radial order n Return Matrix with first dim harmonic order and second dim radial order

void get_dens(Eigen::VectorXd &vec, double x, int l, int which = 1)

double get_force(double x, int l, int n, int which = 1)

Get force for dimensionless coord with harmonic order l and radial orer n.

void get_force(Eigen::MatrixXd &tab, double x, int which = 1)

Get force for dimensionless coord with harmonic order l and radial order n Return Matrix with first dim harmonic order and second dim radial order

void get_force(Eigen::VectorXd &vec, double x, int l, int which = 1)

Get force for dimensionless coord with harmonic order l and radial orer n Return all radial order values in Vector

double get_pot(double x, int l, int n, int which = 1)

Get potential for dimensionless coord with harmonic order l and radial orer n.

void get_pot(Eigen::MatrixXd &tab, double x, int which = 1)

Get potential for dimensionless coord with harmonic order l and radial order n Return Matrix with first dim harmonic order and second dim radial order

void get_pot(Eigen::VectorXd &vec, double x, int l, int which = 1)

Get potential for dimensionless coord with harmonic order l and radial orer n Return all radial order values in Vector

inline int getLmax()

Get expansion limits.

inline int getNmax()

inline double getRmax()

inline double getRmin()

Get the current minimum and maximum radii for the expansion.

std::vector<Eigen::MatrixXd> orthoCheck(int knots = 40)

Compute the orthogonality of the basis by returning inner produce matrices

double r_to_xi(double r)

Map radial coordinate to nondimensional coordinate.

SLGridSph(std::shared_ptr<SphericalModelTable> mod, int lmax, int nmax, int numr, double rmin, double rmax, bool cache, int Cmap, double RMAP, std::string cachename = ".slgrid_sph_cache", bool Verbose = false)

Constructor with model table.

SLGridSph(std::string cachename)

Constructor (from cache file)

SLGridSph(std::string modelname, int lmax, int nmax, int numr, double rmin, double rmax, bool cache, int Cmap, double RMAP, int DIVERGE, double DFAC, std::string cachename = ".slgrid_sph_cache", bool Verbose = false)

Constructor (uses file model_file_name for file)

double xi_to_r(double x)

Map nondimensional coordinate to radial coordinate.

virtual ~SLGridSph()

Destructor.

Public Static Functions

static std::map<std::string, std::string> cacheInfo(const std::string &cachefile, bool verbose = true)

Get density for dimensionless coord with harmonic order l and radial orer n Return all radial order values in Vector Read and print the cache and return the header parameters as a map/dictionary

static YAML::Node getHeader(const std::string &cachefile)

Read the cache and report parameters.

Public Static Attributes

static int mpi

Flag for MPI enabled (default: 0=off)

Private Types

using table_ptr_1D = std::shared_ptr<TableSph[]>

Private Functions

void bomb(string oops)

void compute_table(TableSph *table, int L)

void compute_table_worker(void)

void init_table(void)

void initialize(int LMAX, int NMAX, int NUMR, double RMIN, double RMAX, bool CACHE, int CMAP, double RMAP)

int mpi_pack_table(TableSph *table, int l)

void mpi_setup(void)

void mpi_unpack_table(void)

bool ReadH5Cache()

Read HDF5 cache.

void WriteH5Cache()

Write HDF5 cache.

Private Members

bool cache

Use basis cache.

int cmap

Eigen::VectorXd d0

const std::string default_cache = ".slgrid_sph_cache"

Default cache file name.

const std::string default_model = "SLGridSph.model"

Default model file name.

double dfac

int diverge

double dxi

int lmax

std::string model_file_name

Model file name.

std::shared_ptr<char[]> mpi_buf

int mpi_bufsz

int mpi_myid

int mpi_numprocs

int nmax

int numr

Eigen::VectorXd p0

Eigen::VectorXd r

double rmap

double rmax

double rmin

std::string sph_cache_name

Cache file name.

table_ptr_1D table

bool tbdbg

For deep debugging.

Eigen::VectorXd xi

double xmax

double xmin

Private Static Attributes

static double Lalpha

For l>=Lswitch: rmin=rmap/rfac, rmax=rmap*rfac with rfac=pow(10, Lalpha/l)

static int Lswitch

Use entire grid for l<Lswitch.

Rmin heuristic for grid construction to prevent underflow issues in Sturm-Liouville solver: sledge

static const std::string Version = "1.0"

Cache versioning.

class SoftKernel

#include <GravKernel.H>

Inheritence diagram for SoftKernel:

Abstract class for smoothing kernel. Derive all new kernels from this class.

Subclassed by PlummerSoft, SplineSoft

Public Functions

virtual std::pair<double, double> operator()(double r, double eps) = 0

This operator returns the fractional mass and gravitational potential inside of radius

Parameters:

• r – for softening

• eps –

Public Members

const double tol = 1.0e-8

Separations smaller than this value are considered to be the same particle.

class SParticle

#include <SParticle.H>

An abbreviated particle class for transferring phase space between processors and writing initial conditions. Changes in or additions to the Particle class should not affect this class.

Public Functions

inline double datr(int i)

inline double datr(int i)

inline int iatr(int i)

inline int iatr(int i)

inline int indx()

inline int indx()

inline double mass()

inline double mass()

inline int ndatr()

inline int ndatr()

inline int niatr()

inline int niatr()

inline void operator[](const Particle &p)

Copy contents of a Particle to an SParticle.

inline double phi()

inline double phi()

inline double pos(int i)

inline double pos(int i)

inline void read(std::istream &in, unsigned rsize, int pcount, list<PSPstanza>::iterator spos)

inline void read(std::istream &in, unsigned rsize, int pcount, std::list<PSPstanza>::iterator spos)

inline void setSize(unsigned rsize)

inline void setSize(unsigned rsize)

inline SParticle()

inline SParticle()

Null constructor.

inline SParticle()

inline SParticle(const Particle &p)

Construct instance from a Particle.

inline double vel(int i)

inline double vel(int i)

void write(std::ostream &out, bool real4, size_t isiz)

void write(std::ostream &out, bool real4, size_t isiz)

Public Members

std::shared_ptr<PParticle<double>> d

std::shared_ptr<PParticle<float>> f

double mass

Data fields.

double pos[3]

double vel[3]

Private Functions

inline void cpy(const Particle &p)

Copy Particle contents.

Private Members

unsigned s

struct SphCoefHeader

#include <coef.H>

Header structure for spherical expansion.

Public Members

char id[64]

int Lmax

int nmax

double scale

double tnow

struct SphCoefs

#include <Coefs.H>

Collaboration diagram for SphCoefs:

Public Types

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor> EigenColMajor

Public Functions

bool read(std::istream &in, bool exp_type)

Public Members

std::shared_ptr<char[]> buf

EigenColMajor coefs

SphCoefHeader header

class Sphere : public SphericalBasis

#include <Sphere.H>

Inheritence diagram for Sphere:

Collaboration diagram for Sphere:

Computes the potential, acceleration and density using the Sturm Liouville direct solution.

YAML configuration

Param rmapping:

is the halo scale length (default is 0.067*rmax). This is used to for the coordinate mapping (see below).

Param cmap:

should be 1 for algebraic coordinate scaling, 2 for log coordinate scaling, 0 for no scaling as follows:

\[ x = {r/r_s-1 \over r/r_s+1} \]

when cmap=1 and

\[ x = \log(r) \]

when cmap=2. Algebraic coordinate scaling is a good general choice. For spherical models with a very large dynamic range (e.g. deep, cuspy halos), logarithmic scaling will be a better choice. Logarithmic scaling will insist that the rmin>0.

Param numr:

is the number radial coordinate knots in the table (default: 2000)

Param nums:

is the number of bins in the empirical mass array (default: 2000)

Param noff:

is the offset into the empirical mass array for computing upper and lower grid boundaries (default: 32)

Param diverge:

set to true means assume a cuspy profile

Param dfac:

is the power of the “divergent” cusp

Param modelname:

is the file containing the input background model profile

Param cachename:

is the name for the SL grid cache file

Param dtime:

is the interval between basis recomputations (<=0 for never)

Param diverge:

sets the power law extrapolation of a cusp profile

Param dfac:

is the inverse slope of the power law

Param logr:

set to true uses a logarithmic spacing for the empirical radial grid (default: false)

Param plummer:

set to true uses a Plummer-model fit to the empirical mass array to make basis model (default: true)

Public Functions

inline virtual void determine_coefficients(void)

Override to redetermine basis, as desired.

Sphere(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor

Parameters:

• c0 – is the instantiating caller (Component)

• conf – passes any parameters to basis instance (rsphSL, rmin and numr

• m – allows the spherical basis to be used for multiple center expansions

virtual ~Sphere()

Destructor.

Private Functions

inline virtual double d_r_to_xi(double r)

inline double d_xi_to_r(double x)

virtual void get_dens(int lmax, int nmax, double r, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_dpotl(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &dp, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• dp – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl(int lmax, int nmax, double r, Eigen::MatrixXd &p, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid)

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void initialize(void)

Initialize method.

inline void make_model()

void make_model_bin()

void make_model_plummer()

double mapDeriv(const std::map<double, double> &data, double x)

double mapIntrp(const std::map<double, double> &data, double x)

inline virtual double r_to_xi(double r)

Coordinate mapping.

inline virtual double xi_to_r(double x)

Private Members

string cache_file

int cmap

double dfac

int diverge

double dtime

bool logr

string model_file

int noff

int numr

int nums

SLGridSphPtr ortho

bool plummer

bool recompute

double rmap

double rsphSL

double tnext

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class SphereSL : public AxiSymBiorth

#include <sphereSL.H>

Inheritence diagram for SphereSL:

Collaboration diagram for SphereSL:

Public Functions

virtual double d_r_to_rb(double const x)

double d_rb_to_r(const double x)

virtual double dens(const int n, const int l, const double x)

virtual void dens(const int n, const int l, const double x, Eigen::VectorXd &t)

double get_dens(const double r, const int l, const Eigen::VectorXd &coef)

double get_potl(const double r, const int l, const Eigen::VectorXd &coef)

inline virtual double krnl(const int n, const int l)

inline virtual double norm(const int n, const int l)

virtual double potl(const int n, const int l, const double x)

virtual void potl(const int n, const int l, const double x, Eigen::VectorXd &t)

inline virtual double potlR(const int n, const int l, const double r)

inline virtual double potlRZ(const int n, const int l, const double r, const double z)

virtual double r_to_rb(double const r)

inline virtual double rb_max(void)

inline virtual double rb_min(void)

virtual double rb_to_r(double const x)

SphereSL(int lmax, int nmax, int numr, double rmin, double rmax, double scale, std::shared_ptr<SphericalModelTable> mod)

~SphereSL(void)

Public Static Attributes

static bool cache

static int mpi

Private Members

int lmax

int nmax

int numr

double rmax

double rmin

double scale

SLGridSph *slgrid

class SphericalBasis : public AxisymmetricBasis

#include <SphericalBasis.H>

Inheritence diagram for SphericalBasis:

Collaboration diagram for SphericalBasis:

Defines a spherical basis with members specific to spherical symmetry.

YAML configuration

Param scale:

Radial scale factor between particle coordinates and the basis coorindates. The default is 1 and should be 1 if the input basis model matches the phase-space coordinates of the particles.

Param rmin:

is the lower-bound of the target basis. This will be set to minimum radius in the input model by default.

Param rmax:

is the upper-bound of the target basis. This will be set to maximum radius in the input model by default.

Param self_consistent:

set to true allows the particles to evolve under the time-dependent basis expansion. For a basis fixed in time to the initial time: set to false.

Param FIX_L0:

set to true saves the monopole coefficients on the first evaluation

Param NO_L0:

set to true disables the monopole coefficients altogehter for all time

Param NO_L1:

set to true disables the dipole coefficients altogehter for all time

Param EVEN_L:

set to true eliminates all \(l\) harmonic coefficients of odd order for all time

Param EVEN_M:

set to true eliminates all \(m\) harmonic coefficients of odd order for all time

Param M0_ONLY:

set to true eliminates all \(|m|>0\) harmonic coefficients for all time

Param NOISE:

set to true enables the signal-to-noise ratio computation for diagnostic purposes

Param noiseN:

is the variance scale factor for estimating the RMS noise (1.0e-6 by default; \(1/N\) is a good choice for the standard deviation of the noise)

Param noise_model_file:

is the filename for the background model model used to estimate the noise

Param seedN:

is the random number generator seed for the noise computation

Param ssfrac:

sets a fraction of the total phase space used for coefficient estimation (this is an experimental feature)

Param “playback:

set to true uses a coefficient file to evaluate the coefficients rather than direct expansion

Param coefCompute:

set to true computes a new set of coefficients during playback for comparison

Param coefMaster:

set to true evaluates the playback coefficients on a single node which are then broadcast to all nodes

Param orthocheck:

set to true computed the basis biorthgoonal check by direct quadrature

Subclassed by Bessel, Sphere

Public Functions

virtual void determine_acceleration_and_potential(void)

Required member to compute accleration and potential with threading.

The thread member must be supplied by the derived class

inline virtual void determine_coefficients(Component *c)

Compute coefficients with threading using the provided component.

virtual void determine_coefficients(void)

Required member to compute coeifficients with threading.

The thread member must be supplied by the derived class

virtual void determine_fields_at_point(double x, double y, double z, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotx, double *tpoty, double *tpotz)

Return the value for the fields in Cartesian coordinates.

virtual void determine_fields_at_point_cyl(double r, double z, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpotz, double *tpotp)

Returns the potential, its derivatives & density in cylindrical coords.

virtual void determine_fields_at_point_sph(double r, double theta, double phi, double *tdens0, double *tpotl0, double *tdens, double *tpotl, double *tpotr, double *tpott, double *tpotp)

Returns the potential, its derivatives & density in spherical coords.

virtual void dump_coefs(ostream&)

Dump current coefficients.

virtual void dump_coefs_h5(const std::string &file)

Dump current coefficients into named HDF5 file.

virtual void get_acceleration_and_potential(Component *cC)

Required member to compute accelration and potential.

This implemenation should be fine for most cases

virtual void get_dens(int lmax, int nmax, double r, Eigen::MatrixXd &d, int tid) = 0

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_dpotl(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &dp, int tid) = 0

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• dp – will be returned array in harmonics l and radial order n for the derivative of the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl(int lmax, int nmax, double r, Eigen::MatrixXd &p, int tid) = 0

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• tid – is the thread enumerator that allows the function to provide some thread safety

virtual void get_potl_dens(int lmax, int nmax, double r, Eigen::MatrixXd &p, Eigen::MatrixXd &d, int tid) = 0

Get derivative of potential

Parameters:

• lmax – is the maximum harmonic order

• nmax – is the maximum radial order

• r – is the evaluation radius

• p – will be returned array in harmonics l and radial order n for the potential

• d – will be returned array in harmonics l and radial order n for the density

• tid – is the thread enumerator that allows the function to provide some thread safety

inline virtual double knl(int, int)

Kernel value for recursion relation basis.

inline virtual void multistep_add_debug(const std::vector<std::vector<std::pair<unsigned, unsigned>>> &data)

virtual void multistep_reset()

Update the multi time step coefficient table when moving particle i from level cur to level next

virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

virtual void multistep_update_begin()

Execute to begin level shifts for particles.

Update the multi time step force algorithm when moving particle i from level cur to level next

virtual void multistep_update_finish()

Execute to finish level shifts for particles.

inline virtual double norm(int, int)

Normalization for recursion relation basis.

SphericalBasis(Component *c0, const YAML::Node &conf, MixtureBasis *m = 0)

Constructor (line contains the paramter list)

SphericalBasis(const SphericalBasis &p)

Copy constructor.

virtual ~SphericalBasis()

Destructor.

Public Static Attributes

static bool NewCoefs

Use YAML header in coefficient file.

Protected Types

typedef std::shared_ptr<Eigen::VectorXd> VectorXdP

Matrices per thread for obtaining expansion coefficients.

Protected Functions

void biorthogonality_check()

virtual void check_range()

Provided by derived classes to check consistency.

void compute_multistep_coefficients()

Extrapolate and sum coefficents per multistep level to get a complete set of coefficients for force evaluation at an intermediate time step

void compute_rms_coefs(void)

Compute rms coefficients.

inline virtual double d_r_to_xi(double r)

virtual void *determine_acceleration_and_potential_thread(void *arg)

Thread method for accerlation compuation.

virtual void determine_coefficients_particles(void)

Compute the coefficients from particles.

virtual void determine_coefficients_playback(void)

Compute the coefficients from an table.

virtual void *determine_coefficients_thread(void *arg)

Thread method for coefficient accumulation.

void dump_coefs_all(ostream&)

Dump current coefficients (all multistep levels) For debugging …

void get_dens_coefs(int l, Eigen::VectorXd &coef, double &p)

Get density from coefficient vector.

void get_pot_coefs(int l, const Eigen::VectorXd &coef, double &p, double &dp)

Get potential and accel field values from coefficients.

void get_pot_coefs_safe(int l, const Eigen::VectorXd &coef, double &p, double &dp, Eigen::MatrixXd &potd1, Eigen::MatrixXd &dpot1)

Get potential and field values from coefficients (provide workspace for thread safety)

virtual void initialize()

Initialize method.

void occt_output()

Print deep debugging data.

inline virtual double r_to_xi(double r)

Radial coordinate mapping (r->x, and x->r)

void setup()

Should be called by derived classes after initialization.

void update_noise(void)

Add noise.

inline virtual double xi_to_r(double x)

Protected Attributes

Eigen::VectorXd C0

Frozen monopole coefficients.

const unsigned int cmagic = 0xc0a57a2

Coefficient magic number.

bool coefMaster

Master node ships coefficients to hosts. True (default) implies that only the master node caches the coefficients for playback to save core memory. This is set in the config input using the ‘coefMaster: bool’ parameter. Once I am sure that there are no algorithmic issues, I will remove this as an option.

std::vector<Eigen::VectorXd> cosm

Work vectors for cosines for all values m

Eigen::MatrixXd dend

Work matrix.

std::vector<std::vector<Eigen::MatrixXd>> differ1

For updating levels.

std::vector<Eigen::MatrixXd> dlegs

Matrices per thread for obtaining derivatives legendre coefficients.

std::vector<Eigen::MatrixXd> dpot

Matrices per thread for obtaining derivative of potential field.

std::vector<Eigen::VectorXd> du

Work vectors to make recursion evaluations thread safe.

bool EVEN_L

Flag use of even l harmonics only.

bool EVEN_M

Flag use of even m harmonics only.

std::vector<std::vector<VectorXdP>> expcoef0

Eigen::MatrixXd factorial

Cache factorial values.

bool firstime_accel

Flag whether or not work space has been initialized for acceleration.

bool firstime_coef

Flag whether or not work space has been initialized for coefficients.

bool FIX_L0

Freeze monopole.

Eigen::MatrixXd krnl

Will cache values of the kernel required for recursion relations.

double lastPlayTime

Last playback coefficient evaluation time.

std::vector<Eigen::MatrixXd> legs

Matrices per thread for obtaining legendre coefficients.

bool M0_only

Use axisymmetric term s.

Eigen::VectorXd meanC

Expected coefficient values for RMS noise computation.

MixtureBasis *mix

For massive satellite simulations.

double muse0

vector<double> muse1

Mass accumulation for PCA.

bool NO_L0

Flag fixed monopole.

bool NO_L1

Flag drop l=1 term.

bool NOISE

Flag adding noise to coefficients (for testing diffusion)

string noise_model_file

Model for RMS noise computation.

double noiseN

Number of “effective” points for RMS noise computation.

std::normal_distribution nrand

std::vector<std::vector<unsigned>> occt

CUDA method for coefficient accumulation.

Test change level counts for deep debugging enabled by setting SPH_UPDATE_TABLE at the top of this header file

bool ortho_check

Compute the biorthogonality inner product and write to a file for internal self-consistency check. Enabled by including the YAML boolean ‘orthocheck’.

std::vector<double> pack

std::shared_ptr<CoefClasses::SphCoefs> playback

Coefficient playback instance. Using shared_ptr to avoid constructing a simple pointer or null instance

std::vector<Eigen::MatrixXd> potd

Matrices per thread for obtaining potential field.

double resetT

Time at last multistep reset.

std::mt19937 rgen

double rmax

The maximum radius.

double rmin

The minimum radius.

Eigen::MatrixXd rmsC

Expected squared coefficient values for RMS noise computation.

unsigned int seedN

Pseudorandom generation.

bool self_consistent

Flag self_consitency.

bool setup_noise

std::vector<Eigen::VectorXd> sinm

Work vectors for sines for all values m

CoefClasses::SphCoefs sphCoefs

Coefficient container instance for writing HDF5.

double ssfrac

Subsample fraction of particles.

bool subset

Flag to use subset.

std::vector<Eigen::VectorXd> u

Work vectors to make recursion evaluations thread safe.

std::vector<double> unpack

Protected Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class SphericalModelMulti : public AxiSymModel

#include <massmodel.H>

Inheritence diagram for SphericalModelMulti:

Collaboration diagram for SphericalModelMulti:

This uses two SphericalModelTables to define a mass profile and a number profile for generating a distribution with variable mass per particle.

Public Functions

inline void allowNegativeMass()

Turn off negative mass suppression by NOT requeueing particle selection if the DF ratio is negative

inline virtual double d2fde2(double E, double L)

inline virtual double dfde(double E, double L)

inline virtual double dfdl(double E, double L)

inline virtual double distf(double E, double L)

Evaluate distribution function and its partial derivatives.

virtual PSret gen_point()

Overloaded to provide mass distribution from Real and Number distribution from Fake.

virtual PSret gen_point(double Emin, double Emax, double Kmin, double Kmax)

Generate a phase-space point at a particular energy and angular momentum.

virtual PSret gen_point(double r)

Generate a phase-space point at a particular radius.

virtual PSret gen_point(double r, double theta, double phi)

Generate a phase-space point at a particular radius, theta, and phi.

inline virtual double get_density(const double r)

inline virtual double get_density(const double x1, const double x2, const double x3)

The density at (x, y, z)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Evaluate the profile at a radial point.

inline virtual double get_mass(const double x1, const double x2, const double x3)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

Additional member functions.

inline virtual double get_pot(const double r)

inline virtual double get_pot(const double x1, const double x2, const double x3)

The potential at (x, y, z)

inline virtual void get_pot_dpot(const double r, double &p, double &dp)

inline void set_max_radius(const double &r)

inline void set_min_radius(const double &r)

Set new minimum and maximum for realization.

SphericalModelMulti(std::shared_ptr<AxiSymModel> Real, std::shared_ptr<AxiSymModel> Fake)

Constructor.

Protected Attributes

std::shared_ptr<AxiSymModel> fake

SphericalOrbit gen_orb

bool noneg

SphericalOrbit orb

std::shared_ptr<AxiSymModel> real

double rmax_gen

double rmin_gen

class SphericalModelTable : public AxiSymModel

#include <massmodel.H>

Inheritence diagram for SphericalModelTable:

Collaboration diagram for SphericalModelTable:

Describe a spherical model from a four-column table of radius, density, enclosed mass, and gravitational potential

The file may have any number of leading comment lines, any line that starts with a “!” or a “#”. The first non-comment record is assumed to be an integer containing the number of lines. The subseuqnet lines are assumed to be records beginning the radius and followed by the triple of (density, enclosed mass, gravitational potential).

Subclassed by KingSphere

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

Evaluate the distribution function.

inline virtual double get_density(const double x1, const double x2, const double x3)

The density at (x, y, z)

virtual double get_density(const double)

virtual double get_dpot(const double)

virtual double get_dpot2(const double)

inline virtual double get_mass(const double x1, const double x2, const double x3)

Get the mass inside of position (x, y, z) (this is ambiguous in general and will depend on the model)

virtual double get_mass(const double)

Evaluate the profile at a particular radius.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline int get_num_param(void)

Get info about the model.

inline double get_param(int i)

inline virtual double get_pot(const double x1, const double x2, const double x3)

The potential at (x, y, z)

virtual double get_pot(const double)

virtual void get_pot_dpot(const double, double&, double&)

inline double get_ra2(void)

inline int grid_size(void)

void print_df(const std::string &name)

void print_model(const std::string &name)

void print_model_eval(const std::string &name, int number)

void setup_df(int NUM, double RA = 1.0e20)

Set up and get info about the phase-space distribution.

SphericalModelTable(int num, double *r, double *d, double *m, double *p, int DIVERGE = 0, double DIVERGE_RFAC = 0, int EXTERNAL = 0, std::string ID = "")

Constructor (from array pointers)

SphericalModelTable(std::vector<double> &r, std::vector<double> &d, std::vector<double> &m, std::vector<double> &p, int DIVERGE = 0, double DIVERGE_RFAC = 0, int EXTERNAL = 0, std::string ID = "")

Constructor (from vectors)

SphericalModelTable(string filename, int DIVERGE = 0, double DIVERGE_RFAC = 1.0, int EXTERNAL = 0)

Constructor (from a table)

virtual ~SphericalModelTable()

Destructor.

Public Static Attributes

static int chebyN

Chebyshev order (default: 0, no Chebyshev)

static int count

Count the number of instantiations (for debugging)

static int even

Assume even spacing in the mass model table (default: yes)

static int linear

Linear interpolation in model (default: no)

Private Functions

void debug_fdist()

Private Members

RUN density

FDIST df

FDISTC dfc

int diverge

double diverge_rfac

int external

double foffset

RUN mass

int num

int num_params

int numdf

std::vector<double> params

RUN pot

class SphericalOrbit : public RegularOrbit

#include <orbit.H>

Inheritence diagram for SphericalOrbit:

Collaboration diagram for SphericalOrbit:

Public Functions

inline double AngMom(void)

The value of the orbital angular momentum.

inline double apo(void)

Radius of the apocenter of this orbit.

inline double Beta(void)

The specified altitude of the orbital plane.

inline double circ(void)

Radius of the circular orbit with energy E.

inline double Energy(void)

Safe access to internal quantities.

The value of the orbital energy

inline virtual double get_action(const int i)

Required functions for accessing phase-space parameters.

Return the action where: index 0 is radial action, I_r index 1 is angular action, J index 2 should be J_z/J, current set to zero

virtual double get_angle(const int i, const double time)

Get angle dependent quantities for the orbit where the index signifies:

i val

1 w1 2 w2 3 t 4 dw1dt 5 f 6 r 7 phi

inline struct ANGLE_GRID *get_angle_grid(void)

Access to underlying grid for pot_trans.

inline virtual double get_freq(const int i)

Return the orbital frequency where: index 0 is radial frequency, I_r index 1 is angular frequency, J index 2 is frequency of line of nodes (zero for a spherical system)

double get_w1(double r, double vr)

Get radial angle for a given radius.

inline double Jmax(void)

The value of the current J_{max}(E)

inline double Kappa(void)

The value of the current J/J_{max}(E)

inline AxiSymModel &modl(void)

Get the underlying axisymmetric model object.

void new_orbit(double Energy, double kappa, double beta = 0.0)

Set the energy and kappa for the orbit.

SphericalOrbit &operator=(const SphericalOrbit&)

inline AxiSymBiorth &orth(void)

Get the underlying biorthogonal function object.

inline double peri(void)

Radius of the pericenter of this orbit.

void pot_trans(int l1, int l2, Eigen::VectorXd &t)

double pot_trans(int l1, int l2, int n)

double pot_trans(int l1, int l2, std::function<double(double)> func)

inline void set_biorth(std::shared_ptr<AxiSymBiorth> type, int ll, int max, int recur = 0)

Set the biorthogonal ffunction type.

inline void set_numerical_params(int RECS = 64, int NMAX = 40, int NBSCT = 3)

Set the numerical parameters for angle transform computation.

SphericalOrbit(const SphericalOrbit&)

SphericalOrbit(std::shared_ptr<AxiSymModel> model)

SphericalOrbit(std::shared_ptr<AxiSymModel> model, double Energy, double kappa, double beta = 0.0)

SphericalOrbit(void)

inline virtual ~SphericalOrbit()

Public Static Attributes

static bool guard

static int Nseg

static double RMAXF

static double tol

static double tolnr

static double ZFRAC

Private Functions

inline void compute_action(void)

void compute_angles(void)

void compute_angles_epi(void)

void compute_angles_old(void)

void compute_biorth(void)

void compute_freq(void)

void compute_freq_epi(void)

std::tuple<double, double, bool> search(std::function<double(double)> func, double rmin, double rmax)

Private Members

double am

struct ANGLE_GRID angle_grid

double ap

double beta

std::shared_ptr<AxiSymBiorth> biorth

Eigen::VectorXd cosvec

double energy

GaussQuad Gkn

double jmax

double kappa

int l

int l1s

int l2s

std::shared_ptr<AxiSymModel> model

int nbsct

int nmax

double r_apo

double r_circ

double r_peri

int recs

int RECUR

double sm

double sp

class SphericalSL

#include <SphericalSL.H>

Public Functions

void accumulate(vector<Particle> &particles)

void determine_fields_at_point(double r, double theta, double phi, double *tdens, double *tpotl, double *tpotr, double *tpott, double *tpotp, int id = 0)

void dump_basis(string &dumpname)

void dump_coefs(ofstream &out, bool binary)

void get_dens_coefs(int l, const Eigen::VectorXd &coef, double &p, int id = 0)

inline int get_maxNL(void)

inline int get_maxNR(void)

void get_pot_coefs(int l, const Eigen::VectorXd &coef, double &p, double &dp, int id = 0)

inline void get_potl_dens(int l, int n, double r, int id = 0)

void reset(std::string file, int Nth, int lmax, int nmax, int CMAP, double SCALE)

inline void set_compute()

inline std::shared_ptr<SLGridSph> SL(void)

SphericalSL(std::string file, int Nth, int lmax, int nmax, int CMAP, double SCALE = 1.0)

SphericalSL(void)

inline void unset_compute()

~SphericalSL(void)

Public Static Attributes

static int NUMR

static double RMAX

static double RMIN

static int selector

static int tk_type

static double tkcum

static double tksmooth

Private Functions

inline void bomb(const char *s)

void compute_coefficients_single(vector<Particle> &part)

void compute_coefficients_thread(vector<Particle> &part)

void compute_coefficients_thread_call(int id, vector<Particle> *p)

void initialize(void)

void parallel_distribute_coefficients(Eigen::MatrixXd &expcoef)

void parallel_gather_coefficients(Eigen::MatrixXd &expcoef, Eigen::MatrixXd &expcoef1, std::vector<Eigen::MatrixXd> &cc, std::vector<Eigen::MatrixXd> &cc1, int lmax)

void pca_hall(int compute, Eigen::MatrixXd &expcoef, std::vector<Eigen::MatrixXd> &cc, Eigen::MatrixXd &normM)

Private Members

std::vector<Eigen::MatrixXd> cc

std::vector<std::vector<Eigen::MatrixXd>> cc1

bool coefs_made

int compute

std::vector<Eigen::VectorXd> cosm

std::vector<Eigen::MatrixXd> dend

std::vector<Eigen::MatrixXd> dlegs

std::vector<Eigen::MatrixXd> dpot

Eigen::MatrixXd expcoef

std::vector<Eigen::MatrixXd> expcoef1

Eigen::MatrixXd factorial

bool initialized

Eigen::MatrixXd krnl

std::vector<Eigen::MatrixXd> legs

int LMAX

double *MPIin

double *MPIout

bool MPIset

int n

int NMAX

Eigen::MatrixXd normM

int nthrds

std::shared_ptr<SLGridSph> ortho

std::vector<Eigen::MatrixXd> potd

std::vector<Eigen::VectorXd> sinm

std::vector<int> use

int used

class SphSL

#include <SphSL.H>

Uses SLGridSph basis to evaluate expansion coeffients and provide potential and density basis fields

Public Functions

void accumulate(double x, double y, double z, double mass)

Accumulate new coefficients.

void all_eval(double r, double costh, double phi, double &den0, double &den1, double &pot0, double &pot1, double &potr, double &pott, double &potp, int L1 = 0, int L2 = 10000, int N1 = 0, int N2 = 10000)

inline std::shared_ptr<SLGridSph> basis(void)

Access to basis.

void dens_pot_eval(double r, double costh, double phi, double &dens0, double &dens, double &potl0, double &potl, int L1 = 0, int L2 = 10000, int N1 = 0, int N2 = 10000)

Evaluate potential and density.

void dump_coefs(double time, std::ostream &out)

Dump coefficients using the standard header.

inline Eigen::MatrixXd get_pot(double x)

Retrieve potential.

double get_power(double snr, double mass)

Get fractional power in trimmed coefficients.

Eigen::MatrixXd get_trimmed(double snr, double mass, bool Hall = false)

Retrieve coefficients with SNR trim.

inline int getLmax()

Return current maximum harmonic order in expansion.

inline double getMass(void)

Get mass on grid.

inline double getMaxSNR(void)

Maximum SNR coefficient value.

inline double getMinSNR(void)

Minimum SNR coefficient value.

inline int getNmax()

Return current maximum order in radial expansion.

void install_coefs(Eigen::MatrixXd &newcoef)

Install coefficients.

void legendre_R(int lmax, double x, Eigen::MatrixXd &p)

void legendre_R(int lmax, double x, Eigen::MatrixXd &p, Eigen::MatrixXd &dp)

void legendre_R(int lmax, double x, Eigen::MatrixXd &p, Eigen::MatrixXd &dp, Eigen::MatrixXd &d2p)

void make_coefs(void)

Make coefficients after accumulation.

void make_covar(bool verbose = false)

Covariance analysis.

void pot_force_eval(double r, double costh, double phi, double &potl, double &potr, double &pott, double &potp, int L1 = 0, int L2 = 10000, int N1 = 0, int N2 = 10000)

Evaluate potential and force.

void reset_coefs(void)

Zero out coefficients to prepare for a new expansion.

inline Eigen::MatrixXd retrieve_coefs(void)

Retrieve coefficients.

inline std::vector<Eigen::MatrixXd> retrieve_covar(void)

Retrieve coefficients.

inline void set_scale(const double scl)

Prescaling factor.

SphSL(std::shared_ptr<SphericalModelTable> mod, int LMAX, int NMAX, int CMAP = 0, double SCALE = 0.067, bool COVAR = false, int NPART = 0)

Constructor

Parameters:

• mod – instance of SphericalModelTable to condition eigenfunctions

• LMAX – is the maximum harmonic order

• NMAX – is the maximum radial order

• CMAP – is the SLGridSph coordindate mapping type

• SCALE – is the SLGridSph coordindate scale length

• COVAR – true will evaluate the covariance matrix for coeffficients

• NPART – >0 will evaluate the covariance matrix using a jackknife partition with number given

~SphSL(void)

Destructor.

Public Static Attributes

static double HEXP

Hall exponent (default: 1)

static bool mpi

Use MPI? (default: false)

static int NEV

Number of eigenfunctions for each subspace for PNG figure.

static int NUMR

Number of radial points in table (default: 800)

Private Types

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor> EigenColMajor

For coefficient writing.

using matT = std::vector<Eigen::MatrixXd>

using vecT = std::vector<Eigen::VectorXd>

Private Functions

void bomb(char *s)

Private Members

const unsigned int cmagic = 0xc0a57a2

Coefficient magic number.

bool coefs_defined

bool compute_covar

matT covar

int curbin

Eigen::MatrixXd d2legs

Eigen::MatrixXd dend

Eigen::MatrixXd dlegs

Eigen::MatrixXd dpot

Eigen::MatrixXd dpt2

Eigen::MatrixXd expcoef

Eigen::MatrixXd factorial

Eigen::MatrixXd legs

int lmax

std::vector<double> massB

double maxSNR

vecT mean

std::vector<vecT> meanB

double minSNR

int nmax

int npart

Eigen::MatrixXd potd

double rmax

double rmin

double rscl

std::shared_ptr<SLGridSph> sl

vecT svar

double totalMass

int used

matT uvec

Eigen::VectorXd work

class Spline1d : public Interp1d

#include <interp.H>

Inheritence diagram for Spline1d:

Collaboration diagram for Spline1d:

Public Functions

virtual double deriv(const double &x)

Evaluate first derivative.

virtual double eval(const double &x)

Evaluate the interpolant.

void eval(const double &x, double &val, double &deriv)

Evaluate the interpolant and its first derivative.

Spline1d &operator=(const Spline1d&)

Copy constructor.

Spline1d()

Null constructor.

Spline1d(const Eigen::VectorXd &x, const Eigen::VectorXd &y, double d1 = -1.0e30, double d2 = -1.0e30)

Consruct with Eigen input. d1 and d2 are 2nd derivative BCs.

Spline1d(const std::vector<double> &x, const std::vector<double> &y, double d1 = -1.0e30, double d2 = -1.0e30)

Consruct with std::vector input. d1 and d2 are 2nd derivative BCs.

inline virtual double xhi()

inline virtual double xlo()

Data limits.

~Spline1d()

Destructor.

Private Members

Eigen::VectorXd x

Eigen::VectorXd y

Eigen::VectorXd y2

class Spline2d

#include <interp.H>

Two dimensional spline interpolator.

Public Functions

double eval(const double &x, const double &y)

Evaluate the interpolant.

Spline2d &operator=(const Spline2d&)

Copy constructor.

Spline2d(const Eigen::VectorXd &x, const Eigen::VectorXd &y, const Eigen::MatrixXd &mat)

Construct from Eigen input.

Spline2d(void)

Null constructor.

Public Static Attributes

static double DERIV

Private Members

Eigen::MatrixXd mat

Eigen::MatrixXd mat2d

Eigen::VectorXd x

Eigen::VectorXd xval

Eigen::VectorXd xval2

Eigen::VectorXd y

class SplineSoft : public SoftKernel

#include <GravKernel.H>

Inheritence diagram for SplineSoft:

Collaboration diagram for SplineSoft:

Cubic-spline softened gravity (compact support)

Public Functions

virtual std::pair<double, double> operator()(double r, double eps)

Main operator returning enclosed mass and gravitational potential

inline SplineSoft()

Constructor.

Private Functions

inline double m1(double x)

Spline kernel integrals.

inline double m2(double x)

inline double p1(double x)

inline double p2(double x)

Private Members

double eps

double fac0

double fac1

double fac2

class SPLInput

Input class to adaptively handle SPL. format specifically

inputs
---------------
filename : str
    the input filename to be read
comp     : str, optional
    the name of the component for which to extract data. If None, will read primary header and exit.
verbose  : int, default 0
    verbosity flag.

returns
---------------
self        : Input instance
  .header   : dict, all header values pulled from the file
    the .keys() are the names of each component
    each component has a dictionary of values, including 'parameters'
    the details of the force calculation are in 'force'
  .filename : str, the filename that was read
  .comp     : str, name of the component
  .time     : float, the time in the output file
  .data     : dictionary, with keys:
    x       : float, the x position
    y       : float, the y position
    z       : float, the z position
    vx      : float, the x velocity
    vy      : float, the y velocity
    vz      : float, the z velocity
    mass    : float, the mass of the particle
    index   : int, the integer index of the particle
    potE    : float, the potential energy value

Public Members

comp

component_map

data

f

filename

header

indexing

indir

nprocs

primary_header

subfiles

time

verbose

class SPtype

#include <SParticle.H>

Create an MPI particle type SParticle. The class creates and registers the particle type. It is freed when the instance goes out of scope and/or is destroyed.

Public Functions

inline MPI_Datatype operator()()

SPtype()

~SPtype()

Private Members

MPI_Datatype Particletype

template<typename T>
class standard_value : public cxxopts::values::abstract_value<T>

#include <cxxopts.H>

Inheritence diagram for cxxopts::values::standard_value:

Collaboration diagram for cxxopts::values::standard_value:

Public Functions

inline virtual CXXOPTS_NODISCARD std::shared_ptr< Value > clone () const override

template<>
class standard_value<bool> : public cxxopts::values::abstract_value<bool>

#include <cxxopts.H>

Inheritence diagram for cxxopts::values::standard_value< bool >:

Collaboration diagram for cxxopts::values::standard_value< bool >:

Public Functions

inline virtual std::shared_ptr<Value> clone() const override

inline standard_value()

inline explicit standard_value(bool *b)

~standard_value() override = default

Private Functions

inline void set_default_and_implicit()

struct star_particle

#include <tipsydefs.h>

Tipsy particle structure for a star particle.

Public Members

Real eps

Smoothing.

Real mass

particle mass

Real metals

Metallicty value.

Real phi

Gravitational potential.

Real pos[MAXDIM]

particle position vector

Real tform

Formation time.

Real vel[MAXDIM]

particle velocity vector

struct star_particle

#include <tipsy.H>

Public Functions

inline int ID() const

Convert phi to index.

Public Members

Real eps

Real mass

Particle data.

Real metals

Real phi

Real pos[MAXDIM]

Real tform

Real vel[MAXDIM]

class StatsMPI

#include <StatsMPI.H>

A class for accumulating data and computing rate coefficients from the DSMC simulation distribution.

Public Types

typedef std::map<speciesKey, SpStat> Return

typedef std::array<double, 4> SpStat

Public Functions

inline void add(const speciesKey &k, double wgt, double val)

Add a value.

inline void clear()

Reset values.

inline Return stats()

Gather values from nodes and return count, mean weighted value, and min and max preweighted value

inline StatsMPI()

Constructor.

Private Functions

inline void share()

Gather from MPI nodes.

Private Members

std::map<speciesKey, double> ccnt

std::map<speciesKey, double> cntT

std::map<speciesKey, double> curT

std::map<speciesKey, double> vmax

std::map<speciesKey, double> vmin

std::map<speciesKey, double> vsum

template<class T>
class StringTok

#include <StringTok.H>

Public Functions

T operator()(const T &delim)

inline StringTok(const T seq, typename T::size_type pos = 0)

Private Members

T::size_type pos_

const T seq_

template<class T>
class Swap

#include <Swap.H>

Public Functions

inline T &in()

inline T out()

inline T &rin()

inline Swap()

inline Swap(T i)

Public Members

unsigned char b[sizeof(T)]

T n

Private Members

int done

union Swap u

class TableCyl

#include <sltableMP2.H>

Public Members

Eigen::MatrixXd ef

Eigen::VectorXd ev

int k

int m

class TableGrid : public ThreeDGrid

#include <TableGrid.H>

Inheritence diagram for TableGrid:

Collaboration diagram for TableGrid:

This implementation of ThreeDGrid will write ascii files with records of the form X, Y, Z, D1, D2, D3, … where Dn are the data fields loaded by n called to the Add() member.

Public Functions

virtual void Add(const std::vector<double> &data, const std::string &name)

Add data.

TableGrid(int nx, int ny, int nz, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)

Constructor.

virtual void Write(const std::string &name)

Write output file.

Protected Types

typedef std::shared_ptr<dtype> dptr

typedef Dynamic3dArray<double> dtype

Protected Attributes

std::map<std::string, dptr> arrays

std::vector<float> XX

std::vector<float> YY

std::vector<float> ZZ

class TableSlab

#include <sltableMP2.H>

Public Members

Eigen::MatrixXd ef

Eigen::VectorXd ev

int kx

int ky

class TableSph

#include <sltableMP2.H>

Public Members

Eigen::MatrixXd ef

Eigen::VectorXd ev

int l

class TanhMap : public SLGridSlab::CoordMap

Inheritence diagram for SLGridSlab::TanhMap:

Collaboration diagram for SLGridSlab::TanhMap:

x = tanh(z/H)

Public Functions

virtual double d_xi_to_z(double z)

Jacobian of the transformation.

inline TanhMap(double H)

virtual double xi_to_z(double z)

Convert from mapped coordinate back to vertical.

virtual double z_to_xi(double z)

Convert from vertical to mapped coordinate.

class TaperedMestelDisk : public MestelDisk

#include <mestel.H>

Inheritence diagram for TaperedMestelDisk:

Collaboration diagram for TaperedMestelDisk:

Doubly tapered Mestel Disk.

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

Overloaded DF member functions.

virtual double get_density(const double R)

Overloaded density function.

virtual double get_mass(double R)

Overloaded cumulative mass function.

TaperedMestelDisk(double nu, double mu, double Ri, double Ro, double VROT = 1.0, double RMIN = 1.0e-6, double RMAX = 1.0e6)

Constructor.

Protected Functions

double dTinner(double Jp)

Deriv of inner taper function.

double dTouter(double Jp)

Deriv of outer taper function.

double Tinner(double Jp)

Inner taper function.

double Touter(double Jp)

Outer taper function.

Protected Attributes

double mu

double nu

Taper exponents.

double Ri

Inner taper radius.

double Ro

Outer taper radius.

double Tifac

Taper factors.

double Tofac

Private Members

std::shared_ptr<Linear1d> interp

struct thrd_pass_posvel

#include <global.H>

Helper class to pass info for incr_postion and incr_velocity.

Public Members

double dt

Time step.

int id

Thread counter id.

int mlevel

Levels flag.

struct thrd_pass_PotAccel

#include <PotAccel.H>

Collaboration diagram for thrd_pass_PotAccel:

Helper class to pass info to threaded member.

Public Members

bool coef

Call coefficient thread member (true) or acceleration/potential (false)

int id

Thread counter id.

PotAccel *t

Pointer to force.

class ThreeDGrid

#include <ThreeDGrid.H>

Inheritence diagram for ThreeDGrid:

This is an API for populating a 3d grid rectangular grid database for diagnostic output.

The user provides the size of the grid and extents. Calls to Add() add additiional data fields with the predefined rectangular grid shape. The input array is flattened and packed in C (not Fortran) order. A call to Write() dumps the array in the format implemented by the derived class.

Subclassed by DataGrid, TableGrid, VtkGrid

Public Functions

virtual void Add(const std::vector<double> &data, const std::string &name) = 0

Add a data field to the rectangular grid database.

inline ThreeDGrid()

Null constructor.

inline ThreeDGrid(int nx, int ny, int nz, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)

Constructor.

virtual void Write(const std::string &name) = 0

Write output file.

Protected Attributes

int nx

int ny

int nz

float xmax

float xmin

float ymax

float ymin

float zmax

float zmin

class tidalField : public ExternalForce

#include <tidalField.H>

Inheritence diagram for tidalField:

Collaboration diagram for tidalField:

Compute tidal acceleration and potential in the Hills limit.

The calculation is done in a frame having its cartesian axis directions fixed in space; i.e., the system is not phase locked with the perturber as is usually the case. Unfortunately, I know of no conserved quantities in this frame. int freeze_particle(int i) Freeze the i-th particle if it has gone too far away from the origin.

Public Functions

tidalField(const YAML::Node &config)

Constructor.

inline virtual ~tidalField()

Destructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

double hills_omega

double hills_p

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Time

#include <chkTimer.H>

A “helper” class to print time_t intervals.

Public Functions

inline Time(double T)

Constructor for double input.

inline Time(time_t T)

Constructor for time_t input.

Protected Attributes

time_t t

Friends

friend ostream &operator<<(ostream &out, Time const &T)

std output stream manipulator

class Timer

#include <Timer.H>

This is a diagnostic stopwatch-like timer implemented using std::chrono.

Public Functions

inline double getTime()

Return time measured up to this point.

inline bool isStarted()

Return the status of the timer.

inline double operator()()

Return time measured up to this point.

inline void reset()

Reset the timer, this will reset the time measured to 0 and reset the zero point if the timer is active

inline void start()

Start timer, if already started then do nothing.

inline double stop()

Stop timer and return time measured so far. If timer was stopped the time returned will be the current elapsed time.

inline Timer()

Constructor.

inline Timer(const Timer &t)

Copy consructor.

Private Members

std::chrono::high_resolution_clock::time_point begin

Time structures (will initialize to zero by default)

std::chrono::high_resolution_clock::time_point end

double rtime

The time measured so far.

bool started

Indicate whether the timer has been started.

class Tipsy : public PR::ParticleReader

#include <ParticleReader.H>

Inheritence diagram for PR::Tipsy:

Collaboration diagram for PR::Tipsy:

Class to access a Tipsy file

Public Types

enum class TipsyType

Values:

enumerator native

enumerator xdr

enumerator bonsai

Public Functions

virtual unsigned long CurrentNumber()

Number of particles in the chosen type.

inline virtual double CurrentTime()

Get current time.

virtual const Particle *firstParticle()

Particle access.

inline virtual std::vector<std::string> GetTypes()

Return list of particle types.

virtual const Particle *nextParticle()

Get the next particle.

virtual void SelectType(const std::string &type)

Select a particular particle type and reset the iterator.

Tipsy(const std::string &file, TipsyType type = TipsyType::native, bool verbose = false)

Single-file constructor.

Tipsy(const std::vector<std::string> &file, TipsyType type = TipsyType::native, bool verbose = false)

Constructor.

inline virtual ~Tipsy()

Destructor.

Protected Functions

void getNumbers()

bool nextFile()

void packParticle()

Protected Attributes

unsigned pcount

int ptype

Protected Static Attributes

static std::unordered_map<std::string, int> findP

static std::vector<std::string> Ptypes

Private Members

std::vector<std::string>::iterator curfile

Current file.

std::string curName

Current name.

std::vector<std::string> curTypes

Current types.

std::vector<std::string> files

List of files.

unsigned long Ndark

unsigned long Ngas

Totals.

unsigned long Nstar

Particle P

Temporary for packing array.

std::shared_ptr<TipsyReader::TipsyFile> ps

Pointer to Tipsy particle structures.

TipsyType ttype

Tipsy file type.

class TipsyFile

#include <tipsy.H>

Inheritence diagram for TipsyReader::TipsyFile:

Collaboration diagram for TipsyReader::TipsyFile:

Subclassed by TipsyReader::TipsyNative

Public Functions

virtual int readParticles() = 0

inline virtual ~TipsyFile()

Public Members

std::vector<dark_particle> dark_particles

std::vector<gas_particle> gas_particles

Header header

std::vector<star_particle> star_particles

Protected Functions

virtual void read_dark() = 0

virtual void read_gas() = 0

virtual void read_star() = 0

class TipsyNative : public TipsyReader::TipsyFile

#include <tipsy.H>

Inheritence diagram for TipsyReader::TipsyNative:

Collaboration diagram for TipsyReader::TipsyNative:

Public Functions

inline virtual int readParticles()

inline TipsyNative(const std::string filename)

inline ~TipsyNative()

Private Functions

inline int native_header()

Read the header.

inline int native_init(const std::string &filename)

inline int native_read()

inline virtual void read_dark()

inline virtual void read_gas()

inline virtual void read_star()

Private Members

std::ifstream input

The input file stream.

Friends

friend class PR::Tipsy

class ToomreDisk : public AxiSymModel

#include <toomre.H>

Inheritence diagram for ToomreDisk:

Collaboration diagram for ToomreDisk:

Public Functions

virtual double d2fde2(double E, double L)

virtual double dfde(double E, double L)

virtual double dfdl(double E, double L)

virtual double distf(double E, double L)

inline virtual double get_density(const double r)

inline virtual double get_dpot(const double r)

inline virtual double get_dpot2(const double r)

inline virtual double get_mass(const double r)

Access the profile.

inline virtual double get_max_radius(void)

inline virtual double get_min_radius(void)

inline virtual double get_pot(const double r)

inline virtual void get_pot_dpot(const double r, double &ur, double &dur)

inline ToomreDisk(int M = 0, double RMAX = 1.0e6)

Private Functions

void pdist(double E, double L)

Private Members

double e

double m

double p0

double p1

double p2

double rmax

double x

class TransformFFT

#include <TransformFFT.H>

Public Functions

void Inverse(Eigen::VectorXd &F, Eigen::VectorXcd &W)

void Inverse(std::vector<double> &F, std::vector<double> &Wr, std::vector<double> &Wi)

void Power(Eigen::VectorXd &F, Eigen::VectorXd &P)

void Power(std::vector<double> &F, std::vector<double> &P)

TransformFFT(double dr, Eigen::VectorXd &Y)

TransformFFT(double dr, std::vector<double> &Y)

~TransformFFT()

Private Members

double dk

double dr

int hi

std::vector<double> in

int lo

int N

std::vector<std::complex<double>> out

fftw_plan p

class Truncated : public EmpCylSL::AxiDisk

#include <DiskModels.H>

Inheritence diagram for Truncated:

Collaboration diagram for Truncated:

Truncate a AxiDisk.

Public Functions

inline virtual double operator()(double R, double z, double phi = 0.)

Density function.

inline Truncated(double R, double W, AxiDiskPtr p)

Private Types

typedef std::shared_ptr<EmpCylSL::AxiDisk> AxiDiskPtr

Private Members

AxiDiskPtr model

double rt

double rw

class TwoCenter : public PotAccel

#include <TwoCenter.H>

Inheritence diagram for TwoCenter:

Collaboration diagram for TwoCenter:

Computes the potential, acceleration and density using two basis sets with different expansion centers

This class provides a virtual member “mixture(double *pos)” that must be implemented by a derived class to provide the mixture function for associating particles with a force center for gravitational field determination. EJcom is an example of an implementation using an erf-based ramp whose argument is the distance from the particle to the inner center and the width is the distance between the centers.

All parameters are parsed by the underlying basis instances for the two centers. There is only one diagnostic parameter:

Param nhisto:

enables diagnostic output of mixture distribution if set to a value larger than 1

Param basis:

is the name of the force method to use for the two-center expansion. Available types are: “bessel” (Bessel), “sphereSL” (Sphere), “cylinder” (Cylinder).

Subclassed by EJcom

Public Types

typedef double (TwoCenter::* mixFunc)(double *p)

The mixture function.

Public Functions

inline double Cmixture(double *p)

The complement of the mixture function, also in [0,1].

virtual void determine_coefficients(Component *c)

Call Basis routines to make coefficients.

virtual void determine_coefficients(void)

Used by get_acceleration_and_potential to request that the expansion be performed.

virtual void get_acceleration_and_potential(Component*)

Main force evaluation routine: cycle through each grid.

virtual double mixture(double *p) = 0

Mixture function for the two expansions.

To be provided: must return a value in [0,1]

inline virtual void multistep_debug()

Print debug info.

inline virtual void multistep_reset()

Reset data for multistep.

inline virtual void multistep_update(int cur, int next, Component *c, int i, int id)

Implementation of level shifts.

inline virtual void multistep_update_begin()

Execute to begin level shifts for particles.

Update the multi time step force algorithm when moving particle i from level cur to level next

inline virtual void multistep_update_finish()

Execute to finish level shifts for particles.

inline virtual void RegisterComponent(Component *c)

For access to parent component.

inline virtual void set_multistep_level(unsigned n)

Multistepping routines: call the basis members for each component.

TwoCenter(Component *c0, const YAML::Node &conf)

Constructor

Parameters:

• c0 – is the instantiating caller (a Component)

• line – passes any parameters (rsphSL, rmin and numr)

~TwoCenter()

Destructor.

Public Members

vector<double> inner

INNER center for current component.

vector<double> outer

OUTER center for current component.

Protected Functions

void accum_histo(double value)

Make a histogram for debugging the mixture factor distribution.

Protected Attributes

double dz

The bin spacing.

vector<double> histo

The histogram bins.

unsigned nhisto

Number of bins.

string ohisto

Name for the histogram file.

Protected Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

Private Functions

inline virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreading implementation of the force computation.

inline virtual void *determine_coefficients_thread(void *arg)

The required force members, but this class does not multithread directly.

virtual void initialize(void)

Force initialization.

void reset_histo()

Zero out the histogram bins.

void write_histo()

Write the current histogram to the log file.

Private Members

string basis

The name of the basis (for reflection)

Basis *exp_in

Basis *exp_out

MixtureBasis *mix_in

Mixture containers for each basis.

MixtureBasis *mix_out

class TwoDCoefs

#include <TwoDCoefs.H>

Public Types

using CoefPtr = std::shared_ptr<Coefs>

using DataPtr = std::shared_ptr<Eigen::MatrixXd>

using LMkey = std::tuple<unsigned, unsigned>

Public Functions

DataPtr interpolate(const double time)

DataPtr operator()(const double time)

TwoDCoefs(const std::string &file, unsigned stride = 1)

Public Members

std::map<double, Eigen::MatrixXd> coefs

int Lmax

int nmax

int ntimes

std::vector<double> times

Private Functions

inline double to_ndigits(double x)

DataPtr zero_ret()

Private Members

int ndigits

DataPtr ret

template<typename T>
struct type_is_container

#include <cxxopts.H>

Public Static Attributes

static constexpr bool value = false

template<typename T>
struct type_is_container<std::vector<T>>

#include <cxxopts.H>

Public Static Attributes

static constexpr bool value = true

class Ultra : public OrthoPoly

#include <OrthoPoly.H>

Inheritence diagram for Ultra:

Collaboration diagram for Ultra:

Public Functions

inline virtual double coef1(const int n)

inline virtual double coef2(const int n)

inline virtual double coef3(const int n)

inline virtual double coef4(const int n)

inline virtual double f0(const double x)

inline virtual double f1(const double x)

inline virtual double h(const int n)

inline Ultra(double A)

inline virtual double w(const double x)

Private Members

double alpha

class UserBar : public ExternalForce

#include <UserBar.H>

Inheritence diagram for UserBar:

Collaboration diagram for UserBar:

Bar rotating at specified fraction of corotation

Param length:

is the bar length

Param bratio:

is the ratio of the submajor axis to the major axis

Param cratio:

is the ratio of the minor axis to the submajor axis

Param amp:

is the bar amplitude in fraction of the monopole mass

Param Ton:

is the time at the center of the erf turn on

Param Toff:

is the time at the center of the erf turn off

Param DeltaT:

is the spread of the turn on

Param Fcorot:

is fraction of the length relative to the corotation radius

Param fixed:

if nonzero, pattern speed is computed at every step from the current potential, if zero, pattern speed is evaluated once to start (default: false).

Param soft:

use the shallow form of the potential (default: false)

Param ctr_name:

defines the component that defines the bar center

Param angm_name:

defines the component that defines the L_z reservoir

Public Functions

UserBar(const YAML::Node &conf)

Constructor.

~UserBar()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void userinfo()

Private Members

double afac

double amplitude

std::string angm_name

double b5

double bratio

Component *c0

Component *c1

double cratio

std::string ctr_name

double DeltaT

double Fcorot

string filename

bool firstime

bool fixed

double Iz

double lastomega

double lasttime

double length

double Lz

double Lz0

double Lzbar

string name

double omega

double posang

bool soft

double Toff

double Ton

Private Static Attributes

static constexpr double numfac = 3.86274202023190e-01

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class UserDisk : public ExternalForce

#include <UserDisk.H>

Inheritence diagram for UserDisk:

Collaboration diagram for UserDisk:

Potential and force of a thin exponential disk. The force is tabulated on a two-dimensional grid with positive Z and interpolated using bilinear interpolation.

The default values for Nscale, Ngrid and Nint should suffice for most applications.

Param a:

is the disk scale length

Param mass:

is the total mass of the disk

Param Ton:

is the time at the center of the erf turn on

Param Toff:

is the time at the center of the erf turn off

Param DeltaT:

is the spread of the turn on

Param ctrname:

defines the component that defines the center (otherwise the center is fixed to the origin)

Param Nscale:

is the physical scale of the grid in numbers of disk scale lengths

Param Ngrid:

is the number of table points in each dimension

Param Nint:

is the number of integration knots

Public Functions

UserDisk(const YAML::Node &conf)

Constructor.

~UserDisk()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

void genTable()

void getTable(double R, double Z, double &pot, double &fr, double &fz)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void printTable()

void userinfo()

Private Members

double a

Component *c0

string ctr_name

bool debug

double DeltaT

double dfac

double dR

double dZ

double mass

string name

int Ngrid

int Nint

double Nscale

double *Ptable

double Rmax

double *Rtable

double Toff

double Ton

double Zmax

double *Ztable

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class UserHalo : public ExternalForce

#include <UserHalo.H>

Inheritence diagram for UserHalo:

Collaboration diagram for UserHalo:

Halo model based on SphericalModelTable

Param model_file:

is the filename

Param comp_name:

is the component to apply this (blank for all, default=””)

Param diverge:

set to 1 uses a power law inner profile

Param diverge_rfac:

is the value of power law exponent

Param q0:

is the x-axis scaling (for simulating a triaxial halo, default: 1)

Param q1:

is the y-axis scaling (for simulating a triaxial halo, default: 1)

Param q2:

is the z-axis scaling (for simulating a triaxial halo, default: 1)

Public Functions

UserHalo(const YAML::Node &conf)

Constructor.

~UserHalo()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void userinfo()

Private Members

Component *c0

std::string comp_name

int diverge

double diverge_rfac

SphericalModelTable *model

std::string model_file

double q1

double q2

double q3

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class UserLogPot : public ExternalForce

#include <UserLogPot.H>

Inheritence diagram for UserLogPot:

Collaboration diagram for UserLogPot:

Logarithmic triaxial potential

Param R:

is the core size

Param b:

is the y-axis scale factor

Param c:

is the z-axis scale factor

Param v2:

is the amplitude (e.g. the velocity on the axis at x=1)

Public Functions

UserLogPot(const YAML::Node &conf)

Constructor.

~UserLogPot()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void userinfo()

Private Members

double b

double c

double R

double v2

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class UserMNdisk : public ExternalForce

#include <UserMNdisk.H>

Inheritence diagram for UserMNdisk:

Collaboration diagram for UserMNdisk:

Potential and force of the Miyamoto-Nagai disk.

Param a:

is the disk scale length parameter

Param b:

is the disk scale height parameter

Param mass:

is the total mass of the disk

Param Ton:

is the time at the center of the erf turn on

Param Toff:

is the time at the center of the erf turn off

Param DeltaT:

is the spread of the turn on

Param ctrname:

defines the component that defines the center (otherwise the center is fixed to the origin)

Public Functions

UserMNdisk(const YAML::Node &conf)

Constructor.

~UserMNdisk()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

void userinfo()

Private Members

double a

double b

Component *c0

string ctr_name

double DeltaT

double mass

string name

double Toff

double Ton

Private Static Attributes

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class UserMW : public ExternalForce

#include <UserMW.H>

Inheritence diagram for UserMW:

Collaboration diagram for UserMW:

Potential and force of the Milky Way, a la Gala.

!!!ADD ALL PARAMETERS YOU WANT TO DEFINE, using this format (for automatic documentation)!!! Done

Param G:

is the gravitational constant

Param M_halo:

is the total mass of the Navarro-Frank-White (NFW) halo component

Param rs_halo:

is the scale radius of the Navarro-Frank-White (NFW) halo component

Param M_disk:

is the total mass of the Miyamoto-Nagai (MN) disk component

Param a_disk:

is the scale length of the Miyamoto-Nagai (MN) disk component

Param b_disk:

is the scale height of the Miyamoto-Nagai (MN) disk component

Param M_nucl:

is the total mass of the Hernquist (HN) nucleus component

Param c_nucl:

is the concentration of the Hernquist (HN) nucleus component

Param M_bulge:

is the total mass of the Hernquist (HN) bulge component

Param c_bulge:

is the concentration of the Hernquist (HN) bulge component

Param Ton:

is the time at the center of the erf turn on

Param Toff:

is the time at the center of the erf turn off

Param DeltaT:

is the spread of the turn on

Param ctrname:

defines the component that defines the center (otherwise the center is fixed to the origin)

Public Functions

UserMW(const YAML::Node &conf)

Constructor.

~UserMW()

Destructor.

Private Functions

virtual void determine_acceleration_and_potential(void)

Called to evaluate acceleration Default version calls the provided thread function. Can be overloaded to provide additional non-threaded tasks.

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

inline void HN_bulge_dphi_dr(double x, double y, double z, double *ax3, double *ay3, double *az3)

inline double HN_bulge_pot(double r)

inline void HN_nucl_dphi_dr(double x, double y, double z, double *ax2, double *ay2, double *az2)

inline double HN_nucl_pot(double r)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

inline void MN_dphi_dR_dz(double x, double y, double z, double *ax4, double *ay4, double *az4)

inline double MN_pot(double z, double R)

inline void NFW_dphi_dr(double x, double y, double z, double *ax1, double *ay1, double *az1)

inline double NFW_pot(double r)

void userinfo()

Private Members

double a_disk

double b_disk

Component *c0

double c_bulge

double c_nucl

string ctr_name

double DeltaT

double G

double M_bulge

double M_disk

double M_halo

double M_nucl

string name

double rs_halo

double Toff

double Ton

class UserTest : public ExternalForce

#include <UserTest.H>

Inheritence diagram for UserTest:

Collaboration diagram for UserTest:

Simple skeleton user routine Does nothing but print out messages at each call

Public Functions

UserTest(const YAML::Node &conf)

Constructor.

~UserTest()

Destructor.

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

class UserTestCuda : public ExternalForce

#include <UserTestCuda.H>

Inheritence diagram for UserTestCuda:

Collaboration diagram for UserTestCuda:

Public Functions

UserTestCuda(const YAML::Node &conf)

~UserTestCuda()

Private Functions

virtual void *determine_acceleration_and_potential_thread(void *arg)

Multithreaded method (must be thread safe) for force computation that must be provided by all derived classes (hence pure virtual)

virtual void initialize()

Used by derived class to initialize any storage and parameters.

Private Members

int callno

int instance

int maxcall

Private Static Attributes

static int total

static const std::set<std::string> valid_keys

Valid keys for YAML configurations.

class Value : public std::enable_shared_from_this<Value>

#include <cxxopts.H>

Inheritence diagram for cxxopts::Value:

Collaboration diagram for cxxopts::Value:

Subclassed by cxxopts::values::abstract_value< bool >, cxxopts::values::abstract_value< T >

Public Functions

virtual std::shared_ptr<Value> clone() const = 0

virtual std::shared_ptr<Value> default_value(const std::string &value) = 0

virtual std::string get_default_value() const = 0

virtual std::string get_implicit_value() const = 0

virtual bool has_default() const = 0

virtual bool has_implicit() const = 0

virtual std::shared_ptr<Value> implicit_value(const std::string &value) = 0

virtual bool is_boolean() const = 0

virtual bool is_container() const = 0

virtual std::shared_ptr<Value> no_implicit_value() = 0

virtual void parse() const = 0

virtual void parse(const std::string &text) const = 0

virtual ~Value() = default

class VtkGrid : public ThreeDGrid

#include <VtkGrid.H>

Inheritence diagram for VtkGrid:

Collaboration diagram for VtkGrid:

A ThreeDGrid implementation of the rectangular grid database implement in VTK and designed for consumption by PyVTK or ParaView.

Public Functions

virtual void Add(const std::vector<double> &data, const std::string &name)

Add data for two-dimensional cylindrical basis.

VtkGrid(int nx, int ny, int nz, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)

Constructor.

virtual void Write(const std::string &name)

Write output file.

Private Functions

void replaceAll(std::string &str, const std::string &from, const std::string &to)

void writeBeg(std::ofstream &file)

void writeCoords(std::ofstream &file)

void writeEnd(std::ofstream &file)

void writeFields(std::ofstream &file)

Private Members

std::map<std::string, std::vector<float>> coord

std::map<std::string, std::vector<float>> dataSet

class VtkPCA

#include <VtkPCA.H>

Public Functions

void Add(const Eigen::VectorXd &coef, const Eigen::VectorXd &hall, const Eigen::VectorXd &snr, const Eigen::VectorXd &eval, const Eigen::MatrixXd &evec, const Eigen::MatrixXd &covr, int l, int m)

Add data for three-dimensional spherical basis.

void Add(const Eigen::VectorXd &coef, const Eigen::VectorXd &hall, const Eigen::VectorXd &snr, const Eigen::VectorXd &eval, const Eigen::MatrixXd &evec, const Eigen::MatrixXd &covr, int m)

Add data for two-dimensional cylindrical basis.

VtkPCA(int N, bool reorder = false, bool smooth = false)

Constructor.

void Write(const std::string &name)

Write output file.

Private Members

std::vector<vtkFloatArrayP> coef

std::vector<vtkFloatArrayP> covr

vtkRectilinearGridP dataSet

std::vector<std::string> elab

std::vector<vtkFloatArrayP> eval

std::vector<vtkFloatArrayP> hall

int nmax

bool reorder

bool smooth

std::vector<vtkFloatArrayP> snrv

std::vector<vtkFloatArrayP> vec2

std::vector<vtkFloatArrayP> vecs

vtkFloatArrayP XX

vtkFloatArrayP YY

vtkFloatArrayP ZZ

class WRgrid

#include <massmodel.H>

Public Members

vector<double> r

vector<double> w1

class YamlConfigError : public EXPException

#include <EXPException.H>

Inheritence diagram for YamlConfigError:

Collaboration diagram for YamlConfigError:

Configuration error.

Public Functions

inline YamlConfigError(const std::string classname, const std::string type, const std::set<std::string> keys, const std::string sourcefilename, int sourcelinenumber, int errorcode = -1, bool deadlock = false)

Constructor.

class ZangCyl : public EmpCyl2d::MestelCyl

#include <EmpCyl2d.H>

Inheritence diagram for EmpCyl2d::ZangCyl:

Collaboration diagram for EmpCyl2d::ZangCyl:

Public Functions

inline virtual double dens(double R)

Surface density.

inline ZangCyl(const YAML::Node &par)

Constructor.

Protected Functions

inline virtual void parse(const YAML::Node &conf)

Assign values from YAML.

Private Functions

inline double dTinner(double Jp)

Deriv of inner taper function.

inline double dTouter(double Jp)

Deriv of outer taper function.

inline double Tinner(double Jp)

Inner taper function.

inline double Touter(double Jp)

Outer taper function.

Private Members

double asoft = 1.0e-8

Softening factor (not currently used)

bool Inner = true

Ignore inner cut-off for N<0.05.

double mu

Parameters.

double nu

double ri

double ro

double Tifac

Taper factors.

double Tofac

template<class T>
class ZBrent

#include <ZBrent.H>

Public Functions

ZBrentReturn find(func_T func, T &param, double x1, double x2, double tol, double &result)

inline ZBrent()

Public Static Attributes

static double EPS = 1.0e-16

static double epsilon = 1.0e-3

static int ITMAX = 100

Private Types

using func_T = std::function<double(double, T&)>

namespace AltMath

Functions

double assoc_laguerre(unsigned l, unsigned n, double x)

double cyl_bessel_i(double nu, double x)

double cyl_bessel_j(double nu, double x)

double cyl_bessel_k(double nu, double x)

double sph_bessel(unsigned n, double x)

namespace cxxopts

Typedefs

using NameHashMap = std::unordered_map<std::string, size_t>

using OptionMap = std::unordered_map<std::string, std::shared_ptr<OptionDetails>>

using ParsedHashMap = std::unordered_map<size_t, OptionValue>

using PositionalList = std::vector<std::string>

using PositionalListIterator = PositionalList::const_iterator

using String = std::string

Functions

inline bool empty(const std::string &s)

inline String &stringAppend(String &s, const String &a)

template<typename Iterator>
String &stringAppend(String &s, Iterator begin, Iterator end)

inline String &stringAppend(String &s, size_t n, char c)

inline size_t stringLength(const String &s)

template<typename T>
void throw_or_mimic(const std::string &text)

template<typename T>
T toLocalString(T &&t)

template<typename T>
std::string toUTF8String(T &&t)

template<typename T>
std::shared_ptr<Value> value()

template<typename T>
std::shared_ptr<Value> value(T &t)

Variables

uint8_t major

uint8_t minor

uint8_t patch

static constexpr struct cxxopts version = {CXXOPTS__VERSION_MAJOR, CXXOPTS__VERSION_MINOR, CXXOPTS__VERSION_PATCH}

namespace cxxopts

namespace values

Functions

template<typename R, typename T>
void checked_negate(R&, T&&, const std::string &text, std::false_type)

template<typename R, typename T>
void checked_negate(R &r, T &&t, const std::string&, std::true_type)

template<typename T>
void integer_parser(const std::string &text, T &value)

inline void parse_value(const std::string &text, bool &value)

inline void parse_value(const std::string &text, char &c)

inline void parse_value(const std::string &text, std::string &value)

template<typename T>
void parse_value(const std::string &text, std::vector<T> &value)

template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void parse_value(const std::string &text, T &value)

template<typename T>
void stringstream_parser(const std::string &text, T &value)

namespace detail

Functions

template<typename T, typename U>
void check_signed_range(bool negative, U value, const std::string &text)

namespace parser_tool

Functions

inline bool IsFalseText(const std::string &text)

inline bool IsTrueText(const std::string &text)

inline ArguDesc ParseArgument(const char *arg, bool &matched)

inline IntegerDesc SplitInteger(const std::string &text)

inline std::pair<std::string, std::string> SplitSwitchDef(const std::string &text)

namespace parser_tool

namespace Eigen

namespace KDE

namespace KDtree

Functions

template<typename coordinate_type, size_t dimensions>
std::ostream &operator<<(std::ostream &out, const point<coordinate_type, dimensions> &pt)

For iostream printing of points.

namespace ODE

namespace PR

Typedefs

typedef std::shared_ptr<ParticleReader> PRptr

namespace progress

module psp_io

psp_io.py
   driver for input classes and handling particle data in Python

MSP 25 Oct 2021 Overhauled version


TODO

namespace std

namespace TipsyReader

Typedefs

using Real = float

Variables

const int MAXDIM = 3

file AsciiHisto.H

#include <iostream>

#include <iomanip>

#include <vector>

#include <memory>

Include dependency graph for AsciiHisto.H:

Typedefs

typedef std::shared_ptr<AsciiHisto<double>> ahistoDPtr

typedef std::shared_ptr<AsciiHisto<int>> ahistoIPtr

typedef std::shared_ptr<AsciiHisto<unsigned>> ahistoUPtr

file BarrierWrapper.H

#include <iostream>

#include <iomanip>

#include <vector>

#include <string>

#include <list>

#include <map>

#include <set>

#include <memory>

#include <Timer.H>

#include <mpi.h>

Include dependency graph for BarrierWrapper.H:

This graph shows which files directly or indirectly include BarrierWrapper.H:

Typedefs

typedef std::shared_ptr<BWData> BWPtr

typedef std::shared_ptr<char> CharPtr

typedef std::shared_ptr<Info> InfoPtr

typedef std::shared_ptr<MPI_Request> ReqPtr

file biorth.H

#include <iostream>

#include <iomanip>

#include <cstdlib>

#include <string>

#include <memory>

#include <Eigen/Eigen>

Include dependency graph for biorth.H:

This graph shows which files directly or indirectly include biorth.H:

Typedefs

typedef std::shared_ptr<AxiSymBiorth> AxiSymBioPtr

Enums

enum BiorthFcts3d

Values:

enumerator bessel

enumerator clutton_brock

enumerator hernquist

enumerator sturm

enum ScalarType

Values:

enumerator density

enumerator potential

Functions

Eigen::VectorXd scalar_prod(ScalarType type, double rmin, double rmax, int l, int m, AxiSymBiorth &s, std::function<double(double, int, int)> func, int nc, int ng)

std::string &ScalarTypeName(ScalarType i)

Variables

static std::string BiorthFcts3dName[] = {"BSSphere", "CBSphere", "HQSphere", "SphereSL"}

file biorth1d.H

#include <cmath>

#include <biorth.H>

Include dependency graph for biorth1d.H:

This graph shows which files directly or indirectly include biorth1d.H:

file biorth2d.H

#include <string>

#include <biorth.H>

Include dependency graph for biorth2d.H:

Enums

enum BiorthFcts2d

Values:

enumerator clutton_brock_2d

enumerator bessel_2d

file biorth_wake.H

#include <Eigen/Eigen>

#include <complex>

#include <biorth.H>

Include dependency graph for biorth_wake.H:

file BiorthCube.H

#include <iostream>

#include <fstream>

#include <string>

#include <cmath>

#include <Eigen/Eigen>

#include <mpi.h>

#include <localmpi.H>

#include <config_exp.h>

#include <massmodel.H>

#include <yaml-cpp/yaml.h>

#include <highfive/H5File.hpp>

#include <highfive/H5DataSet.hpp>

#include <highfive/H5DataSpace.hpp>

#include <highfive/H5Attribute.hpp>

#include <EmpCyl2d.H>

Include dependency graph for BiorthCube.H:

file BiorthCyl.H

#include <iostream>

#include <fstream>

#include <string>

#include <cmath>

#include <Eigen/Eigen>

#include <mpi.h>

#include <localmpi.H>

#include <config_exp.h>

#include <massmodel.H>

#include <yaml-cpp/yaml.h>

#include <highfive/H5File.hpp>

#include <highfive/H5DataSet.hpp>

#include <highfive/H5DataSpace.hpp>

#include <highfive/H5Attribute.hpp>

#include <EmpCyl2d.H>

Include dependency graph for BiorthCyl.H:

This graph shows which files directly or indirectly include BiorthCyl.H:

file BWHelper.H

#include <iostream>

#include <iomanip>

#include <vector>

#include <string>

#include <limits>

#include <set>

Include dependency graph for BWHelper.H:

file CauchyPV.H

#include <vector>

#include <Eigen/Eigen>

Include dependency graph for CauchyPV.H:

file CenterFile.H

#include <fstream>

#include <vector>

#include <array>

#include <yaml-cpp/yaml.h>

Include dependency graph for CenterFile.H:

This graph shows which files directly or indirectly include CenterFile.H:

file Circular.H

#include <vector>

Include dependency graph for Circular.H:

This graph shows which files directly or indirectly include Circular.H:

file circular_buffer.H

#include <algorithm>

#include <iterator>

#include <mutex>

#include <memory>

#include <stdexcept>

#include <utility>

Include dependency graph for circular_buffer.H:

file coef.H

This graph shows which files directly or indirectly include coef.H:

file coef.H

This graph shows which files directly or indirectly include coef.H:

file Coefs.H

#include <memory>

#include <Eigen/Eigen>

#include <yaml-cpp/yaml.h>

#include “src/coef.H”

Include dependency graph for Coefs.H:

Typedefs

typedef std::shared_ptr<CylCoefs> CylCoefsPtr

typedef std::shared_ptr<SphCoefs> SphCoefsPtr

file ColorGradient.H

#include <png++/png.hpp>

Include dependency graph for ColorGradient.H:

file cpoly.H

#include “poly.H”

Include dependency graph for cpoly.H:

Functions

void bomb_CPoly(const char*)

void bomb_CPoly_operation(const char*)

file Cspline.H

#include <iostream>

#include <vector>

Include dependency graph for Cspline.H:

file cubic.H

#include <Eigen/Eigen>

Include dependency graph for cubic.H:

file cxxopts.H

#include <cctype>

#include <cstring>

#include <exception>

#include <iostream>

#include <limits>

#include <list>

#include <map>

#include <memory>

#include <sstream>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <vector>

#include <algorithm>

#include <regex>

Include dependency graph for cxxopts.H:

This graph shows which files directly or indirectly include cxxopts.H:

Defines

CXXOPTS__VERSION_MAJOR

CXXOPTS__VERSION_MINOR

CXXOPTS__VERSION_PATCH

CXXOPTS_NODISCARD

CXXOPTS_VECTOR_DELIMITER

file DataGrid.H

#include <vector>

#include <sstream>

#include <memory>

#include <config_exp.h>

#include <TableGrid.H>

#include <VtkGrid.H>

Include dependency graph for DataGrid.H:

Typedefs

typedef std::shared_ptr<DataGrid> DataGridPtr

file DiskDensityFunc.H

#include <functional>

#include <pybind11/pybind11.h>

#include <pybind11/embed.h>

Include dependency graph for DiskDensityFunc.H:

This graph shows which files directly or indirectly include DiskDensityFunc.H:

file DiskModels.H

#include <EmpCylSL.H>

#include <DiskDensityFunc.H>

Include dependency graph for DiskModels.H:

This graph shows which files directly or indirectly include DiskModels.H:

file DiskWithHalo.H

#include <massmodel.H>

Include dependency graph for DiskWithHalo.H:

This graph shows which files directly or indirectly include DiskWithHalo.H:

file EmpCyl2d.H

#include <algorithm>

#include <memory>

#include <string>

#include <vector>

#include <array>

#include <tuple>

#include <Eigen/Eigen>

#include <Eigen/Eigenvalues>

#include <yaml-cpp/yaml.h>

#include <config_exp.h>

#include <gaussQ.H>

#include <EXPmath.H>

#include <localmpi.H>

#include <highfive/highfive.hpp>

#include <highfive/eigen.hpp>

Include dependency graph for EmpCyl2d.H:

This graph shows which files directly or indirectly include EmpCyl2d.H:

file EmpCylSL.H

#include <functional>

#include <vector>

#include <memory>

#include <limits>

#include <cmath>

#include <Eigen/Eigen>

#include <gaussQ.H>

#include <interp.H>

#include <Timer.H>

#include <Particle.H>

#include <SLGridMP2.H>

#include <coef.H>

#include <libvars.H>

Include dependency graph for EmpCylSL.H:

This graph shows which files directly or indirectly include EmpCylSL.H:

Typedefs

typedef std::shared_ptr<EmpCylSL> EmpCylSLptr

Functions

void dlegendre_R(int lmax, double x, Eigen::MatrixXd &p, Eigen::MatrixXd &dp)

void legendre_R(int lmax, double x, Eigen::MatrixXd &p)

void sinecosine_R(int mmax, double phi, Eigen::VectorXd &c, Eigen::VectorXd &s)

file euler.H

#include <Eigen/Eigen>

Include dependency graph for euler.H:

This graph shows which files directly or indirectly include euler.H:

Functions

Eigen::Matrix3d return_euler(double PHI, double THETA, double PSI, int BODY)

Eigen::Matrix3d return_euler_slater(double PHI, double THETA, double PSI, int BODY)

file exp_thread.h

#include <pthread.h>

Include dependency graph for exp_thread.h:

Functions

void exp_thread_fork(void *(*func)(void*), char *caller)

void kill_mutex(pthread_mutex_t *m, char *caller, char *name)

void make_mutex(pthread_mutex_t *m, char *caller, char *name)

file exp_thread.h

#include <pthread.h>

Include dependency graph for exp_thread.h:

Functions

void exp_thread_fork(void *(*func)(void*), char *caller)

void kill_mutex(pthread_mutex_t *m, char *caller, char *name)

void make_mutex(pthread_mutex_t *m, char *caller, char *name)

file EXPException.H

#include <set>

#include <vector>

#include <string>

#include <sstream>

#include <libvars.H>

Include dependency graph for EXPException.H:

This graph shows which files directly or indirectly include EXPException.H:

file EXPini.H

#include <algorithm>

#include <typeinfo>

#include <iostream>

#include <iomanip>

#include <fstream>

#include <sstream>

#include <cstring>

#include <yaml-cpp/yaml.h>

#include <cxxopts.H>

Include dependency graph for EXPini.H:

Functions

cxxopts::ParseResult LoadConfig(cxxopts::Options &options, const std::string &config)

Read the YAML parameter config file and load the cxxopts database with parameters

void SaveConfig(const cxxopts::ParseResult &vm, const cxxopts::Options &options, const std::string &config, const std::vector<std::string> groups = {""}, const std::vector<std::string> exclude = {"help", "template", "expert", "config"})

Saves the current command-line cxxopts database in YAML format for user configuration. For ease, the current convention is that all vector-values options will be stored as strings, and converted by the calling program to the correct value internally.

file EXPmath.H

This graph shows which files directly or indirectly include EXPmath.H:

file exponential.H

#include <massmodel.H>

Include dependency graph for exponential.H:

This graph shows which files directly or indirectly include exponential.H:

file exputils.H

#include <string>

#include <Eigen/Eigen>

Include dependency graph for exputils.H:

Functions

std::tuple<bool, double, std::vector<double>> orthoCompute(const std::vector<Eigen::MatrixXd> &tests)

void orthoTest(const std::vector<Eigen::MatrixXd> &tests, const std::string &classname, const std::string &indexname)

file FileUtils.H

#include <string>

Include dependency graph for FileUtils.H:

Functions

bool FileExists(const std::string &filename)

bool FileRename(const std::string &file1, const std::string &file2)

file FindOrb.H

#include <functional>

Include dependency graph for FindOrb.H:

file fpetrap.h

#include <iostream>

#include <iomanip>

#include <cfenv>

#include <list>

#include <signal.h>

Include dependency graph for fpetrap.h:

Functions

static void my_fpu_handler(int err)

Very lean error handler. Only good for setting a debugger breakpoint.

void set_fpu_handler(void)

Turns on exceptions for invalid, div by zero and overflow, other

bits default. This will only work for x86 architecture.

Variables

static int my_err

Global to hold error code.

Some FPE trapping stuff for debugging

static void (*oldhandler)(int)

file Func1d.H

file gadget.H

This graph shows which files directly or indirectly include gadget.H:

file gaussQ.H

#include <iostream>

#include <iomanip>

#include <sstream>

#include <cstdlib>

#include <string>

#include <vector>

Include dependency graph for gaussQ.H:

This graph shows which files directly or indirectly include gaussQ.H:

file GenPoly.H

#include <cmath>

#include <massmodel.H>

Include dependency graph for GenPoly.H:

file gknots.h

Functions

void free_gknots(struct GAUSS*, int)

void get_gknots(struct GAUSS*, int)

file Hankel.H

#include <functional>

#include <algorithm>

#include <vector>

#include <cmath>

#include <boost/math/special_functions/bessel.hpp>

#include <boost/math/tools/minima.hpp>

Include dependency graph for Hankel.H:

file header.H

#include <iostream>

#include <iomanip>

#include <sstream>

#include <memory>

#include “localmpi.H”

Include dependency graph for header.H:

This graph shows which files directly or indirectly include header.H:

file hernquist_model.H

#include <cmath>

#include <massmodel.H>

Include dependency graph for hernquist_model.H:

file hunter.H

#include <massmodel.H>

Include dependency graph for hunter.H:

This graph shows which files directly or indirectly include hunter.H:

file HunterX.H

#include <massmodel.H>

#include <hunter.h>

Include dependency graph for HunterX.H:

file InitContainer.H

#include <map>

Include dependency graph for InitContainer.H:

Functions

template<template<class, class, class...> class C, typename K, typename V, typename ...Args>
V &GetWithDef(C<K, V, Args...> &m, K const &key, const V &defval)

Non-invasive, assignable, lvalue return.

template<template<class, class, class...> class C, typename K, typename V, typename ...Args>
V GetWithDef(const C<K, V, Args...> &m, K const &key, const V &defval)

Non-invasive, constant rvalue return.

Wrapper template for STL containers for initializing value for new key.

GetWithDef returns a value and MapWithDef returns the container.

The Icont class derives a helper class using the STL container as a base class. This version seems the cleanest but may have slightly more overhead.

This version is updated for C++11 variadic arguments. Should work for generic associative containers including the optional comparator and allocator parameters.

file interp.H

#include <Eigen/Eigen>

#include <vector>

#include <deque>

#include <MonotCubicInterpolator.H>

Include dependency graph for interp.H:

This graph shows which files directly or indirectly include interp.H:

Functions

template<class V>
double drv2(double x, const V &xtab, const V &ftab, int even = 0)

template<class V>
double odd2(double x, const V &xtab, const V &ftab, int even = 0)

void Spline(const Eigen::VectorXd &x, const Eigen::VectorXd &y, double yp1, double ypn, Eigen::VectorXd &y2)

void Splint1(const Eigen::VectorXd &xa, const Eigen::VectorXd &ya, const Eigen::VectorXd &y2a, double x, double &y, int even = 0)

void Splint2(const Eigen::VectorXd &xa, const Eigen::VectorXd &ya, const Eigen::VectorXd &y2a, double x, double &y, double &dy, int even = 0)

void Splint3(const Eigen::VectorXd &xa, const Eigen::VectorXd &ya, const Eigen::VectorXd &y2a, double x, double &y, double &dy, double &dyy, int even = 0)

double Splsum(const Eigen::VectorXd &x, const Eigen::VectorXd &y)

void Splsum(const Eigen::VectorXd &x, const Eigen::VectorXd &y, Eigen::VectorXd &z)

double Trapsum(const Eigen::VectorXd &x, const Eigen::VectorXd &y)

void Trapsum(const Eigen::VectorXd &x, const Eigen::VectorXd &y, Eigen::VectorXd &z)

template<class V>
int Vlocate(double x, const V &xtab)

template<class V>
int Vlocate_with_guard(double value, const V &vec)

file isothermal.H

#include <cmath>

#include <massmodel.H>

#include <interp.H>

Include dependency graph for isothermal.H:

file Iterable.H

#include <iterator>

#include <cstddef>

Include dependency graph for Iterable.H:

file kalnajs.H

file KDtree.H

#include <algorithm>

#include <random>

#include <vector>

#include <array>

#include <cmath>

#include <tuple>

#include <map>

Include dependency graph for KDtree.H:

file king.H

#include <massmodel.H>

Include dependency graph for king.H:

file libvars.H

#include <random>

#include <mpi.h>

Include dependency graph for libvars.H:

This graph shows which files directly or indirectly include libvars.H:

file localmpi.H

#include <mpi.h>

#include <iostream>

#include <fstream>

#include <iomanip>

#include <string>

Include dependency graph for localmpi.H:

This graph shows which files directly or indirectly include localmpi.H:

Functions

void local_init_mpi(int argc, char **argv)

Initialize MPI.

inline void mpi_report_location(const std::string &msg)

For MPI debugging.

Variables

MPI_Comm MPI_COMM_WORKER

std::ofstream mpi_debug

int myid

int numprocs

int proc_namelen

char processor_name[MPI_MAX_PROCESSOR_NAME]

MPI_Group worker_group

int workers

MPI_Group world_group

file massmodel.H

#include <vector>

#include <memory>

#include <random>

#include <tuple>

#include <Eigen/Eigen>

#include <interp.H>

#include <orbit.H>

#include <QPDistF.H>

Include dependency graph for massmodel.H:

This graph shows which files directly or indirectly include massmodel.H:

Typedefs

typedef std::shared_ptr<AxiSymModel> AxiSymModPtr

typedef std::shared_ptr<EmbeddedDiskModel> EmbDiskModPtr

typedef std::shared_ptr<SphericalModelMulti> SphModMultPtr

typedef std::shared_ptr<SphericalModelTable> SphModTblPtr

file mestel.H

#include <massmodel.H>

Include dependency graph for mestel.H:

file model2d.H

Enums

enum Models2d

Values:

enumerator mestel

enumerator toomre

enumerator expon

enumerator kalnajs

enumerator hunter

enumerator hunterx

Variables

static string Model2dNames[] = {"Mestel", "Toomre", "Exponential", "Kalnajs", "Hunter", "HunterX"}

file model3d.H

Enums

enum Models3d

Values:

enumerator file

enumerator isothermal

enumerator sing_isothermal

enumerator low_sing_isothermal

enumerator hernquist_model

enumerator gen_polytrope

enumerator plummer

Variables

static std::string Model3dNames[] = {"file", "Isothermal", "SingIsothermal", "LowSingIsothermal", "Hernquist", "GeneralizedPolytrope", "PlummerSphere"}

file models.H

#include <Eigen/Eigen>

Include dependency graph for models.H:

file MonotCubicInterpolator.H

#include <vector>

#include <map>

#include <string>

Include dependency graph for MonotCubicInterpolator.H:

This graph shows which files directly or indirectly include MonotCubicInterpolator.H:

file needle.H

file norminv.H

#include <cmath>

Include dependency graph for norminv.H:

Defines

A1

A2

A3

A4

A5

A6

B1

B2

B3

B4

B5

C1

C2

C3

C4

C5

C6

D1

D2

D3

D4

P_HIGH

P_LOW

Functions

double norminv(double p)

file numerical.H

#include <functional>

#include <Eigen/Eigen>

Include dependency graph for numerical.H:

This graph shows which files directly or indirectly include numerical.H:

Defines

DOUBLE(X)

FLOAT(X)

MAX(X, Y)

MIN(X, Y)

Sign(X)

SQR(X)

TINY

Typedefs

using ode_derivs = std::function<void(double, Eigen::VectorXd&, Eigen::VectorXd&)>

using ode_integrator = std::function<void(Eigen::VectorXd&, Eigen::VectorXd&, int, double&, double, double, Eigen::VectorXd&, double&, double&, ode_derivs)>

using ode_rk = std::function<void(Eigen::VectorXd&, Eigen::VectorXd&, int, double, double, Eigen::VectorXd&, ode_derivs)>

using symp_derivs = std::function<void(double, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&)>

using symp_integrator = std::function<void(Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, double, double, symp_derivs)>

Functions

double brent(double, double, double, std::function<double(double)>, double, double&)

void bsstep(Eigen::VectorXd&, Eigen::VectorXd&, int, double&, double, double, Eigen::VectorXd&, double&, double&, ode_derivs)

void constant_step(Eigen::VectorXd&, Eigen::VectorXd&, int, double, ode_derivs, ode_rk)

void gauleg(double, double, Eigen::VectorXd&, Eigen::VectorXd&, int)

void integrate_ode(Eigen::VectorXd&, double, double, double&, double, int, ode_derivs, ode_integrator)

void locate(Eigen::VectorXd&, int, double, int*)

void mnbrak(Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, std::function<double(double)>)

void onestep(Eigen::VectorXd&, double&, int, double&, double, ode_derivs, ode_integrator)

double poly(double, int, double*)

double qadapt(double, double, std::function<double(double)>, double)

double qadapt2d(double, double, double, double, std::function<double(double, double)>, double)

void rk2qc(Eigen::VectorXd&, Eigen::VectorXd&, int, double&, double, double, Eigen::VectorXd&, double&, double&, ode_derivs)

void rk4(Eigen::VectorXd&, Eigen::VectorXd&, int, double, double, Eigen::VectorXd&, ode_derivs)

void rkqc(Eigen::VectorXd&, Eigen::VectorXd&, int, double&, double, double, Eigen::VectorXd&, double&, double&, ode_derivs)

double rtbis(std::function<double(double)>, double, double, double)

double rtsafe(std::function<void(double, double&, double&)>, double, double, double)

void sia4(Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, Eigen::VectorXd&, double, double, symp_derivs)

int zbrac(std::function<double(double)>, Eigen::VectorXd&, Eigen::VectorXd&)

double zbrent(std::function<double(double)>, double, double, double)

Variables

const double Pi = 3.141592653589793

file orbit.H

#include <functional>

#include <memory>

#include <Eigen/Eigen>

#include <gaussQ.H>

Include dependency graph for orbit.H:

This graph shows which files directly or indirectly include orbit.H:

file OrthoFunction.H

#include <functional>

#include <memory>

#include <Eigen/Eigen>

#include <gaussQ.H>

Include dependency graph for OrthoFunction.H:

file OrthoPoly.H

#include <cfloat>

#include <cmath>

#include <Eigen/Eigen>

Include dependency graph for OrthoPoly.H:

file P2Quantile.H

#include <array>

Include dependency graph for P2Quantile.H:

file parseVersionString.H

#include <vector>

#include <string>

Include dependency graph for parseVersionString.H:

Functions

std::vector<int> parseVersionString(const std::string &version_str)

file Particle.H

#include <unordered_map>

#include <vector>

#include <memory>

Include dependency graph for Particle.H:

This graph shows which files directly or indirectly include Particle.H:

Typedefs

typedef std::unordered_map<unsigned long, PartPtr> PartMap

typedef std::unordered_map<unsignedlong, PartPtr>::iterator PartMapItr

typedef std::shared_ptr<Particle> PartPtr

typedef std::pair<unsigned long, PartPtr> PMapType

Functions

std::ostream &operator<<(std::ostream &os, const PMapType &p)

file Particle.h

file ParticleReader.H

#include <unordered_map>

#include <stdexcept>

#include <algorithm>

#include <iostream>

#include <fstream>

#include <iomanip>

#include <vector>

#include <memory>

#include <string>

#include <cmath>

#include <list>

#include <mpi.h>

#include <config_exp.h>

#include <StringTok.H>

#include <header.H>

#include <Particle.H>

#include <gadget.H>

#include <tipsy.H>

Include dependency graph for ParticleReader.H:

file permutation.H

#include <algorithm>

#include <numeric>

#include <random>

Include dependency graph for permutation.H:

file phase.H

#include <ostream>

#include <vector>

#include <Eigen/Eigen>

#include <numerical.H>

Include dependency graph for phase.H:

Typedefs

typedef Eigen::Vector3d (*force_func_ptr)(double, Eigen::Vector3d&, Eigen::Vector3d&)

typedef int (*freezing_function)(Phase&)

typedef double (*pot_func_ptr)(double, Eigen::Vector3d&)

Functions

double epicyclic_kappa(double)

void forward_interp(double, double, double, double, double, double, double, double&, double&)

double inverse_interp_zero(double, double, double, double, double, double)

void Newton(double, Eigen::VectorXd&, Eigen::VectorXd&)

double Oort_A(double)

double Oort_B(double)

double v_circ(double)

double vertical_kappa(double)

Eigen::Matrix3d z_Rotation(double)

file plummer.H

#include <cmath>

#include <massmodel.H>

Include dependency graph for plummer.H:

file poly.H

#include <iostream>

#include <fstream>

#include <Eigen/Eigen>

Include dependency graph for poly.H:

This graph shows which files directly or indirectly include poly.H:

Functions

void bomb_Poly(const char*)

void bomb_Poly_operation(const char*)

file PotRZ.H

#include <QDHT.H>

#include <cmath>

Include dependency graph for PotRZ.H:

file Progress.H

#include <iostream>

#include <string>

Include dependency graph for Progress.H:

file PseudoAccel.H

#include <deque>

#include <array>

#include <Eigen/Eigen>

#include <QuadLS.H>

Include dependency graph for PseudoAccel.H:

This graph shows which files directly or indirectly include PseudoAccel.H:

file QDHT.H

#include <functional>

#include <algorithm>

#include <chrono>

#include <vector>

#include <cmath>

#include <Eigen/Eigen>

#include <EXPmath.H>

Include dependency graph for QDHT.H:

This graph shows which files directly or indirectly include QDHT.H:

file QPDistF.H

#include <iomanip>

#include <string>

#include <map>

#include <massmodel.H>

#include <DiskWithHalo.H>

#include <orbit.H>

Include dependency graph for QPDistF.H:

This graph shows which files directly or indirectly include QPDistF.H:

file QuadLS.H

#include <iostream>

#include <iomanip>

#include <tuple>

Include dependency graph for QuadLS.H:

This graph shows which files directly or indirectly include QuadLS.H:

file RK4.H

#include <Eigen/Eigen>

Include dependency graph for RK4.H:

file rotcurv.H

Functions

double epicyclic_kappa(double)

double omega_circ(double)

double Oort_A(double)

double Oort_B(double)

double v_circ(double)

double vertical_kappa(double)

file RunningTime.H

#include <deque>

#include <Timer.H>

Include dependency graph for RunningTime.H:

file SimAnn.H

#include <functional>

#include <iostream>

#include <iomanip>

#include <fstream>

#include <random>

#include <limits>

#include <cmath>

Include dependency graph for SimAnn.H:

Defines

SIM_ANN_HPP_

file SLGridMP2.H

#include <math.h>

#include <iostream>

#include <fstream>

#include <string>

#include <mpi.h>

#include <localmpi.H>

#include <config_exp.h>

#include <massmodel.H>

#include <sltableMP2.H>

#include <yaml-cpp/yaml.h>

#include <libvars.H>

Include dependency graph for SLGridMP2.H:

This graph shows which files directly or indirectly include SLGridMP2.H:

file sltableMP2.H

#include <Eigen/Eigen>

Include dependency graph for sltableMP2.H:

This graph shows which files directly or indirectly include sltableMP2.H:

file Species.H

#include <map>

#include <set>

#include <vector>

Include dependency graph for Species.H:

This graph shows which files directly or indirectly include Species.H:

Typedefs

typedef std::map<speciesKey, sKeyDmap> sKey2Dmap

typedef std::map<speciesKey, sKeyUmap> sKey2Umap

typedef std::map<speciesKey, double> sKeyDmap

typedef std::pair<speciesKey, speciesKey> sKeyPair

typedef std::set<speciesKey> sKeySet

typedef std::map<speciesKey, unsigned> sKeyUmap

typedef std::map<speciesKey, std::vector<double>> sKeyvDmap

typedef std::pair<unsigned short, unsigned short> speciesKey

Typedefs for the species key.

file sphereSL.H

#include <cmath>

#include <iostream>

#include <fstream>

#include <string>

#include <numerical.H>

#include <biorth.H>

#include <SLGridMP2.H>

Include dependency graph for sphereSL.H:

file Spline.H

#include <cstdlib>

#include <vector>

#include <cmath>

Include dependency graph for Spline.H:

Functions

template<class T>
void Spline(const std::vector<T> &x, const std::vector<T> &y, T yp1, T ypn, std::vector<T> &y2)

template<class T>
void Splint1(const std::vector<T> &xa, const std::vector<T> &ya, const std::vector<T> &y2a, T x, T &y, int even = 0)

template<class T>
void Splint2(const std::vector<T> &xa, const std::vector<T> &ya, const std::vector<T> &y2a, T x, T &y, T &dy, int even = 0)

template<class T>
void Splint3(const std::vector<T> &xa, const std::vector<T> &ya, const std::vector<T> &y2a, T x, T &y, T &dy, T &ddy, int even = 0)

file staeckel.H

file StringTok.H

This graph shows which files directly or indirectly include StringTok.H:

file Sutils.H

#include <algorithm>

#include <sstream>

#include <string>

#include <vector>

#include <cctype>

#include <locale>

Include dependency graph for Sutils.H:

Functions

static inline void ltrim(std::string &s)

String trim white-space from start (in place version)

static inline std::string ltrim_copy(std::string s)

String trim white space from start (new copy)

static inline void rtrim(std::string &s)

String trim white-space string from end (in place version)

static inline std::string rtrim_copy(std::string s)

String trim white space from end (new copy)

std::vector<std::string> str_split(const std::string &s, char delimiter)

Split string on a character delimiter.

std::string str_to_lower(const std::string &s)

Return a lower case copy.

std::string str_to_upper(const std::string &s)

Return an upper case copy.

static inline void trim(std::string &s)

String trim white-spacefrom both ends (in place)

static inline std::string trim_copy(std::string s)

String trim white space from both ends (new copy)

file Swap.H

file TableGrid.H

#include <sstream>

#include <vector>

#include <memory>

#include <map>

#include <ThreeDGrid.H>

Include dependency graph for TableGrid.H:

This graph shows which files directly or indirectly include TableGrid.H:

Typedefs

typedef std::shared_ptr<TableGrid> TableGridPtr

file TempFile.H

#include <filesystem>

#include <iostream>

#include <random>

Include dependency graph for TempFile.H:

Functions

std::filesystem::path temp_file(const std::string &prefix, std::size_t length = 16)

Generate a unique file name with a given prefix and ‘length’ random characters. The routine will check for existence and attempt ‘max_try’ times to make unique name. Otherwise, it throws an exception reporting the last attempted file name. We use std::filesystem to obtain the path for temporary files. The value of max_try=1000 by default.

Examples:

auto path = temp_file(“my_prog”); // Uses the default length=16 auto path = temp_file(“my_prog”, 8); // User specfied length=8

file ThreeDGrid.H

#include <vector>

#include <sstream>

#include <memory>

Include dependency graph for ThreeDGrid.H:

This graph shows which files directly or indirectly include ThreeDGrid.H:

Typedefs

typedef std::shared_ptr<ThreeDGrid> ThreeDGridPtr

file Timer.H

#include <iostream>

#include <cstdlib>

#include <chrono>

Include dependency graph for Timer.H:

This graph shows which files directly or indirectly include Timer.H:

file tipsy.H

This graph shows which files directly or indirectly include tipsy.H:

file toomre.H

#include <massmodel.H>

Include dependency graph for toomre.H:

file TransformFFT.H

#include <complex>

#include <vector>

#include <Eigen/Dense>

#include <fftw3.h>

Include dependency graph for TransformFFT.H:

file VtkGrid.H

#include <algorithm>

#include <fstream>

#include <sstream>

#include <vector>

#include <memory>

#include <limits>

#include <map>

#include <ThreeDGrid.H>

Include dependency graph for VtkGrid.H:

This graph shows which files directly or indirectly include VtkGrid.H:

Typedefs

typedef std::shared_ptr<VtkGrid> VtkGridPtr

file VtkPCA.H

#include <sstream>

#include <memory>

#include <Eigen/Eigen>

#include <vtkSmartPointer.h>

#include <vtkDoubleArray.h>

#include <vtkFloatArray.h>

#include <vtkIntArray.h>

#include <vtkUnsignedCharArray.h>

#include <vtkStructuredPoints.h>

#include <vtkRectilinearGrid.h>

#include <vtkPoints.h>

#include <vtkPointData.h>

#include <vtkXMLRectilinearGridWriter.h>

#include <vtkLookupTable.h>

#include <vtkVersion.h>

Include dependency graph for VtkPCA.H:

Typedefs

using vtkFloatArrayP = vtkSmartPointer<vtkFloatArray>

typedef std::shared_ptr<VtkPCA> VtkPCAptr

using vtkRectilinearGridP = vtkSmartPointer<vtkRectilinearGrid>

using vtkRectilinearGridWriterP = vtkSmartPointer<vtkXMLRectilinearGridWriter>

file writePVD.H

#include <iostream>

#include <iomanip>

#include <fstream>

#include <vector>

#include <string>

Include dependency graph for writePVD.H:

Functions

void writePVD(const std::string &filename, const std::vector<double> &times, const std::vector<std::string> &files)

file YamlCheck.H

#include <string>

#include <set>

#include <yaml-cpp/yaml.h>

Include dependency graph for YamlCheck.H:

This graph shows which files directly or indirectly include YamlCheck.H:

Functions

std::set<std::string> YamlCheck(const YAML::Node &node, const std::set<std::string> &valid)

Check for unmatched configuration keys in a YAML::node

Returns an std::vector of unmatched keys which is empty if all keys are matched

file YamlConfig.H

#include <typeinfo>

#include <iostream>

#include <iomanip>

#include <fstream>

#include <sstream>

#include <cstring>

#include <yaml-cpp/yaml.h>

#include <cxxopts.H>

Include dependency graph for YamlConfig.H:

Functions

cxxopts::ParseResult LoadConfig(cxxopts::Options &options, const std::string &config)

Read the YAML parameter config file and load the cxxopts database with parameters

void SaveConfig(const cxxopts::ParseResult &vm, const cxxopts::Options &options, const std::string &config, const std::vector<std::string> groups = {""}, const std::vector<std::string> exclude = {"help", "template", "expert", "config"})

Saves the current command-line cxxopts database in YAML format for user configuration. For ease, the current convention is that all vector-values options will be stored as strings, and converted by the calling program to the correct value internally.

file ZBrent.H

#include <math.h>

#include <functional>

#include <iostream>

#include <iomanip>

#include <vector>

Include dependency graph for ZBrent.H:

Enums

enum ZBrentReturn

Values:

enumerator Good

enumerator Bracket

enumerator Iteration

file AxisymmetricBasis.H

#include <Basis.H>

#include <Eigen/Eigen>

Include dependency graph for AxisymmetricBasis.H:

This graph shows which files directly or indirectly include AxisymmetricBasis.H:

file Basis.H

#include <PotAccel.H>

#include <Eigen/Eigen>

Include dependency graph for Basis.H:

This graph shows which files directly or indirectly include Basis.H:

file Bessel.H

#include <assert.h>

#include <SphericalBasis.H>

Include dependency graph for Bessel.H:

This graph shows which files directly or indirectly include Bessel.H:

Functions

Eigen::VectorXd sbessjz(int n, int m)

file BN.H

#include <iostream>

#include <iomanip>

#include <vector>

#include <cmath>

Include dependency graph for BN.H:

file CBDisk.H

#include <memory>

#include <map>

#include <PolarBasis.H>

Include dependency graph for CBDisk.H:

file chkTimer.H

#include <time.h>

#include <cmath>

#include <iostream>

#include <fstream>

#include <iomanip>

Include dependency graph for chkTimer.H:

This graph shows which files directly or indirectly include chkTimer.H:

file Component.H

#include <mpi.h>

#include <utility>

#include <yaml-cpp/yaml.h>

#include <EXPException.H>

#include <global.H>

#include <Orient.H>

#include <header.H>

#include <localmpi.H>

#include <ParticleFerry.H>

#include <CenterFile.H>

#include <PotAccel.H>

#include <Circular.H>

#include <Timer.H>

#include <config_exp.h>

Include dependency graph for Component.H:

This graph shows which files directly or indirectly include Component.H:

file ComponentContainer.H

#include <list>

#include <Component.H>

#include <Timer.H>

Include dependency graph for ComponentContainer.H:

This graph shows which files directly or indirectly include ComponentContainer.H:

file Cube.H

#include <complex>

#include <vector>

#include <string>

#include <set>

#include <Eigen/Eigen>

#include <unsupported/Eigen/CXX11/Tensor>

#include <Coefficients.H>

#include <PotAccel.H>

Include dependency graph for Cube.H:

file CylEXP.H

#include <global.H>

#include <expand.H>

#include <EmpCylSL.H>

Include dependency graph for CylEXP.H:

This graph shows which files directly or indirectly include CylEXP.H:

file Cylinder.H

#include <memory>

#include <Orient.H>

#include <Basis.H>

#include <CylEXP.H>

#include <Coefficients.H>

#include <config_exp.h>

#include <CoefContainer.H>

Include dependency graph for Cylinder.H:

This graph shows which files directly or indirectly include Cylinder.H:

file Direct.H

#include <utility>

#include <memory>

#include <vector>

#include <string>

#include <set>

#include <AxisymmetricBasis.H>

#include <GravKernel.H>

#include <massmodel.H>

Include dependency graph for Direct.H:

file EJcom.H

#include <TwoCenter.H>

Include dependency graph for EJcom.H:

file EnumBitset.H

#include <bitset>

#include <type_traits>

Include dependency graph for EnumBitset.H:

file expand.H

#include <config_exp.h>

#include <mpi.h>

#include <pthread.h>

#include <stdexcept>

#include <cstdlib>

#include <cmath>

#include <cstring>

#include <iostream>

#include <fstream>

#include <sstream>

#include <iomanip>

#include <vector>

#include <string>

#include <limits>

#include <Eigen/Eigen>

#include <ComponentContainer.H>

#include <ExternalForce.H>

#include <Output.H>

#include <yaml-cpp/yaml.h>

#include <global.H>

#include <EXPException.H>

Include dependency graph for expand.H:

This graph shows which files directly or indirectly include expand.H:

Defines

BSD_SOURCE

MAX(A, B)

MIN(A, B)

Functions

void adjust_multistep_level()

inline double atof(string &s)

inline int atoi(string &s)

inline bool atol(string &s)

void begin_run(void)

void create_tipsy(void)

double densi(double rr, int l, int n)

double dgammln()

void do_output_init(void)

double dplgndr(int l, int m, double x)

void exp_mpi_error_handler(MPI_Comm *communicator, int *error_code, ...)

double factrl(int n)

double get_dens(double r, int l, double *coef)

void get_potacc(double r, int l, double *coef, double *p, double *dp)

void get_ultra(int nmax, double l, double x, Eigen::VectorXd &p)

void incr_com_position(double dt)

void incr_com_velocity(double dt)

void incr_position(double dt, int mlevel = 0)

void incr_velocity(double dt, int mlevel = 0)

void init_velocity(void)

void initialize_cuda(void)

void initialize_multistep()

void locate()

void make_grid(double rmin, double rmax, int lmax, int nmax)

void mpi_gdb_print_trace(int sig)

void mpi_gdb_wait_trace(int sig)

void mpi_print_trace(const string &routine, const string &msg, const char *file, int line)

double MPL_read_timer(int reset)

void MPL_reset_timer(void)

void MPL_start_timer(void)

void MPL_stop_timer(void)

void parallel_distribute_coefficients(void)

void parallel_gather_coefficients(void)

double plgndr(int, int, double)

double potli(double rr, int l, int n)

void print_trace(std::ostream &out, const char *file, int line)

void recompute_processor_rates(void)

void redistribute_particles(void)

void set_fpu_gdb_handler(void)

void set_fpu_invalid_handler(void)

void set_fpu_trace_handler(void)

void set_global_com(void)

void setup_distribution(void)

void signal_handler_dump(int sig)

void signal_handler_stop(int sig)

void sync_eval_multistep()

void test_mpi(void)

string trimComment(const string)

string trimLeft(const string)

string trimRight(const string)

void write_parm(void)

double zbrent()

Variables

static const double DSMALL = 1.0e-16

static const int mdtDim = 7

file ExternalCollection.H

#include <map>

#include <ComponentContainer.H>

#include <ExternalForce.H>

Include dependency graph for ExternalCollection.H:

This graph shows which files directly or indirectly include ExternalCollection.H:

Variables

map<string, maker_t*, less<string>> factory

factory for dynamically loaded forces

map<string, maker_t*, less<string>>::iterator fitr

file ExternalForce.H

#include <PotAccel.H>

#include <Component.H>

Include dependency graph for ExternalForce.H:

This graph shows which files directly or indirectly include ExternalForce.H:

Typedefs

typedef ExternalForce *maker_t(const YAML::Node&)

file externalShock.H

#include <orbit.H>

#include <massmodel.H>

Include dependency graph for externalShock.H:

file FlatDisk.H

#include <memory>

#include <map>

#include <BiorthCyl.H>

#include <PolarBasis.H>

Include dependency graph for FlatDisk.H:

Typedefs

typedef std::shared_ptr<BiorthCyl> CylPtr

file generateRelaxation.H

file global.H

#include <pthread.h>

#include <mpi.h>

#include <vector>

#include <string>

#include <memory>

#include <random>

#include <list>

#include <coef.H>

#include <chkTimer.H>

#include <BarrierWrapper.H>

#include <yaml-cpp/yaml.h>

#include <localmpi.H>

#include <libvars.H>

#include “Species.H”

Include dependency graph for global.H:

This graph shows which files directly or indirectly include global.H:

Global variables.

These variables can be changed/specified in the [global] stanza of the inputfile

Coefficient header on each output dump

BarrierWrapper *barrier

Barrier instance for debugging.

bool barrier_check

Turn on Barrier check debugging.

bool barrier_debug

Turn on Barrier check debugging.

bool barrier_extra

Turn on Barrier extra debugging.

bool barrier_label

Barrier label checking.

bool barrier_light

Barrier label light weight method.

bool barrier_quiet

Do not report good barrier condtion if true.

CheckpointTimer chktimer

Checkpoint timer.

struct CylCoefHeader coefheadercyl

Cylindrical header type.

struct SphCoefHeader coefheadersph

Spherical header.

ComponentContainer *comp

bool cuda_prof

For toggling CUDA profiling.

bool debug_wait

Endless loop for setting gdb breakpoints.

ExternalCollection *external

string lastPS

Last PS file name.

string lastPSQ

string lastPSR

bool leapfrog_cuda

Can we leave phase space on GPUs or do we need to copy back to host?

bool main_wait

MPI_Datatype MPI_EXP_KEYTYPE

MPI datatype for pHOT key.

OutputContainer *output

One output routine container per simulation.

YAML::Node parse

Parameter database.

unsigned int random_seed

Mersenne random number generator provided by Boost.Random. This could be changed to another if needed.

string restart_cmd

Restart command on successful completion but early termination according to the checkpoint timer

int rlimit_val

Default memory limit value in GB. If value is set to zero, use the system default. If value is less than zero, attempt to set memory to unlimited.

double runtime

Total alloted runtime (runtime < 0 turns off timer)

bool use_cuda

Set to false to suppress cuda computation.

Variables

bool all_couples

Toggle interactions “on” or “off” by default. If interactions are “on” (the default), interactions listed in the ‘Interaction’ list be turned “off”. Alternatively, if interactions are “off”, interactions listed in the ‘Interaction’ list be turned “on”.

int centerlevl

Lowest level for centering recomputation (default: multistep/2)

double dbthresh

Load balancing threshold (larger difference initiates balancing)

vector<vector<int>> dstepL

Multistep interpolation array.

vector<vector<int>> dstepN

double dtime

Time step.

unsigned char dump_signal

Phase space dump on next step

This flag is set by signalling the root process with SIGHUP

int dump_signal0

double dynfracA

Acceleration coefficient (default: 0.03)

double dynfracD

Drift coefficient (default: 1000.0)

double dynfracP

Escape time scale coefficient (default: 0.05)

double dynfracS

Fraction of dynamical time for determining multistep level.

Scale coefficient (default: 1.00)

double dynfracV

Velocity coefficient (default: 0.01)

bool eqmotion

Toggle phase space advance (e.g. for use with externally supplied mapping). On by default.

bool fpe_trace

Install error handler for fpe backtrace.

bool fpe_trap

Install error handler for fpe debugging.

bool fpe_wait

Install error handler for fpe wait.

double *gcom

Global center of mass.

double *gcov

Global center of velocity.

bool gdb_trace

Use gdb or native trace handling.

bool global_cov

Resets total center of velocity to zero if true.

string homedir

Home directory for configuration files, etc.

bool ignore_info

Suppress parsing of info fields on restart; use config specified parameters instead

string infile

Input file (for restart)

bool initializing

True when initializing before first time step.

int is_init

Used to flag separate behavior on inintialization (unused)

string ldlibdir

Directory to look for loadable modules.

vector<vector<bool>> mactive

Multistep level flag: levels currently synchronized.

double max_mindt

Maximum fraction of particles that request a smaller than minimum timestep.

unsigned maxlev

Multistep sublevel info used for nbody.

int mdrft

Current point in multistepping for drift step.

vector<int> mfirst

Lowest synchronized level at a step.

vector<int> mintvl

Multistep time step spacing.

MPI_Comm MPI_COMM_WORKER

Internally defined worker communicator.

bool mpi_wait

Install error handler for MPI debugging.

int mstep

Current point in multistepping for velocity step.

int Mstep

Maximum number of multistep steps.

double mtot

Total mass in simulation (used by Orient and log diagnostics)

std::map<std::string, std::vector<int>> nameMap

List of host names and ranks.

int nbalance

Number of steps between load balancing (use 0 for none)

int ngpus

Number of gpu devices per node.

int NICE

Process priority set to NICE value.

int nreport

Number of steps between particle number reports (use 0 for none)

int nsteps

Maximum number of steps to execute.

string parmfile

Parameter dump file.

unsigned PFbufsz

Particle ferry buffer size.

vector<thrd_pass_posvel> posvel_data

Multithreding data structures for incr_position and incr_velocity.

vector<pthread_t> posvel_thrd

Threads for incr_position and incr_velocity.

int psdump

Last phase space dump step.

unsigned char quit_signal

Quit now

This flag is set by checkpoint itmer

string ratefile

Initial processor rate file.

bool restart

Global set on restart (to used by initializers and user modules)

unsigned shiftlevl

Constrain level changes per step (default: 0 means no constraint)

std::vector<int> siblingList

List of sibling ranks.

bool step_timing

Step timing.

unsigned char stop_signal

Stop on next step

This flag is set by signalling the root process with SIGTERM

int stop_signal0

Implementation variables for handlers

int this_step

Current Nbody step id.

double tnow

Times for each phase-space time slice (for Leap-Frog)

bool traceback

Enable traceback on exceptions.

bool use_cwd

Use Node 0’s home dir for the working dir on all nodes.

int VERBOSE

Output logging level.

file global_key_set.H

Variables

const std::set<std::string> global_valid_keys

file GravKernel.H

#include <utility>

Include dependency graph for GravKernel.H:

This graph shows which files directly or indirectly include GravKernel.H:

file HaloBulge.H

#include <string>

#include <vector>

#include <set>

#include <ExternalForce.H>

Include dependency graph for HaloBulge.H:

file MixtureBasis.H

#include <TwoCenter.H>

Include dependency graph for MixtureBasis.H:

Defines

CALL_MEMBER_FN(object, ptrToMember)

file NoForce.H

#include <string>

#include <PotAccel.H>

Include dependency graph for NoForce.H:

file NVTX.H

#include <memory>

#include <config_exp.h>

Include dependency graph for NVTX.H:

This graph shows which files directly or indirectly include NVTX.H:

Typedefs

typedef std::shared_ptr<nvTracer> nvTracerPtr

file OrbTrace.H

#include <OrbTrace.H>

Include dependency graph for OrbTrace.H:

This graph shows which files directly or indirectly include OrbTrace.H:

file Orient.H

#include <vector>

#include <set>

#include <deque>

#include <algorithm>

#include <euler.H>

#include <Particle.H>

#include <PseudoAccel.H>

#include <config_exp.h>

Include dependency graph for Orient.H:

This graph shows which files directly or indirectly include Orient.H:

Variables

bool use_cuda

file OutAscii.H

#include <Component.H>

#include <OutAscii.H>

Include dependency graph for OutAscii.H:

This graph shows which files directly or indirectly include OutAscii.H:

file OutCalbr.H

#include <Output.H>

#include <Component.H>

Include dependency graph for OutCalbr.H:

file OutCHKPT.H

#include <OutCHKPT.H>

Include dependency graph for OutCHKPT.H:

This graph shows which files directly or indirectly include OutCHKPT.H:

file OutCHKPTQ.H

#include <Output.H>

Include dependency graph for OutCHKPTQ.H:

file OutCoef.H

#include <OutCoef.H>

Include dependency graph for OutCoef.H:

This graph shows which files directly or indirectly include OutCoef.H:

file OutDiag.H

#include <OutDiag.H>

Include dependency graph for OutDiag.H:

This graph shows which files directly or indirectly include OutDiag.H:

file OutFrac.H

#include <Output.H>

#include <Component.H>

Include dependency graph for OutFrac.H:

file OutLog.H

#include <OutLog.H>

Include dependency graph for OutLog.H:

This graph shows which files directly or indirectly include OutLog.H:

file OutMulti.H

#include <OutMulti.H>

Include dependency graph for OutMulti.H:

This graph shows which files directly or indirectly include OutMulti.H:

file OutPS.H

#include <OutPS.H>

Include dependency graph for OutPS.H:

This graph shows which files directly or indirectly include OutPS.H:

file OutPSN.H

#include <OutPSN.H>

Include dependency graph for OutPSN.H:

This graph shows which files directly or indirectly include OutPSN.H:

file OutPSP.H

#include <OutPSP.H>

Include dependency graph for OutPSP.H:

This graph shows which files directly or indirectly include OutPSP.H:

file OutPSQ.H

#include <OutPSQ.H>

Include dependency graph for OutPSQ.H:

This graph shows which files directly or indirectly include OutPSQ.H:

file OutPSR.H

#include <OutPSR.H>

Include dependency graph for OutPSR.H:

This graph shows which files directly or indirectly include OutPSR.H:

file Output.H

#include <string>

#include <vector>

#include <utility>

#include <set>

#include <StringTok.H>

#include <Timer.H>

Include dependency graph for Output.H:

This graph shows which files directly or indirectly include Output.H:

file OutputContainer.H

#include <thread>

#include <list>

#include <Output.H>

Include dependency graph for OutputContainer.H:

file OutRelaxation.H

#include <Output.H>

Include dependency graph for OutRelaxation.H:

file OutVel.H

#include <functional>

#include <string>

#include <vector>

#include <Eigen/Eigen>

#include <unsupported/Eigen/CXX11/Tensor>

#include <highfive/H5File.hpp>

#include <highfive/H5DataSet.hpp>

#include <highfive/H5DataSpace.hpp>

#include <highfive/H5Attribute.hpp>

#include <interp.H>

#include <Component.H>

#include <EXPException.H>

#include <Coefficients.H>

#include <FieldBasis.H>

Include dependency graph for OutVel.H:

file ParticleFerry.H

#include <vector>

#include <memory>

#include “localmpi.H”

#include “Particle.H”

Include dependency graph for ParticleFerry.H:

This graph shows which files directly or indirectly include ParticleFerry.H:

Typedefs

typedef std::shared_ptr<ParticleFerry> ParticleFerryPtr

file PeriodicBC.H

#include <random>

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for PeriodicBC.H:

file PolarBasis.H

#include <memory>

#include <random>

#include <vector>

#include <string>

#include <set>

#include <AxisymmetricBasis.H>

#include <Coefficients.H>

#include <config_exp.h>

#include <NVTX.H>

#include <CoefContainer.H>

#include <BiorthCyl.H>

Include dependency graph for PolarBasis.H:

This graph shows which files directly or indirectly include PolarBasis.H:

file PotAccel.H

#include <cstdlib>

#include <string>

#include <chrono>

#include <list>

#include <map>

#include <memory>

#include <yaml-cpp/yaml.h>

#include <Particle.H>

#include <StringTok.H>

#include <YamlCheck.H>

#include <config_exp.h>

Include dependency graph for PotAccel.H:

This graph shows which files directly or indirectly include PotAccel.H:

Functions

bool ltdub(const pair<double, PotAccel::NData> &A, const pair<double, PotAccel::NData> &B)

Used for thread timing only (VERBOSE>5)

file ScatterMFP.H

#include <utility>

#include <random>

#include <ExternalForce.H>

Include dependency graph for ScatterMFP.H:

Typedefs

typedef pair<double, int> rpair

Functions

bool less_rpair(const rpair &one, const rpair &two)

file Shells.H

#include <vector>

#include <string>

#include <set>

#include “expand.H”

#include “interp.H”

#include <AxisymmetricBasis.H>

#include <massmodel.H>

Include dependency graph for Shells.H:

file SlabSL.H

#include <complex>

#include <Eigen/Eigen>

#include <unsupported/Eigen/CXX11/Tensor>

#include <Coefficients.H>

#include <SLGridMP2.H>

#include <biorth1d.H>

#include <PotAccel.H>

Include dependency graph for SlabSL.H:

file Sphere.H

#include <memory>

#include <map>

#include <SLGridMP2.H>

#include <SphericalBasis.H>

Include dependency graph for Sphere.H:

This graph shows which files directly or indirectly include Sphere.H:

Typedefs

typedef std::shared_ptr<SLGridSph> SLGridSphPtr

file SphericalBasis.H

#include <memory>

#include <random>

#include <vector>

#include <string>

#include <set>

#include <AxisymmetricBasis.H>

#include <Coefficients.H>

#include <config_exp.h>

#include <NVTX.H>

#include <CoefContainer.H>

Include dependency graph for SphericalBasis.H:

This graph shows which files directly or indirectly include SphericalBasis.H:

file StatsMPI.H

#include “localmpi.H”

#include “Species.H”

#include <array>

#include <map>

Include dependency graph for StatsMPI.H:

file tidalField.H

#include <yaml-cpp/yaml.h>

Include dependency graph for tidalField.H:

file tipsydefs.h

Defines

forever

MAXDIM

Typedefs

typedef float Real

Variables

struct dark_particle *dark_particles

struct gas_particle *gas_particles

struct dump header

struct star_particle *star_particles

file tipsydefs.h

Defines

MAXDIM

Typedefs

typedef float Real

Functions

void xdr_dark()

void xdr_gas()

int xdr_init()

void xdr_quit()

void xdr_star()

Variables

struct dark_particle *dark_particles

struct gas_particle *gas_particles

struct dump header

struct star_particle *star_particles

file TwoCenter.H

#include <SLGridMP2.H>

#include <Sphere.H>

#include <Bessel.H>

#include <Cylinder.H>

Include dependency graph for TwoCenter.H:

This graph shows which files directly or indirectly include TwoCenter.H:

file TwoDCoefs.H

#include <iostream>

#include <iomanip>

#include <fstream>

#include <memory>

#include <vector>

#include <tuple>

#include <cmath>

#include <map>

#include <Eigen/Eigen>

Include dependency graph for TwoDCoefs.H:

file UserBar.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserBar.H:

file UserDisk.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserDisk.H:

file UserHalo.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserHalo.H:

file UserLogPot.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserLogPot.H:

file UserMNdisk.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserMNdisk.H:

file UserMW.H

#include <Particle.H>

#include <AxisymmetricBasis.H>

#include <ExternalCollection.H>

Include dependency graph for UserMW.H:

file UserTest.H

#include <ExternalCollection.H>

Include dependency graph for UserTest.H:

file UserTestCuda.H

#include <ExternalForce.H>

Include dependency graph for UserTestCuda.H:

file version.h

Variables

static char version_id[] = "[$Id$]"

file foarray.H

#include <vector>

#include <string>

#include <algorithm>

Include dependency graph for foarray.H:

file largest.H

#include <queue>

Include dependency graph for largest.H:

file PSP2.H

#include <stdexcept>

#include <algorithm>

#include <iostream>

#include <fstream>

#include <iomanip>

#include <vector>

#include <memory>

#include <string>

#include <cmath>

#include <list>

#include <StringTok.H>

#include <header.H>

Include dependency graph for PSP2.H:

Typedefs

typedef std::shared_ptr<PSP> PSPptr

Functions

std::string trimLeft(const string)

std::string trimRight(const string)

file psp_io.py

file SphSL.H

#include <string>

#include <SLGridMP2.H>

#include <localmpi.H>

#include <Eigen/Eigen>

Include dependency graph for SphSL.H:

file AddDisk.H

#include <vector>

#include <memory>

#include <massmodel.H>

Include dependency graph for AddDisk.H:

This graph shows which files directly or indirectly include AddDisk.H:

file AddSpheres.H

#include <vector>

#include <memory>

#include <massmodel.H>

Include dependency graph for AddSpheres.H:

file CylDisk.H

#include “massmodel.H”

#include “EmpCylSL.H”

#include “interp.H”

Include dependency graph for CylDisk.H:

file Disk2d.H

#include <memory>

#include <tuple>

#include <map>

#include <yaml-cpp/yaml.h>

#include <BiorthCyl.H>

#include <Particle.H>

#include <gaussQ.H>

Include dependency graph for Disk2d.H:

This graph shows which files directly or indirectly include Disk2d.H:

Typedefs

typedef std::shared_ptr<BiorthCyl> CylPtr

file Disk2dHalo.H

#include <stdexcept>

#include <iostream>

#include <iomanip>

#include <string>

#include <random>

#include <cmath>

#include <exponential.H>

#include <massmodel.H>

#include <gaussQ.H>

#include <localmpi.H>

#include <AddDisk.H>

#include <SphericalSL.H>

#include <Disk2d.H>

#include <SParticle.H>

#include <libvars.H>

Include dependency graph for Disk2dHalo.H:

file DiskEval.H

#include <iostream>

#include <iomanip>

#include <cstdlib>

#include <fstream>

#include <sstream>

#include <cstring>

#include <string>

#include <vector>

#include <cmath>

#include <tuple>

#include <numerical.H>

#include <gaussQ.H>

#include <EmpCylSL.H>

#include <DiskModels.H>

#include <config_exp.h>

Include dependency graph for DiskEval.H:

Functions

double dplgndr(int l, int m, double x)

double plgndr(int l, int m, double x)

file DiskHalo.H

#include <stdexcept>

#include <iostream>

#include <iomanip>

#include <string>

#include <random>

#include <cmath>

#include <exponential.H>

#include <massmodel.H>

#include <gaussQ.H>

#include <localmpi.H>

#include <AddDisk.H>

#include <SphericalSL.H>

#include <EmpCylSL.H>

#include <SParticle.H>

#include <libvars.H>

Include dependency graph for DiskHalo.H:

file EllipForce.H

#include <algorithm>

#include <iostream>

#include <iomanip>

#include <memory>

#include <vector>

#include <interp.H>

#include <gaussQ.H>

Include dependency graph for EllipForce.H:

file EllipsoidForce.H

#include <algorithm>

#include <iostream>

#include <iomanip>

#include <memory>

#include <vector>

#include <Eigen/Eigen>

#include <interp.H>

#include <gaussQ.H>

Include dependency graph for EllipsoidForce.H:

file massmodel1d.H

#include <string>

#include <tuple>

#include <massmodel.H>

Include dependency graph for massmodel1d.H:

file SParticle.H

#include <Particle.H>

#include <localmpi.H>

Include dependency graph for SParticle.H:

This graph shows which files directly or indirectly include SParticle.H:

file SphericalSL.H

#include <vector>

#include <Particle.H>

#include <SLGridMP2.H>

Include dependency graph for SphericalSL.H:

This graph shows which files directly or indirectly include SphericalSL.H:

Typedefs

typedef std::shared_ptr<SphericalSL> SphericalSLptr

file atomic_constants.H

Variables

const double a0 = 0.052917721092e-7

const double amu = 1.660539e-24

const std::vector<double> atomic_mass

const double boltz = 1.3806504e-16

const double boltzEv = 8.6173324e-5

const double esu = 4.80320427e-10

const double eV = 1.60217653e-12

const double light = 2.99792458e+10

const double me = 9.10938291e-28

const double mec2 = 0.51099891013

const double mp = 1.67262158e-24

const double msun = 1.9891e33

const double pc = 3.08567758e18

const double planck = 6.626075540e-27

const double year = 365.242 * 24 * 3600

file Bess.H

#include <cmath>

#include <EXPmath.H>

Include dependency graph for Bess.H:

file Grid2D.H

#include <fstream>

#include <vector>

Include dependency graph for Grid2D.H:

file KDE2d.H

#include <iostream>

#include <iomanip>

#include <fstream>

#include <string>

#include <vector>

#include <cmath>

#include <Eigen/Eigen>

#include <fftw3.h>

#include <cxxopts.H>

Include dependency graph for KDE2d.H:

file MakeModel.H

#include <string>

#include <memory>

#include <Eigen/Eigen>

#include <massmodel.H>

Include dependency graph for MakeModel.H:

file PSP.H

#include <stdexcept>

#include <algorithm>

#include <iostream>

#include <fstream>

#include <iomanip>

#include <vector>

#include <memory>

#include <string>

#include <cmath>

#include <list>

#include <StringTok.H>

#include <header.H>

Include dependency graph for PSP.H:

Typedefs

typedef std::shared_ptr<PSP> PSPptr

Functions

std::string trimLeft(const std::string)

std::string trimRight(const std::string)

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/utils/Analysis

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/utils/ICs

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/include

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/utils/PhaseSpace

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/src

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/src/user

dir /home/runner/work/EXP-docs/EXP-docs/exp_repo/utils