Complete Class Reference

std::vector<particle_template*> make_particle(std::vector<std::vector<double>> *pt, std::vector<std::vector<double>> *eta, std::vector<std::vector<double>> *phi, std::vector<std::vector<double>> *energy)

Public Members

cproperty<std::string, metric_template> name

cproperty<std::string, metric_template> output_path

cproperty<std::vector<std::string>, metric_template> variables

cproperty<std::map<std::string, std::string>, metric_template> run_names

Framework Classes

Analysis

class analysis : public notification, public tools 

Public Functions

analysis()

~analysis()

void add_samples(std::string path, std::string label)

void add_selection_template(selection_template *sel)

void add_event_template(event_template *ev, std::string label)

void add_graph_template(graph_template *gr, std::string label)

void add_metric_template(metric_template *mx, model_template *mdl)

void add_model(model_template *model, optimizer_params_t *op, std::string run_name)

void add_model(model_template *model, std::string run_name)

void attach_threads()

void start()

std::map<std::string, std::vector<float>> progress()

std::map<std::string, std::string> progress_mode()

std::map<std::string, std::string> progress_report()

std::map<std::string, bool> is_complete()

Public Members

settings_t m_settings

std::map<std::string, meta*> meta_data = {}

Container

class container : public tools 

Public Functions

container()

~container()

void add_meta_data(meta*, std::string)

meta *get_meta_data()

bool add_selection_template(selection_template*)

bool add_event_template(event_template*, std::string label)

bool add_graph_template(graph_template*, std::string label)

void fill_selections(std::map<std::string, selection_template*> *inpt)

void get_events(std::vector<event_template*>*, std::string label)

void populate_dataloader(dataloader *dl)

void compile(size_t *len, int threadIdx)

size_t len()

entry_t *add_entry(std::string hash)

Public Members

meta *meta_data = nullptr

std::string *filename = nullptr

std::string *output_path = nullptr

std::string label = ""

std::map<std::string, entry_t> random_access

std::map<std::string, selection_template*> *merged = nullptr

DataLoader

class dataloader : public notification, public tools 

Public Functions

dataloader()

~dataloader()

std::vector<graph_t*> *get_k_train_set(int k)

std::vector<graph_t*> *get_k_validation_set(int k)

std::vector<graph_t*> *get_test_set()

std::vector<graph_t*> *build_batch(std::vector<graph_t*> *data, model_template *mdl, model_report *rep)

std::map<std::string, std::vector<graph_t*>> *get_inference()

void generate_test_set(float percentage = 50)

void generate_kfold_set(int k)

void dump_dataset(std::string path)

bool restore_dataset(std::string path)

std::vector<graph_t*> get_random(int num = 5)

void extract_data(graph_t *gr)

void datatransfer(torch::TensorOptions *op, size_t *num_events = nullptr, size_t *prg_events = nullptr)

void datatransfer(std::map<int, torch::TensorOptions*> *ops)

bool dump_graphs(std::string path = "./", int threads = 10)

void restore_graphs(std::vector<std::string> paths, int threads)

void restore_graphs(std::string paths, int threads)

void start_cuda_server()

Public Static Functions

static void safe_delete(std::vector<graph_t*> *data)

IO

class io : public tools, public notification 

Public Functions

io()

~io()

template<typename g> inline void write(std::vector<g> *inpt, std::string set_name)

template<typename g> inline void write(g *inpt, std::string set_name)

template<typename g> inline void read(std::vector<g> *outpt, std::string set_name)

template<typename g> inline void read(g *out, std::string set_name)

void read(graph_hdf5_w *out, std::string set_name)

bool start(std::string filename, std::string read_write)

void end()

std::vector<std::string> dataset_names()

std::map<std::string, long> root_size()

void check_root_file_paths()

bool scan_keys()

void root_begin()

void root_end()

void trigger_pcm()

void import_settings(settings_t *params)

std::map<std::string, data_t*> *get_data()

Public Members

bool enable_pyami = true

std::string metacache_path = "./"

std::string current_working_path = "."

std::string sow_name = ""

std::vector<std::string> trees = {}

std::vector<std::string> branches = {}

std::vector<std::string> leaves = {}

std::map<std::string, TFile*> files_open = {}

std::map<std::string, meta*> meta_data = {}

std::map<std::string, std::map<std::string, TTree*>> tree_data = {}

std::map<std::string, std::map<std::string, long>> tree_entries = {}

std::map<std::string, std::map<std::string, TBranch*>> branch_data = {}

std::map<std::string, std::map<std::string, TLeaf*>> leaf_data = {}

std::map<std::string, std::map<std::string, std::string>> leaf_typed = {}

std::map<std::string, bool> root_files = {}

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<std::string>>>> keys

LossFx

class lossfx : public tools, public notification 

Public Functions

lossfx()

lossfx(std::string var, std::string enx)

~lossfx()

loss_enum loss_string(std::string name)

opt_enum optim_string(std::string name)

scheduler_enum scheduler_string(std::string name)

void loss_opt_string(std::string name)

torch::Tensor loss(torch::Tensor *pred, torch::Tensor *truth)

torch::Tensor loss(torch::Tensor *pred, torch::Tensor *truth, loss_enum lss)

void weight_init(torch::nn::Sequential *data, mlp_init method)

torch::optim::Optimizer *build_optimizer(optimizer_params_t *op, std::vector<torch::Tensor> *params)

void build_scheduler(optimizer_params_t *op, torch::optim::Optimizer *opx)

bool build_loss_function(loss_enum lss)

bool build_loss_function()

void to(torch::TensorOptions*)

void step()

Public Members

std::string variable = ""

loss_opt lss_cfg

Meta

class meta : public tools, public notification 

Public Functions

meta()

~meta()

const folds_t *get_tags(std::string hash)

void scan_data(TObject *obj)

void scan_sow(TObject *obj)

void parse_json(std::string inpt)

std::string hash(std::string fname)

Public Members

rapidjson::Document *rpd = nullptr

std::string metacache_path

meta_t meta_data

cproperty<bool, meta> isMC

cproperty<bool, meta> found

cproperty<double, meta> eventNumber

cproperty<double, meta> event_index

cproperty<double, meta> totalSize

cproperty<double, meta> kfactor

cproperty<double, meta> ecmEnergy

cproperty<double, meta> genFiltEff

cproperty<double, meta> completion

cproperty<double, meta> beam_energy

cproperty<double, meta> cross_section_nb

cproperty<double, meta> cross_section_fb

cproperty<double, meta> cross_section_pb

cproperty<double, meta> campaign_luminosity

cproperty<double, meta> sum_of_weights

cproperty<unsigned int, meta> dsid

cproperty<unsigned int, meta> nFiles

cproperty<unsigned int, meta> totalEvents

cproperty<unsigned int, meta> datasetNumber

cproperty<std::string, meta> derivationFormat

cproperty<std::string, meta> AMITag

cproperty<std::string, meta> generators

cproperty<std::string, meta> identifier

cproperty<std::string, meta> DatasetName

cproperty<std::string, meta> prodsysStatus

cproperty<std::string, meta> dataType

cproperty<std::string, meta> version

cproperty<std::string, meta> PDF

cproperty<std::string, meta> AtlasRelease

cproperty<std::string, meta> principalPhysicsGroup

cproperty<std::string, meta> physicsShort

cproperty<std::string, meta> generatorName

cproperty<std::string, meta> geometryVersion

cproperty<std::string, meta> conditionsTag

cproperty<std::string, meta> generatorTune

cproperty<std::string, meta> amiStatus

cproperty<std::string, meta> beamType

cproperty<std::string, meta> productionStep

cproperty<std::string, meta> projectName

cproperty<std::string, meta> statsAlgorithm

cproperty<std::string, meta> genFilterNames

cproperty<std::string, meta> file_type

cproperty<std::string, meta> sample_name

cproperty<std::string, meta> logicalDatasetName

cproperty<std::string, meta> campaign

cproperty<std::vector<std::string>, meta> keywords

cproperty<std::vector<std::string>, meta> weights

cproperty<std::vector<std::string>, meta> keyword

cproperty<std::vector<std::string>, meta> fileGUID

cproperty<std::vector<int>, meta> events

cproperty<std::vector<int>, meta> run_number

cproperty<std::vector<double>, meta> fileSize

cproperty<std::map<int, int>, meta> inputrange

cproperty<std::map<int, std::string>, meta> inputfiles

cproperty<std::map<std::string, int>, meta> LFN

cproperty<std::map<std::string, weights_t>, meta> misc

cproperty<std::map<std::string, std::string>, meta> config

Metrics

class metrics : public tools, public notification 

Public Functions

metrics()

~metrics()

void dump_plots(int k)

void dump_loss_plots(int k)

void dump_accuracy_plots(int k)

void dump_mass_plots(int k)

model_report *register_model(model_template *model, int kfold)

void capture(mode_enum, int kfold, int epoch, int smpl_len)

Public Members

std::string output_path

const std::vector<Color_t> colors_h = {kRed, kGreen, kBlue, kCyan, kViolet, kOrange, kCoffee, kAurora}

settings_t m_settings

Notification

class notification

Subclassed by analysis, dataloader, io, lossfx, meta, metric_template, metrics, model_template, nusol, optimizer, plotting, sampletracer

Public Functions

notification()

~notification()

void success(std::string message)

void warning(std::string message)

void failure(std::string message)

void info(std::string message)

void progressbar(float prog, std::string title)

void progressbar(std::vector<size_t> *threads, std::vector<size_t> *trgt, std::vector<std::string> *title)

int running(std::vector<std::thread*> *thr, std::vector<size_t> *prg, std::vector<size_t> *trgt)

void monitor(std::vector<std::thread*> *thr)

Public Members

std::string prefix

int _warning = 33

int _failure = 31

int _success = 32

int _info = 37

bool bold = false

bool shush = false

Public Static Functions

static void progressbar1(std::vector<size_t> *threads, size_t l, std::string title)

static void progressbar2(std::vector<size_t> *threads, size_t *l, std::string *title)

static void progressbar3(std::vector<size_t> *threads, std::vector<size_t> *l, std::vector<std::string*> *title)

Optimizer

class optimizer : public tools, public notification 

Public Functions

optimizer()

~optimizer()

void import_dataloader(dataloader *dl)

void import_model_sessions(std::tuple<model_template*, optimizer_params_t*> *models)

void training_loop(int k, int epoch)

void validation_loop(int k, int epoch)

void evaluation_loop(int k, int epoch)

void launch_model(int k)

Public Members

settings_t m_settings

std::map<int, model_template*> kfold_sessions = {}

std::map<std::string, model_report*> reports = {}

metrics *metric = nullptr

dataloader *loader = nullptr

Plotting

class plotting : public tools, public notification 

Subclassed by roc

Public Functions

plotting()

~plotting()

std::string build_path()

float get_max(std::string dim)

float get_min(std::string dim)

float sum_of_weights()

void build_error()

std::tuple<float, float> mean_stdev(std::vector<float> *data)

Public Members

std::string extension = ".pdf"

std::string filename = "untitled"

std::string output_path = "./Figures"

float x_min = 0

float y_min = 0

float x_max = 0

float y_max = 0

int x_bins = 100

int y_bins = 100

bool errors = false

bool counts = false

std::string style = "ROOT"

std::string title = "untitled"

std::string ytitle = "y-axis"

std::string xtitle = "x-axis"

std::string histfill = "fill"

std::string overflow = "sum"

std::string marker = "."

std::string hatch = ""

std::string linestyle = "-"

std::string color = ""

std::vector<std::string> colors = {}

bool stack = false

bool density = false

bool x_logarithmic = false

bool y_logarithmic = false

float line_width = 0.1

float cap_size = 1.0

float alpha = 0.4

float x_step = -1

float y_step = -1

float font_size = 10

float axis_size = 12.5

float legend_size = 10

float title_size = 10

bool use_latex = true

int dpi = 400

float xscaling = 1.25 * 6.4

float yscaling = 1.25 * 4.8

bool auto_scale = true

std::vector<float> x_data = {}

std::vector<float> y_data = {}

std::vector<float> y_error_up = {}

std::vector<float> y_error_down = {}

std::unordered_map<std::string, float> x_labels = {}

std::unordered_map<std::string, float> y_labels = {}

std::vector<float> variable_x_bins = {}

std::vector<float> variable_y_bins = {}

std::vector<float> weights = {}

float cross_section = -1

float integrated_luminosity = 140.1

SampleTracer

class sampletracer : public tools, public notification 

Public Functions

sampletracer()

~sampletracer()

bool add_meta_data(meta *meta_, std::string filename)

meta *get_meta_data(std::string filename)

std::vector<event_template*> get_events(std::string label)

void fill_selections(std::map<std::string, selection_template*> *inpt)

bool add_event(event_template *ev, std::string label)

bool add_graph(graph_template *gr, std::string label)

bool add_selection(selection_template *sel)

void populate_dataloader(dataloader *dl)

void compile_objects(int threads)

Public Members

std::string *output_path = nullptr

Tools

class tools

Subclassed by analysis, collector, collector, container, dataloader, event_template, graph_template, io, lossfx, meta, metric_template, metrics, model_template, nusol, odeRK, odeRK, optimizer, particle_template, plotting, sampletracer, selection_template

Public Functions

tools()

~tools()

Public Static Functions

static void create_path(std::string path)

static void delete_path(std::string path)

static bool is_file(std::string path)

static void rename(std::string start, std::string target)

static std::string absolute_path(std::string path)

static std::vector<std::string> ls(std::string path, std::string ext = "")

static std::string to_string(double val)

static std::string to_string(double val, int prec)

static void replace(std::string *in, std::string repl_str, std::string repl_with)

static bool has_string(std::string *inpt, std::string trg)

static bool ends_with(std::string *inpt, std::string val)

static bool has_value(std::vector<std::string> *data, std::string trg)

static std::vector<std::string> split(std::string in, std::string delim)

static std::vector<std::string> split(std::string in, size_t n)

static std::string hash(std::string input, int len = 18)

static std::string lower(std::string*)

static std::string encode64(std::string *data)

static std::string encode64(unsigned char const*, unsigned int len)

static std::string decode64(std::string *inpt)

static std::string decode64(std::string const &s)

template<typename G> static inline std::vector<std::vector<G>> discretize(std::vector<G> *v, int N)

template<typename g> static inline g max(std::vector<g> *inpt)

template<typename g> static inline g min(std::vector<g> *inpt)

template<typename g> static inline g sum(std::vector<g> *inpt)

template<typename g> static inline std::vector<g*> put(std::vector<g*> *src, std::vector<int> *trg)

template<typename g> static inline void put(std::vector<g*> *out, std::vector<g*> *src, std::vector<int> *trg)

template<typename g> static inline void unique_key(std::vector<g> *inx, std::vector<g> *oth)

CProperty

template<typename T, typename G> class cproperty

Public Functions

inline cproperty()

inline void set_setter(std::function<void(T*, G*)> c = x_setter<T, G>)

inline void set_getter(std::function<void(T*, G*)> c = x_getter<T, G>)

inline void set_object(G *_obj)

inline cproperty &operator=(const T &val)

inline T operator+(const T &val)

inline bool operator==(const T &val)

inline bool operator!=(const T &val)

inline operator T()

inline T *operator&()

inline void clear()

Event Implementations

BSM 4tops Event

class bsm_4tops : public event_template 

Public Functions

bsm_4tops()

virtual ~bsm_4tops()

virtual event_template *clone() override

virtual void build(element_t *el) override

virtual void CompileEvent() override

Public Members

std::vector<particle_template*> Tops = {}

std::vector<particle_template*> Children = {}

std::vector<particle_template*> TruthJets = {}

std::vector<particle_template*> Jets = {}

std::vector<particle_template*> Electrons = {}

std::vector<particle_template*> Muons = {}

std::vector<particle_template*> DetectorObjects = {}

unsigned long long event_number = 0

float mu = 0

float met = 0

float phi = 0

EXP MC20 Event

class exp_mc20 : public event_template 

Public Functions

exp_mc20()

virtual ~exp_mc20()

virtual event_template *clone() override

virtual void build(element_t *el) override

virtual void CompileEvent() override

Public Members

std::vector<particle_template*> Tops

std::vector<particle_template*> TopChildren

std::vector<particle_template*> PhysicsTruth

std::vector<particle_template*> PhysicsDetector

std::vector<particle_template*> Jets

std::vector<particle_template*> Leptons

std::vector<particle_template*> Detector

unsigned long long event_number = 0

float met_sum = 0

float met = 0

float phi = 0

float mu = 0

GNN Event

class gnn_event : public event_template 

Public Functions

gnn_event()

~gnn_event() override

virtual event_template *clone() override

virtual void build(element_t *el) override

virtual void CompileEvent() override

Public Members

int num_bjets = 0

double num_jets = 0

double num_leps = 0

double met = 0

double phi = 0

int p_ntops = 0

int p_signal = 0

float s_ntops = 0

float s_signal = 0

std::vector<float> ntops_scores = {}

std::vector<float> signal_scores = {}

std::vector<std::vector<float>> edge_res_scores = {}

std::vector<std::vector<float>> edge_top_scores = {}

std::vector<top*> r_tops = {}

std::vector<zprime*> r_zprime = {}

std::vector<particle_gnn*> event_particles = {}

std::vector<top*> t_tops = {}

std::vector<zprime*> t_zprime = {}

std::vector<int> t_edge_res = {}

std::vector<int> t_edge_top = {}

int t_ntops = 0

bool t_signal = 0

SSML MC20 Event

class ssml_mc20 : public event_template 

Public Functions

ssml_mc20()

virtual ~ssml_mc20()

virtual event_template *clone() override

virtual void build(element_t *el) override

virtual void CompileEvent() override

Public Members

unsigned long long eventNumber

float event_category

float weight_mc

float weight_pileup

float weight_beamspot

float weight_jvt_effSF

float weight_lep_tightSF

float weight_ftag_effSF

float global_trigger_SF

float phi

float met

float met_sum

float HT_all

int pass_ssee

int pass_ssem

int pass_ssmm

int pass_eem_zveto

int pass_eee_zveto

int pass_emm_zveto

int pass_mmm_zveto

int pass_llll_zveto

int pass_eem

int pass_eee

int pass_emm

int pass_mmm

bool broken_event = false

int n_electrons

int n_fjets

int n_jets

int n_leptons

int n_muons

std::vector<particle_template*> Tops

std::vector<particle_template*> TruthChildren

std::vector<particle_template*> Zprime

std::vector<particle_template*> Leptsn

std::vector<particle_template*> Electrons

std::vector<particle_template*> Jets

std::vector<particle_template*> Leptons

std::vector<particle_template*> Detector

std::vector<particle_template*> TruthJets

Particle Implementations

Electron

class electron : public particle_template, public particle_template, public particle_template 

Public Functions

electron()

virtual ~electron()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

electron()

virtual ~electron()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

electron()

virtual ~electron()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

bool from_res = false

int top_index = -1

float d0 = 0

int true_type = 0

float delta_z0 = 0

int true_origin = 0

bool is_tight = false

std::vector<int> top_index = {}

cproperty<bool, electron> from_res

int pass_ecids = -1

Public Static Functions

static void get_from_res(bool *val, electron *el)

Muon

class muon : public particle_template, public particle_template, public particle_template 

Public Functions

muon()

virtual ~muon()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

muon()

virtual ~muon()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

muon()

virtual ~muon()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

bool from_res = false

int top_index = -1

float d0 = 0

int true_type = 0

float delta_z0 = 0

int true_origin = 0

bool is_tight = false

std::vector<int> top_index = {}

cproperty<bool, muon> from_res

Public Static Functions

static void get_from_res(bool *val, muon *el)

Jet

class jet : public particle_template, public particle_template, public particle_template 

Public Functions

jet()

virtual ~jet()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

jet()

virtual ~jet()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

jet()

virtual ~jet()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

std::vector<top*> Tops = {}

std::vector<jetparton*> Parton = {}

std::vector<int> top_index = {}

cproperty<bool, jet> from_res

bool btag_DL1r_60

bool btag_DL1_60

bool btag_DL1r_70

bool btag_DL1_70

bool btag_DL1r_77

bool btag_DL1_77

bool btag_DL1r_85

bool btag_DL1_85

float DL1_b

float DL1_c

float DL1_u

float DL1r_b

float DL1r_c

float DL1r_u

bool btag_65

bool btag_70

bool btag_77 = false

bool btag_85 = false

bool btag_90 = false

int flav

int label

int top_index = -1

bool sel_85 = false

Public Static Functions

static void get_from_res(bool *val, jet *el)

TruthJet

class truthjet : public particle_template, public particle_template 

Public Functions

truthjet()

virtual ~truthjet()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

truthjet()

virtual ~truthjet()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

int top_quark_count = -1

int w_boson_count = -1

std::vector<int> top_index = {}

cproperty<bool, truthjet> from_res

std::vector<top*> Tops = {}

std::vector<truthjetparton*> Parton = {}

int top_index = -1

Lepton

class lepton : public particle_template 

Public Functions

lepton()

virtual ~lepton()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Public Members

int ambiguity = 99

Neutrino

class neutrino : public particle_template 

Public Functions

neutrino()

neutrino(double px, double py, double pz)

virtual ~neutrino()

Public Members

double min = 0

long l_idx = -1

long b_idx = -1

particle_template *bquark = nullptr

particle_template *lepton = nullptr

std::vector<neutrino*> alternatives = {}

std::vector<int> top_index = {}

bool from_res = false

Top

class top : public particle_template, public particle_template, public particle_template, public particle_template 

Public Functions

top()

virtual ~top()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

top()

virtual ~top()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

top()

~top()

top()

virtual ~top()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

bool from_res = false

int status = -1

std::vector<truthjet*> TruthJets = {}

std::vector<jet*> Jets = {}

int top_index = -1

float av_score = 0

int n_leps = 0

int n_nodes = 0

std::vector<particle_template*> jets = {}

std::vector<particle_template*> leptons = {}

std::vector<particle_template*> truthjets = {}

Child

class child : public particle_template 

Public Functions

child()

virtual ~child()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Public Members

std::vector<int> top_index = {}

Parton

class parton : public particle_template, public selection_template 

Public Functions

parton()

virtual ~parton()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

parton()

~parton() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

template<typename g, typename gx> inline float top_mass_contribution(std::vector<g*> jts, std::map<std::string, std::vector<float>> *fracx, gx *p, top *ti, float cut, bool cut_gluon)

Public Members

int top_index = -1

int jet_index = -1

int truthjet_index = -1

int muon_index = -1

int electron_index = -1

std::map<std::string, jet*> jets

std::map<std::string, truthjet*> truthjets

std::map<std::string, std::vector<float>> ntops_tjets_pt

std::map<std::string, std::vector<float>> ntops_tjets_e

std::map<std::string, std::vector<float>> ntops_jets_pt

std::map<std::string, std::vector<float>> ntops_jets_e

std::map<std::string, std::vector<float>> nparton_tjet_e

std::map<std::string, std::vector<float>> nparton_jet_e

std::map<std::string, std::vector<float>> frac_parton_tjet_e

std::map<std::string, std::vector<float>> frac_parton_jet_e

std::map<std::string, std::vector<float>> frac_ntop_tjet_contribution

std::map<std::string, std::vector<float>> frac_ntop_jet_contribution

std::map<std::string, std::vector<float>> frac_mass_top

JetParton

class jetparton : public particle_template 

Public Functions

jetparton()

virtual ~jetparton()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

int jet_index

std::vector<int> topchild_index = {}

TruthJetParton

class truthjetparton : public particle_template 

Public Functions

truthjetparton()

virtual ~truthjetparton()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

int truthjet_index

std::vector<int> topchild_index = {}

ZBoson

class zboson : public particle_template 

Public Functions

zboson()

virtual ~zboson()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Particle GNN

class particle_gnn : public particle_template 

Public Functions

particle_gnn()

~particle_gnn()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Public Members

bool lep = false

Graph Implementations

Graph Children

class graph_children : public graph_template 

Public Functions

graph_children()

virtual ~graph_children()

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph Detector

class graph_detector : public graph_template, public graph_template, public graph_template 

Public Functions

graph_detector()

virtual ~graph_detector()

virtual graph_template *clone() override

virtual void CompileEvent() override

virtual bool PreSelection() override

graph_detector()

~graph_detector() override

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_detector()

~graph_detector() override

virtual graph_template *clone() override

virtual void CompileEvent() override

Public Members

std::vector<particle_template*> nux = {}

bool force_match = false

int num_cuda = 1

Graph Jets

class graph_jets : public graph_template, public graph_template, public graph_template 

Public Functions

graph_jets()

virtual ~graph_jets()

virtual graph_template *clone() override

virtual void CompileEvent() override

virtual bool PreSelection() override

graph_jets()

~graph_jets() override

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_jets()

~graph_jets() override

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph Jets Detector Lep

class graph_jets_detector_lep : public graph_template, public graph_template, public graph_template 

Public Functions

graph_jets_detector_lep()

virtual ~graph_jets_detector_lep()

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_jets_detector_lep()

~graph_jets_detector_lep() override

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_jets_detector_lep()

~graph_jets_detector_lep() override

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph Jets NoNu

class graph_jets_nonu : public graph_template, public graph_template, public graph_template 

Public Functions

graph_jets_nonu()

virtual ~graph_jets_nonu()

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_jets_nonu()

~graph_jets_nonu() override

virtual graph_template *clone() override

virtual void CompileEvent() override

graph_jets_nonu()

~graph_jets_nonu() override

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph Tops

class graph_tops : public graph_template 

Public Functions

graph_tops()

virtual ~graph_tops()

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph TruthJets

class graph_truthjets : public graph_template 

Public Functions

graph_truthjets()

virtual ~graph_truthjets()

virtual graph_template *clone() override

virtual void CompileEvent() override

Graph TruthJets NoNu

class graph_truthjets_nonu : public graph_template 

Public Functions

graph_truthjets_nonu()

virtual graph_template *clone() override

virtual ~graph_truthjets_nonu()

virtual void CompileEvent() override

Top Children

class top_children : public particle_template 

Public Functions

top_children()

virtual ~top_children()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

particle_template()

explicit particle_template(particle_t *p)

explicit particle_template(particle_template *p, bool dump = false)

explicit particle_template(double px, double py, double pz, double e)

explicit particle_template(double px, double py, double pz)

Public Members

int top_index = -1

cproperty<bool, top_children> from_res

Physics Detector

class physics_detector : public particle_template 

Public Functions

physics_detector()

virtual ~physics_detector()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Public Members

std::vector<int> top_index = {}

Physics Truth

class physics_truth : public particle_template 

Public Functions

physics_truth()

virtual ~physics_truth()

virtual particle_template *clone() override

virtual void build(std::map<std::string, particle_template*> *prt, element_t *el) override

Public Members

std::vector<int> top_index = {}

Model Implementations

RecursiveGraphNeuralNetwork

class recursivegraphneuralnetwork : public model_template 

Public Functions

recursivegraphneuralnetwork(int rep = 1024, double dpt = 0.1)

~recursivegraphneuralnetwork()

virtual model_template *clone() override

virtual void forward(graph_t*) override

torch::Tensor message(torch::Tensor trk_i, torch::Tensor trk_j, torch::Tensor pmc, torch::Tensor pmc_i, torch::Tensor pmc_j, torch::Tensor hx_i, torch::Tensor hx_j)

Public Members

int _dx = 26

int _x = 5

int _output = 2

int _rep = 256

double res_mass = 0

double drop_out = 0.1

bool is_mc = true

torch::nn::Sequential *rnn_x = nullptr

torch::nn::Sequential *rnn_dx = nullptr

torch::nn::Sequential *rnn_merge = nullptr

torch::nn::Sequential *rnn_update = nullptr

torch::nn::Sequential *exotic_mlp = nullptr

torch::nn::Sequential *node_aggr_mlp = nullptr

torch::nn::Sequential *ntops_mlp = nullptr

torch::nn::Sequential *exo_mlp = nullptr

GRIFT

class grift : public model_template 

Public Functions

grift()

~grift()

virtual model_template *clone() override

virtual void forward(graph_t*) override

torch::Tensor message(torch::Tensor trk_i, torch::Tensor trk_j, torch::Tensor pmc, torch::Tensor hx_i, torch::Tensor hx_j)

torch::Tensor node_encode(torch::Tensor pmc, torch::Tensor num_node, torch::Tensor *node_rnn)

Public Members

int _hidden = 1024

int _xrec = 128

int _xin = 6

int _xout = 2

int _xtop = 5

double drop_out = 0.01

bool is_mc = true

bool init = false

bool pagerank = false

torch::nn::Sequential *rnn_x = nullptr

torch::nn::Sequential *rnn_dx = nullptr

torch::nn::Sequential *rnn_txx = nullptr

torch::nn::Sequential *rnn_rxx = nullptr

torch::nn::Sequential *rnn_hxx = nullptr

torch::nn::Sequential *mlp_ntop = nullptr

torch::nn::Sequential *mlp_sig = nullptr

torch::Tensor x_nulls

torch::Tensor dx_nulls

torch::Tensor te_nulls

Metric Implementations

Accuracy Metric

class accuracy_metric : public metric_template 

Public Functions

accuracy_metric()

~accuracy_metric() override

virtual accuracy_metric *clone() override

virtual void define_metric(metric_t *mtx) override

virtual void define_variables() override

virtual void event() override

virtual void batch() override

virtual void end() override

PageRank Metric

class pagerank_metric : public metric_template 

Public Functions

pagerank_metric()

~pagerank_metric() override

virtual pagerank_metric *clone() override

virtual void define_metric(metric_t *mtx) override

virtual void define_variables() override

virtual void event() override

virtual void batch() override

virtual void end() override

void pagerank(std::map<int, std::map<std::string, particle_template*>> *clust, std::map<std::string, std::vector<particle_template*>> *out, std::map<std::string, float> *bin_out, std::map<int, std::map<int, float>> *bin_data, int batch_offset)

std::vector<particle_template*> build_top(std::map<int, std::map<int, particle_template*>>*)

Public Members

std::map<std::string, std::map<std::string, long>> file_maps

std::map<std::string, std::map<std::string, long>> file_stats

float alpha = 0.85

float norm_lim = 1e-6

size_t max_itr = 1e6

int kfold = -1

int epoch = -1

Collector

class collector : public tools, public tools 

Public Functions

collector()

~collector()

cdata_t *get_mode(std::string model, std::string mode, int epoch, int kfold)

void add_ntop_truth(std::string mode, std::string model, int epoch, int kfold, int data)

void add_ntop_edge_accuracy(std::string mode, std::string model, int epoch, int kfold, int ntops, double data)

void add_ntop_scores(std::string mode, std::string model, int epoch, int kfold, std::vector<double> *data)

void add_ntru_ntop_scores(std::string mode, std::string model, int epoch, int kfold, int ntru, int ntop, double data)

std::map<std::string, std::vector<cdata_t*>> get_plts()

collector()

~collector()

void set_index(long idx_)

kinematic_t create_kinematic(double px, double py, double pz, double mass, double pt, double eta, double phi, double energy, int num_nodes, double score)

void add_truth(kinematic_t *p, std::string mode, std::string model, int kfold, int epoch)

void add_pagerank(kinematic_t *p, std::string mode, std::string model, int kfold, int epoch)

void add_nominal(kinematic_t *p, std::string mode, std::string model, int kfold, int epoch)

void add_process(int prc, std::string mode, std::string model, int kfold, int epoch)

bool add_meta(std::string data, std::string model, int kfold, int epoch)

void add_file_map(std::string fname, long idx_, std::string mode, std::string model, int kfold, int epoch, bool stat)

Public Members

std::vector<std::string> model_names = {}

std::vector<std::string> modes = {}

std::vector<int> epochs = {}

std::vector<int> kfolds = {}

std::map<std::string, cmodel_t> model_data = {}

ROC

class roc : public plotting 

Public Functions

roc()

~roc()

void build_ROC(std::string name, int kfold, std::vector<int> *label, std::vector<std::vector<double>> *scores)

std::vector<roc_t*> get_ROC()

Public Members

std::map<std::string, std::map<int, std::vector<std::vector<double>>*>> roc_data = {}

std::map<std::string, std::map<int, std::vector<std::vector<int>>*>> labels = {}

Selection Implementations

ChildrenKinematics

class childrenkinematics : public selection_template 

Public Functions

childrenkinematics()

~childrenkinematics() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::vector<kinematic_t> res_kinematics = {}

std::vector<kinematic_t> spec_kinematics = {}

std::vector<misc_t> res_decay_mode = {}

std::vector<misc_t> spec_decay_mode = {}

std::vector<perms_t> top_clusters = {}

DecayModes

class decaymodes : public selection_template 

Public Functions

decaymodes()

~decaymodes() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::map<std::string, std::vector<double>> res_top_modes = {}

std::map<std::string, std::vector<double>> res_top_charges = {}

std::map<std::string, int> res_top_pdgid = {}

std::map<std::string, std::vector<double>> spec_top_modes = {}

std::map<std::string, std::vector<double>> spec_top_charges = {}

std::map<std::string, int> spec_top_pdgid = {}

std::map<std::string, int> all_pdgid = {}

std::map<std::string, std::vector<double>> signal_region = {}

std::map<std::string, int> lepton_statistics = {}

std::vector<int> ntops = {}

MET

class met : public selection_template, public selection_template 

Public Functions

met()

~met() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

met()

~met() override

virtual selection_template *clone() override

std::map<int, std::map<std::string, particle_template*>> match_tops(std::vector<particle_template*> tops, std::vector<particle_template*> leps)

std::tuple<std::vector<neutrino*>, std::vector<neutrino*>> reconstruction(std::vector<particle_template*> nodes, double met_, double phi_)

std::vector<double> sum_cart(std::vector<particle_template*> ptx)

std::vector<double> cross(std::vector<double> v1, std::vector<double> v2, bool norm)

std::vector<double> pmc(particle_template *p1)

double chi2(particle_template *nut, particle_template *nur)

double cart_px(std::vector<particle_template*> prt)

double cart_py(std::vector<particle_template*> prt)

double cart_pz(std::vector<particle_template*> prt)

double cart_px(double met, double phi)

double cart_py(double met, double phi)

angle_t angle(particle_template *nu1, particle_template *l1, particle_template *b1, particle_template *nu2, particle_template *l2, particle_template *b2, std::vector<double> det_, std::vector<double> met_)

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::map<std::string, float> missing_et

int steps = 20

double perturb = 1e-2

double distance = 1e-3

double masstop = 172.62 * 1000

double massw = 80.385 * 1000

Matching

class matching : public selection_template 

Public Functions

matching()

~matching()

virtual selection_template *clone() override

void reference(event_template *ev)

void experimental(event_template *ev)

void current(event_template *ev)

void dump(object_data_t *data, std::vector<particle_template*> *obj, bool is_lepx, bool is_tru, int *num_jets = nullptr, std::vector<int> *num_merged = nullptr)

bool match_obj(std::vector<particle_template*> *vx, std::vector<particle_template*> *out, std::string hash_, std::vector<int> *num_merged, int *num_jets, bool exl_lep)

std::vector<int> get_pdgid(std::vector<particle_template*> *prt)

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

double energy_constraint = -1

buffer_t data

TopJets

class topjets : public selection_template 

Public Functions

topjets()

~topjets() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> top_mass = {}

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> jet_partons = {}

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> jets_contribute = {}

std::map<std::string, std::map<std::string, std::vector<float>>> jet_top = {}

std::map<std::string, std::vector<float>> jet_mass = {}

std::vector<int> ntops_lost = {}

TopKinematics

class topkinematics : public selection_template, public selection_template 

Public Functions

topkinematics()

~topkinematics() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

topkinematics()

~topkinematics() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::map<std::string, std::vector<float>> res_top_kinematics = {}

std::map<std::string, std::vector<float>> spec_top_kinematics = {}

std::map<std::string, std::vector<float>> mass_combi = {}

std::map<std::string, std::vector<float>> deltaR = {}

TopMatching

class topmatching : public selection_template, public selection_template 

Public Functions

topmatching()

~topmatching() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

template<typename T> inline std::vector<T*> vectorize(std::map<std::string, T*> *mp)

template<typename T> inline std::vector<particle_template*> downcast(std::vector<T*> *mp)

topmatching()

~topmatching() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

template<typename T> inline std::vector<T*> vectorize(std::map<std::string, T*> *mp)

template<typename T> inline std::vector<particle_template*> downcast(std::vector<T*> *mp)

Public Members

std::vector<float> truth_top = {}

std::vector<int> no_children = {}

std::vector<float> topchildren_mass = {}

std::vector<int> topchildren_leptonic = {}

std::vector<float> toptruthjets_mass = {}

std::vector<int> toptruthjets_leptonic = {}

std::vector<int> toptruthjets_njets = {}

std::vector<float> topjets_children_mass = {}

std::vector<int> topjets_children_leptonic = {}

std::vector<float> topjets_leptons_mass = {}

std::vector<int> topjets_leptons_leptonic = {}

std::vector<int> topjets_leptons_pdgid = {}

std::vector<int> topjets_leptons_njets = {}

std::map<std::string, std::vector<float>> truth_children = {}

std::map<std::string, std::vector<float>> truth_jets = {}

std::map<std::string, std::vector<float>> n_truth_jets_lep = {}

std::map<std::string, std::vector<float>> n_truth_jets_had = {}

std::map<std::string, std::vector<float>> jets_truth_leps = {}

std::map<std::string, std::vector<float>> jet_leps = {}

std::map<std::string, std::vector<float>> n_jets_lep = {}

std::map<std::string, std::vector<float>> n_jets_had = {}

TopTruthJets

class toptruthjets : public selection_template 

Public Functions

toptruthjets()

~toptruthjets() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> top_mass = {}

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> truthjet_partons = {}

std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> truthjets_contribute = {}

std::map<std::string, std::map<std::string, std::vector<float>>> truthjet_top = {}

std::map<std::string, std::vector<float>> truthjet_mass = {}

std::vector<int> ntops_lost = {}

ZPrime

class zprime : public particle_template, public selection_template, public selection_template 

Public Functions

zprime()

~zprime()

zprime()

~zprime() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

zprime()

~zprime() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

float av_score = 0

int n_leps = 0

int n_nodes = 0

std::vector<float> zprime_truth_tops = {}

std::vector<float> zprime_children = {}

std::vector<float> zprime_truthjets = {}

std::vector<float> zprime_jets = {}

Regions

class regions : public selection_template 

Public Functions

regions()

~regions() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

Public Members

std::vector<package_t> output

TopEfficiency

class topefficiency : public selection_template 

Public Functions

topefficiency()

~topefficiency()

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

int iters(double start, double end, double step)

std::string region(double pt, double eta)

std::string decaymode(std::vector<top*> ev_tops)

Public Members

double pt_start = 0

double eta_start = 0

double pt_end = 1500

double eta_end = 6

double eta_step = 0.5

double pt_step = 100

double score_step = 0.01

std::map<std::string, std::map<std::string, std::vector<float>>> p_topmass = {}

std::map<std::string, std::map<std::string, std::vector<float>>> t_topmass = {}

std::map<std::string, std::map<std::string, std::vector<float>>> p_zmass = {}

std::map<std::string, std::map<std::string, std::vector<float>>> t_zmass = {}

std::map<std::string, std::map<std::string, std::vector<float>>> prob_tops = {}

std::map<std::string, std::map<std::string, std::vector<float>>> prob_zprime = {}

std::map<std::string, std::map<std::string, std::vector<float>>> t_decay_region = {}

std::map<std::string, std::map<std::string, std::vector<float>>> p_decay_region = {}

std::map<std::string, std::map<float, int>> p_nodes = {}

std::map<std::string, std::map<float, int>> t_nodes = {}

std::map<std::string, int> n_tru_tops = {}

std::map<std::string, std::map<float, int>> n_pred_tops = {}

std::map<std::string, std::map<float, int>> n_perfect_tops = {}

std::vector<int> truth_res_edge = {}

std::vector<int> truth_top_edge = {}

std::vector<int> truth_ntops = {}

std::vector<int> truth_signal = {}

std::vector<std::vector<float>> pred_res_edge_score = {}

std::vector<std::vector<float>> pred_top_edge_score = {}

std::vector<std::vector<float>> pred_ntops_score = {}

std::vector<std::vector<float>> pred_signal_score = {}

Combinatorial

class combinatorial : public selection_template 

Public Functions

combinatorial()

~combinatorial() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

void update_state(packet_t *data)

void reconstruction(packet_t *data)

Public Members

int num_device = 1

double masstop = 172.62 * 1000

double massw = 80.385 * 1000

Validation

class validation : public selection_template 

Public Functions

validation()

~validation() override

virtual selection_template *clone() override

virtual bool selection(event_template *ev) override

virtual bool strategy(event_template *ev) override

virtual void merge(selection_template *sl) override

void reconstruction(packet_t *data)

void update_state(packet_t *data)

Public Members

int num_device = 1

double masstop = 172.62 * 1000

double massw = 80.385 * 1000

PyC/CUDA Classes

Conics

class conics

Public Functions

conics(nusol_t *parameters)

~conics()

Ellipse

class ellipse

Public Functions

ellipse(nusol_t *parameters)

void prepare(double mt, double mw)

std::vector<particle_template*> nunu_make()

void solve()

~ellipse()

NuSol

class nusol : private notification, private tools 

Public Functions

nusol(nusol_t *parameters)

void solve()

~nusol()

Conuic

class conuic

Public Functions

conuic(particle_template *jet, particle_template *lep)

~conuic()

void solve()

Public Members

cproperty<long double, conuic> t

cproperty<long double, conuic> z

cproperty<long double, conuic> l

Conuix

class conuix

Public Functions

conuix(nusol_t *params)

~conuix()

void solve()

Nuclx

class nuclx

Public Functions

nuclx(particle_template *bjet, particle_template *lep)

matrix_t H(double z, double t)

matrix_t H_tilde(double z, double t)

double P(double lambda, double t, double z)

double dP_dL(double lambda, double t, double z)

eig_t dPl0(double t, double z)

~nuclx()

Nuelx

class nuelx

Public Functions

nuelx()

nuelx(particle_template *b, particle_template *l, double mW, double mT)

~nuelx()

double Sx()

double dSx_dmW()

double Sy()

double dSy_dmW()

double dSy_dmT()

double w()

double w2()

double om2()

double Z()

double Z2()

double dZ_dmT()

double dZ_dmW()

double x0()

double x1()

double dx1_dmW()

double dx1_dmT()

double y1()

double dy1_dmW()

double dy1_dmT()

void r_mT(double *mt1_, double *mt2_)

void r_mW(double *mw1_, double *mw2_)

void Z_mW(double *mw1_, double *mw2_)

void Z_mT(double *mt1_, double *mt2_, double mw_)

void update(double mt, double mw)

void flush()

mtx *N()

mtx *H()

mtx *H_perp()

mtx *H_tilde()

mtx *dH_dmW()

mtx *dH_dmT()

mtx *K()

mtx *R_T()

void Z2(double *A, double *B, double *C)

void misc()

Public Members

wrapper *b = nullptr

wrapper *l = nullptr

Mtx

class mtx

Public Functions

mtx()

mtx(int idx, int idy)

mtx(mtx *in)

mtx(mtx &in)

~mtx()

double trace()

double det()

mtx copy()

void copy(const mtx *ipt, int idx, int idy = -1)

void copy(const mtx *ipt, int idx, int jdy, int idy)

bool assign(int idx, int idy, double val, bool valid = true)

bool unique(int id1, int id2, double v1, double v2)

mtx *cat(const mtx *v2)

mtx *slice(int idx)

mtx *eigenvalues()

mtx *eigenvector()

mtx T()

mtx inv()

mtx cof()

mtx diag()

mtx dot(const mtx &other)

mtx dot(const mtx *other)

mtx cross(mtx *r1)

mtx cross(mtx *r1, mtx *r2)

bool valid(int idx, int idy)

void print(int prec = 6, int width = 12)

mtx &operator=(const mtx &o)

double m_00()

double m_01()

double m_02()

double m_10()

double m_11()

double m_12()

double m_20()

double m_21()

double m_22()

Public Members

double **_m = nullptr

bool **_b = nullptr

int dim_i = 0

int dim_j = 0

double tol = 1e-9

Multisol

class multisol

Public Functions

multisol(particle_template *b, particle_template *l)

~multisol()

void make_rt()

matrix H_tilde(double t, double z)

matrix dHdt_tilde(double t, double z = 1)

matrix H(double t, double z)

matrix dHdt(double t, double z = 1)

matrix d2Hdt2(double t, double z = 1)

vec3 v(double t, double z, double phi)

vec3 dv_dt(double t, double z, double phi)

vec3 dv_dphi(double t, double z, double phi)

vec3 d2v_dt_dphi(double t, double z, double phi)

geo_t geometry(double t, double z)

geo_t intersection(multisol *nu, double t1, double z1, double t2, double z2)

geo_t *intersection(const vec3 &r0, const vec3 &d, double t, double z)

vec3 center(double t, double z)

vec3 normal(double t, double z)

bool eigenvalues(double t, double z, vec3 *real = nullptr, vec3 *imag = nullptr)

double dp_dt()

mass_t masses(double t, double z)

rev_t translate(double sx, double sy)

void export_ellipse(std::string name, double t, double z)

void export_ellipse(std::string name, double t, double z, int n_points)

multisol(particle_template *b, particle_template *l)

~multisol()

void make_rt()

matrix H_tilde(double t, double z)

matrix dHdt_tilde(double t, double z = 1)

matrix H(double t, double z)

matrix dHdt(double t, double z = 1)

matrix d2Hdt2(double t, double z = 1)

vec3 v(double t, double z, double phi)

vec3 dv_dt(double t, double z, double phi)

vec3 dv_dphi(double t, double z, double phi)

vec3 d2v_dt_dphi(double t, double z, double phi)

geo_t geometry(double t, double z)

geo_t intersection(multisol *nu, double t1, double z1, double t2, double z2)

geo_t *intersection(const vec3 &r0, const vec3 &d, double t, double z)

vec3 center(double t, double z)

vec3 normal(double t, double z)

bool eigenvalues(double t, double z, vec3 *real = nullptr, vec3 *imag = nullptr)

double dp_dt()

mass_t masses(double t, double z)

rev_t translate(double sx, double sy)

void export_ellipse(std::string name, double t, double z)

void export_ellipse(std::string name, double t, double z, int n_points)

OdeRK

class odeRK : public tools, public tools 

Public Functions

odeRK(std::vector<multisol*> *sols, vec3 met, int iter, double step)

~odeRK()

void solve()

void rk4(double dt)

void update_t()

double solve_z_phi()

double residual(std::vector<double> wg, std::vector<double> phx)

std::vector<ellipse_t> derivative(const std::vector<ellipse_t> &dS)

double ghost_angle(int nui)

std::vector<double> plane_rk4(const std::vector<double> &t_initial)

std::vector<double> plane_align(const std::vector<ellipse_t> &current_state)

odeRK(std::vector<multisol*> *sols, vec3 met, int iter, double step)

~odeRK()

void solve()

void rk4(double dt)

void update_t()

double solve_z_phi()

double residual(std::vector<double> wg, std::vector<double> phx)

std::vector<ellipse_t> derivative(const std::vector<ellipse_t> &dS)

double ghost_angle(int nui)

std::vector<double> plane_rk4(const std::vector<double> &t_initial)

std::vector<double> plane_align(const std::vector<ellipse_t> &current_state)

Optimizer Params

class optimizer_params_t

Public Functions

optimizer_params_t()

Public Members

std::string optimizer = ""

cproperty<double, optimizer_params_t> lr

cproperty<double, optimizer_params_t> lr_decay

cproperty<double, optimizer_params_t> weight_decay

cproperty<double, optimizer_params_t> initial_accumulator_value

cproperty<double, optimizer_params_t> eps

cproperty<double, optimizer_params_t> tolerance_grad

cproperty<double, optimizer_params_t> tolerance_change

cproperty<double, optimizer_params_t> alpha

cproperty<double, optimizer_params_t> momentum

cproperty<double, optimizer_params_t> dampening

cproperty<bool, optimizer_params_t> amsgrad

cproperty<bool, optimizer_params_t> centered

cproperty<bool, optimizer_params_t> nesterov

cproperty<int, optimizer_params_t> max_iter

cproperty<int, optimizer_params_t> max_eval

cproperty<int, optimizer_params_t> history_size

cproperty<std::tuple<float, float>, optimizer_params_t> betas

cproperty<std::vector<float>, optimizer_params_t> beta_hack

std::string scheduler = ""

unsigned int step_size = 1

double gamma = 0.1

bool m_lr = false

bool m_lr_decay = false

bool m_weight_decay = false

bool m_initial_accumulator_value = false

bool m_eps = false

bool m_betas = false

bool m_amsgrad = false

bool m_max_iter = false

bool m_max_eval = false

bool m_tolerance_grad = false

bool m_tolerance_change = false

bool m_history_size = false

bool m_alpha = false

bool m_momentum = false

bool m_centered = false

bool m_dampening = false

bool m_nesterov = false