Table Of Contents

Previous topic

lattice module

Next topic

collective module

This Page

simulation module

The simulation module contains the classes necessary to perform a simulation of a Bunch traversing a Lattice.

Classes

class Aperture_operation

Public Functions

Aperture_operation(Lattice_element_slice_sptr slice_sptr)

Aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

template < typename T >
void apply_impl(T & t, Bunch & bunch, int verbosity, Logger & logger)

template < typename T >
void dump_particles(T & t, Bunch & bunch, int verbosity, Logger & logger)

double get_x_offset()

double get_y_offset()

void apply(Bunch & bunch, int verbosity, Logger & logger)

void deposit_charge(double charge)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Aperture_operation()

Public Static Attributes

const char charge_attribute[]

class Aperture_operation_extractor

Public Functions

Aperture_operation_extractor()

~Aperture_operation_extractor()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Aperture_operation_extractor_map

Public Functions

Aperture_operation_extractor_map()

void set_extractor(std::string const & name, Aperture_operation_extractor_sptr operation_extractor)

Aperture_operation_extractor_sptr get_extractor(std::string const & name)

std::list< std::string > get_extractor_names()

~Aperture_operation_extractor_map()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Bunch_simulator

Public Functions

Bunch_simulator(Bunch_sptr bunch_sptr)

Bunch_simulator(Bunch_sptr bunch_sptr, Diagnostics_actions_sptr diagnostics_actions_sptr)

Bunch_simulator()

Bunch & get_bunch()

Bunch_sptr get_bunch_sptr()

Diagnostics_actions & get_diagnostics_actions()

Diagnostics_actions_sptr get_diagnostics_actions_sptr()

void add_per_turn(Diagnostics_sptr diagnostics_sptr, int turn_period = 1)

void add_per_turn(Diagnostics_sptr diagnostics_sptr, std::list< int > const & turn_numbers)

void add_per_step(Diagnostics_sptr diagnostics_sptr, int step_period = 1)

void add_per_step(Diagnostics_sptr diagnostics_sptr, std::list< int > const & step_numbers, int turn_period = 1)

void add_per_forced_diagnostics_step(Diagnostics_sptr diagnostics_sptr, int turn_period = 1)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Bunch_simulator()

class Bunch_train_simulator

Public Functions

Bunch_train_simulator(Bunch_train_sptr bunch_train_sptr)

Bunch_train_simulator()

Bunch_train & get_bunch_train()

Bunch_train_sptr get_bunch_train_sptr()

Diagnostics_actionss & get_diagnostics_actionss()

void add_per_turn(int which, Diagnostics_sptr diagnostics_sptr, int period = 1)

void add_per_turn(int which, Diagnostics_sptr diagnostics_sptr, std::list< int > const & turn_numbers)

void add_per_step(int which, Diagnostics_sptr diagnostics_sptr, int period = 1)

void add_per_step(int which, Diagnostics_sptr diagnostics_sptr, std::list< int > const & step_numbers, int turn_period = 1)

void add_per_forced_diagnostics_step(int which, Diagnostics_sptr diagnostics_sptr, int turn_period = 1)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Bunch_train_simulator()

class Chef_map_operation_extractor

Public Functions

Chef_map_operation_extractor(Chef_lattice_sptr chef_lattice_sptr, int map_order)

Chef_map_operation_extractor()

Independent_operations extract(Reference_particle const & reference_particle, Lattice_element_slices const & slices)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Chef_mixed_operation_extractor

Public Functions

Chef_mixed_operation_extractor(Chef_lattice_sptr chef_lattice_sptr, int map_order)

Chef_mixed_operation_extractor()

Independent_operations extract(Reference_particle const & reference_particle, Lattice_element_slices const & slices)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Chef_propagate_operation

Public Functions

Chef_propagate_operation(Chef_lattice_section const & chef_lattice_section)

Chef_propagate_operation()

Default constructor for serialization use only.

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Chef_propagate_operation()

class Chef_propagate_operation_extractor

Public Functions

Chef_propagate_operation_extractor(Chef_lattice_sptr chef_lattice_sptr, int map_order)

Chef_propagate_operation_extractor()

Independent_operations extract(Reference_particle const & reference_particle, Lattice_element_slices const & slices)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Chef_propagator

Public Functions

Chef_propagator(Chef_lattice_section_sptr chef_lattice_section_sptr)

Chef_propagator()

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Circular_aperture_operation

A circular aperture with radius in meters determined by the Lattice_element attribute “circular_aperture_radius”.

If the radius is not defined, the default value of 1000.0 m will be used.

Public Functions

Circular_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Circular_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Circular_aperture_operation const & circular_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Circular_aperture_operation()

Public Static Attributes

const double default_radius

const char aperture_type[]

const char attribute_name[]

class Collective_operator

Public Functions

Collective_operator(std::string const & name)

Collective_operator()

Default constructor for serialization use only.

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Diagnosticss const & per_operation_diagnosticss, Logger & logger)

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Collective_operator()

Public Static Attributes

const char type_name[]

class Dense_mapping

Public Functions

Dense_mapping(Fast_mapping const & fast_mapping)

MArray1d_ref get_constant_term()

MArray2d_ref get_linear_term()

~Dense_mapping()

class Diagnostics_actions

Public Type

typedef std::list< Periodic > Periodics

typedef std::list< int > Numbers

typedef std::list< Listed > Listeds

typedef std::list< Periodic_listed > Periodic_listeds

Public Functions

Diagnostics_actions()

void set_bunch_sptr(Bunch_sptr bunch_sptr)

bool have_bunch_sptr()

Bunch_sptr get_bunch_sptr()

void add_per_turn(Diagnostics_sptr diagnostics_sptr, int turn_period = 1)

void add_per_turn(Diagnostics_sptr diagnostics_sptr, std::list< int > const & turn_numbers)

void add_per_step(Diagnostics_sptr diagnostics_sptr, int step_period = 1)

void add_per_step(Diagnostics_sptr diagnostics_sptr, std::list< int > const & step_numbers, int turn_period = 1)

void add_per_forced_diagnostics_step(Diagnostics_sptr diagnostics_sptr, int turn_period = 1)

void add_per_operator(Diagnostics_sptr diagnostics_sptr)

void add_per_operation(Diagnostics_sptr diagnostics_sptr)

void first_action(Stepper & stepper, Bunch & bunch)

void turn_end_action(Stepper & stepper, Bunch & bunch, int turn_num)

void step_end_action(Stepper & stepper, Step & step, Bunch & bunch, int turn_num, int step_num)

Diagnosticss & get_per_operator_diagnosticss()

Diagnosticss & get_per_operation_diagnosticss()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Diagnostics_actions()

class Listed

Public Functions

Listed(Numbers const & numbers, Diagnostics_sptr diagnostics_sptr)

Listed()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

Public Members

Numbers numbers

Diagnostics_sptr diagnostics_sptr

class Periodic

Public Functions

Periodic(int period, Diagnostics_sptr diagnostics_sptr)

Periodic()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

Public Members

int period

Diagnostics_sptr diagnostics_sptr

class Periodic_listed

Public Functions

Periodic_listed(int turn_period, Numbers const & step_numbers, Diagnostics_sptr diagnostics_sptr)

Periodic_listed()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

Public Members

int turn_period

Numbers step_numbers

Diagnostics_sptr diagnostics_sptr

class Dummy_collective_operator

Public Functions

Dummy_collective_operator(std::string const & name)

Dummy_collective_operator()

Default constructor for serialization use only.

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Dummy_collective_operator()

class Elliptical_aperture_operation

An elliptical aperture with horizontal and vertical radii in meters determined by the Lattice_element_attributes “elliptical_aperture_horizontal_radius” and “elliptical_aperture_vertical_radius”, respectively.

Both radii must be specified. Failing to do so will cause an exception.

Public Functions

Elliptical_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Elliptical_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Elliptical_aperture_operation const & Elliptical_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Elliptical_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

class Fast_mapping

Public Functions

Fast_mapping(int order)

Fast_mapping(std::string const & filename)

Fast_mapping(Reference_particle const & reference_particle, Mapping const & chef_mapping, double mapping_length)

Fast_mapping()

Default constructor for serialization use only.

void set_length(double length)

double get_length()

int get_order()

void add_term(int index, Fast_mapping_term const & term)

std::vector< std::vector< Fast_mapping_terms > > const & get_terms()

void apply(Bunch & bunch)

std::string as_string()

void write_to_file(std::string const & filename)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Fast_mapping_operation

Public Functions

Fast_mapping_operation(Fast_mapping const & mapping)

Fast_mapping_operation()

Default constructor for serialization use only.

void apply(Bunch & bunch, int verbosity, Logger & logger)

Fast_mapping const & get_fast_mapping()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Fast_mapping_operation()

class Fast_mapping_term

Public Functions

Fast_mapping_term(int order)

Fast_mapping_term(std::ifstream & stream)

Fast_mapping_term()

Default constructor for serialization use only.

Fast_mapping_term(Fast_mapping_term const & fast_mapping_term)

int order()

double & coeff()

double const & coeff()

int & index(int which)

int const & index(int which)

void write_to_stream(std::ostream & stream)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Fast_mapping_term()

class Finite_aperture_operation

An aperture to remove all particles with infinite and/or NaN coordinates.

Public Functions

Finite_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Finite_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Finite_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

template < typename T >
class Generic_aperture_extractor

Public Functions

Generic_aperture_extractor()

~Generic_aperture_extractor()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Independent_operation

Public Functions

Independent_operation(std::string const & type)

Independent_operation()

Default constructor for serialization use only.

std::string const & get_type()

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Independent_operation()

class Independent_operator

Public Functions

Independent_operator(std::string const & name, Operation_extractor_map_sptr operation_extractor_map_sptr, Aperture_operation_extractor_map_sptr aperture_operation_extractor_map_sptr)

Independent_operator()

Default constructor for serialization use only.

void append_slice(Lattice_element_slice_sptr slice_sptr)

Lattice_element_slices const & get_slices()

void update_operations(Reference_particle const & reference_particle)

bool need_update(Reference_particle const & reference_particle, int verbosity, Logger & logger)

Independent_operations const & get_operations()

Independent_operations & get_operations()

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Diagnosticss const & per_operation_diagnosticss, Logger & logger)

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Logger & logger, Multi_diagnostics & diagnostics)

void print()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Independent_operator()

Public Static Attributes

const char type_name[]

class Independent_stepper

The Independent_stepper class generates evenly-spaced Independent_operator steps through a Lattice.

No collective effects are included.

Public Functions

Independent_stepper(Lattice_sptr lattice_sptr, int map_order, int num_steps)

Construct an Independent_stepper.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • num_steps -

    the number of steps to take in the Lattice

Independent_stepper(Lattice_simulator const & lattice_simulator, int num_steps)

Deprecated.

Construct an Independent_stepper

Parameters

Independent_stepper()

Default constructor for serialization use only.

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Independent_stepper()

class Independent_stepper_elements

The Independent_stepper_elements class generates a constant number of Independent_operator steps per thick element.

Thin elements are assigned a single step each. No collective effects are included.

Public Functions

Independent_stepper_elements(Lattice_sptr lattice_sptr, int map_order, int steps_per_element)

Construct an Independent_stepper.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • steps_per_element -

    the number of steps per thick element

Independent_stepper_elements(Lattice_simulator const & lattice_simulator, int steps_per_element)

Deprecated.

Construct an Independent_stepper

Parameters

Independent_stepper_elements()

Default constructor for serialization use only.

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Independent_stepper_elements()

class Lambertson_aperture_operation

A Lambertson aperture with radius in meters determined by the Lattice_element attribute “lambertson_aperture_radius”.

If the radius is not defined, the default value of 1000.0 m will be used.

Public Functions

Lambertson_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Lambertson_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Lambertson_aperture_operation const & lambertson_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosit, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Lambertson_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

class Lattice_simulator

Public Functions

Lattice_simulator(Lattice_sptr lattice_sptr, int map_order)

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

Lattice_simulator()

Lattice_simulator(Lattice_simulator const & lattice_simulator)

void set_slices(Lattice_element_slices const & slices)

Lattice_element_slices const & get_slices()

int get_map_order()

void set_bucket_length()

double get_bucket_length()

bucket length is in z_lab frame

int get_number_buckets()

Operation_extractor_map_sptr get_operation_extractor_map_sptr()

Aperture_operation_extractor_map_sptr get_aperture_operation_extractor_map_sptr()

Lattice & get_lattice()

Lattice_sptr get_lattice_sptr()

Chef_lattice & get_chef_lattice()

Chef_lattice_sptr get_chef_lattice_sptr()

void update()

void calculate_element_lattice_functions()

void calculate_slice_lattice_functions()

void calculate_element_et_lattice_functions()

void calculate_slice_et_lattice_functions()

void calculate_element_lb_lattice_functions()

void calculate_slice_lb_lattice_functions()

void calculate_element_dispersion_functions()

void calculate_slice_dispersion_functions()

Lattice_functions const & get_lattice_functions(Lattice_element & lattice_element)

Lattice_functions const & get_lattice_functions(Lattice_element_slice & lattice_element_slice)

ET_lattice_functions const & get_et_lattice_functions(Lattice_element & lattice_element)

ET_lattice_functions const & get_et_lattice_functions(Lattice_element_slice & lattice_element_slice)

LB_lattice_functions const & get_lb_lattice_functions(Lattice_element & lattice_element)

LB_lattice_functions const & get_lb_lattice_functions(Lattice_element_slice & lattice_element_slice)

Dispersion_functions const & get_dispersion_functions(Lattice_element & lattice_element)

Dispersion_functions const & get_dispersion_functions(Lattice_element_slice & lattice_element_slice)

void print_cs_lattice_functions()

void print_et_lattice_functions()

void print_lb_lattice_functions()

void print_dispersion_closedOrbit()

void print_lattice_functions()

std::pair< double, double > get_both_tunes(bool use_eigen_tune = false)

double get_horizontal_tune(bool use_eigen_tune = false)

double get_vertical_tune(bool use_eigen_tune = false)

bool is_ring()

Normal_form_sage_sptr get_normal_form_sptr()

Const_MArray2d_ref get_linear_one_turn_map(bool sliced = true)

void convert_human_to_normal(MArray2d_ref coords)

void convert_normal_to_human(MArray2d_ref coords)

bool check_linear_normal_form()

std::vector< double > get_stationary_actions(const double stdx, const double stdy, const double std_cdt)

void adjust_tunes(double horizontal_tune, double vertical_tune, Lattice_elements const & horizontal_correctors, Lattice_elements const & vertical_correctors, double tolerance = 1.0e-5, int verbosity = 0)

double get_slip_factor(double dpp = 1.e-4)

double get_momentum_compaction(double dpp = 1.e-4)

double get_horizontal_chromaticity(double dpp = 1.e-4)

double get_vertical_chromaticity(double dpp = 1.e-4)

void adjust_chromaticities(double horizontal_chromaticity, double vertical_chromaticity, Lattice_elements const & horizontal_correctors, Lattice_elements const & vertical_correctors, double tolerance = 1.0e-4, int max_steps = 6)

template < class Archive >
void save(Archive & ar, const unsigned int version)

template < class Archive >
void load(Archive & ar, const unsigned int version)

BOOST_SERIALIZATION_SPLIT_MEMBER()

~Lattice_simulator()

class Operation_extractor

Public Functions

Operation_extractor(Chef_lattice_sptr chef_lattice_sptr, int map_order)

Operation_extractor()

Chef_lattice_sptr & get_chef_lattice_sptr()

int get_map_order()

Independent_operations extract(Reference_particle const & reference_particle, Lattice_element_slices const & slices)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Operation_extractor()

class Operation_extractor_map

Public Functions

Operation_extractor_map()

void set_extractor(std::string const & name, Operation_extractor_sptr operation_extractor)

Operation_extractor_sptr & get_extractor(std::string const & name)

std::list< std::string > get_extractor_names()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Operation_extractor_map()

class Operator

Public Functions

Operator(std::string const & name, std::string const & type)

Operator()

Default constructor for serialization use only.

std::string const & get_name()

std::string const & get_type()

void apply(Bunch & bunch, double time_step, Step & step, int verbosity, Diagnosticss const & per_operation_diagnosticss, Logger & logger)

void apply(Bunch_train & bunch_train, double time_step, Step & step, int verbosity, Train_diagnosticss const & per_operation_train_diagnosticss, Logger & logger)

void print()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Operator()

class Polygon_aperture_operation

A polygon aperture with vertices determined by the Lattice_element_attributes “pax1”, “pay1”, “pax2”, “pay2”, and so on.

And it also requires “the_number_of_vertices”, which determines the number of vertices and must be greter than and equal to 3. Must have at least 3 vertcies. Failing to do so will cause an exception.

Public Functions

Polygon_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Polygon_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Polygon_aperture_operation const & polygon_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Polygon_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

class Propagate_actions

Public Functions

Propagate_actions()

void first_action(Stepper & stepper, Bunch & bunch)

void first_action(Stepper & stepper, Bunch_train & bunch_train)

void turn_end_action(Stepper & stepper, Bunch & bunch, int turn_num)

void turn_end_action(Stepper & stepper, Bunch_train & bunch_train, int turn_num)

void step_end_action(Stepper & stepper, Step & step, Bunch & bunch, int turn_num, int step_num)

void step_end_action(Stepper & stepper, Step & step, Bunch_train & bunch_train, int turn_num, int step_num)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Propagate_actions()

class Propagator

Public Functions

Propagator(Stepper_sptr stepper_sptr)

Propagator()

Stepper_sptr get_stepper_sptr()

void set_checkpoint_period(int period)

int get_checkpoint_period()

void set_checkpoint_dir(std::string const & directory_name)

std::string const & get_checkpoint_dir()

void set_checkpoint_with_xml(bool with_xml)

bool get_checkpoint_with_xml()

void set_final_checkpoint(bool final_checkpoint)

bool get_final_checkpoint()

void set_concurrent_io(int max)

int get_concurrent_io()

void propagate(State & state)

State get_resume_state(std::string const & checkpoint_dir)

jfa note: the lifetime of the pointers in state must be managed manually

void resume(std::string const & checkpoint_dir, bool new_max_turns, int max_turns, bool new_verbosity, int verbosity)

void propagate(Bunch_simulator & bunch_simulator, int num_turns, int max_turns = 0, int verbosity = 1)

void propagate(Bunch_simulator & bunch_simulator, Propagate_actions & general_actions, int num_turns, int max_turns = 0, int verbosity = 1)

void propagate(Bunch_train_simulator & bunch_train_simulator, int num_turns, int max_turns = 0, int verbosity = 1)

void propagate(Bunch_train_simulator & bunch_train_simulator, Propagate_actions & general_actions, int num_turns, int max_turns = 0, int verbosity = 1)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Propagator()

Public Static Attributes

const std::string default_checkpoint_dir

const std::string description_file_name

const std::string propagator_archive_name

const std::string propagator_xml_archive_name

const std::string state_archive_name

const std::string state_xml_archive_name

const std::string log_file_name

const std::string stop_file_name

const std::string alt_stop_file_name

const int default_checkpoint_period

const int default_concurrent_io

class State

Public Functions

State(Bunch_simulator * bunch_simulator_ptr, Propagate_actions * propagate_actions_ptr, int num_turns, int first_turn, int max_turns, int verbosity)

State(Bunch_train_simulator * bunch_train_simulator_ptr, Propagate_actions * propagate_actions_ptr, int num_turns, int first_turn, int max_turns, int verbosity)

State()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

Public Members

Bunch_simulator * bunch_simulator_ptr

Bunch_train_simulator * bunch_train_simulator_ptr

Propagate_actions * propagate_actions_ptr

int num_turns

int first_turn

int max_turns

int verbosity

class Rectangular_aperture_operation

A rectangular aperture with horizontal and vertical dimensions in meters determined by the Lattice_element_attributes “rectangular_aperture_width” and “rectangular_aperture_height”, respectively.

Both dimensions must be specified. Failing to do so will cause an exception.

Public Functions

Rectangular_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Rectangular_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Rectangular_aperture_operation const & rectangular_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Rectangular_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

class Resume

Public Functions

Resume(std::string const & checkpoint_dir = Propagator::default_checkpoint_dir)

void set_checkpoint_period(int period)

int get_checkpoint_period()

void set_new_checkpoint_dir(std::string const & directory_name)

std::string const & get_new_checkpoint_dir()

Content get_content()

void propagate(bool new_max_turns, int max_turns, bool new_verbosity, int verbosity)

~Resume()

class Content

Public Functions

Content(Bunch_simulator * bunch_simulator_ptr, Stepper_sptr stepper_sptr)

Public Members

Bunch_sptr bunch_sptr

Stepper_sptr stepper_sptr

Lattice_sptr lattice_sptr

class Split_operator_stepper

The Split_operator_stepper class generates evenly-spaced split-operator steps through a Lattice.

One or more collective effects are included per step.

Public Functions

Split_operator_stepper(Lattice_sptr lattice_sptr, int map_order, Collective_operator_sptr collective_operator, int num_steps)

Construct a Split_operator_stepper with a single Collective_operator.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • collective_operator -

    the Collective_operator to apply in each step

  • num_steps -

    the number of steps to take in the Lattice

Split_operator_stepper(Lattice_sptr lattice_sptr, int map_order, Collective_operators const & collective_operators, int num_steps)

Construct a Split_operator_stepper with multiple Collective_operators.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • collective_operators -

    the set of Collective_operators to apply in each step

  • num_steps -

    the number of steps to take in the Lattice

Split_operator_stepper(Lattice_simulator const & lattice_simulator, Collective_operator_sptr collective_operator, int num_steps)

Deprecated.

Construct a Split_operator_stepper with a single Collective_operator

Parameters

Split_operator_stepper(Lattice_simulator const & lattice_simulator, Collective_operators const & collective_operators, int num_steps)

Deprecated.

Construct a Split_operator_stepper with multiple Collective_operators

Parameters
  • lattice_simulator -

    the Lattice_simulator for the Lattice

  • collective_operators -

    the set of Collective_operators to apply in each step

  • num_steps -

    the number of steps to take in the Lattice

Split_operator_stepper()

Default constructor for serialization use only.

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Split_operator_stepper()

class Split_operator_stepper_choice

Generate steps according with a list.

Public Functions

Split_operator_stepper_choice(Lattice_sptr lattice_sptr, int map_order, List_choice_map const & list_choice_map, bool split_else = true)

Split_operator_stepper_choice(int num_steps_else, Lattice_sptr lattice_sptr, int map_order, List_choice_map const & list_choice_map, bool split_else = true)

Split_operator_stepper_choice(Lattice_simulator const & lattice_simulator, List_choice_map const & list_choice_map, bool split_else = true)

Deprecated.

Split_operator_stepper_choice(int num_steps_else, Lattice_simulator const & lattice_simulator, List_choice_map const & list_choice_map, bool split_else = true)

Deprecated.

Split_operator_stepper_choice()

Default constructor for serialization use only.

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Split_operator_stepper_choice()

class Split_operator_stepper_elements

The Split_operator_stepper_elements class generates a constant number of split-operator steps per thick element.

Thin elements are assigned a single step each. One or more collective effects are included per step.

Public Functions

Split_operator_stepper_elements(Lattice_sptr lattice_sptr, int map_order, Collective_operator_sptr collective_operator, int steps_per_element)

Construct a Split_operator_stepper_elements with a single Collective_operator.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • collective_operator -

    the Collective_operator to apply in each step

  • steps_per_element -

    the number of steps per thick element

Split_operator_stepper_elements(Lattice_sptr lattice_sptr, int map_order, Collective_operators const & collective_operators, int steps_per_element)

Construct a Split_operator_stepper_elements with multiple Collective_operators.

Parameters
  • lattice_sptr -

    the Lattice

  • map_order -

    order for Chef_map operations

  • collective_operators -

    the set of Collective_operators to apply in each step

  • steps_per_element -

    the number of steps per thick element

Split_operator_stepper_elements(Lattice_simulator const & lattice_simulator, Collective_operator_sptr collective_operator, int steps_per_element)

Deprecated.

Construct a Split_operator_stepper_elements with a single Collective_operator

Parameters

Split_operator_stepper_elements(Lattice_simulator const & lattice_simulator, Collective_operators const & collective_operators, int steps_per_element)

Deprecated.

Construct a Split_operator_stepper_elements with multiple Collective_operators

Parameters
  • lattice_simulator -

    the Lattice_simulator for the Lattice

  • collective_operators -

    the set of Collective_operators to apply in each step

  • steps_per_element -

    the number of steps per thick element

Split_operator_stepper_elements()

Default constructor for serialization use only.

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Split_operator_stepper_elements()

class Step

Public Functions

Step(double length)

Step()

void append(Operator_sptr operator_sptr, double time_fraction)

void append(Operators const & operators, double time_fraction)

void apply(Bunch & bunch, int verbosity, Diagnosticss const & per_operator_diagnostics, Diagnosticss const & per_operation_diagnostics, Logger & logger)

void apply(Bunch_train & bunch_train, int verbosity, Train_diagnosticss const & per_operator_train_diagnosticss, Train_diagnosticss const & per_operation_train_diagnosticss, Logger & logger)

Operators const & get_operators()

Operators & get_operators()

std::list< double > const & get_time_fractions()

double get_length()

void print(int index)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

class Stepper

Public Functions

Stepper(Lattice_sptr lattice_sptr, int map_order)

Stepper(Lattice_simulator const & lattice_simulator)

Deprecated.

Stepper()

Default constructor for serialization use only.

Lattice_simulator & get_lattice_simulator()

Steps & get_steps()

void force_update_operations_no_collective()

void print()

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Stepper()

Public Static Attributes

const std::string force_diagnostics_attribute

const double fixed_step_tolerance

class Wire_elliptical_aperture_operation

An wire_elliptical aperture with horizontal and vertical radii in meters determined by the Lattice_element_attributes “wire_elliptical_aperture_horizontal_radius” and “wire_elliptical_aperture_vertical_radius”, respectively.

Both radii must be specified. Also needs Lattice_element_attributes “wire_elliptical_aperture_wire_x”, “wire_elliptical_aperture_wire_width”, and “wire_elliptical_aperture_gap.” Failing to do so will cause an exception.

Public Functions

Wire_elliptical_aperture_operation(Lattice_element_slice_sptr slice_sptr)

Wire_elliptical_aperture_operation()

const char * get_aperture_type()

bool operator==(Aperture_operation const & aperture_operation)

bool operator==(Wire_elliptical_aperture_operation const & Wire_elliptical_aperture_operation)

bool operator()(MArray2d_ref & particles, int part)

void apply(Bunch & bunch, int verbosity, Logger & logger)

template < class Archive >
void serialize(Archive & ar, const unsigned int version)

~Wire_elliptical_aperture_operation()

Public Static Attributes

const char aperture_type[]

const char attribute_name[]

Typedefs

typedef boost::shared_ptr< Aperture_operation_extractor_map > Aperture_operation_extractor_map_sptr

typedef boost::shared_ptr< Aperture_operation_extractor > Aperture_operation_extractor_sptr

typedef boost::shared_ptr< Aperture_operation > Aperture_operation_sptr

typedef std::list< Aperture_operation_sptr > Aperture_operation_sptrs

typedef boost::shared_ptr< Chef_propagate_operation > Chef_propagate_operation_sptr

typedef Generic_aperture_extractor < Circular_aperture_operation > Circular_extractor

typedef boost::shared_ptr< Collective_operator > Collective_operator_sptr

typedef std::list< Collective_operator_sptr > Collective_operators

typedef boost::shared_ptr< Diagnostics_actions > Diagnostics_actions_sptr

typedef boost::shared_ptr< Dummy_collective_operator > Dummy_collective_operator_sptr

typedef std::list< Dummy_collective_operator_sptr > Dummy_collective_operators

typedef Generic_aperture_extractor < Elliptical_aperture_operation > Elliptical_extractor

typedef boost::shared_ptr< Fast_mapping_operation > Fast_mapping_operation_sptr

typedef std::list< Fast_mapping_term > Fast_mapping_terms

typedef boost::shared_ptr< Independent_operation > Independent_operation_sptr

typedef std::list< Independent_operation_sptr > Independent_operations

typedef boost::shared_ptr< Independent_operator > Independent_operator_sptr

typedef std::list< Independent_operator_sptr > Independent_operators

typedef boost::shared_ptr< Independent_stepper_elements > Independent_stepper_elements_sptr

typedef boost::shared_ptr< Independent_stepper > Independent_stepper_sptr

typedef Generic_aperture_extractor < Lambertson_aperture_operation > Lambertson_extractor

typedef std::list< Listed > Listeds

typedef boost::shared_ptr< normalFormSage > Normal_form_sage_sptr

typedef std::list< int > Numbers

typedef boost::shared_ptr< Operation_extractor_map > Operation_extractor_map_sptr

typedef boost::shared_ptr< Operation_extractor > Operation_extractor_sptr

typedef boost::shared_ptr< Operator > Operator_sptr

typedef std::list< Operator_sptr > Operators

typedef std::list< Periodic_listed > Periodic_listeds

typedef std::list< Periodic > Periodics

typedef Generic_aperture_extractor < Polygon_aperture_operation > Polygon_extractor

typedef boost::shared_ptr< Propagate_actions > Propagate_actions_sptr

typedef Generic_aperture_extractor < Rectangular_aperture_operation > Rectangular_extractor

typedef boost::shared_ptr< Split_operator_stepper_choice > Split_operator_stepper_choice_sptr

typedef boost::shared_ptr< Split_operator_stepper_elements > Split_operator_stepper_elements_sptr

typedef boost::shared_ptr< Split_operator_stepper > Split_operator_stepper_sptr

typedef boost::shared_ptr< Step > Step_sptr

typedef boost::shared_ptr< Stepper > Stepper_sptr

typedef std::list< Step_sptr > Steps

typedef Generic_aperture_extractor < Wire_elliptical_aperture_operation > Wire_elliptical_extractor