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

virtual void	Execute ()

virtual void	Finalize ()

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

virtual void	Initialize ()

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:

/home/antonio/fedra_doxygen/src/libShowRec/EdbShowAlg_NN.h
/home/antonio/fedra_doxygen/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