ShowRec_Alg_NN.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	Create_NN_Alg_Histograms ()
void	Get_NN_ALG_MLP (TTree *inputtree, Int_t parasetnr)
Int_t	GetMeansBeforeAndAfter (Float_t &mean_dT, Float_t &mean_dR, EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Int_t	GetMinsBeforeAndAfter (Float_t &min_dT, Float_t &min_dR, EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Int_t	GetNSegBeforeAndAfter (EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
void	Load_NN_ALG_MLP_weights (TMultiLayerPerceptron *mlp, Int_t parasetnr)

Variables
TMultiLayerPerceptron *	TMlpANN
TH1F *	var_NN__ALL__dR_InBT_To_TestBT
TH1F *	var_NN__ALL__dR_TestBT_To_InBT
TH1F *	var_NN__ALL__dT_InBT_To_TestBT
TH1F *	var_NN__ALL__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__ALL__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__ALL__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__ALL__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__nseg_TestBT_ToSamePlate
TH1F *	var_NN__ALL__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__ALL__zDiff_TestBT_To_InBT
TH1F *	var_NN__BG__dR_InBT_To_TestBT
TH1F *	var_NN__BG__dR_TestBT_To_InBT
TH1F *	var_NN__BG__dT_InBT_To_TestBT
TH1F *	var_NN__BG__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__BG__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__BG__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__BG__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__BG__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__BG__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__BG__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__BG__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__BG__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__BG__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__BG__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__BG__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__BG__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__BG__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__BG__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__BG__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__BG__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__BG__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__BG__nseg_TestBT_ToSamePlate
TH1F *	var_NN__BG__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__BG__zDiff_TestBT_To_InBT
TH1F *	var_NN__SG__dR_InBT_To_TestBT
TH1F *	var_NN__SG__dR_TestBT_To_InBT
TH1F *	var_NN__SG__dT_InBT_To_TestBT
TH1F *	var_NN__SG__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__SG__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__SG__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__SG__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__SG__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__SG__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__SG__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__SG__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__SG__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__SG__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__SG__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__SG__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__SG__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__SG__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__SG__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__SG__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__SG__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__SG__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__SG__nseg_TestBT_ToSamePlate
TH1F *	var_NN__SG__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__SG__zDiff_TestBT_To_InBT
Bool_t	var_NN_DoRUN =kTRUE
Bool_t	var_NN_DoTrain =kFALSE

Function Documentation

Create_NN_Alg_Histograms()

void Create_NN_Alg_Histograms

(

)

{
    var_NN__BG__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__BG__SpatialDist_TestBT_To_InBT","var_NN__BG__SpatialDist_TestBT_To_InBT",1000,0,60000);
    var_NN__SG__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__SG__SpatialDist_TestBT_To_InBT","var_NN__SG__SpatialDist_TestBT_To_InBT",1000,0,60000);
    var_NN__ALL__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__ALL__SpatialDist_TestBT_To_InBT","var_NN__ALL__SpatialDist_TestBT_To_InBT",1000,0,60000);
 
    var_NN__BG__zDiff_TestBT_To_InBT = new TH1F("var_NN__BG__zDiff_TestBT_To_InBT","var_NN__BG__zDiff_TestBT_To_InBT",1000,0,60000);
    var_NN__SG__zDiff_TestBT_To_InBT = new TH1F("var_NN__SG__zDiff_TestBT_To_InBT","var_NN__SG__zDiff_TestBT_To_InBT",1000,0,60000);
    var_NN__ALL__zDiff_TestBT_To_InBT = new TH1F("var_NN__ALL__zDiff_TestBT_To_InBT","var_NN__ALL__zDiff_TestBT_To_InBT",1000,0,60000);
 
 
    var_NN__SG__dT_InBT_To_TestBT = new TH1F("var_NN__SG__dT_InBT_To_TestBT","var_NN__SG__dT_InBT_To_TestBT",100,0,1);
    var_NN__BG__dT_InBT_To_TestBT = new TH1F("var_NN__BG__dT_InBT_To_TestBT","var_NN__BG__dT_InBT_To_TestBT",100,0,1);
    var_NN__ALL__dT_InBT_To_TestBT = new TH1F("var_NN__ALL__dT_InBT_To_TestBT","var_NN__ALL__dT_InBT_To_TestBT",100,0,1);
 
    var_NN__SG__dR_InBT_To_TestBT = new TH1F("var_NN__SG__dR_InBT_To_TestBT","var_NN__SG__dR_InBT_To_TestBT",100,0,2000);
    var_NN__BG__dR_InBT_To_TestBT = new TH1F("var_NN__BG__dR_InBT_To_TestBT","var_NN__BG__dR_InBT_To_TestBT",100,0,2000);
    var_NN__ALL__dR_InBT_To_TestBT = new TH1F("var_NN__ALL__dR_InBT_To_TestBT","var_NN__ALL__dR_InBT_To_TestBT",100,0,2000);
 
    var_NN__SG__dR_TestBT_To_InBT = new TH1F("var_NN__SG__dR_TestBT_To_InBT","var_NN__SG__dR_TestBT_To_InBT",100,0,2000);
    var_NN__BG__dR_TestBT_To_InBT = new TH1F("var_NN__BG__dR_TestBT_To_InBT","var_NN__BG__dR_TestBT_To_InBT",100,0,2000);
    var_NN__ALL__dR_TestBT_To_InBT = new TH1F("var_NN__ALL__dR_TestBT_To_InBT","var_NN__ALL__dR_TestBT_To_InBT",100,0,2000);
 
 
 
    var_NN__SG__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__SG__nseg_TestBT_To2BeforePlate","var_NN__SG__nseg_TestBT_To2BeforePlate",10,0,10);
    var_NN__BG__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__BG__nseg_TestBT_To2BeforePlate","var_NN__BG__nseg_TestBT_To2BeforePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__nseg_TestBT_To2BeforePlate","var_NN__ALL__nseg_TestBT_To2BeforePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__BG__nseg_TestBT_ToBeforePlate","var_NN__BG__nseg_TestBT_ToBeforePlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__SG__nseg_TestBT_ToBeforePlate","var_NN__SG__nseg_TestBT_ToBeforePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__nseg_TestBT_ToBeforePlate","var_NN__ALL__nseg_TestBT_ToBeforePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToSamePlate = new TH1F("var_NN__BG__nseg_TestBT_ToSamePlate","var_NN__BG__nseg_TestBT_ToSamePlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToSamePlate = new TH1F("var_NN__SG__nseg_TestBT_ToSamePlate","var_NN__SG__nseg_TestBT_ToSamePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToSamePlate = new TH1F("var_NN__ALL__nseg_TestBT_ToSamePlate","var_NN__ALL__nseg_TestBT_ToSamePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__BG__nseg_TestBT_To2AfterPlate","var_NN__BG__nseg_TestBT_To2AfterPlate",10,0,10);
    var_NN__SG__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__SG__nseg_TestBT_To2AfterPlate","var_NN__SG__nseg_TestBT_To2AfterPlate",10,0,10);
    var_NN__ALL__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__nseg_TestBT_To2AfterPlate","var_NN__ALL__nseg_TestBT_To2AfterPlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__BG__nseg_TestBT_ToAfterPlate","var_NN__BG__nseg_TestBT_ToAfterPlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__SG__nseg_TestBT_ToAfterPlate","var_NN__SG__nseg_TestBT_ToAfterPlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__nseg_TestBT_ToAfterPlate","var_NN__ALL__nseg_TestBT_ToAfterPlate",10,0,10);
 
 
 
    var_NN__BG__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToSamePlate","var_NN__BG__mean_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__SG__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToSamePlate","var_NN__SG__mean_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToSamePlate","var_NN__ALL__mean_dT_TestBT_ToSamePlate",100,0,0.2);
 
    var_NN__BG__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToSamePlate","var_NN__BG__mean_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__SG__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToSamePlate","var_NN__SG__mean_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToSamePlate","var_NN__ALL__mean_dR_TestBT_ToSamePlate",100,0,800);
 
 
    var_NN__SG__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToAfterPlate","var_NN__SG__mean_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToAfterPlate","var_NN__BG__mean_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToAfterPlate","var_NN__ALL__mean_dR_TestBT_ToAfterPlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToAfterPlate","var_NN__SG__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToAfterPlate","var_NN__BG__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToAfterPlate","var_NN__ALL__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
 
 
    var_NN__SG__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__SG__mean_dR_TestBT_To2AfterPlate","var_NN__SG__mean_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__BG__mean_dR_TestBT_To2AfterPlate","var_NN__BG__mean_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__mean_dR_TestBT_To2AfterPlate","var_NN__ALL__mean_dR_TestBT_To2AfterPlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__SG__mean_dT_TestBT_To2AfterPlate","var_NN__SG__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__BG__mean_dT_TestBT_To2AfterPlate","var_NN__BG__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__mean_dT_TestBT_To2AfterPlate","var_NN__ALL__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
 
    var_NN__SG__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToBeforePlate","var_NN__SG__mean_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToBeforePlate","var_NN__BG__mean_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToBeforePlate","var_NN__ALL__mean_dR_TestBT_ToBeforePlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToBeforePlate","var_NN__SG__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToBeforePlate","var_NN__BG__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToBeforePlate","var_NN__ALL__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
 
 
    var_NN__SG__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__SG__mean_dR_TestBT_To2BeforePlate","var_NN__SG__mean_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__BG__mean_dR_TestBT_To2BeforePlate","var_NN__BG__mean_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_To2BeforePlate","var_NN__ALL__mean_dR_TestBT_To2BeforePlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__SG__mean_dT_TestBT_To2BeforePlate","var_NN__SG__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__BG__mean_dT_TestBT_To2BeforePlate","var_NN__BG__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_To2BeforePlate","var_NN__ALL__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
 
    //---------
 
    var_NN__BG__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__BG__min_dT_TestBT_ToSamePlate","var_NN__BG__min_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__SG__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__SG__min_dT_TestBT_ToSamePlate","var_NN__SG__min_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToSamePlate","var_NN__ALL__min_dT_TestBT_ToSamePlate",100,0,0.2);
 
    var_NN__BG__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__BG__min_dR_TestBT_ToSamePlate","var_NN__BG__min_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__SG__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__SG__min_dR_TestBT_ToSamePlate","var_NN__SG__min_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToSamePlate","var_NN__ALL__min_dR_TestBT_ToSamePlate",100,0,800);
 
 
    var_NN__SG__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__SG__min_dR_TestBT_ToAfterPlate","var_NN__SG__min_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__BG__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__BG__min_dR_TestBT_ToAfterPlate","var_NN__BG__min_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToAfterPlate","var_NN__ALL__min_dR_TestBT_ToAfterPlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__SG__min_dT_TestBT_ToAfterPlate","var_NN__SG__min_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__BG__min_dT_TestBT_ToAfterPlate","var_NN__BG__min_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToAfterPlate","var_NN__ALL__min_dT_TestBT_ToAfterPlate",100,0,0.2);
 
 
    var_NN__SG__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__SG__min_dR_TestBT_To2AfterPlate","var_NN__SG__min_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__BG__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__BG__min_dR_TestBT_To2AfterPlate","var_NN__BG__min_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__min_dR_TestBT_To2AfterPlate","var_NN__ALL__min_dR_TestBT_To2AfterPlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__SG__min_dT_TestBT_To2AfterPlate","var_NN__SG__min_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__BG__min_dT_TestBT_To2AfterPlate","var_NN__BG__min_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__min_dT_TestBT_To2AfterPlate","var_NN__ALL__min_dT_TestBT_To2AfterPlate",100,0,0.2);
 
    var_NN__SG__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__SG__min_dR_TestBT_ToBeforePlate","var_NN__SG__min_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__BG__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__BG__min_dR_TestBT_ToBeforePlate","var_NN__BG__min_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToBeforePlate","var_NN__ALL__min_dR_TestBT_ToBeforePlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__SG__min_dT_TestBT_ToBeforePlate","var_NN__SG__min_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__BG__min_dT_TestBT_ToBeforePlate","var_NN__BG__min_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToBeforePlate","var_NN__ALL__min_dT_TestBT_ToBeforePlate",100,0,0.2);
 
 
    var_NN__SG__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__SG__min_dR_TestBT_To2BeforePlate","var_NN__SG__min_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__BG__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__BG__min_dR_TestBT_To2BeforePlate","var_NN__BG__min_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__min_dR_TestBT_To2BeforePlate","var_NN__ALL__min_dR_TestBT_To2BeforePlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__SG__min_dT_TestBT_To2BeforePlate","var_NN__SG__min_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__BG__min_dT_TestBT_To2BeforePlate","var_NN__BG__min_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__min_dT_TestBT_To2BeforePlate","var_NN__ALL__min_dT_TestBT_To2BeforePlate",100,0,0.2);
 
    return;
}

Get_NN_ALG_MLP()

void Get_NN_ALG_MLP	(	TTree *	inputtree,
		Int_t	parasetnr
	)

{
    if (!gROOT->GetClass("TMultiLayerPerceptron")) {
        gSystem->Load("libMLP");
    }
 
//-----------------------------------------------------------------------------
//-
//-
//-    WE USE FOR NN_ALG and the PARAMETERSETS For it the following conventions:
//-
//-    NCUTSteps =   20;
//-    MLP Structure:
//-
//-    a)  Paraset [0..20[
//-           first five variables.
//-    b)  Paraset [20..40[
//-           first ten variables.
//-    c)  Paraset [40..60[
//-           all (30) variables.
//-    d)  ....(something else)
//-
//-    As Trainingssample we use EXP2500 Events, Padi 199 ... 196 with b11845 BG
//-    additionally as BG samples b99999GENERICBG  and b99998GENERICBG
//-    (both with no signal...)
//-
//-
//-    Take care thet the added Traingssample has about the same traingssampledata for BG and SG
//-
//-----------------------------------------------------------------------------
 
// Define NN_ALG charactereistic variables:
    Float_t dT_InBT_To_TestBT=0;
    Float_t dR_InBT_To_TestBT=0;
    Float_t dR_TestBT_To_InBT=0;
    Float_t zDist_TestBT_To_InBT=0;
    Float_t SpatialDist_TestBT_To_InBT=0;
    Float_t zDiff_TestBT_To_InBT=0;
    Float_t dT_NextBT_To_TestBT=0;
    Float_t dR_NextBT_To_TestBT=0;
    Float_t mean_dT_2before=0;
    Float_t mean_dR_2before=0;
    Float_t  mean_dT_before=0;
    Float_t mean_dR_before=0;
    Float_t  mean_dT_same=0;
    Float_t mean_dR_same=0;
    Float_t  mean_dT_after=0;
    Float_t mean_dR_after=0;
    Float_t  mean_dT_2after=0;
    Float_t  mean_dR_2after=0;
 
    Float_t min_dT_2before=0;
    Float_t min_dR_2before=0;
    Float_t  min_dT_before=0;
    Float_t min_dR_before=0;
    Float_t  min_dT_same=0;
    Float_t min_dR_same=0;
    Float_t  min_dT_after=0;
    Float_t min_dR_after=0;
    Float_t  min_dT_2after=0;
    Float_t  min_dR_2after=0;
    Int_t nseg_1before=0;
    Int_t nseg_2before=0;
    Int_t nseg_3before=0;
    Int_t nseg_1after=0;
    Int_t nseg_2after=0;
    Int_t nseg_3after=0;
    Int_t nseg_same=0;
    Int_t type;
 
    TString layout="";
 
    int ann_inputneurons=CUT_PARAMETER[1];
 
    if (ann_inputneurons==5) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,@SpatialDist_TestBT_To_InBT:6:5:type";
    }
    if (ann_inputneurons==10) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after:11:10:type";
    }
    if (ann_inputneurons==20) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after,mean_dT_2before,mean_dT_before,mean_dT_same,mean_dT_after,mean_dT_2after,mean_dR_2before,mean_dR_before,mean_dR_same,mean_dR_after,mean_dR_2after:21:20:type";
    }
    if (ann_inputneurons==30) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after,mean_dT_2before,mean_dT_before,mean_dT_same,mean_dT_after,mean_dT_2after,mean_dR_2before,mean_dR_before,mean_dR_same,mean_dR_after,mean_dR_2after,min_dT_2before,min_dT_before,min_dT_same,min_dT_after,min_dT_2after,min_dR_2before,min_dR_before,min_dR_same,min_dR_after,min_dR_2after:31:30:type";
    }
 
    cout << "ann_inputneurons:   " << ann_inputneurons << endl;
    cout << "Layout of ANN:   " << layout << endl;
 
// Create the network:
    TMlpANN = new TMultiLayerPerceptron(layout,simu,"(Entry$)%2","(Entry$+1)%2");
 
    return;
}

GetMeansBeforeAndAfter()

Int_t GetMeansBeforeAndAfter	(	Float_t &	mean_dT,
		Float_t &	mean_dR,
		EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetMeansBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
    mean_dT=-1;
    mean_dR=-1;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        if (Z_plus1>Z_normal) Factor=1;
    }
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    Int_t n_return=0;
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    if (n_return==0) return n_return;
 
    //seg->PrintNice();
    for (int i=0; i<n_return; i++) {
        EdbSegP* s_of_array=(EdbSegP*)array.At(i);
        if (i==0) {
            mean_dT=0;
            mean_dR=0;
        }
        //s_of_array->PrintNice();
        mean_dT+=GetdeltaThetaSingleAngles(seg,s_of_array);
        mean_dR+=GetdeltaRNoPropagation(seg,s_of_array);
    }
    if (n_return>0) mean_dT=mean_dT/(Double_t)n_return;
    if (n_return>0) mean_dR=mean_dR/(Double_t)n_return;
 
    //   cout << " mean_dT  = " <<  mean_dT  << endl;
    //   cout << " mean_dR  = " <<  mean_dR  << endl;
 
    // „Hab ich mich aus einfachsten Verhältnissen emporgequält, um dann zu bitten?“
    return n_return;
}

GetMinsBeforeAndAfter()

Int_t GetMinsBeforeAndAfter	(	Float_t &	min_dT,
		Float_t &	min_dR,
		EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetMinsBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
    min_dT=-1;
    min_dR=-1;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        if (Z_plus1>Z_normal) Factor=1;
    }
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    Int_t n_return=0;
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    if (n_return==0) return n_return;
 
    if (n_return==1) {
        EdbSegP* s_of_array=(EdbSegP*)array.At(0);
        min_dT=GetdeltaThetaSingleAngles(seg,s_of_array);
        min_dR=GetdeltaRNoPropagation(seg,s_of_array);
    }
 
 
    Float_t tmp_min_dT=-1;
    Float_t tmp_min_dR=-1;
    Float_t tmp2_min_dT=-1;
    Float_t tmp2_min_dR=-1;
    Float_t angle;
    Float_t dist;
 
    if (n_return>1) {
        for (int i=0; i<n_return; i++) {
            EdbSegP* s_of_array=(EdbSegP*)array.At(i);
            if (i==0) {
                min_dT=999999;
                min_dR=9999999;
            }
            angle=(Float_t)GetdeltaThetaSingleAngles(seg,s_of_array);
            tmp_min_dT=min_dT;
            tmp2_min_dT=TMath::Min(angle, tmp_min_dT);
            min_dT=tmp2_min_dT;
 
            dist=(Float_t)GetdeltaRNoPropagation(seg,s_of_array);
            tmp_min_dR=min_dR;
            tmp2_min_dR=TMath::Min(dist, tmp_min_dR);
            min_dR=tmp2_min_dR;
        }
    }
    return n_return;
}

GetNSegBeforeAndAfter()

Int_t GetNSegBeforeAndAfter	(	EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetNSegBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        //     cout << "WHAT IS GREATER?   Z_normal  Z_minus1  " << Z_normal << "  " << Z_minus1 << endl;
        //Factor=(Int_t)TMath::Sign(Z_normal,Z_minus1);
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        //     cout << "WHAT IS GREATER?   Z_normal  Z_plus1  " << Z_normal << "  " << Z_plus1 << endl;
        if (Z_plus1>Z_normal) Factor=1;
    }
 
    //   cout << Z_minus1 << endl;
    //   cout << Z_normal << endl;
    //   cout << Z_plus1 << endl;
    //   cout << "Is edge_npat_lower = " << edge_npat_lower << endl;
    //   cout << "Is edge_npat_upper = " << edge_npat_upper << endl;
    //   cout << "Factor =  " << Factor << endl;
 
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
    //   cout << "So NEW n_patterns would be " << patterloop_test << endl;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    int n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    return n_return;
}

Load_NN_ALG_MLP_weights()

void Load_NN_ALG_MLP_weights	(	TMultiLayerPerceptron *	mlp,
		Int_t	parasetnr
	)

{
    int ann_inputneurons=CUT_PARAMETER[1];
 
    if (ann_inputneurons==5) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_0_To_20.txt");
        gSystem->Exec("ls -ltr ANN_WEIGHTS_PARASET_0_To_20.txt");
    }
    if (ann_inputneurons==10) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_20_To_40.txt");
    }
    if (ann_inputneurons==20) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_40_To_60.txt");
    }
    if (ann_inputneurons==30) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_60_To_80.txt");
    }
 
    mlp->GetStructure();
 
    return;
}

Variable Documentation

TMlpANN

TMultiLayerPerceptron* TMlpANN

var_NN__ALL__dR_InBT_To_TestBT

TH1F* var_NN__ALL__dR_InBT_To_TestBT

var_NN__ALL__dR_TestBT_To_InBT

TH1F* var_NN__ALL__dR_TestBT_To_InBT

var_NN__ALL__dT_InBT_To_TestBT

TH1F* var_NN__ALL__dT_InBT_To_TestBT

var_NN__ALL__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__ALL__mean_dR_TestBT_To2AfterPlate

var_NN__ALL__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__ALL__mean_dR_TestBT_To2BeforePlate

var_NN__ALL__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToAfterPlate

var_NN__ALL__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToBeforePlate

var_NN__ALL__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToSamePlate

var_NN__ALL__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__ALL__mean_dT_TestBT_To2AfterPlate

var_NN__ALL__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__ALL__mean_dT_TestBT_To2BeforePlate

var_NN__ALL__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToAfterPlate

var_NN__ALL__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToBeforePlate

var_NN__ALL__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToSamePlate

var_NN__ALL__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__ALL__min_dR_TestBT_To2AfterPlate

var_NN__ALL__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__ALL__min_dR_TestBT_To2BeforePlate

var_NN__ALL__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__ALL__min_dR_TestBT_ToAfterPlate

var_NN__ALL__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__ALL__min_dR_TestBT_ToBeforePlate

var_NN__ALL__min_dR_TestBT_ToSamePlate

TH1F* var_NN__ALL__min_dR_TestBT_ToSamePlate

var_NN__ALL__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__ALL__min_dT_TestBT_To2AfterPlate

var_NN__ALL__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__ALL__min_dT_TestBT_To2BeforePlate

var_NN__ALL__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__ALL__min_dT_TestBT_ToAfterPlate

var_NN__ALL__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__ALL__min_dT_TestBT_ToBeforePlate

var_NN__ALL__min_dT_TestBT_ToSamePlate

TH1F* var_NN__ALL__min_dT_TestBT_ToSamePlate

var_NN__ALL__nseg_TestBT_To2AfterPlate

TH1F* var_NN__ALL__nseg_TestBT_To2AfterPlate

var_NN__ALL__nseg_TestBT_To2BeforePlate

TH1F* var_NN__ALL__nseg_TestBT_To2BeforePlate

var_NN__ALL__nseg_TestBT_ToAfterPlate

TH1F* var_NN__ALL__nseg_TestBT_ToAfterPlate

var_NN__ALL__nseg_TestBT_ToBeforePlate

TH1F* var_NN__ALL__nseg_TestBT_ToBeforePlate

var_NN__ALL__nseg_TestBT_ToSamePlate

TH1F* var_NN__ALL__nseg_TestBT_ToSamePlate

var_NN__ALL__SpatialDist_TestBT_To_InBT

TH1F* var_NN__ALL__SpatialDist_TestBT_To_InBT

var_NN__ALL__zDiff_TestBT_To_InBT

TH1F* var_NN__ALL__zDiff_TestBT_To_InBT

var_NN__BG__dR_InBT_To_TestBT

TH1F* var_NN__BG__dR_InBT_To_TestBT

var_NN__BG__dR_TestBT_To_InBT

TH1F* var_NN__BG__dR_TestBT_To_InBT

var_NN__BG__dT_InBT_To_TestBT

TH1F* var_NN__BG__dT_InBT_To_TestBT

var_NN__BG__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__BG__mean_dR_TestBT_To2AfterPlate

var_NN__BG__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__BG__mean_dR_TestBT_To2BeforePlate

var_NN__BG__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__BG__mean_dR_TestBT_ToAfterPlate

var_NN__BG__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__BG__mean_dR_TestBT_ToBeforePlate

var_NN__BG__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__BG__mean_dR_TestBT_ToSamePlate

var_NN__BG__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__BG__mean_dT_TestBT_To2AfterPlate

var_NN__BG__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__BG__mean_dT_TestBT_To2BeforePlate

var_NN__BG__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__BG__mean_dT_TestBT_ToAfterPlate

var_NN__BG__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__BG__mean_dT_TestBT_ToBeforePlate

var_NN__BG__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__BG__mean_dT_TestBT_ToSamePlate

var_NN__BG__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__BG__min_dR_TestBT_To2AfterPlate

var_NN__BG__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__BG__min_dR_TestBT_To2BeforePlate

var_NN__BG__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__BG__min_dR_TestBT_ToAfterPlate

var_NN__BG__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__BG__min_dR_TestBT_ToBeforePlate

var_NN__BG__min_dR_TestBT_ToSamePlate

TH1F* var_NN__BG__min_dR_TestBT_ToSamePlate

var_NN__BG__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__BG__min_dT_TestBT_To2AfterPlate

var_NN__BG__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__BG__min_dT_TestBT_To2BeforePlate

var_NN__BG__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__BG__min_dT_TestBT_ToAfterPlate

var_NN__BG__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__BG__min_dT_TestBT_ToBeforePlate

var_NN__BG__min_dT_TestBT_ToSamePlate

TH1F* var_NN__BG__min_dT_TestBT_ToSamePlate

var_NN__BG__nseg_TestBT_To2AfterPlate

TH1F* var_NN__BG__nseg_TestBT_To2AfterPlate

var_NN__BG__nseg_TestBT_To2BeforePlate

TH1F* var_NN__BG__nseg_TestBT_To2BeforePlate

var_NN__BG__nseg_TestBT_ToAfterPlate

TH1F* var_NN__BG__nseg_TestBT_ToAfterPlate

var_NN__BG__nseg_TestBT_ToBeforePlate

TH1F* var_NN__BG__nseg_TestBT_ToBeforePlate

var_NN__BG__nseg_TestBT_ToSamePlate

TH1F* var_NN__BG__nseg_TestBT_ToSamePlate

var_NN__BG__SpatialDist_TestBT_To_InBT

TH1F* var_NN__BG__SpatialDist_TestBT_To_InBT

var_NN__BG__zDiff_TestBT_To_InBT

TH1F* var_NN__BG__zDiff_TestBT_To_InBT

var_NN__SG__dR_InBT_To_TestBT

TH1F* var_NN__SG__dR_InBT_To_TestBT

var_NN__SG__dR_TestBT_To_InBT

TH1F* var_NN__SG__dR_TestBT_To_InBT

var_NN__SG__dT_InBT_To_TestBT

TH1F* var_NN__SG__dT_InBT_To_TestBT

var_NN__SG__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__SG__mean_dR_TestBT_To2AfterPlate

var_NN__SG__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__SG__mean_dR_TestBT_To2BeforePlate

var_NN__SG__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__SG__mean_dR_TestBT_ToAfterPlate

var_NN__SG__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__SG__mean_dR_TestBT_ToBeforePlate

var_NN__SG__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__SG__mean_dR_TestBT_ToSamePlate

var_NN__SG__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__SG__mean_dT_TestBT_To2AfterPlate

var_NN__SG__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__SG__mean_dT_TestBT_To2BeforePlate

var_NN__SG__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__SG__mean_dT_TestBT_ToAfterPlate

var_NN__SG__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__SG__mean_dT_TestBT_ToBeforePlate

var_NN__SG__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__SG__mean_dT_TestBT_ToSamePlate

var_NN__SG__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__SG__min_dR_TestBT_To2AfterPlate

var_NN__SG__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__SG__min_dR_TestBT_To2BeforePlate

var_NN__SG__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__SG__min_dR_TestBT_ToAfterPlate

var_NN__SG__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__SG__min_dR_TestBT_ToBeforePlate

var_NN__SG__min_dR_TestBT_ToSamePlate

TH1F* var_NN__SG__min_dR_TestBT_ToSamePlate

var_NN__SG__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__SG__min_dT_TestBT_To2AfterPlate

var_NN__SG__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__SG__min_dT_TestBT_To2BeforePlate

var_NN__SG__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__SG__min_dT_TestBT_ToAfterPlate

var_NN__SG__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__SG__min_dT_TestBT_ToBeforePlate

var_NN__SG__min_dT_TestBT_ToSamePlate

TH1F* var_NN__SG__min_dT_TestBT_ToSamePlate

var_NN__SG__nseg_TestBT_To2AfterPlate

TH1F* var_NN__SG__nseg_TestBT_To2AfterPlate

var_NN__SG__nseg_TestBT_To2BeforePlate

TH1F* var_NN__SG__nseg_TestBT_To2BeforePlate

var_NN__SG__nseg_TestBT_ToAfterPlate

TH1F* var_NN__SG__nseg_TestBT_ToAfterPlate

var_NN__SG__nseg_TestBT_ToBeforePlate

TH1F* var_NN__SG__nseg_TestBT_ToBeforePlate

var_NN__SG__nseg_TestBT_ToSamePlate

TH1F* var_NN__SG__nseg_TestBT_ToSamePlate

var_NN__SG__SpatialDist_TestBT_To_InBT

TH1F* var_NN__SG__SpatialDist_TestBT_To_InBT

var_NN__SG__zDiff_TestBT_To_InBT

TH1F* var_NN__SG__zDiff_TestBT_To_InBT

var_NN_DoRUN

Bool_t var_NN_DoRUN =kTRUE

var_NN_DoTrain

Bool_t var_NN_DoTrain =kFALSE