Complete Struct Reference

This page provides comprehensive API documentation for all C++ structs and data structures in the AnalysisG framework.

Core Data Structures

element_t

struct element_t

Public Functions

bool next()
void set_meta()
bool boundary()
template<typename g>
inline bool get(std::string key, g *var)

Public Members

std::string tree = ""
long event_index = -1
std::string filename = ""
std::map<std::string, data_t*> handle = {}

variable_t

struct variable_t : public bsc_t

Public Functions

variable_t()
variable_t(bool use_external)
~variable_t() override
void create_meta(meta_t *mt)
void build_switch(size_t s, torch::Tensor *tx)
void process(torch::Tensor *data, std::string *varname, TTree *tr)
void process(std::vector<std::vector<float>> *data, std::string *varname, TTree *tr)
void process(std::vector<std::vector<double>> *data, std::string *varname, TTree *tr)
void process(std::vector<std::vector<long>> *data, std::string *varname, TTree *tr)
void process(std::vector<std::vector<int>> *data, std::string *varname, TTree *tr)
void process(std::vector<std::vector<bool>> *data, std::string *varname, TTree *tr)
void process(std::vector<float> *data, std::string *varname, TTree *tr)
void process(std::vector<double> *data, std::string *varname, TTree *tr)
void process(std::vector<long> *data, std::string *varname, TTree *tr)
void process(std::vector<int> *data, std::string *varname, TTree *tr)
void process(std::vector<bool> *data, std::string *varname, TTree *tr)
void process(float *data, std::string *varname, TTree *tr)
void process(double *data, std::string *varname, TTree *tr)
void process(long *data, std::string *varname, TTree *tr)
void process(int *data, std::string *varname, TTree *tr)
void process(bool *data, std::string *varname, TTree *tr)

Public Members

std::string variable_name = ""
bool failed_branch = false

data_t

struct data_t : public bsc_t

Public Functions

data_t()
~data_t() override
void initialize()
void flush()
bool next()

Public Members

std::string leaf_name = ""
std::string branch_name = ""
std::string tree_name = ""
std::string leaf_type = ""
std::string path = ""
std::string *fname = nullptr
TLeaf *leaf = nullptr
TBranch *branch = nullptr
TTree *tree = nullptr
TFile *file = nullptr
int file_index = 0
std::vector<std::string> *files_s = nullptr
std::vector<long> *files_i = nullptr
std::vector<TFile*> *files_t = nullptr

write_t

struct write_t

Public Functions

variable_t *process(std::string *name)
void write()
void create(std::string tr_name, std::string path)
void close()

Public Members

TFile *file = nullptr
TTree *tree = nullptr
meta_t *mtx = nullptr
std::map<std::string, variable_t*> *data = nullptr

Event Structures

event_t

struct event_t

Public Members

std::string name = ""
double weight = 1
long index = -1
std::string hash = ""
std::string tree = ""

meta_event_t

struct meta_event_t

Public Members

int process_mapping = -1
std::vector<kinematic_t> truth = {}
std::vector<kinematic_t> pageranked = {}
std::vector<kinematic_t> nominal = {}

particle_t

struct particle_t

Public Members

double e = -0.000000000000001
double mass = -1
double px = 0
double py = 0
double pz = 0
double pt = 0
double eta = 0
double phi = 0
bool cartesian = false
bool polar = false
double charge = 0
int pdgid = 0
int index = -1
std::string type = ""
std::string hash = ""
std::string symbol = ""
std::vector<int> lepdef = {11, 13, 15}
std::vector<int> nudef = {12, 14, 16}
std::map<std::string, bool> children = {}
std::map<std::string, bool> parents = {}
std::map<std::string, particle_template*> *data_p = nullptr

Metadata Structures

meta_t

struct meta_t

Public Members

unsigned int dsid = 0
bool isMC = true
std::string derivationFormat = ""
std::map<int, std::string> inputfiles = {}
std::map<std::string, std::string> config = {}
std::string AMITag = ""
std::string generators = ""
std::map<int, int> inputrange = {}
double eventNumber = -1
double event_index = -1
bool found = false
std::string DatasetName = ""
double totalSize = 0
double kfactor = 0
double ecmEnergy = 0
double genFiltEff = 0
double completion = 0
double beam_energy = 0
double crossSection = 0
double crossSection_mean = 0
double campaign_luminosity = 0
unsigned int nFiles = 0
unsigned int totalEvents = 0
unsigned int datasetNumber = 0
std::string identifier = ""
std::string prodsysStatus = ""
std::string dataType = ""
std::string version = ""
std::string PDF = ""
std::string AtlasRelease = ""
std::string principalPhysicsGroup = ""
std::string physicsShort = ""
std::string generatorName = ""
std::string geometryVersion = ""
std::string conditionsTag = ""
std::string generatorTune = ""
std::string amiStatus = ""
std::string beamType = ""
std::string productionStep = ""
std::string projectName = ""
std::string statsAlgorithm = ""
std::string genFilterNames = ""
std::string file_type = ""
std::string sample_name = ""
std::string logicalDatasetName = ""
std::string campaign = ""
std::vector<std::string> keywords = {}
std::vector<std::string> weights = {}
std::vector<std::string> keyword = {}
std::vector<int> events = {}
std::vector<int> run_number = {}
std::vector<double> fileSize = {}
std::vector<std::string> fileGUID = {}
std::map<std::string, int> LFN = {}
std::map<std::string, weights_t> misc = {}

settings_t

struct settings_t

Public Members

std::string output_path = "./ProjectName"
std::string run_name = ""
std::string sow_name = ""
std::string metacache_path = "./"
bool fetch_meta = false
bool pretagevents = false
int epochs = 10
int kfolds = 10
int batch_size = 1
std::vector<int> kfold = {}
int num_examples = 3
float train_size = 50
bool training = true
bool validation = true
bool evaluation = true
bool continue_training = true
std::string training_dataset = ""
std::string graph_cache = ""
std::string var_pt = "pt"
std::string var_eta = "eta"
std::string var_phi = "phi"
std::string var_energy = "energy"
std::vector<std::string> targets = {}
int nbins = 400
int max_range = 400
bool logy = false
int threads = 10
bool debug_mode = false
bool build_cache = false
bool selection_root = false

sample_t

struct sample_t

Public Members

std::string meta_data = ""
std::map<std::string, std::map<std::string, long>> file_map = {}
std::map<std::string, std::map<std::string, long>> file_stat = {}
std::map<std::string, std::map<long, meta_event_t>> data = {}

entry_t

struct entry_t

Public Functions

void init()
void destroy()
bool has_event(event_template *ev)
bool has_graph(graph_template *gr)
bool has_selection(selection_template *sel)
template<typename g>
inline void destroy(std::vector<g*> *c)

Public Members

std::string hash = ""
std::vector<graph_t*> m_data = {}
std::vector<graph_template*> m_graph = {}
std::vector<event_template*> m_event = {}
std::vector<selection_template*> m_selection = {}

Graph Structures

graph_t

struct graph_t

Public Functions

template<typename g>
inline torch::Tensor *get_truth_graph(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_truth_node(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_truth_edge(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_data_graph(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_data_node(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_data_edge(std::string _name, g *mdl)
template<typename g>
inline torch::Tensor *get_edge_index(g *mdl)
template<typename g>
inline torch::Tensor *get_event_weight(g *mdl)
template<typename g>
inline torch::Tensor *get_batch_index(g *mdl)
template<typename g>
inline torch::Tensor *get_batched_events(g *mdl)
torch::Tensor *has_feature(graph_enum tp, std::string _name, int dev)
void add_truth_graph(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void add_truth_node(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void add_truth_edge(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void add_data_graph(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void add_data_node(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void add_data_edge(std::map<std::string, torch::Tensor*> *data, std::map<std::string, int> *maps)
void transfer_to_device(torch::TensorOptions *dev)
void _purge_all()

Public Members

int num_nodes = 0
long event_index = 0
double event_weight = 1
bool preselection = false
std::vector<long> batched_events = {}
std::vector<std::string*> batched_filenames = {}
std::string *hash = nullptr
std::string *filename = nullptr
std::string *graph_name = nullptr
c10::DeviceType device = c10::kCPU
int in_use = 1

graph_hdf5

struct graph_hdf5

Public Members

int num_nodes = -1
double event_weight = 1
long event_index = -1
std::string hash
std::string filename
std::string edge_index
std::string data_map_graph
std::string data_map_node
std::string data_map_edge
std::string truth_map_graph
std::string truth_map_node
std::string truth_map_edge
std::string data_graph
std::string data_node
std::string data_edge
std::string truth_graph
std::string truth_node
std::string truth_edge

graph_hdf5_w

struct graph_hdf5_w

Public Functions

void flush_data()

Public Members

int num_nodes = -1
double event_weight = 1
long event_index = -1
char *hash = nullptr
char *filename = nullptr
char *edge_index = nullptr
char *data_map_graph = nullptr
char *data_map_node = nullptr
char *data_map_edge = nullptr
char *truth_map_graph = nullptr
char *truth_map_node = nullptr
char *truth_map_edge = nullptr
char *data_graph = nullptr
char *data_node = nullptr
char *data_edge = nullptr
char *truth_graph = nullptr
char *truth_node = nullptr
char *truth_edge = nullptr

Model Structures

cmodel_t

struct cmodel_t

Public Members

std::map<int, std::map<int, cdata_t>> evaluation_kfold_data = {}
std::map<int, std::map<int, cdata_t>> validation_kfold_data = {}
std::map<int, std::map<int, cdata_t>> training_kfold_data = {}

model_settings_t

struct model_settings_t

Public Members

opt_enum e_optim
std::string s_optim
std::string weight_name
std::string tree_name
std::string model_name
std::string model_device
std::string model_checkpoint_path
bool inference_mode
bool is_mc
std::map<std::string, std::string> o_graph
std::map<std::string, std::string> o_node
std::map<std::string, std::string> o_edge
std::vector<std::string> i_graph
std::vector<std::string> i_node
std::vector<std::string> i_edge

model_report

struct model_report

Public Functions

std::string print()
std::string prx(std::map<mode_enum, std::map<std::string, float>> *data, std::string title)

Public Members

int k
int epoch
bool is_complete = false
metrics *waiting_plot = nullptr
std::vector<double> current_lr = {}
std::map<mode_enum, std::map<std::string, float>> loss_graph = {}
std::map<mode_enum, std::map<std::string, float>> loss_node = {}
std::map<mode_enum, std::map<std::string, float>> loss_edge = {}
std::map<mode_enum, std::map<std::string, float>> accuracy_graph = {}
std::map<mode_enum, std::map<std::string, float>> accuracy_node = {}
std::map<mode_enum, std::map<std::string, float>> accuracy_edge = {}
std::string run_name
std::string mode
long iters = 0
long num_evnt = 0
float progress

folds_t

struct folds_t

Public Functions

inline void flush_data()

Public Members

int k = -1
bool is_train = false
bool is_valid = false
bool is_eval = false
char *hash = nullptr

loss_opt

struct loss_opt

Public Members

loss_enum fx = loss_enum::invalid_loss
bool mean = false
bool sum = false
bool none = false
bool swap = false
bool full = false
bool batch_mean = false
bool target = false
bool zero_inf = false
bool defaults = true
int ignore = 1000
int blank = 0
double margin = 0
double beta = 0
double eps = 0
double smoothing = 0
double delta = 0
std::vector<double> weight = {}

weights_t

struct weights_t

Public Members

int dsid = -1
bool isAFII = false
std::string generator = ""
std::string ami_tag = ""
float total_events_weighted = -1
float total_events = -1
float processed_events = -1
float processed_events_weighted = -1
float processed_events_weighted_squared = -1
std::map<std::string, float> hist_data = {}

Metric Structures

metric_t

struct metric_t

Public Functions

~metric_t()
template<typename g>
inline g get(graph_enum grx, std::string _name)
std::string mode()
std::string *get_filename(long unsigned int idx)

Public Members

int kfold = 0
int epoch = 0
int device = 0

roc_t

struct roc_t

Public Members

int cls = 0
int kfold = 0
std::string model = ""
std::vector<double> _auc = {}
std::vector<std::vector<double>> tpr_ = {}
std::vector<std::vector<double>> fpr_ = {}
std::vector<std::vector<int>> *truth = nullptr
std::vector<std::vector<double>> *scores = nullptr

regions_t

struct regions_t

Public Members

double weight = 0
double variable1 = 0
double variable2 = 0
bool passed = true

analytics_t

struct analytics_t

Public Functions

inline void purge()
inline void destroy(std::map<mode_enum, std::map<std::string, TH1F*>> *data)

Public Members

model_template *model = nullptr
model_report *report = nullptr
int this_epoch = 0
std::map<mode_enum, std::map<std::string, TH1F*>> loss_graph = {}
std::map<mode_enum, std::map<std::string, TH1F*>> loss_node = {}
std::map<mode_enum, std::map<std::string, TH1F*>> loss_edge = {}
std::map<mode_enum, std::map<std::string, TH1F*>> accuracy_graph = {}
std::map<mode_enum, std::map<std::string, TH1F*>> accuracy_node = {}
std::map<mode_enum, std::map<std::string, TH1F*>> accuracy_edge = {}
std::map<mode_enum, std::map<std::string, TH1F*>> pred_mass_edge = {}
std::map<mode_enum, std::map<std::string, TH1F*>> truth_mass_edge = {}

Data Container Structures

cdata_t

struct cdata_t

Public Members

int kfold = -1
std::vector<int> ntops_truth = {}
std::vector<std::vector<double>> ntop_score = {}
std::map<int, std::vector<double>> ntop_edge_accuracy = {}
std::map<int, std::map<int, std::vector<double>>> ntru_npred_matrix = {}

object_data_t

struct object_data_t

Public Members

int num_tops = 0
int num_ltop = 0
int num_htop = 0
int num_false = 0
std::vector<double> mass = {}
std::vector<double> wrong_matched = {}
std::vector<int> num_jets = {}
std::vector<int> is_leptonic = {}
std::vector<int> is_hadronic = {}
std::vector<std::vector<int>> merged = {}
std::vector<std::vector<int>> pdgid = {}

buffer_t

struct buffer_t

Public Members

object_data_t top_partons
object_data_t top_children
object_data_t top_truthjets
object_data_t top_jets_children
object_data_t top_jets_leptons

packet_t

struct packet_t

Public Functions

~packet_t()
~packet_t()

Public Members

double missing_evn_px = 0
double missing_evn_py = 0
double missing_det_px = 0
double missing_det_py = 0
double missing_det_pz = 0
double missing_nus_px = 0
double missing_nus_py = 0
double missing_nus_pz = 0
double num_neutrino = 0
double num_leptons = 0
double num_leptons_reco = 0
std::vector<int> top_index = {}
std::vector<double> mass_tru_top = {}
std::vector<double> mass_tru_top3 = {}
std::vector<particle_template*> tru_nu = {}
std::vector<double> chi2_sols = {}
std::vector<int> top_index_sols1 = {}
std::vector<int> top_index_sols2 = {}
std::vector<double> top_mass_sols1 = {}
std::vector<double> top_mass_sols2 = {}
std::vector<neutrino*> nu1 = {}
std::vector<neutrino*> nu2 = {}
std::vector<angle_t> agnR = {}
std::vector<angle_t> agnT = {}
std::vector<particle_template*> particles = {}
std::vector<particle_template*> t_bquarks = {}
std::vector<particle_template*> t_leptons = {}
std::vector<particle_template*> t_neutrino = {}
std::vector<int> matched_bquarks = {}
std::vector<int> matched_leptons = {}
std::vector<double> distance = {}
std::vector<double> chi2_nu1 = {}
std::vector<double> chi2_nu2 = {}
std::vector<particle_template*> nu1 = {}
std::vector<particle_template*> nu2 = {}
std::string name = ""
std::string device = "cuda:0"
double met = 0
double phi = 0
double null = 1e-5
double perturb = 1e-1
long steps = 20
bool _is_marked = false
std::vector<particle_template*> bquarks = {}
std::vector<particle_template*> leptons = {}
std::vector<particle_template*> neutrino = {}
std::vector<particle_template*> objects = {}
std::vector<particle_template*> static_nu1 = {}
std::vector<particle_template*> static_nu2 = {}
std::vector<double> static_distances = {}
std::vector<particle_template*> dynamic_nu1 = {}
std::vector<particle_template*> dynamic_nu2 = {}
std::vector<double> dynamic_distances = {}
double step = 1e-9
double tolerance = 1e-6
unsigned int timeout = 100

package_t

struct package_t

Public Members

regions_t CRttbarCO2l_CO
regions_t CRttbarCO2l_CO_2b
regions_t CRttbarCO2l_gstr
regions_t CRttbarCO2l_gstr_2b
regions_t CR1b3lem
regions_t CR1b3le
regions_t CR1b3lm
regions_t CRttW2l_plus
regions_t CRttW2l_minus
regions_t CR1bplus
regions_t CR1bminus
regions_t CRttW2l
regions_t VRttZ3l
regions_t VRttWCRSR
regions_t SR4b
regions_t SR2b
regions_t SR3b
regions_t SR2b2l
regions_t SR2b3l4l
regions_t SR2b4l
regions_t SR3b2l
regions_t SR3b3l4l
regions_t SR3b4l
regions_t SR4b4l
regions_t SR

writer

struct writer

Public Functions

writer()
~writer()
void create(std::string *pth)
void write(std::string *tree)
template<typename g>
inline void process(std::string *tree, std::string *name, g *t)

wrapper

struct wrapper

Public Functions

wrapper(particle_template *p_)

Public Members

double p = 0
double m = 0
double b = 0
double p2 = 0
double m2 = 0
double b2 = 0
double phi = 0
double theta = 0
double px = 0
double py = 0
double pz = 0
double e = 0
particle_template *lnk = nullptr

Physics/Kinematics Structures

kinematic_t

struct kinematic_t

Public Members

double px = 0
double py = 0
double pz = 0
double mass = 0
double pt = 0
double eta = 0
double phi = 0
double energy = 0
int num_nodes = 0
double score = 0
float pt = 0
float energy = 0
float eta = 0
float phi = 0
int pdgid = 0

mass_t

struct mass_t

Public Members

double mt = 0
double mw = 0
double sx = 0
double sy = 0

angle_t

struct angle_t

Public Members

std::vector<double> pln_w1 = {}
std::vector<double> pln_t1 = {}
std::vector<double> pln_w2 = {}
std::vector<double> pln_t2 = {}
std::vector<double> pln_t1xt2 = {}
double dR_nu_lep1 = 0
double dR_nu_lep2 = 0
bool has_null = true

geo_t

struct geo_t

Public Functions

~geo_t()
double px(double u, double v)
double py(double u, double v)
double pz(double u, double v)
double lx(double s)
double ly(double s)
double lz(double s)
~geo_t()
double px(double u, double v)
double py(double u, double v)
double pz(double u, double v)
double lx(double s)
double ly(double s)
double lz(double s)

Public Members

vec3 perp1
vec3 perp2
vec3 center
vec3 r0
vec3 d
vec3 _pts1
vec3 _pts2
bool valid = false
double _s1 = 0
double _s2 = 0
double _p1 = 0
double _p2 = 0
double _d1 = 0
double _d2 = 0
double asym = 0
geo_t *nu1 = nullptr
geo_t *nu2 = nullptr

misc_t

struct misc_t

Public Members

kinematic_t kin
bool is_lep = false
float mass_clust = 0
float delta_R = 0
float frc_energy = 0
float frc_pt = 0

bsc_t

struct bsc_t

Subclassed by data_t, variable_t

Public Functions

bsc_t()
virtual ~bsc_t()
void flush_buffer()
std::string as_string()
std::string scan_buffer()
data_enum root_type_translate(std::string*)
bool element(std::vector<std::vector<std::vector<float>>> *el)
bool element(std::vector<std::vector<std::vector<double>>> *el)
bool element(std::vector<std::vector<std::vector<long>>> *el)
bool element(std::vector<std::vector<std::vector<int>>> *el)
bool element(std::vector<std::vector<std::vector<bool>>> *el)
bool element(std::vector<std::vector<float>> *el)
bool element(std::vector<std::vector<double>> *el)
bool element(std::vector<std::vector<long>> *el)
bool element(std::vector<std::vector<int>> *el)
bool element(std::vector<std::vector<bool>> *el)
bool element(std::vector<float> *el)
bool element(std::vector<double> *el)
bool element(std::vector<long> *el)
bool element(std::vector<int> *el)
bool element(std::vector<char> *el)
bool element(std::vector<bool> *el)
bool element(double *el)
bool element(float *el)
bool element(long *el)
bool element(int *el)
bool element(bool *el)
bool element(unsigned long long *el)
bool element(unsigned int *el)
bool element(char *el)
template<typename T>
inline bool flush_buffer(std::vector<T> **data)
template<typename T>
inline bool flush_buffer(T **data)

Public Members

std::vector<std::vector<std::vector<unsigned long long>>> *vvv_ull = nullptr
std::vector<std::vector<std::vector<unsigned int>>> *vvv_ui = nullptr
std::vector<std::vector<std::vector<double>>> *vvv_d = nullptr
std::vector<std::vector<std::vector<long>>> *vvv_l = nullptr
std::vector<std::vector<std::vector<float>>> *vvv_f = nullptr
std::vector<std::vector<std::vector<int>>> *vvv_i = nullptr
std::vector<std::vector<std::vector<bool>>> *vvv_b = nullptr
std::vector<std::vector<std::vector<char>>> *vvv_c = nullptr
std::vector<std::vector<unsigned long long>> *vv_ull = nullptr
std::vector<std::vector<unsigned int>> *vv_ui = nullptr
std::vector<std::vector<double>> *vv_d = nullptr
std::vector<std::vector<long>> *vv_l = nullptr
std::vector<std::vector<float>> *vv_f = nullptr
std::vector<std::vector<int>> *vv_i = nullptr
std::vector<std::vector<bool>> *vv_b = nullptr
std::vector<std::vector<char>> *vv_c = nullptr
std::vector<unsigned long long> *v_ull = nullptr
std::vector<unsigned int> *v_ui = nullptr
std::vector<double> *v_d = nullptr
std::vector<long> *v_l = nullptr
std::vector<float> *v_f = nullptr
std::vector<int> *v_i = nullptr
std::vector<bool> *v_b = nullptr
std::vector<char> *v_c = nullptr
unsigned long long *ull = nullptr
unsigned int *ui = nullptr
double *d = nullptr
long *l = nullptr
float *f = nullptr
int *i = nullptr
bool *b = nullptr
char *c = nullptr
long index = 0
bool clear = false
data_enum type = data_enum::unset

Mathematical Structures

matrix

struct matrix

Public Functions

matrix(int r = 3, int c = 3)
matrix(const matrix &other)
~matrix()
void print(int p = 5)
double &at(int r, int c)
const double &at(int r, int c) const
int rows() const
int cols() const
double mag() const
matrix T() const
matrix inverse()
double det()
matrix dot(const matrix &m)
void eigenvalues(vec3 *real, vec3 *imag)
matrix &operator=(const matrix &other)
matrix operator+(const matrix &o) const
matrix operator-(const matrix &o) const
matrix operator*(const matrix &o) const
matrix operator*(double s) const
vec4 operator*(const vec4 &v) const
vec3 operator*(const vec3 &v) const
matrix(int r = 3, int c = 3)
matrix(const matrix &other)
~matrix()
void print(int p = 5)
double &at(int r, int c)
const double &at(int r, int c) const
int rows() const
int cols() const
double mag() const
matrix T() const
matrix inverse()
double det()
matrix dot(const matrix &m)
void eigenvalues(vec3 *real, vec3 *imag)
matrix &operator=(const matrix &other)
matrix operator+(const matrix &o) const
matrix operator-(const matrix &o) const
matrix operator*(const matrix &o) const
matrix operator*(double s) const
vec4 operator*(const vec4 &v) const
vec3 operator*(const vec3 &v) const

Public Members

double **data = nullptr
int _r = 0
int _c = 0

Public Static Functions

static matrix I(int size)
static matrix I(int size)

matrix_t

struct matrix_t

Public Functions

matrix_t(int _r = 3, int _c = 3)
~matrix_t()
matrix_t dot(const matrix_t &o)
matrix_t T() const
long double &at(int _r, int _c)
const long double &at(int _r, int _c) const
matrix_t &operator=(const matrix_t &other)
matrix_t &operator+(const matrix_t &o) const
matrix_t &operator-(const matrix_t &o) const
matrix_t &operator*(long double s) const
void print(int p = 9)
matrix_t(int _r = 3, int _c = 3)
~matrix_t()
matrix_t dot(const matrix_t &o)
matrix_t T() const
const double &at(int _r, int _c) const
double &at(int _r, int _c)
matrix_t &operator=(const matrix_t &other)
matrix_t operator+(const matrix_t &o) const
matrix_t operator-(const matrix_t &o) const
matrix_t operator*(double s) const
void print(int p)

Public Members

double **data = nullptr

vec3

struct vec3

Public Functions

vec3 operator+(const vec3 &o) const
vec3 operator-(const vec3 &o) const
vec3 operator*(double s) const
vec3 cross(const vec3 &o) const
double dot(const vec3 &o) const
double mag2() const
double mag() const
void print() const
vec3 operator+(const vec3 &o) const
vec3 operator-(const vec3 &o) const
vec3 operator*(double s) const
vec3 cross(const vec3 &o) const
double dot(const vec3 &o) const
double mag2() const
double mag() const
void print() const

Public Members

double x = 0
double y = 0
double z = 0

vec4

struct vec4

Public Functions

vec4 operator+(const vec4 &o) const
vec4 operator-(const vec4 &o) const
vec4 operator*(double s) const
double dot(const vec4 &o) const
void print()
vec4 operator+(const vec4 &o) const
vec4 operator-(const vec4 &o) const
vec4 operator*(double s) const
double dot(const vec4 &o) const
void print()

Public Members

double x = 0
double y = 0
double z = 0
double w = 0

eig_t

struct eig_t

Public Members

double r1 = 0
double r2 = 0
double i1 = 0
double i2 = 0

NuSol Structures

nusol_t

struct nusol_t

Public Members

double met = 0
double phi = 0
double mt = 172.68 * 1000
double mw = 80.385 * 1000
double limit = 10000
nusol_enum mode = nusol_enum::undefined
std::vector<particle_template*> *targets = nullptr

nunu_t

struct nunu_t

Public Functions

nunu_t()
~nunu_t()

Public Members

mtx *nu1 = nullptr
mtx *nu2 = nullptr
mtx *agl = nullptr
nuelx *nux1 = nullptr
nuelx *nux2 = nullptr

multisol_t

struct multisol_t

Public Members

double A = 0
double B = 0
double C = 0
double D = 0
double E = 0
double F = 0
double s0x = 0
double s0y = 0
double psi = 0
double cpsi = 0
double spsi = 0
double lmb1 = -1
double lmb2 = 0
double a_x = 0
double b_x = 0
double c_x = 0
double a_y = 0
double b_y = 0
double c_y = 0
double a_w = 0
double b_w = 0
double a_t = 0
double b_t = 0
double c_t = 0
matrix ht1
matrix ht2
matrix ht3
matrix hx1
matrix hx2
matrix hx3

nuclx_t

struct nuclx_t

Public Functions

nuclx_t(particle_template *jet, particle_template *lep)
nuclx_t from_sx_sy(double _sx, double _sy)
double get_t(double _vp, double _up, double _z)
double get_z(double _sx, double _sy)
nuclx_t from_z_t(double _z, double _t)
double get_mt(double _sx, double _sy)
double get_mw(double _sx)
void surface()
void shifts()
void sx()
void sy()
void mw()
void mt()
void polynomial()
void critical_t0()
void H_bar()
void H()
void rotation()

Public Members

double u = 0
double v = 0
double u_p = 0
double v_p = 0
double t_v = 0
double z_v = 0
double sx_v = 0
double sy_v = 0
double mt_v = 0
double mw_v = 0
double A = 0
double B = 0
double C = 0
double D = 0
double E = 0
double F = 0
double s0x = 0
double s0y = 0
double psi = 0
double cpsi = 0
double spsi = 0
double lmb1 = -1
double lmb2 = 0
double a_x = 0
double b_x = 0
double c_x = 0
double a_y = 0
double b_y = 0
double c_y = 0
double a_w = 0
double b_w = 0
double a_t = 0
double b_t = 0
double c_t = 0
double a_l = 0
double b_l = 0
double c_l = 0
double d_l = 0
double t_0 = 0
matrix_t HBc
matrix_t HB1
matrix_t HB2
matrix_t Hc
matrix_t H1
matrix_t H2
matrix_t vec_jet
matrix_t R_T
double beta_lep = 0
double beta_jet = 0
double mass_lep = 0
double mass_jet = 0
double p_lep = 0
double p_jet = 0
double e_lep = 0
double e_jet = 0
double phi_mu = 0
double theta_mu = 0
double cos_t = 0
double sin_t = 0
double w = 0
double o = 0
double w2 = 0
double o2 = 0
double wr = 0

ellipse_t

struct ellipse_t

Public Functions

void print()
void print()

Public Members

vec3 A
vec3 B
vec3 C
vec3 vA
vec3 vB
vec3 vC
double t
double z = 1.0

Conuix Structures

base_t

struct base_t : public Conuix::debug

Public Functions

virtual void print(int p) override

Public Members

long double rbl = 0
long double cos = 0
long double sin = 0
long double w = 0
long double o = 0
long double w2 = 0
long double o2 = 0
long double beta = 0
long double mass = 0
long double E = 0
long double tpsi = 0
long double cpsi = 0
long double spsi = 0

H_matrix_t

struct H_matrix_t : public Conuix::debug

Public Functions

matrix_t H_Matrix(long double tau, long double Z)
matrix_t H_Tilde(long double tau, long double Z)
virtual void print(int p) override

Public Members

matrix_t HBX
matrix_t HBS
matrix_t HBC
matrix_t HTX
matrix_t HTS
matrix_t HTC

Sx_t

struct Sx_t : public Conuix::debug

Public Functions

long double Sx(long double tau, long double Z)
virtual void print(int p) override

Public Members

long double a = 0
long double b = 0
long double c = 0

Sy_t

struct Sy_t : public Conuix::debug

Public Functions

long double Sy(long double tau, long double Z)
virtual void print(int p) override

Public Members

long double a = 0
long double b = 0
long double c = 0

kinematic_t (Conuix)

struct kinematic_t : public Conuix::debug

Public Functions

virtual void print(int p) override

Public Members

long double beta = 0
long double mass = 0
long double energy = 0

pencil_t

struct pencil_t : public Conuix::debug

Public Functions

long double Z2(long double Sx, long double Sy)
virtual void print(int p) override

Public Members

long double a = 0
long double b = 0
long double c = 0
long double d = 0
long double e = 0

rotation_t

struct rotation_t : public Conuix::debug

Public Functions

virtual void print(int p) override

Public Members

long double phi = 0
long double theta = 0
matrix_t vec
matrix_t R_T

thetapsi_t

struct thetapsi_t

Public Members

long double p_sin = 0
long double m_sin = 0
long double p_cos = 0
long double m_cos = 0

debug

struct debug

Subclassed by Conuix::H_matrix_t, Conuix::Sx_t, Conuix::Sy_t, Conuix::base_t, Conuix::characteristic::poly_t, Conuix::kinematic_t, Conuix::pencil_t, Conuix::rotation_t

Public Functions

virtual void print(int p = 16)
void variable(std::string name, long double val)

Public Members

int prec = 16

Characteristic Structures

P_t

struct P_t : public Conuix::characteristic::poly_t

Public Functions

P_t(base_t *base)
virtual long double P(long double lambda, long double Z, long double tau) override
virtual void print(int p) override

dPdtau_t

struct dPdtau_t : public Conuix::characteristic::poly_t

Public Functions

dPdtau_t(base_t *base)
virtual long double P(long double lambda, long double Z, long double tau) override
long double L0(long double Z, long double tau)
long double PL0(long double tau)
long double PL0(atomics_t *tx)
void test(atomics_t *tx)

Public Members

long double cf = 0

poly_t

struct poly_t : public Conuix::debug

Subclassed by Conuix::characteristic::P_t, Conuix::characteristic::dPdtau_t

Public Functions

virtual long double xlinear(long double tau)
virtual long double ylinear(long double tau)
virtual long double xyratio(long double tau)
virtual long double P(long double lambda, long double Z, long double tau)

Public Members

long double a
long double b
long double c
long double d = 0
long double x_a
long double x_b
long double y_a
long double y_b = 0

Utility Structures

atomics_t

struct atomics_t

Public Functions

atomics_t(particle_template *jet, particle_template *lep, double m_nu = 0)
void debug_mode(particle_template *jet, particle_template *lep)

Public Members

Conuix::kinematic_t lp
Conuix::kinematic_t jt
Conuix::kinematic_t nu
Conuix::base_t base
Conuix::rotation_t rotation
Conuix::thetapsi_t psi_theta
Conuix::pencil_t pencil
Conuix::Sx_t Sx
Conuix::Sy_t Sy
Conuix::H_matrix_t H_Matrix
Conuix::characteristic::P_t *P = nullptr
Conuix::characteristic::dPdtau_t *dPdtau = nullptr

perms_t

struct perms_t

Public Members

bool RR = false
bool SS = false
bool RS = false
bool CT = false
bool FT = false
float delta_R = 0
float top_pt = 0
float top_e = 0
float mass = 0

recon_t

struct recon_t

Public Members

bool is_valid = false
double residual = -1
std::vector<double> t
std::vector<double> z
std::vector<double> phi

rev_t

struct rev_t

Public Members

double u = 0
double v = 0
double u_p = 0
double v_p = 0
double t = 0
double z = 0