FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Private Attributes | List of all members
EdbShowAlg_NN Class Reference

#include <EdbShowAlg_NN.h>

Inheritance diagram for EdbShowAlg_NN:
Inheritance graph
[legend]
Collaboration diagram for EdbShowAlg_NN:
Collaboration graph
[legend]

Public Member Functions

 ClassDef (EdbShowAlg_NN, 1)
 
TMultiLayerPerceptron * Create_NN_ALG_MLP (TTree *inputtree, Int_t inputneurons)
 
void CreateANNTree ()
 
 EdbShowAlg_NN ()
 
void Execute ()
 
void Finalize ()
 
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)
 
TString GetWeightFileString ()
 
void Init ()
 
void Initialize ()
 
void LoadANNWeights ()
 
void LoadANNWeights (TMultiLayerPerceptron *TMlpANN, TString WeightFileString)
 
void Print ()
 
void SetANNWeightString ()
 
void SetWeightFileString (TString WeightFileString)
 
virtual ~EdbShowAlg_NN ()
 
- Public Member Functions inherited from EdbShowAlg
void AddRecoShowerArray (EdbShowerP *shower)
 
 ClassDef (EdbShowAlg, 1)
 
Double_t DeltaR_NoPropagation (EdbSegP *s, EdbSegP *stest)
 
Double_t DeltaR_WithoutPropagation (EdbSegP *s, EdbSegP *stest)
 
Double_t DeltaR_WithPropagation (EdbSegP *s, EdbSegP *stest)
 
Double_t DeltaTheta (EdbSegP *s1, EdbSegP *s2)
 
Double_t DeltaThetaComponentwise (EdbSegP *s1, EdbSegP *s2)
 
Double_t DeltaThetaSingleAngles (EdbSegP *s1, EdbSegP *s2)
 
 EdbShowAlg ()
 
 EdbShowAlg (TString AlgName, Int_t AlgValue)
 
TString GetAlgName () const
 
Int_t GetAlgValue () const
 
Double_t GetMinimumDist (EdbSegP *seg1, EdbSegP *seg2)
 
TObjArray * GetRecoShowerArray () const
 
Int_t GetRecoShowerArrayN () const
 
EdbShowerP * GetShower (Int_t i) const
 
Double_t GetSpatialDist (EdbSegP *s1, EdbSegP *s2)
 
void Help ()
 
Bool_t IsInConeTube (EdbSegP *sTest, EdbSegP *sStart, Double_t CylinderRadius, Double_t ConeAngle)
 
void Print ()
 
void PrintAll ()
 
void PrintMore ()
 
void PrintParameters ()
 
void PrintParametersShort ()
 
void SetActualAlgParameterset (Int_t ActualAlgParametersetNr)
 
void SetEdbPVRec (EdbPVRec *Ali)
 
void SetEdbPVRecPIDNumbers (Int_t FirstPlate_eAliPID, Int_t LastPlate_eAliPID, Int_t MiddlePlate_eAliPID, Int_t NumberPlate_eAliPID)
 
void SetInBTArray (TObjArray *InBTArray)
 
void SetParameter (Int_t parNr, Float_t par)
 
void SetParameters (Float_t *par)
 
void SetRecoShowerArray (TObjArray *RecoShowerArray)
 
void SetRecoShowerArrayN (Int_t RecoShowerArrayN)
 
void SetUseAliSub (Bool_t UseAliSub)
 
void Transform_eAli (EdbSegP *InitiatorBT, Float_t ExtractSize)
 
void UpdateShowerIDs ()
 
void UpdateShowerMetaData ()
 
virtual ~EdbShowAlg ()
 

Private Attributes

Int_t eANN_Inputtype
 
Float_t eANN_var_dR_InBT_To_TestBT
 
Float_t eANN_var_dR_NextBT_To_TestBT
 
Float_t eANN_var_dR_TestBT_To_InBT
 
Float_t eANN_var_dT_InBT_To_TestBT
 
Float_t eANN_var_dT_NextBT_To_TestBT
 
Float_t eANN_var_InBT_To_TestBT
 
Float_t eANN_var_mean_dR_2after
 
Float_t eANN_var_mean_dR_2before
 
Float_t eANN_var_mean_dR_after
 
Float_t eANN_var_mean_dR_before
 
Float_t eANN_var_mean_dR_same
 
Float_t eANN_var_mean_dT_2after
 
Float_t eANN_var_mean_dT_2before
 
Float_t eANN_var_mean_dT_after
 
Float_t eANN_var_mean_dT_before
 
Float_t eANN_var_mean_dT_same
 
Float_t eANN_var_min_dR_2after
 
Float_t eANN_var_min_dR_2before
 
Float_t eANN_var_min_dR_after
 
Float_t eANN_var_min_dR_before
 
Float_t eANN_var_min_dR_same
 
Float_t eANN_var_min_dT_2after
 
Float_t eANN_var_min_dT_2before
 
Float_t eANN_var_min_dT_after
 
Float_t eANN_var_min_dT_before
 
Float_t eANN_var_min_dT_same
 
Int_t eANN_var_nseg_1after
 
Int_t eANN_var_nseg_1before
 
Int_t eANN_var_nseg_2after
 
Int_t eANN_var_nseg_2before
 
Int_t eANN_var_nseg_3after
 
Int_t eANN_var_nseg_3before
 
Int_t eANN_var_nseg_same
 
Float_t eANN_var_SpatialDist_TestBT_To_InBT
 
Float_t eANN_var_zDiff_TestBT_To_InBT
 
Float_t eANN_var_zDist_TestBT_To_InBT
 
TTree * eANNTree
 
TMultiLayerPerceptron * eTMlpANN
 
TString eWeightFileLayoutString
 
TString eWeightFileString
 

Additional Inherited Members

- Protected Member Functions inherited from EdbShowAlg
void Set0 ()
 
- Protected Attributes inherited from EdbShowAlg
Int_t eActualAlgParametersetNr
 
TString eAlgName
 
Int_t eAlgValue
 
EdbPVRec * eAli
 
EdbPVRec * eAli_Sub
 
Int_t eAli_SubNpat
 
Int_t eAliNpat
 
Int_t eFirstPlate_eAliPID
 
TObjArray * eInBTArray
 
Int_t eInBTArrayN
 
Int_t eLastPlate_eAliPID
 
Int_t eMiddlePlate_eAliPID
 
Int_t eNumberPlate_eAliPID
 
Int_t eParaN
 
TString eParaString [10]
 
Float_t eParaValue [10]
 
EdbShowerP * eRecoShower
 
TObjArray * eRecoShowerArray
 
Int_t eRecoShowerArrayN
 
Int_t eUseAliSub
 

Constructor & Destructor Documentation

◆ EdbShowAlg_NN()

EdbShowAlg_NN::EdbShowAlg_NN ( )

◆ ~EdbShowAlg_NN()

EdbShowAlg_NN::~EdbShowAlg_NN ( )
virtual
41 {
42  // Default Destructor
43  Log(2,"EdbShowAlg_NN::~EdbShowAlg_NN","Default Destructor");
44  if (eANNTree) {
45  delete eANNTree;
46  eANNTree=0;
47  }
48 }
Log
bool Log(int level, const char *location, const char *fmt,...)
Definition: EdbLog.cxx:75
EdbShowAlg_NN::eANNTree
TTree * eANNTree
Definition: EdbShowAlg_NN.h:52

Member Function Documentation

◆ ClassDef()

EdbShowAlg_NN::ClassDef ( EdbShowAlg_NN  ,
1   
)

◆ Create_NN_ALG_MLP()

TMultiLayerPerceptron * EdbShowAlg_NN::Create_NN_ALG_MLP ( TTree *  inputtree,
Int_t  inputneurons 
)
140 {
141  Log(2,"EdbShowAlg_NN::Create_NN_ALG_MLP","Creates the TTree for the data to be filled.");
142 
143  if (gEDBDEBUGLEVEL>2) cout << "EdbShowAlg_NN::Create_NN_ALG_MLP() inputneurons= " << inputneurons << endl;
144 
145  const char* layout="";
146  if (inputneurons==5) {
147  layout="eANN_var_dT_InBT_To_TestBT,eANN_var_dR_InBT_To_TestBT,eANN_var_dR_TestBT_To_InBT,eANN_var_zDiff_TestBT_To_InBT,eANN_var_SpatialDist_TestBT_To_InBT:6:5:type";
148  }
149  if (inputneurons==10) {
150  layout="@eANN_var_dT_InBT_To_TestBT,@eANN_var_dR_InBT_To_TestBT,@eANN_var_dR_TestBT_To_InBT,@eANN_var_zDiff_TestBT_To_InBT,eANN_var_SpatialDist_TestBT_To_InBT,eANN_var_nseg_2before,eANN_var_nseg_1before,eANN_var_nseg_same,eANN_var_nseg_1after,eANN_var_nseg_2after:11:10:type";
151  }
152  if (inputneurons==20) {
153  layout="@eANN_var_dT_InBT_To_TestBT,@eANN_var_dR_InBT_To_TestBT,@eANN_var_dR_TestBT_To_InBT,@eANN_var_zDiff_TestBT_To_InBT,eANN_var_SpatialDist_TestBT_To_InBT,eANN_var_nseg_2before,eANN_var_nseg_1before,eANN_var_nseg_same,eANN_var_nseg_1after,eANN_var_nseg_2after,eANN_var_mean_dT_2before,eANN_var_mean_dT_before,eANN_var_mean_dT_same,eANN_var_mean_dT_after,eANN_var_mean_dT_2after,eANN_var_mean_dR_2before,eANN_var_mean_dR_before,eANN_var_mean_dR_same,eANN_var_mean_dR_after,eANN_var_mean_dR_2after:21:20:type";
154  }
155  if (inputneurons==30) {
156  layout="@eANN_var_dT_InBT_To_TestBT,@eANN_var_dR_InBT_To_TestBT,@eANN_var_dR_TestBT_To_InBT,@eANN_var_zDiff_TestBT_To_InBT,eANN_var_SpatialDist_TestBT_To_InBT,eANN_var_nseg_2before,eANN_var_nseg_1before,eANN_var_nseg_same,eANN_var_nseg_1after,eANN_var_nseg_2after,eANN_var_mean_dT_2before,eANN_var_mean_dT_before,eANN_var_mean_dT_same,eANN_var_mean_dT_after,eANN_var_mean_dT_2after,eANN_var_mean_dR_2before,eANN_var_mean_dR_before,eANN_var_mean_dR_same,eANN_var_mean_dR_after,eANN_var_mean_dR_2after,eANN_var_min_dT_2before,eANN_var_min_dT_before,eANN_var_min_dT_same,eANN_var_min_dT_after,eANN_var_min_dT_2after,eANN_var_min_dR_2before,eANN_var_min_dR_before,eANN_var_min_dR_same,eANN_var_min_dR_after,eANN_var_min_dR_2after:31:30:type";
157  }
158 
159  if (gEDBDEBUGLEVEL>2) cout << "EdbShowAlg_NN::Create_NN_ALG_MLP() layout: " << layout << endl;
160 
161  // Create the network:
162  TMultiLayerPerceptron* TMlpANN = new TMultiLayerPerceptron(layout,simu);
163 
164  if (gEDBDEBUGLEVEL>2) {
165  cout << "EdbShowAlg_NN::Create_NN_ALG_MLP() GetStructure: " << endl;
166  cout << TMlpANN->GetStructure() << endl;
167  }
168  Log(2,"EdbShowAlg_NN::Create_NN_ALG_MLP","Creates the TTree for the data to be filled...done.");
169  return TMlpANN;
170 }
TMlpANN
TMultiLayerPerceptron * TMlpANN
Definition: ShowRec.h:340
gEDBDEBUGLEVEL
gEDBDEBUGLEVEL
Definition: energy.C:7
simu
TTree * simu
Definition: testBGReduction_By_ANN.C:12

◆ CreateANNTree()

void EdbShowAlg_NN::CreateANNTree ( )
88 {
89  Log(2,"EdbShowAlg_NN::CreateANNTree","CreateANNTree()");
90 
91  if (!eANNTree) eANNTree = new TTree("EdbShowAlg_NN_eANNTree", "EdbShowAlg_NN_eANNTree");
92 
93  // Variables and things important for neural Network:
94  eANNTree->Branch("dT_InBT_To_TestBT", &eANN_var_InBT_To_TestBT, "dT_InBT_To_TestBT/F");
95  eANNTree->Branch("dR_InBT_To_TestBT", &eANN_var_dR_InBT_To_TestBT, "dR_InBT_To_TestBT/F");
96  eANNTree->Branch("dR_TestBT_To_InBT", &eANN_var_dR_TestBT_To_InBT, "dR_TestBT_To_InBT/F");
97  eANNTree->Branch("zDiff_TestBT_To_InBT", &eANN_var_zDiff_TestBT_To_InBT, "zDiff_TestBT_To_InBT/F");
98  eANNTree->Branch("SpatialDist_TestBT_To_InBT", &eANN_var_SpatialDist_TestBT_To_InBT, "SpatialDist_TestBT_To_InBT/F");
99  //---------
100  eANNTree->Branch("nseg_1before", &eANN_var_nseg_1before, "nseg_1before/I");
101  eANNTree->Branch("nseg_2before", &eANN_var_nseg_2before, "nseg_2before/I");
102  eANNTree->Branch("nseg_same", &eANN_var_nseg_same, "nseg_same/I");
103  eANNTree->Branch("nseg_1after", &eANN_var_nseg_1after, "nseg_1after/I");
104  eANNTree->Branch("nseg_2after", &eANN_var_nseg_2after, "nseg_2after/I");
105  //---------
106  eANNTree->Branch("mean_dT_2before", &eANN_var_mean_dT_2before, "mean_dT_2before/F");
107  eANNTree->Branch("mean_dT_before", &eANN_var_mean_dT_before, "mean_dT_before/F");
108  eANNTree->Branch("mean_dT_same", &eANN_var_mean_dT_same, "mean_dT_same/F");
109  eANNTree->Branch("mean_dT_after", &eANN_var_mean_dT_after, "mean_dT_after/F");
110  eANNTree->Branch("mean_dT_2after", &eANN_var_mean_dT_2after, "mean_dT_2after/F");
111  //---------
112  eANNTree->Branch("mean_dR_2before", &eANN_var_mean_dR_2before, "mean_dR_2before/F");
113  eANNTree->Branch("mean_dR_before", &eANN_var_mean_dR_before, "mean_dR_before/F");
114  eANNTree->Branch("mean_dR_same", &eANN_var_mean_dR_same, "mean_dR_same/F");
115  eANNTree->Branch("mean_dR_after", &eANN_var_mean_dR_after, "mean_dR_after/F");
116  eANNTree->Branch("mean_dR_2after", &eANN_var_mean_dR_2after, "mean_dR_2after/F");
117  //---------
118  eANNTree->Branch("min_dT_2before", &eANN_var_min_dT_2before, "min_dT_2before/F");
119  eANNTree->Branch("min_dT_before", &eANN_var_min_dT_before, "min_dT_before/F");
120  eANNTree->Branch("min_dT_same", &eANN_var_min_dT_same, "min_dT_same/F");
121  eANNTree->Branch("min_dT_after", &eANN_var_min_dT_after, "min_dT_after/F");
122  eANNTree->Branch("min_dT_2after", &eANN_var_min_dT_2after, "min_dT_2after/F");
123  //---------
124  eANNTree->Branch("min_dR_2before", &eANN_var_min_dR_2before, "min_dR_2before/F");
125  eANNTree->Branch("min_dR_before", &eANN_var_min_dR_before, "min_dR_before/F");
126  eANNTree->Branch("min_dR_same", &eANN_var_min_dR_same, "min_dR_same/F");
127  eANNTree->Branch("min_dR_after", &eANN_var_min_dR_after, "min_dR_after/F");
128  eANNTree->Branch("min_dR_2after", &eANN_var_min_dR_2after, "min_dR_2after/F");
129  //---------
130  eANNTree->Branch("type", &eANN_Inputtype, "type/I");
131  //---------
132  Log(2,"EdbShowAlg_NN::CreateANNTree","CreateANNTree()...done.");
133  return;
134 }
EdbShowAlg_NN::eANN_var_nseg_2before
Int_t eANN_var_nseg_2before
Definition: EdbShowAlg_NN.h:87
EdbShowAlg_NN::eANN_var_dR_TestBT_To_InBT
Float_t eANN_var_dR_TestBT_To_InBT
Definition: EdbShowAlg_NN.h:60
EdbShowAlg_NN::eANN_var_min_dR_after
Float_t eANN_var_min_dR_after
Definition: EdbShowAlg_NN.h:83
EdbShowAlg_NN::eANN_var_mean_dR_same
Float_t eANN_var_mean_dR_same
Definition: EdbShowAlg_NN.h:71
EdbShowAlg_NN::eANN_var_mean_dR_before
Float_t eANN_var_mean_dR_before
Definition: EdbShowAlg_NN.h:69
EdbShowAlg_NN::eANN_var_min_dR_before
Float_t eANN_var_min_dR_before
Definition: EdbShowAlg_NN.h:79
EdbShowAlg_NN::eANN_var_min_dR_2after
Float_t eANN_var_min_dR_2after
Definition: EdbShowAlg_NN.h:85
EdbShowAlg_NN::eANN_var_min_dR_same
Float_t eANN_var_min_dR_same
Definition: EdbShowAlg_NN.h:81
EdbShowAlg_NN::eANN_var_mean_dR_after
Float_t eANN_var_mean_dR_after
Definition: EdbShowAlg_NN.h:73
EdbShowAlg_NN::eANN_var_InBT_To_TestBT
Float_t eANN_var_InBT_To_TestBT
Definition: EdbShowAlg_NN.h:57
EdbShowAlg_NN::eANN_var_mean_dT_same
Float_t eANN_var_mean_dT_same
Definition: EdbShowAlg_NN.h:70
EdbShowAlg_NN::eANN_var_min_dT_before
Float_t eANN_var_min_dT_before
Definition: EdbShowAlg_NN.h:78
EdbShowAlg_NN::eANN_var_min_dT_after
Float_t eANN_var_min_dT_after
Definition: EdbShowAlg_NN.h:82
EdbShowAlg_NN::eANN_var_mean_dT_before
Float_t eANN_var_mean_dT_before
Definition: EdbShowAlg_NN.h:68
EdbShowAlg_NN::eANN_var_SpatialDist_TestBT_To_InBT
Float_t eANN_var_SpatialDist_TestBT_To_InBT
Definition: EdbShowAlg_NN.h:62
EdbShowAlg_NN::eANN_var_min_dT_2before
Float_t eANN_var_min_dT_2before
Definition: EdbShowAlg_NN.h:76
EdbShowAlg_NN::eANN_var_nseg_1after
Int_t eANN_var_nseg_1after
Definition: EdbShowAlg_NN.h:89
EdbShowAlg_NN::eANN_var_zDiff_TestBT_To_InBT
Float_t eANN_var_zDiff_TestBT_To_InBT
Definition: EdbShowAlg_NN.h:63
EdbShowAlg_NN::eANN_var_mean_dT_after
Float_t eANN_var_mean_dT_after
Definition: EdbShowAlg_NN.h:72
EdbShowAlg_NN::eANN_var_mean_dT_2before
Float_t eANN_var_mean_dT_2before
Definition: EdbShowAlg_NN.h:66
EdbShowAlg_NN::eANN_var_nseg_same
Int_t eANN_var_nseg_same
Definition: EdbShowAlg_NN.h:92
EdbShowAlg_NN::eANN_var_dR_InBT_To_TestBT
Float_t eANN_var_dR_InBT_To_TestBT
Definition: EdbShowAlg_NN.h:59
EdbShowAlg_NN::eANN_var_nseg_2after
Int_t eANN_var_nseg_2after
Definition: EdbShowAlg_NN.h:90
EdbShowAlg_NN::eANN_var_mean_dR_2after
Float_t eANN_var_mean_dR_2after
Definition: EdbShowAlg_NN.h:75
EdbShowAlg_NN::eANN_var_nseg_1before
Int_t eANN_var_nseg_1before
Definition: EdbShowAlg_NN.h:86
EdbShowAlg_NN::eANN_var_min_dT_2after
Float_t eANN_var_min_dT_2after
Definition: EdbShowAlg_NN.h:84
EdbShowAlg_NN::eANN_var_min_dT_same
Float_t eANN_var_min_dT_same
Definition: EdbShowAlg_NN.h:80
EdbShowAlg_NN::eANN_Inputtype
Int_t eANN_Inputtype
Definition: EdbShowAlg_NN.h:93
EdbShowAlg_NN::eANN_var_mean_dT_2after
Float_t eANN_var_mean_dT_2after
Definition: EdbShowAlg_NN.h:74
EdbShowAlg_NN::eANN_var_mean_dR_2before
Float_t eANN_var_mean_dR_2before
Definition: EdbShowAlg_NN.h:67
EdbShowAlg_NN::eANN_var_min_dR_2before
Float_t eANN_var_min_dR_2before
Definition: EdbShowAlg_NN.h:77

◆ Execute()

void EdbShowAlg_NN::Execute ( )
virtual

Reimplemented from EdbShowAlg.

218 {
219  Log(2,"EdbShowAlg_NN::Execute","Execute() DOING MAIN SHOWER RECONSTRUCTION HERE");
220 
221  EdbSegP* InBT;
222  EdbSegP* Segment;
223  EdbSegP* seg;
224  EdbShowerP* RecoShower;
225 
226  Bool_t StillToLoop=kTRUE;
227  Int_t ActualPID;
228  Int_t newActualPID;
229  Int_t STEP=-1;
230  Int_t NLoopedPattern=0;
231  if (eFirstPlate_eAliPID-eLastPlate_eAliPID<0) STEP=1;
232  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- STEP for patternloop direction = " << STEP << endl;
233 
234 
235  Double_t params[30]; // Used for ANN Evaluation
236 
237  //--- Loop over InBTs:
238 
239  // Since eInBTArray is filled in ascending ordering by zpositon
240  // We use the descending loop to begin with BT with lowest z first.
241  for (Int_t i=eInBTArrayN-1; i>=0; --i) {
242 
243  // CounterOutPut
244  if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << eInBTArrayN <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
245 
246  //-----------------------------------
247  // 0a) Reset characteristic variables:
248  //-----------------------------------
249  eANN_var_dT_InBT_To_TestBT=0;
250  eANN_var_dR_InBT_To_TestBT=0;
251  eANN_var_dR_TestBT_To_InBT=0;
252  eANN_var_zDiff_TestBT_To_InBT=0;
253  eANN_var_mean_dT_2before=0;
254  eANN_var_mean_dR_2before=0;
255  eANN_var_mean_dT_before=0;
256  eANN_var_mean_dR_before=0;
257  eANN_var_mean_dT_same=0;
258  eANN_var_mean_dR_same=0;
259  eANN_var_mean_dT_after=0;
260  eANN_var_mean_dR_after=0;
261  eANN_var_mean_dT_2after=0;
262  eANN_var_mean_dR_2after=0;
263  eANN_var_nseg_1before=0;
264  eANN_var_nseg_2before=0;
265  eANN_var_nseg_1after=0;
266  eANN_var_nseg_2after=0;
267  eANN_var_nseg_same=0;
268  eANN_var_min_dT_2before=0;
269  eANN_var_min_dR_2before=0;
270  eANN_var_min_dT_before=0;
271  eANN_var_min_dR_before=0;
272  eANN_var_min_dT_same=0;
273  eANN_var_min_dR_same=0;
274  eANN_var_min_dT_after=0;
275  eANN_var_min_dR_after=0;
276  eANN_var_min_dT_2after=0;
277  eANN_var_min_dR_2after=0;
278 
279  //-----------------------------------
280  // 1) Make eAli with cut parameters:
281  //-----------------------------------
282 
283  // Create new EdbShowerP Object for storage;
284  // See EdbShowerP why I have to call the Constructor as "unique" ideficable value
285  //RecoShower = new EdbShowerP(i,eAlgValue);
286  RecoShower = new EdbShowerP(i,eAlgValue,-1);
287 
288  // Get InitiatorBT from eInBTArray
289  InBT=(EdbSegP*)eInBTArray->At(i);
290  if (gEDBDEBUGLEVEL>2) InBT->PrintNice();
291 
292  // Add InBT to RecoShower:
293  // This has to be done, since by definition the first BT in the RecoShower is the InBT.
294  // Otherwise, also the definition of shower axis and transversal profiles is wrong!
295  RecoShower -> AddSegment(InBT);
296  cout << "Segment (InBT) " << InBT << " was added to RecoShower." << endl;
297 
298  // Transform (make size smaller, extract only events having same MC) the eAli object:
299  // See in Execute_CA for description.
300  Transform_eAli(InBT,1400);
301 
302  // Add InBT to RecoShower // obsolete, since we loop also over the plate containing the InBT
303  //RecoShower --> AddSegment(InBT);
304 
305  //-----------------------------------
306  // 2) Loop over (whole) eAli, check BT for Cuts
307  //-----------------------------------
308  ActualPID= InBT->PID() ;
309  newActualPID= InBT->PID() ;
310 
311  while (StillToLoop) {
312  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- --- Doing patterloop " << ActualPID << endl;
313 
314  // just to adapt to this nomenclature of ShowRec program:
315  int patterloop_cnt=ActualPID;
316 
317 
318  for (Int_t btloop_cnt=0; btloop_cnt<eAli->GetPattern(ActualPID)->GetN(); ++btloop_cnt) {
319 
320  Segment = (EdbSegP*)eAli->GetPattern(ActualPID)->GetSegment(btloop_cnt);
321 
322  // just to adapt to this nomenclature of ShowRec program
323  seg=Segment;
324 
325  if (gEDBDEBUGLEVEL>4) Segment->PrintNice();
326 
327  // Reset characteristic variables:
328  eANN_var_dT_InBT_To_TestBT=0;
329  eANN_var_dR_InBT_To_TestBT=0;
330  eANN_var_dR_TestBT_To_InBT=0;
331  eANN_var_zDiff_TestBT_To_InBT=0;
332  eANN_var_mean_dT_2before=0;
333  eANN_var_mean_dR_2before=0;
334  eANN_var_mean_dT_before=0;
335  eANN_var_mean_dR_before=0;
336  eANN_var_mean_dT_same=0;
337  eANN_var_mean_dR_same=0;
338  eANN_var_mean_dT_after=0;
339  eANN_var_mean_dR_after=0;
340  eANN_var_mean_dT_2after=0;
341  eANN_var_mean_dR_2after=0;
342  eANN_var_nseg_1before=0;
343  eANN_var_nseg_2before=0;
344  eANN_var_nseg_1after=0;
345  eANN_var_nseg_2after=0;
346  eANN_var_nseg_same=0;
347  eANN_var_min_dT_2before=0;
348  eANN_var_min_dR_2before=0;
349  eANN_var_min_dT_before=0;
350  eANN_var_min_dR_before=0;
351  eANN_var_min_dT_same=0;
352  eANN_var_min_dR_same=0;
353  eANN_var_min_dT_after=0;
354  eANN_var_min_dR_after=0;
355  eANN_var_min_dT_2after=0;
356  eANN_var_min_dR_2after=0;
357 
358  // Now calculate NN Inputvariables: --------------------
359  // 1) zDiff_TestBT_To_InBT and SpatialDist_TestBT_To_InBT
360  eANN_var_zDiff_TestBT_To_InBT=seg->Z()-InBT->Z();
361  eANN_var_SpatialDist_TestBT_To_InBT=GetSpatialDist(seg,InBT);
362  // 2) dT_InBT_To_TestBT
363  eANN_var_dT_InBT_To_TestBT=DeltaThetaSingleAngles(seg,InBT);
364  // 3) dR_InBT_To_TestBT (propagation order matters)
365  // In calculation it makes a difference if InBT is extrapolated to Z-pos of seg or vice versa.
366  eANN_var_dR_InBT_To_TestBT=DeltaR_WithPropagation(InBT, seg);
367  eANN_var_dR_TestBT_To_InBT=DeltaR_WithPropagation(seg,InBT);
368 
369  // 4) nseg_1before,nseg_2before,nseg_1after,nseg_2after:
370  if (eParaValue[0]>=10) {
371  eANN_var_nseg_2before = GetNSegBeforeAndAfter(eAli,patterloop_cnt,seg,2,-1);
372  eANN_var_nseg_1before = GetNSegBeforeAndAfter(eAli,patterloop_cnt,seg,1,-1);
373  eANN_var_nseg_same = GetNSegBeforeAndAfter(eAli,patterloop_cnt,seg,0, 1);
374  eANN_var_nseg_1after = GetNSegBeforeAndAfter(eAli,patterloop_cnt,seg,1, 1);
375  eANN_var_nseg_2after = GetNSegBeforeAndAfter(eAli,patterloop_cnt,seg,2, 1);
376  }
377 
378  // 5) mean_dT,dR nseg_1before,nseg_2before,nseg_1after,nseg_2after: mean of all dTheta and dR compliment segments:
379  if (eParaValue[0]>=20) {
380  GetMeansBeforeAndAfter(eANN_var_mean_dT_2before,eANN_var_mean_dR_2before,eAli,patterloop_cnt,seg,2,-1);
381  GetMeansBeforeAndAfter(eANN_var_mean_dT_before,eANN_var_mean_dR_before,eAli,patterloop_cnt,seg,1,-1);
382  GetMeansBeforeAndAfter(eANN_var_mean_dT_same,eANN_var_mean_dR_same,eAli,patterloop_cnt,seg,0, 1);
383  GetMeansBeforeAndAfter(eANN_var_mean_dT_after,eANN_var_mean_dR_after,eAli,patterloop_cnt,seg,1, 1);
384  GetMeansBeforeAndAfter(eANN_var_mean_dT_2after,eANN_var_mean_dR_2after,eAli,patterloop_cnt,seg,2, 1);
385  }
386 
387  // 6) nseg_1before,nseg_2before,nseg_1after,nseg_2after: mean of all dTheta and dR compliment segments:
388  if (eParaValue[0]>=30) {
389  GetMinsBeforeAndAfter(eANN_var_min_dT_2before,eANN_var_min_dR_2before,eAli,patterloop_cnt,seg,2,-1);
390  GetMinsBeforeAndAfter(eANN_var_min_dT_before,eANN_var_min_dR_before,eAli,patterloop_cnt,seg,1,-1);
391  GetMinsBeforeAndAfter(eANN_var_min_dT_same,eANN_var_min_dR_same,eAli,patterloop_cnt,seg,0, 1);
392  GetMinsBeforeAndAfter(eANN_var_min_dT_after,eANN_var_min_dR_after,eAli,patterloop_cnt,seg,1, 1);
393  GetMinsBeforeAndAfter(eANN_var_min_dT_2after,eANN_var_min_dR_2after,eAli,patterloop_cnt,seg,2, 1);
394  }
395  // end of calculate NN Inputvariables: --------------------
396 
397  // Fill ANN params Array:
398  params[0]=eANN_var_dT_InBT_To_TestBT;
399  params[1]=eANN_var_dR_InBT_To_TestBT;
400  params[2]=eANN_var_dR_TestBT_To_InBT;
401  params[3]=eANN_var_zDiff_TestBT_To_InBT;
402  params[4]=eANN_var_SpatialDist_TestBT_To_InBT;
403  params[5]=eANN_var_nseg_2before;
404  params[6]=eANN_var_nseg_1before;
405  params[7]=eANN_var_nseg_same;
406  params[8]=eANN_var_nseg_1after;
407  params[9]=eANN_var_nseg_2after;
408  params[10]=eANN_var_mean_dT_2before;
409  params[11]=eANN_var_mean_dT_before;
410  params[12]=eANN_var_mean_dT_same;
411  params[13]=eANN_var_mean_dT_after;
412  params[14]=eANN_var_mean_dT_2after;
413  params[15]=eANN_var_mean_dR_2before;
414  params[16]=eANN_var_mean_dR_before;
415  params[17]=eANN_var_mean_dR_same;
416  params[18]=eANN_var_mean_dR_after;
417  params[19]=eANN_var_mean_dR_2after;
418  params[20]=eANN_var_min_dT_2before;
419  params[21]=eANN_var_min_dT_before;
420  params[22]=eANN_var_min_dT_same;
421  params[23]=eANN_var_min_dT_after;
422  params[24]=eANN_var_min_dT_2after;
423  params[25]=eANN_var_min_dR_2before;
424  params[26]=eANN_var_min_dR_before;
425  params[27]=eANN_var_min_dR_same;
426  params[28]=eANN_var_min_dR_after;
427  params[29]=eANN_var_min_dR_2after;
428 
429 
430 
431  // Now apply cut conditions: NN Neural Network Alg --------------------
432  Double_t value=0;
433  value=eTMlpANN->Evaluate(0, params);
434  if (gEDBDEBUGLEVEL>3) {
435  cout << "Inputvalues: ";
436  for (int hj=0; hj<5; hj++) cout << " " << params[hj];
437  cout << " , Value= " << value << " eParaValue= " << eParaValue[1] << endl;
438  }
439  if (value<eParaValue[1]) continue;
440  // end of cut conditions: NN Neural Network Alg --------------------
441 
442  // If we arrive here, Basetrack Segment has passed criteria
443  // and is then added to the RecoShower:
444  // Check if its not the InBT which is already added:
445  if (Segment->X()==InBT->X()&&Segment->Y()==InBT->Y()) {
446  ; // is InBT, do nothing;
447  }
448  else {
449  RecoShower -> AddSegment(Segment);
450  }
451  cout << "Segment " << Segment << " was added to &RecoShower : " << &RecoShower << endl;
452  } // of btloop_cnt
453 
454  //------------
455  newActualPID=ActualPID+STEP;
456  ++NLoopedPattern;
457 
458  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- --- newActualPID= " << newActualPID << endl;
459  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- --- NLoopedPattern= " << NLoopedPattern << endl;
460  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- --- eNumberPlate_eAliPID= " << eNumberPlate_eAliPID << endl;
461  if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_NN::Execute--- --- StillToLoop= " << StillToLoop << endl;
462 
463  // This if holds in the case of STEP== +1
464  if (STEP==1) {
465  if (newActualPID>eLastPlate_eAliPID) StillToLoop=kFALSE;
466  if (newActualPID>eLastPlate_eAliPID) cout << "EdbShowAlg_NN::Execute--- ---Stopp Loop since: newActualPID>eLastPlate_eAliPID"<<endl;
467  }
468  // This if holds in the case of STEP== -1
469  if (STEP==-1) {
470  if (newActualPID<eLastPlate_eAliPID) StillToLoop=kFALSE;
471  if (newActualPID<eLastPlate_eAliPID) cout << "EdbShowAlg_NN::Execute--- ---Stopp Loop since: newActualPID<eLastPlate_eAliPID"<<endl;
472  }
473  // This if holds general, since eNumberPlate_eAliPID is not dependent of the structure of the gAli subject:
474  if (NLoopedPattern>eNumberPlate_eAliPID) StillToLoop=kFALSE;
475  if (NLoopedPattern>eNumberPlate_eAliPID) cout << "EdbShowAlg_NN::Execute--- ---Stopp Loop since: NLoopedPattern>eNumberPlate_eAliPID"<<endl;
476 
477  ActualPID=newActualPID;
478  } // of // while (StillToLoop)
479 
480  // Obligatory when Shower Reconstruction is finished!
481  RecoShower ->Update();
482  //RecoShower ->PrintBasics();
483 
484 
485  // Add Shower Object to Shower Reco Array.
486  // Not, if its empty:
487  // Not, if its containing only one BT:
488  if (RecoShower->N()>1) eRecoShowerArray->Add(RecoShower);
489 
490  // Set back loop values:
491  StillToLoop=kTRUE;
492  NLoopedPattern=0;
493  } // of // for (Int_t i=eInBTArrayN-1; i>=0; --i) {
494 
495 
496  // Set new value for eRecoShowerArrayN (may now be < eInBTArrayN).
497  SetRecoShowerArrayN(eRecoShowerArray->GetEntries());
498 
499  cout << "EdbShowAlg_NN::eRecoShowerArray() Entries: " << eRecoShowerArray->GetEntries() << endl;
500  Log(2,"EdbShowAlg_NN::Execute","Execute() DOING MAIN SHOWER RECONSTRUCTION HERE...done.");
501  return;
502 }
EdbPatternsVolume::GetPattern
EdbPattern * GetPattern(int id) const
Definition: EdbPattern.cxx:1887
EdbSegP
Definition: EdbSegP.h:18
EdbSegP::X
Float_t X() const
Definition: EdbSegP.h:170
EdbSegP::Z
Float_t Z() const
Definition: EdbSegP.h:150
EdbSegP::Y
Float_t Y() const
Definition: EdbSegP.h:171
EdbSegP::PrintNice
void PrintNice() const
Definition: EdbSegP.cxx:418
EdbSegP::PID
Int_t PID() const
Definition: EdbSegP.h:145
EdbSegmentsBox::GetSegment
EdbSegP * GetSegment(int i) const
Definition: EdbPattern.h:66
EdbShowAlg_NN::eTMlpANN
TMultiLayerPerceptron * eTMlpANN
Definition: EdbShowAlg_NN.h:53
EdbShowAlg_NN::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)
Definition: EdbShowAlg_NN.cxx:585
EdbShowAlg_NN::GetNSegBeforeAndAfter
Int_t GetNSegBeforeAndAfter(EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Definition: EdbShowAlg_NN.cxx:523
EdbShowAlg_NN::eANN_var_dT_InBT_To_TestBT
Float_t eANN_var_dT_InBT_To_TestBT
Definition: EdbShowAlg_NN.h:58
EdbShowAlg_NN::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)
Definition: EdbShowAlg_NN.cxx:672
EdbShowAlg::Transform_eAli
void Transform_eAli(EdbSegP *InitiatorBT, Float_t ExtractSize)
Definition: EdbShowAlg.cxx:107
EdbShowAlg::eParaValue
Float_t eParaValue[10]
Definition: EdbShowAlg.h:52
EdbShowAlg::GetSpatialDist
Double_t GetSpatialDist(EdbSegP *s1, EdbSegP *s2)
Definition: EdbShowAlg.cxx:463
EdbShowAlg::SetRecoShowerArrayN
void SetRecoShowerArrayN(Int_t RecoShowerArrayN)
Definition: EdbShowAlg.h:117
EdbShowAlg::DeltaThetaSingleAngles
Double_t DeltaThetaSingleAngles(EdbSegP *s1, EdbSegP *s2)
Definition: EdbShowAlg.cxx:455
EdbShowAlg::eRecoShowerArray
TObjArray * eRecoShowerArray
Definition: EdbShowAlg.h:70
EdbShowAlg::eAlgValue
Int_t eAlgValue
Definition: EdbShowAlg.h:50
EdbShowAlg::eFirstPlate_eAliPID
Int_t eFirstPlate_eAliPID
Definition: EdbShowAlg.h:65
EdbShowAlg::eLastPlate_eAliPID
Int_t eLastPlate_eAliPID
Definition: EdbShowAlg.h:66
EdbShowAlg::eInBTArrayN
Int_t eInBTArrayN
Definition: EdbShowAlg.h:63
EdbShowAlg::DeltaR_WithPropagation
Double_t DeltaR_WithPropagation(EdbSegP *s, EdbSegP *stest)
Definition: EdbShowAlg.cxx:411
EdbShowAlg::eInBTArray
TObjArray * eInBTArray
Definition: EdbShowAlg.h:62
EdbShowAlg::eAli
EdbPVRec * eAli
Definition: EdbShowAlg.h:59
EdbShowAlg::eNumberPlate_eAliPID
Int_t eNumberPlate_eAliPID
Definition: EdbShowAlg.h:68
EdbShowerP
Definition: EdbShowerP.h:28
EdbShowerP::N
Int_t N() const
Definition: EdbShowerP.h:412
EdbShowerP::Update
void Update()
Definition: EdbShowerP.cxx:975
params
Double_t params[3]
Definition: testBGReduction_By_ANN.C:84

◆ Finalize()

void EdbShowAlg_NN::Finalize ( )
virtual

Reimplemented from EdbShowAlg.

516 {
517  Log(2,"EdbShowAlg_NN::Finalize","Finalize(). Nothing done here yet.");
518  return;
519 }

◆ GetMeansBeforeAndAfter()

Int_t EdbShowAlg_NN::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 
)
673 {
674 // cout << "GetMeansBeforeAndAfter( XX, " << patterloop_cnt << " , Seg, " << n_patterns << ", " << BeforeOrAfter << endl;
675  mean_dT=-1;
676  mean_dR=-1;
677 
678  float Z_minus1=0;
679  float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
680  float Z_plus1=0;
681 
682  int npat=local_gAli->Npatterns();
683  Bool_t edge_npat_upper=kFALSE;
684  Bool_t edge_npat_lower=kFALSE;
685  Int_t Factor=-1;
686 
687  if (patterloop_cnt==npat-1) {
688  edge_npat_upper=kTRUE;
689  }
690  if (patterloop_cnt==0) {
691  edge_npat_lower=kTRUE;
692  }
693 
694  if (!edge_npat_lower) {
695  Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
696  if (Z_minus1<Z_normal) Factor=1;
697  }
698  if (!edge_npat_upper) {
699  Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
700  if (Z_plus1>Z_normal) Factor=1;
701  }
702  // New PID we want to have:
703  Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
704 
705  // Does this plate exist? If not, return 0 directly:
706  if (patterloop_test>=npat || patterloop_test<0) {
707  //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;
708  return 0;
709  }
710 
711  // Since we have checked now for bounds we can FindCompliments:
712  Int_t n_return=0;
713  TObjArray array;
714  array.Clear();
715  EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
716  TestPattern -> FillCell(20,20,0.01,0.01);
717  n_return = TestPattern->FindCompliments(*seg,array,3,3);
718  //cout << " Found " << n_return << " compliments in 2,2 sigma area:" << endl;
719 
720  if (n_return==0) return n_return;
721 
722  //seg->PrintNice();
723  for (int i=0; i<n_return; i++) {
724  EdbSegP* s_of_array=(EdbSegP*)array.At(i);
725  if (i==0) {
726  mean_dT=0;
727  mean_dR=0;
728  }
729  //s_of_array->PrintNice();
730  mean_dT+=DeltaThetaSingleAngles(seg,s_of_array);
731  mean_dR+=DeltaR_NoPropagation(seg,s_of_array);
732  }
733  if (n_return>0) mean_dT=mean_dT/(Double_t)n_return;
734  if (n_return>0) mean_dR=mean_dR/(Double_t)n_return;
735 
736  return n_return;
737 }
npat
Int_t npat
Definition: Xi2HatStartScript.C:33
EdbPattern
Definition: EdbPattern.h:280
EdbPattern::FindCompliments
int FindCompliments(EdbSegP &s, TObjArray &arr, float nsig, float nsigt)
Definition: EdbPattern.cxx:1447
EdbPatternsVolume::Npatterns
Int_t Npatterns() const
Definition: EdbPattern.h:380
EdbSegmentsBox::Z
Float_t Z() const
Definition: EdbPattern.h:87
EdbShowAlg::DeltaR_NoPropagation
Double_t DeltaR_NoPropagation(EdbSegP *s, EdbSegP *stest)
Definition: EdbShowAlg.cxx:396

◆ GetMinsBeforeAndAfter()

Int_t EdbShowAlg_NN::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 
)
586 {
587 // cout << "GetMinsBeforeAndAfter( XX, " << patterloop_cnt << " , Seg, " << n_patterns << ", " << BeforeOrAfter << endl;
588  min_dT=-1;
589  min_dR=-1;
590 
591  float Z_minus1=0;
592  float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
593  float Z_plus1=0;
594 
595  int npat=local_gAli->Npatterns();
596  Bool_t edge_npat_upper=kFALSE;
597  Bool_t edge_npat_lower=kFALSE;
598  Int_t Factor=-1;
599 
600  if (patterloop_cnt==npat-1) {
601  edge_npat_upper=kTRUE;
602  }
603  if (patterloop_cnt==0) {
604  edge_npat_lower=kTRUE;
605  }
606 
607  if (!edge_npat_lower) {
608  Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
609  if (Z_minus1<Z_normal) Factor=1;
610  }
611  if (!edge_npat_upper) {
612  Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
613  if (Z_plus1>Z_normal) Factor=1;
614  }
615  // New PID we want to have:
616  Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
617 
618  // Does this plate exist? If not, return 0 directly:
619  if (patterloop_test>=npat || patterloop_test<0) {
620  //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;
621  return 0;
622  }
623 
624  // Since we have checked now for bounds we can FindCompliments:
625  Int_t n_return=0;
626  TObjArray array;
627  array.Clear();
628  EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
629  TestPattern -> FillCell(20,20,0.01,0.01);
630  n_return = TestPattern->FindCompliments(*seg,array,3,3);
631  //cout << " Found " << n_return << " compliments in 2,2 sigma area:" << endl;
632 
633  if (n_return==0) return n_return;
634 
635  if (n_return==1) {
636  EdbSegP* s_of_array=(EdbSegP*)array.At(0);
637  min_dT=DeltaThetaSingleAngles(seg,s_of_array);
638  min_dR=DeltaR_NoPropagation(seg,s_of_array);
639  }
640 
641  Float_t tmp_min_dT=-1;
642  Float_t tmp_min_dR=-1;
643  Float_t tmp2_min_dT=-1;
644  Float_t tmp2_min_dR=-1;
645  Float_t angle;
646  Float_t dist;
647 
648  if (n_return>1) {
649  for (int i=0; i<n_return; i++) {
650  EdbSegP* s_of_array=(EdbSegP*)array.At(i);
651  if (i==0) {
652  min_dT=999999;
653  min_dR=9999999;
654  }
655  angle=(Float_t)DeltaThetaSingleAngles(seg,s_of_array);
656  tmp_min_dT=min_dT;
657  tmp2_min_dT=TMath::Min(angle, tmp_min_dT);
658  min_dT=tmp2_min_dT;
659 
660  dist=(Float_t)DeltaR_NoPropagation(seg,s_of_array);
661  tmp_min_dR=min_dR;
662  tmp2_min_dR=TMath::Min(dist, tmp_min_dR);
663  min_dR=tmp2_min_dR;
664  }
665  }
666  return n_return;
667 }

◆ GetNSegBeforeAndAfter()

Int_t EdbShowAlg_NN::GetNSegBeforeAndAfter ( EdbPVRec *  local_gAli,
Int_t  patterloop_cnt,
EdbSegP *  seg,
Int_t  n_patterns,
Int_t  BeforeOrAfter 
)
524 {
525 // cout << "GetNSegBeforeAndAfter( XX, " << patterloop_cnt << " , Seg, " << n_patterns << ", " << BeforeOrAfter << endl;
526 
527  float Z_minus1=0;
528  float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
529  float Z_plus1=0;
530 
531  int npat=local_gAli->Npatterns();
532  Bool_t edge_npat_upper=kFALSE;
533  Bool_t edge_npat_lower=kFALSE;
534  Int_t Factor=-1;
535 
536  if (patterloop_cnt==npat-1) {
537  edge_npat_upper=kTRUE;
538  }
539  if (patterloop_cnt==0) {
540  edge_npat_lower=kTRUE;
541  }
542 
543  if (!edge_npat_lower) {
544  Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
545 // cout << "WHAT IS GREATER? Z_normal Z_minus1 " << Z_normal << " " << Z_minus1 << endl;
546  //Factor=(Int_t)TMath::Sign(Z_normal,Z_minus1);
547  if (Z_minus1<Z_normal) Factor=1;
548  }
549  if (!edge_npat_upper) {
550  Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
551 // cout << "WHAT IS GREATER? Z_normal Z_plus1 " << Z_normal << " " << Z_plus1 << endl;
552  if (Z_plus1>Z_normal) Factor=1;
553  }
554 
555 // cout << Z_minus1 << endl;
556 // cout << Z_normal << endl;
557 // cout << Z_plus1 << endl;
558 // cout << "Is edge_npat_lower = " << edge_npat_lower << endl;
559 // cout << "Is edge_npat_upper = " << edge_npat_upper << endl;
560 // cout << "Factor = " << Factor << endl;
561 
562  // New PID we want to have:
563  Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
564 // cout << "So NEW n_patterns would be " << patterloop_test << endl;
565 
566  // Does this plate exist? If not, return 0 directly:
567  if (patterloop_test>=npat || patterloop_test<0) {
568  //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;
569  return 0;
570  }
571 
572  // Since we have checked now for bounds we can FindCompliments:
573  TObjArray array;
574  array.Clear();
575  EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
576  TestPattern -> FillCell(20,20,0.01,0.01);
577  int n_return = TestPattern->FindCompliments(*seg,array,3,3);
578  //cout << " Found " << n_return << " compliments in 2,2 sigma area:" << endl;
579 
580  return n_return;
581 }

◆ GetWeightFileString()

TString EdbShowAlg_NN::GetWeightFileString ( )
inline
113  {
114  return eWeightFileString;
115  }
EdbShowAlg_NN::eWeightFileString
TString eWeightFileString
Definition: EdbShowAlg_NN.h:50

◆ Init()

void EdbShowAlg_NN::Init ( void  )
53 {
54  Log(2,"EdbShowAlg_NN::EdbShowAlg_NN","Init()");
55 
56  // Init with values according to NN Alg:
57  eParaValue[0]=5;
58  eParaString[0]="INPUTNEURONS";
59  eParaValue[1]=0.75;
60  eParaString[1]="OUTPUT"; // NN output value
61 
62  eWeightFileString="weights.txt";
63  eWeightFileLayoutString="layout";
64 
65  CreateANNTree();
66  //cout << " eANNTree->Show(0) " <<endl; eANNTree->Show(0);
67  eTMlpANN = Create_NN_ALG_MLP(eANNTree, eParaValue[0]);
68 
69  // Standard Weights:
70  SetANNWeightString();
71  LoadANNWeights();
72 
73  return;
74 }
EdbShowAlg_NN::eWeightFileLayoutString
TString eWeightFileLayoutString
Definition: EdbShowAlg_NN.h:51
EdbShowAlg_NN::SetANNWeightString
void SetANNWeightString()
Definition: EdbShowAlg_NN.cxx:175
EdbShowAlg_NN::LoadANNWeights
void LoadANNWeights()
Definition: EdbShowAlg_NN.cxx:193
EdbShowAlg_NN::CreateANNTree
void CreateANNTree()
Definition: EdbShowAlg_NN.cxx:87
EdbShowAlg_NN::Create_NN_ALG_MLP
TMultiLayerPerceptron * Create_NN_ALG_MLP(TTree *inputtree, Int_t inputneurons)
Definition: EdbShowAlg_NN.cxx:139
EdbShowAlg::eParaString
TString eParaString[10]
Definition: EdbShowAlg.h:53

◆ Initialize()

void EdbShowAlg_NN::Initialize ( )
virtual

Reimplemented from EdbShowAlg.

80 {
81  Log(2,"EdbShowAlg_NN::EdbShowAlg_NN","Initialize()");
82  return;
83 }

◆ LoadANNWeights() [1/2]

void EdbShowAlg_NN::LoadANNWeights ( )
194 {
195  eTMlpANN->LoadWeights(eWeightFileString);
196  return;
197 }

◆ LoadANNWeights() [2/2]

void EdbShowAlg_NN::LoadANNWeights ( TMultiLayerPerceptron *  TMlpANN,
TString  WeightFileString 
)
204 {
205  TMlpANN->LoadWeights(WeightFileString);
206  if (gEDBDEBUGLEVEL>2) cout << "EdbShowAlg_NN::LoadANNWeights " << WeightFileString << endl;
207  return;
208 }

◆ Print()

void EdbShowAlg_NN::Print ( )

◆ SetANNWeightString()

void EdbShowAlg_NN::SetANNWeightString ( )
176 {
177  Log(2,"EdbShowAlg_NN::SetANNWeightString","SetANNWeightString()");
178  int inputneurons=eParaValue[0];
179  if (inputneurons==5) eWeightFileString="ANN_WEIGHTS_PARASET_0_To_20.txt";
180  if (inputneurons==10) eWeightFileString="ANN_WEIGHTS_PARASET_20_To_40.txt";
181  if (inputneurons==20) eWeightFileString="ANN_WEIGHTS_PARASET_40_To_60.txt";
182  if (inputneurons==30) eWeightFileString="ANN_WEIGHTS_PARASET_60_To_80.txt";
183 
184  if (gEDBDEBUGLEVEL>2) cout << "EdbShowAlg_NN::SetANNWeightString " << eWeightFileString << endl;
185  Log(2,"EdbShowAlg_NN::SetANNWeightString","SetANNWeightString()...done.");
186  return;
187 }

◆ SetWeightFileString()

void EdbShowAlg_NN::SetWeightFileString ( TString  WeightFileString)
inline
109  {
110  eWeightFileString=WeightFileString;
111  return;
112  }

Member Data Documentation

◆ eANN_Inputtype

Int_t EdbShowAlg_NN::eANN_Inputtype
private

◆ eANN_var_dR_InBT_To_TestBT

Float_t EdbShowAlg_NN::eANN_var_dR_InBT_To_TestBT
private

◆ eANN_var_dR_NextBT_To_TestBT

Float_t EdbShowAlg_NN::eANN_var_dR_NextBT_To_TestBT
private

◆ eANN_var_dR_TestBT_To_InBT

Float_t EdbShowAlg_NN::eANN_var_dR_TestBT_To_InBT
private

◆ eANN_var_dT_InBT_To_TestBT

Float_t EdbShowAlg_NN::eANN_var_dT_InBT_To_TestBT
private

◆ eANN_var_dT_NextBT_To_TestBT

Float_t EdbShowAlg_NN::eANN_var_dT_NextBT_To_TestBT
private

◆ eANN_var_InBT_To_TestBT

Float_t EdbShowAlg_NN::eANN_var_InBT_To_TestBT
private

◆ eANN_var_mean_dR_2after

Float_t EdbShowAlg_NN::eANN_var_mean_dR_2after
private

◆ eANN_var_mean_dR_2before

Float_t EdbShowAlg_NN::eANN_var_mean_dR_2before
private

◆ eANN_var_mean_dR_after

Float_t EdbShowAlg_NN::eANN_var_mean_dR_after
private

◆ eANN_var_mean_dR_before

Float_t EdbShowAlg_NN::eANN_var_mean_dR_before
private

◆ eANN_var_mean_dR_same

Float_t EdbShowAlg_NN::eANN_var_mean_dR_same
private

◆ eANN_var_mean_dT_2after

Float_t EdbShowAlg_NN::eANN_var_mean_dT_2after
private

◆ eANN_var_mean_dT_2before

Float_t EdbShowAlg_NN::eANN_var_mean_dT_2before
private

◆ eANN_var_mean_dT_after

Float_t EdbShowAlg_NN::eANN_var_mean_dT_after
private

◆ eANN_var_mean_dT_before

Float_t EdbShowAlg_NN::eANN_var_mean_dT_before
private

◆ eANN_var_mean_dT_same

Float_t EdbShowAlg_NN::eANN_var_mean_dT_same
private

◆ eANN_var_min_dR_2after

Float_t EdbShowAlg_NN::eANN_var_min_dR_2after
private

◆ eANN_var_min_dR_2before

Float_t EdbShowAlg_NN::eANN_var_min_dR_2before
private

◆ eANN_var_min_dR_after

Float_t EdbShowAlg_NN::eANN_var_min_dR_after
private

◆ eANN_var_min_dR_before

Float_t EdbShowAlg_NN::eANN_var_min_dR_before
private

◆ eANN_var_min_dR_same

Float_t EdbShowAlg_NN::eANN_var_min_dR_same
private

◆ eANN_var_min_dT_2after

Float_t EdbShowAlg_NN::eANN_var_min_dT_2after
private

◆ eANN_var_min_dT_2before

Float_t EdbShowAlg_NN::eANN_var_min_dT_2before
private

◆ eANN_var_min_dT_after

Float_t EdbShowAlg_NN::eANN_var_min_dT_after
private

◆ eANN_var_min_dT_before

Float_t EdbShowAlg_NN::eANN_var_min_dT_before
private

◆ eANN_var_min_dT_same

Float_t EdbShowAlg_NN::eANN_var_min_dT_same
private

◆ eANN_var_nseg_1after

Int_t EdbShowAlg_NN::eANN_var_nseg_1after
private

◆ eANN_var_nseg_1before

Int_t EdbShowAlg_NN::eANN_var_nseg_1before
private

◆ eANN_var_nseg_2after

Int_t EdbShowAlg_NN::eANN_var_nseg_2after
private

◆ eANN_var_nseg_2before

Int_t EdbShowAlg_NN::eANN_var_nseg_2before
private

◆ eANN_var_nseg_3after

Int_t EdbShowAlg_NN::eANN_var_nseg_3after
private

◆ eANN_var_nseg_3before

Int_t EdbShowAlg_NN::eANN_var_nseg_3before
private

◆ eANN_var_nseg_same

Int_t EdbShowAlg_NN::eANN_var_nseg_same
private

◆ eANN_var_SpatialDist_TestBT_To_InBT

Float_t EdbShowAlg_NN::eANN_var_SpatialDist_TestBT_To_InBT
private

◆ eANN_var_zDiff_TestBT_To_InBT

Float_t EdbShowAlg_NN::eANN_var_zDiff_TestBT_To_InBT
private

◆ eANN_var_zDist_TestBT_To_InBT

Float_t EdbShowAlg_NN::eANN_var_zDist_TestBT_To_InBT
private

◆ eANNTree

TTree* EdbShowAlg_NN::eANNTree
private

◆ eTMlpANN

TMultiLayerPerceptron* EdbShowAlg_NN::eTMlpANN
private

◆ eWeightFileLayoutString

TString EdbShowAlg_NN::eWeightFileLayoutString
private

◆ eWeightFileString

TString EdbShowAlg_NN::eWeightFileString
private
The documentation for this class was generated from the following files: