#include <EdbShowAlg_NN.h>

Inheritance diagram for EdbShowAlg_N3:

Collaboration diagram for EdbShowAlg_N3:

[legend]

Public Member Functions
	ClassDef (EdbShowAlg_N3, 1)

TMultiLayerPerceptron *	Create_NN_ALG_MLP (TTree *inputtree, Int_t inputneurons)

void	CreateANNTree ()

	EdbShowAlg_N3 (Bool_t ANN_DoTrain)

void	Execute ()

void	Finalize ()

TString	GetWeightFileString ()

void	Init ()

void	Initialize ()

void	LoadANNWeights ()

void	LoadANNWeights (TMultiLayerPerceptron *TMlpANN, TString WeightFileString)

void	Print ()

void	SetANNWeightString ()

void	SetWeightFileString (TString WeightFileString)

virtual	~EdbShowAlg_N3 ()

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 ()

Public Attributes
TString	eLayout

Private Attributes
Bool_t	eANN_DoTrain =kTRUE

Int_t	eANN_EQUALIZESGBG

Int_t	eANN_INPUTNEURONS

Int_t	eANN_Inputtype

Double_t	eANN_Inputvar [24]

Int_t	eANN_NHIDDENLAYER

Int_t	eANN_NTRAINEPOCHS

Double_t	eANN_OUTPUTTHRESHOLD

Double_t	eANN_OutputValue =0

Int_t	eANN_PLATE_DELTANMAX

TFile *	eANNTrainingsTreeFile

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_N3()

EdbShowAlg_N3::EdbShowAlg_N3 ( Bool_t ANN_DoTrain )

 {
     // Constructor with Train/Run Switch
     Log(2,"EdbShowAlg_N3::EdbShowAlg_N3","Default Constructor ANN_DoTrain=%d",ANN_DoTrain);
  
     // Reset all:
     // Calls Set0 from inheriting function, so some values must be reset to NULL
     // manually, unless a new Set0() function is implemented -- which is not at
     // the moment:
     Set0();
  
     eWeightFileString="";
     eWeightFileLayoutString="";
     eANNTree=NULL;
     eTMlpANN=NULL;
  
     // see default.par_SHOWREC for labeling (labeling identical with ShowRec program)
     eAlgName="N3";
     eAlgValue=11;
  
     // Mostly it will be runnung, but can be set now here:
     eANN_DoTrain=ANN_DoTrain;
  
     //  Init with values according to N3 Alg:
     Init();
  
     Log(2,"EdbShowAlg_N3::EdbShowAlg_N3","Default Constructor ANN_DoTrain=%d...done.",ANN_DoTrain);
 }

◆ ~EdbShowAlg_N3()

EdbShowAlg_N3::~EdbShowAlg_N3 ( )

virtual

 {
     // Default Destructor
     Log(2,"EdbShowAlg_N3::~EdbShowAlg_N3","Default Destructor");
     if (eANNTree) {
         delete eANNTree;
         eANNTree=0;
     }
 }

Member Function Documentation

◆ ClassDef()

EdbShowAlg_N3::ClassDef	(	EdbShowAlg_N3	,
		1
	)

◆ Create_NN_ALG_MLP()

TMultiLayerPerceptron * EdbShowAlg_N3::Create_NN_ALG_MLP	(	TTree *	inputtree,
		Int_t	inputneurons
	)

 {
     Log(2,"EdbShowAlg_N3::Create_NN_ALG_MLP","Create_NN_ALG_MLP().");
  
     if (gEDBDEBUGLEVEL>2) cout << "EdbShowAlg_N3::Create_NN_ALG_MLP()   inputneurons= " << inputneurons << endl;
  
     if ( NULL == simu ) {
         cout << "EdbShowAlg_N3::Create_NN_ALG_MLP() WARNING simu tree is NULL pointer. Return NULL."<< endl;
         return NULL;
     }
  
     // DEBUG START
     // THIS IS TO BE WRITTEN BETTER, CAUSE THE HANDOVER OF THE PARAMETERS SHOULD
     // BE BETTER .....
     eANN_NHIDDENLAYER=eParaValue[2];
     eANN_INPUTNEURONS=eParaValue[5];
  
     // TO DO HERE.... TAKE OVER THE CORRECT LAYOUT.
     // only knowlegde about number of input neurons  and hidden layers is needed.
     cout << "EdbShowAlg_N3::Create_NN_ALG_MLP()   eANN_NHIDDENLAYER =  " <<  eANN_NHIDDENLAYER  << endl;
     cout << "EdbShowAlg_N3::Create_NN_ALG_MLP()   eANN_INPUTNEURONS =  " <<  eANN_INPUTNEURONS  << endl;
  
     // Create the layout here:
     TString layout="";
     TString newstring="";
     // ANN Input Layer
     for (Int_t loop=0; loop<eANN_INPUTNEURONS-1; ++loop) {
         newstring=Form("eANN_Inputvar[%d],",loop);
         layout += newstring; // "+" works only with TStrings!
     }
     newstring=Form("eANN_Inputvar[%d]:",eANN_INPUTNEURONS-1);
     layout += newstring;
     // Hidden Layers
     for (Int_t loop=0; loop<eANN_NHIDDENLAYER; ++loop) {
         newstring=Form("%d:",eANN_INPUTNEURONS);
         layout += newstring;
     }
     // Output Layer, one output neuron
     newstring="eANN_Inputtype";
     layout += newstring;
  
     // Set Layout String as internal variable now:
     eLayout = layout;
  
     // DEBUG MESSAGES:
     cout << "simu = "  << simu << endl;
     cout << "simu->Show(0): "  << endl;
     simu->Show(0);
  
     // Create the network:
     TMultiLayerPerceptron* TMlpANN = new TMultiLayerPerceptron(layout,simu);
  
     if (gEDBDEBUGLEVEL>2) {
         cout << "EdbShowAlg_N3::Create_NN_ALG_MLP()   GetStructure:    " << endl;
         cout << TMlpANN->GetStructure() << endl;
     }
     Log(2,"EdbShowAlg_N3::Create_NN_ALG_MLP","Create_NN_ALG_MLP()...done.");
     return TMlpANN;
 }

◆ CreateANNTree()

void EdbShowAlg_N3::CreateANNTree ( )

 {
     Log(2,"EdbShowAlg_N3::CreateANNTree","CreateANNTree()");
  
     if (!eANNTree) eANNTree = new TTree("EdbShowAlg_N3_eANNTree", "EdbShowAlg_N3_eANNTree");
  
     // Variables and things important for neural Network:
     TTree *simu = new TTree("TreeSignalBackgroundBT", "TreeSignalBackgroundBT");
     eANNTree->Branch("eANN_Inputvar", eANN_Inputvar, "eANN_Inputvar[24]/D");
     eANNTree->Branch("eANN_Inputtype",   &eANN_Inputtype,   "eANN_Inputtype/I");
  
     eANNTree->Print();
  
     // Default, maximal settings. Same plate, Two plates up- downstream connections looking,
     // that for 4 inputvariables there
     // plus 4 fixed input variables for BT(i) to InBT connections: 4+5*4 = 24
     /*
     eANN_PLATE_DELTANMAX=5;
     eANN_NTRAINEPOCHS=100;
     eANN_NHIDDENLAYER=5;
     eANN_EQUALIZESGBG=0;
     eANN_OUTPUTTHRESHOLD=0.85;
     eANN_INPUTNEURONS=24;
     eANN_Inputtype=1;
     */
  
     cout << "DEBUG: Fill Tree with DUMMY variables --- TO BE CHANGED LATER"  <<  endl;
     for (int i=0; i<10; ++i) {
         for (int l=0; l<24; ++l) {
             eANN_Inputvar[l]=gRandom->Uniform();
         }
         eANN_Inputtype=i%2;
         eANNTree->Fill();
     }
     eANNTree->Show(0);
     eANNTree->Show(eANNTree->GetEntries()-1);
     cout << "DEBUG: Fill Tree with DUMMY variables --- TO BE CHANGED LATER  DONE.."  <<  endl;
  
     //---------
     Log(2,"EdbShowAlg_N3::CreateANNTree","CreateANNTree()...done.");
     return;
 }

◆ Execute()

void EdbShowAlg_N3::Execute ( )

virtual

eANN_Inputvar[1] = GetdR(InBT, seg);

Reimplemented from EdbShowAlg.

 {
     Log(2,"EdbShowAlg_N3::Execute","DOING MAIN SHOWER RECONSTRUCTION HERE");
  
     if (eInBTArrayN==0) {
         Log(2,"EdbShowAlg_N3::Execute","Warning: No InitiatorBTs in the array. Return now");
         return;
     }
  
     // TO BE DONE HERE:
     // FILL THE ROUTINE WITH THE CODE FROM ShowReco PROGRAM
     cout << "EdbShowAlg_N3::Execute()...FILL THE ROUTINE WITH THE CODE FROM ShowReco PROGRAM." << endl;
  
  
     // Create the root file that contains the trainingsfile tree data first,
     // otherwise the trees are not connected with the specified file.
     if (eANN_DoTrain==kTRUE) {
         eANNTrainingsTreeFile = new TFile(Form("N3_ANN_TrainingsTreeFile.root",0),"RECREATE");
     }
  
     // Variables and things important for neural Network:
     TTree *eANNTrainingsTree = new TTree("TreeSignalBackgroundBT", "TreeSignalBackgroundBT");
     eANNTrainingsTree->Branch("N3_Type",   &eANN_Inputtype,   "N3_Type/I");
     eANNTrainingsTree->Branch("N3_Inputvar", eANN_Inputvar, "N3_Inputvar[24]/D");
  
  
  
     EdbSegP* InBT;
     EdbSegP* Segment;
     EdbSegP* seg;
     EdbShowerP* RecoShower;
  
     Bool_t    StillToLoop=kTRUE;
     Int_t     ActualPID;
     Int_t     newActualPID;
     Int_t     STEP=-1;
     Int_t     NLoopedPattern=0;
     if (eFirstPlate_eAliPID-eLastPlate_eAliPID<0) STEP=1;
     if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- STEP for patternloop direction =  " << STEP << endl;
  
  
     Double_t params[30]; // Used for ANN Evaluation  // TO BE ADAPTED!!!
  
     //--- Loop over InBTs:
     cout << "Loop over InBTs N=" << eInBTArrayN << endl;
  
     // Since eInBTArray is filled in ascending ordering by zpositon
     // We use the descending loop to begin with BT with lowest z first.
     for (Int_t i=eInBTArrayN-1; i>=0; --i) {
  
         // CounterOutPut
         if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << eInBTArrayN <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
  
         //-----------------------------------
         // 0a) Reset characteristic variables:
         //-----------------------------------
  
         //-----------------------------------
         // 1) Make eAli with cut parameters:
         //-----------------------------------
  
         // Create new EdbShowerP Object for storage;
         // See EdbShowerP why I have to call the Constructor as "unique" ideficable value
         //RecoShower = new EdbShowerP(i,eAlgValue);
         RecoShower = new EdbShowerP(i,eAlgValue,-1);
  
         // Get InitiatorBT from eInBTArray
         InBT=(EdbSegP*)eInBTArray->At(i);
         if (gEDBDEBUGLEVEL>2) InBT->PrintNice();
  
         // Clone InBT, because it is modified a lot of times,
         // avoid rounding errors by propagating back and forth
         EdbSegP* InBTClone = (EdbSegP*)InBT->Clone();
  
         // Add InBT to RecoShower:
         // This has to be done, since by definition the first BT in the RecoShower is the InBT.
         // Otherwise, also the definition of shower axis and transversal profiles is wrong!
         RecoShower -> AddSegment(InBT);
         cout << "Segment  (InBT) " << InBT << " was added to RecoShower." <<  endl;
  
         // Transform (make size smaller, extract only events having same MC) the  eAli  object:
         // See in Execute_CA for description.
         // Transform_eAli(InBT,1400);
         Transform_eAli(InBT,2400);
  
         //-----------------------------------
         // 2) Loop over (whole) eAli, check BT for Cuts
         //-----------------------------------
         ActualPID= InBT->PID() ;
         newActualPID= InBT->PID() ;
  
         while (StillToLoop) {
             if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- --- Doing patterloop " << ActualPID << endl;
  
             // just to adapt to this nomenclature of ShowRec program:
             int patterloop_cnt=ActualPID;
  
             for (Int_t btloop_cnt=0; btloop_cnt<eAli->GetPattern(ActualPID)->GetN(); ++btloop_cnt) {
  
                 Segment = (EdbSegP*)eAli->GetPattern(ActualPID)->GetSegment(btloop_cnt);
  
                 // just to adapt to this nomenclature of ShowRec program
                 seg=Segment;
  
                 if (gEDBDEBUGLEVEL>4) Segment->PrintNice();
  
                 // Reset characteristic variables:
                 for (Int_t loop=0; loop<24; ++loop) eANN_Inputvar[loop]=0;
  
                 // Now    calculate NN Inputvariables:  --------------------
                 // Calculate the first four inputvariables, which depend on InitiatorBT only:
                 // Important: dT, dMindist is symmetric, dR is NOT!
                 // Do propagation from InBT to seg! (i.e. to downstream segments)
                 // Loose PreCuts, in order not to get too much BG BT into trainings sample
                 eANN_Inputvar[0] = seg->Z()-InBT->Z();
                 // Update: It is better to use DistToAxis instead of dR, since dR measures
                 // only distance to InBT without taking care of the direction.
                 // (does not matter for relatively straight tracks, but for tracks in direction)
                 //eANN_Inputvar[1] = GetDistToAxis(InBTClone, seg);
                 cout << "// TO BE CHECKED WHERE THE FUNCTION GetDistToAxis(InBTClone, seg);  IS!!" << endl;
                 // TO BE CHECKED WHERE THE FUNCTION GetDistToAxis(InBTClone, seg);  IS!!
                 if (eANN_DoTrain==kTRUE && eANN_Inputvar[1] > 1200) continue;
  
                 //eANN_Inputvar[2] = GetdeltaThetaSingleAngles(InBT, seg);
                 // TO BE CHECKED WHERE THE FUNCTION GetdeltaThetaSingleAngles(InBT, seg);  IS!!
                 cout << "// TO BE CHECKED WHERE THE FUNCTION GetdeltaThetaSingleAngles(InBT, seg);  IS!!" << endl;
                 if (eANN_DoTrain==kTRUE && eANN_Inputvar[2] >  0.4) continue;
  
                 //eANN_Inputvar[3] = GetdMinDist(InBT, seg);
                 // TO BE CHECKED WHERE THE FUNCTION GetdMinDist(InBT, seg);  IS!!
                 cout << "// TO BE CHECKED WHERE THE FUNCTION GetdMinDist(InBT, seg);  IS!!" << endl;
                 if (eANN_DoTrain==kTRUE && eANN_Inputvar[3] >  800) continue;
                 // 1)
                 // 2) .... // 24)
                 // TO BE FILLED WITH THE CODE FROM    SHOWREC   PROGRAMM
                 // end of calculate NN Inputvariables:  --------------------
  
                 // ---------------------------------------------------------
                 // Calculate eANN Output now:
                 eANN_OutputValue=0;
                 // Adapt: array params should have as many entries as there are inputvariables.
                 // This array is larger than possible used array for evaluation.
                 // The array with the right size is created, when the eANN_INPUTNEURONS
                 // variable is fixed (TMLP class demands #arraysize = #inputneurons)
                 // This is a kind of dump workaround, but for now it should work.
                 Double_t EvalValue=0;
                 Double_t    N3_Evalvar4[4];
                 Double_t    N3_Evalvar8[8];
                 Double_t    N3_Evalvar12[12];
                 Double_t    N3_Evalvar16[16];
                 Double_t    N3_Evalvar20[20];
                 Double_t    N3_Evalvar24[24];
  
                 if (eANN_INPUTNEURONS==4) {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar4[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar4);
                 }
                 else if (eANN_INPUTNEURONS==8) {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar8[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar8);
                 }
                 else if (eANN_INPUTNEURONS==12) {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar12[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar12);
                 }
                 else if (eANN_INPUTNEURONS== 16) {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar16[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar16);
                 }
                 else if (eANN_INPUTNEURONS==20) {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar20[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar20);
                 }
                 else {
                     for (int k=0; k<eANN_INPUTNEURONS; ++k) N3_Evalvar24[k]= eANN_Inputvar[k];
                     eANN_OutputValue=eTMlpANN->Evaluate(0,N3_Evalvar24);
                 }
                 // ---------------------------------------------------------
  
  
                 // Now apply cut conditions: NN Neural Network Alg --------------------
                 Double_t value=0;
  
                 // These conditions have to be calculated, still!!!
                 cout << "TO BE DONE" << endl;
  
                 value=eTMlpANN->Evaluate(0, params);
                 if (gEDBDEBUGLEVEL>3) {
                     cout << "eANN_OutputValue: " << eANN_OutputValue << " Inputvalues: ";
                     for (int i=0; i<5; i++) cout << "  " << eANN_Inputvar[i];
                 }
                 if (eANN_OutputValue<eParaValue[1]) continue;
                 // end of    cut conditions: NN Neural Network Alg --------------------
  
  
  
                 // If we arrive here, Basetrack  Segment  has passed criteria
                 // and is then added to the RecoShower:
                 // Check if its not the InBT which is already added:
                 if (Segment->X()==InBT->X()&&Segment->Y()==InBT->Y()) {
                     ;    // is InBT, do nothing;
                 }
                 else {
                     RecoShower -> AddSegment(Segment);
                 }
                 cout << "Segment  " << Segment << " was added to &RecoShower  : " << &RecoShower  <<  endl;
             } // of btloop_cnt
  
             //------------
             newActualPID=ActualPID+STEP;
             ++NLoopedPattern;
  
             if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- --- newActualPID= " << newActualPID << endl;
             if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- --- NLoopedPattern= " << NLoopedPattern << endl;
             if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- --- eNumberPlate_eAliPID= " << eNumberPlate_eAliPID << endl;
             if (gEDBDEBUGLEVEL>3) cout << "EdbShowAlg_N3::Execute--- --- StillToLoop= " << StillToLoop << endl;
  
             // This if holds in the case of STEP== +1
             if (STEP==1) {
                 if (newActualPID>eLastPlate_eAliPID) StillToLoop=kFALSE;
                 if (newActualPID>eLastPlate_eAliPID) cout << "EdbShowAlg_N3::Execute--- ---Stopp Loop since: newActualPID>eLastPlate_eAliPID"<<endl;
             }
             // This if holds in the case of STEP== -1
             if (STEP==-1) {
                 if (newActualPID<eLastPlate_eAliPID) StillToLoop=kFALSE;
                 if (newActualPID<eLastPlate_eAliPID) cout << "EdbShowAlg_N3::Execute--- ---Stopp Loop since: newActualPID<eLastPlate_eAliPID"<<endl;
             }
             // This if holds  general, since eNumberPlate_eAliPID is not dependent of the structure of the gAli subject:
             if (NLoopedPattern>eNumberPlate_eAliPID) StillToLoop=kFALSE;
             if (NLoopedPattern>eNumberPlate_eAliPID) cout << "EdbShowAlg_N3::Execute--- ---Stopp Loop since: NLoopedPattern>eNumberPlate_eAliPID"<<endl;
  
             ActualPID=newActualPID;
         } // of // while (StillToLoop)
  
         // Obligatory when Shower Reconstruction is finished!
         RecoShower ->Update();
         //RecoShower ->PrintBasics();
  
  
         // Add Shower Object to Shower Reco Array.
         // Not, if its empty:
         // Not, if its containing only one BT:
         if (RecoShower->N()>1) eRecoShowerArray->Add(RecoShower);
  
         // Set back loop values:
         StillToLoop=kTRUE;
         NLoopedPattern=0;
     } // of  //   for (Int_t i=eInBTArrayN-1; i>=0; --i) {
  
  
     // Set new value for  eRecoShowerArrayN  (may now be < eInBTArrayN).
     SetRecoShowerArrayN(eRecoShowerArray->GetEntries());
  
     Log(2,"EdbShowAlg_N3::Execute","eRecoShowerArray():Entries = %d",eRecoShowerArray->GetEntries());
     Log(2,"EdbShowAlg_N3::Execute","DOING MAIN SHOWER RECONSTRUCTION HERE...done.");
     return;
 }

◆ Finalize()

void EdbShowAlg_N3::Finalize ( )

virtual

Reimplemented from EdbShowAlg.

 {
     Log(2,"EdbShowAlg_N3::Finalize","Finalize()");
     cout << "TO BE DONE HERE:  DELETE THE UNNECESSARY OBJECTS CREATED ON THE HEAP..." << endl;
     return;
 }

◆ GetWeightFileString()

TString EdbShowAlg_N3::GetWeightFileString ( )

inline

                                           {
         return eWeightFileString;
     }

◆ Init()

void EdbShowAlg_N3::Init ( void )

 {
     Log(2,"EdbShowAlg_N3::EdbShowAlg_N3","Init()");
  
     Log(2,"EdbShowAlg_N3::EdbShowAlg_N3","Init with values according to N3 Alg   TO BE CHECKED !!");
     // Init with values according to N3 Alg:
     // TO BE CHECKED !!
     // Structure should be equal to the one in file:
     // PARAMETERSET_DEFINITIONFILE_N3_ALG.root
     eParaValue[0]=5;
     eParaString[0]="ANN_PLATE_DELTANMAX";
     eParaValue[1]=100;
     eParaString[1]="ANN_NTRAINEPOCHS";
     eParaValue[2]=7;
     eParaString[2]="ANN_NHIDDENLAYER";
     eParaValue[3]=0.8;
     eParaString[3]="ANN_OUTPUTTHRESHOLD";
     eParaValue[4]=0;
     eParaString[4]="ANN_EQUALIZESGBG";
     eParaValue[5]=24;
     eParaString[5]="N3_ANN_INPUTNEURONS";
  
     cout << "DEBUG::AGAIN, WHERE ARE THE ePARAVALUES SET???????"  << endl;
  
     eWeightFileString="weightsN3.txt";
     eWeightFileLayoutString="layoutN3";
  
     // Create Tree where the Variables for the N3 Neural Net are stored:
     CreateANNTree();
     eTMlpANN = Create_NN_ALG_MLP(eANNTree, eParaValue[5]);
  
     // Standard Weights:
     SetANNWeightString();
     LoadANNWeights();
  
     return;
 }

◆ Initialize()

void EdbShowAlg_N3::Initialize ( )

virtual

Reimplemented from EdbShowAlg.

 {
     Log(2,"EdbShowAlg_N3::EdbShowAlg_N3","Initialize()");
     return;
 }

◆ LoadANNWeights() [1/2]

void EdbShowAlg_N3::LoadANNWeights ( )

 {
     if (eWeightFileString=="") {
         cout <<  "EdbShowAlg_N3::SetANNWeightString  IS EMPTY. Reset to default string!"  << endl;
         eWeightFileString="WEIGHTFILESTRING_N3.txt";
     }
     eTMlpANN->LoadWeights(eWeightFileString);
     return;
 }

◆ LoadANNWeights() [2/2]

void EdbShowAlg_N3::LoadANNWeights	(	TMultiLayerPerceptron *	TMlpANN,
		TString	WeightFileString
	)

 {
     TMlpANN->LoadWeights(WeightFileString);
     if (gEDBDEBUGLEVEL>2) cout <<  "EdbShowAlg_N3::LoadANNWeights   "  << WeightFileString << endl;
     return;
 }

◆ Print()

void EdbShowAlg_N3::Print ( )

 {
     Log(2,"EdbShowAlg_N3::Print","Print()");
  
     cout << "Number of Inputvariables: " << eParaValue[5] << endl;
     cout << "Algorithm method related inputs:" << endl;
     cout << "eANN_PLATE_DELTANMAX " << eParaValue[0] << endl;
     cout << "eANN_NTRAINEPOCHS " << eParaValue[1] << endl;
     cout << "eANN_NHIDDENLAYER " << eParaValue[2] << endl;
     cout << "eANN_OUTPUTTHRESHOLD " << eParaValue[3] << endl;
     cout << "eANN_EQUALIZESGBG " << eParaValue[4] << endl;
  
     cout << "Structure of the Net:" << endl;
     cout << eLayout.Data() << endl;
  
     Log(2,"EdbShowAlg_N3::Print","Print()...done.");
     return;
 }

◆ SetANNWeightString()

void EdbShowAlg_N3::SetANNWeightString ( )

 {
     Log(2,"EdbShowAlg_N3::SetANNWeightString","SetANNWeightString()");
     int inputneurons=eParaValue[5];
     if (inputneurons==5)  eWeightFileString="WEIGHTFILESTRING_N3.txt";
     // TO DO HERE.... TAKE OVER THE CORRECT WEIGHTFILE STRING.
     cout << "EdbShowAlg_N3::SetANNWeightString()   TO DO HERE.... TAKE OVER THE CORRECT WEIGHTFILE STRING. " << endl;
  
 //     if (gEDBDEBUGLEVEL>2)
     cout <<  "EdbShowAlg_N3::SetANNWeightString   "  << eWeightFileString << endl;
     Log(2,"EdbShowAlg_N3::SetANNWeightString","SetANNWeightString()...done.");
     return;
 }

◆ SetWeightFileString()

void EdbShowAlg_N3::SetWeightFileString ( TString WeightFileString )

inline

                                                                {
         eWeightFileString=WeightFileString;
         return;
     }

Member Data Documentation

◆ eANN_DoTrain

Bool_t EdbShowAlg_N3::eANN_DoTrain =kTRUE

private

◆ eANN_EQUALIZESGBG

Int_t EdbShowAlg_N3::eANN_EQUALIZESGBG

private

◆ eANN_INPUTNEURONS

Int_t EdbShowAlg_N3::eANN_INPUTNEURONS

private

◆ eANN_Inputtype

Int_t EdbShowAlg_N3::eANN_Inputtype

private

◆ eANN_Inputvar

Double_t EdbShowAlg_N3::eANN_Inputvar[24]

private

◆ eANN_NHIDDENLAYER

Int_t EdbShowAlg_N3::eANN_NHIDDENLAYER

private

◆ eANN_NTRAINEPOCHS

Int_t EdbShowAlg_N3::eANN_NTRAINEPOCHS

private

◆ eANN_OUTPUTTHRESHOLD

Double_t EdbShowAlg_N3::eANN_OUTPUTTHRESHOLD

private

◆ eANN_OutputValue

Double_t EdbShowAlg_N3::eANN_OutputValue =0

private

◆ eANN_PLATE_DELTANMAX

Int_t EdbShowAlg_N3::eANN_PLATE_DELTANMAX

private

◆ eANNTrainingsTreeFile

TFile* EdbShowAlg_N3::eANNTrainingsTreeFile

private

◆ eANNTree

TTree* EdbShowAlg_N3::eANNTree

private

◆ eLayout

TString EdbShowAlg_N3::eLayout

◆ eTMlpANN

TMultiLayerPerceptron* EdbShowAlg_N3::eTMlpANN

private

◆ eWeightFileLayoutString

TString EdbShowAlg_N3::eWeightFileLayoutString

private

◆ eWeightFileString

TString EdbShowAlg_N3::eWeightFileString

private

The documentation for this class was generated from the following files:

src/libShowRec/EdbShowAlg_NN.h
src/libShowRec/EdbShowAlg_NN.cxx

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ EdbShowAlg_N3()

◆ ~EdbShowAlg_N3()

Member Function Documentation

◆ ClassDef()

◆ Create_NN_ALG_MLP()

◆ CreateANNTree()

◆ Execute()

◆ Finalize()

◆ GetWeightFileString()

◆ Init()

◆ Initialize()

◆ LoadANNWeights() [1/2]

◆ LoadANNWeights() [2/2]

◆ Print()

◆ SetANNWeightString()

◆ SetWeightFileString()

Member Data Documentation

◆ eANN_DoTrain

◆ eANN_EQUALIZESGBG

◆ eANN_INPUTNEURONS

◆ eANN_Inputtype

◆ eANN_Inputvar

◆ eANN_NHIDDENLAYER

◆ eANN_NTRAINEPOCHS

◆ eANN_OUTPUTTHRESHOLD

◆ eANN_OutputValue

◆ eANN_PLATE_DELTANMAX

◆ eANNTrainingsTreeFile

◆ eANNTree

◆ eLayout

◆ eTMlpANN

◆ eWeightFileLayoutString

◆ eWeightFileString