EMCAL/AliCaloRawAnalyzerNN.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the Experimental Nuclear     *
   3  * Physics Group, Dep. of Physics                                         *
   4  * University of Oslo, Norway, 2007                                       *
   5  *                                                                        *
   6  * Author: Per Thomas Hille <perthomas.hille@yale.edu>                    *
   7  * for the ALICE HLT Project.                                             *
   8  * Contributors are mentioned in the code where appropriate.              *
   9  * Please report bugs to perthi@fys.uio.no                                *
  10  *                                                                        *
  11  * Permission to use, copy, modify and distribute this software and its   *
  12  * documentation strictly for non-commercial purposes is hereby granted   *
  13  * without fee, provided that the above copyright notice appears in all   *
  14  * copies and that both the copyright notice and this permission notice   *
  15  * appear in the supporting documentation. The authors make no claims     *
  16  * about the suitability of this software for any purpose. It is          *
  17  * provided "as is" without express or implied warranty.                  *
  18  **************************************************************************/
  19
  20 // Evaluation of peak position
  21 // and amplitude using Neural Networks (NN)
  22 // ------------------
  23 // ------------------
  24 // ------------------
  25
  26
  27 #include "AliCaloRawAnalyzerNN.h"
  28 #include "AliCaloNeuralFit.h"
  29 #include "AliCaloFitResults.h"
  30 #include "AliCaloBunchInfo.h"
  31
  32 #include <iostream>
  33
  34 using namespace std;
  35
  36 ClassImp( AliCaloRawAnalyzerNN )
  37
  38 AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network", "NN"), fNeuralNet(0)
  39 {
  40   // Comment
  41
  42   fNeuralNet = new AliCaloNeuralFit();
  43
  44   for(int i=0; i < 5 ; i++)
  45     {
  46       fNNInput[i]  = 0;
  47     }
  48
  49 }
  50
  51
  52 AliCaloRawAnalyzerNN::~AliCaloRawAnalyzerNN()
  53 {
  54   delete fNeuralNet;
  55 }
  56
  57
  58 AliCaloFitResults
  59 AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector,
  60                                        const UInt_t altrocfg1,  const UInt_t altrocfg2 )
  61 {
  62   // The eveluation of  Peak position and amplitude using the Neural Network
  63   if( bunchvector.size()  <=  0 )
  64     {
  65       return AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid);
  66     }
  67
  68   short maxampindex;
  69   short maxamp;
  70
  71   int index = SelectBunch( bunchvector, &maxampindex , &maxamp ) ;
  72
  73   if( index   < 0 )
  74     {
  75       return AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid);
  76     }
  77
  78   Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( index ) )  ,  altrocfg1, altrocfg2, fReversed  );
  79   short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
  80   double maxf =  maxamp - ped;
  81
  82   if(  maxf < fAmpCut  ||  ( maxamp - ped) > fOverflowCut  ) // (maxamp - ped) > fOverflowCut = Close to saturation (use low gain then)
  83     {
  84       return  AliCaloFitResults( maxamp, ped, AliCaloFitResults::kCrude, maxf, timebinOffset);
  85     }
  86
  87   int first = 0;
  88   int last = 0;
  89   short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
  90   SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev , &first, &last);
  91
  92   Float_t chi2 = 0;
  93   Int_t ndf = 0;
  94   if(maxrev  < 1000 )
  95     {
  96       if (  ( maxrev   - first) < 2  &&  (last -   maxrev ) < 2)
  97         {
  98           chi2 = CalculateChi2(maxf, maxrev, first, last);
  99           ndf = last - first - 1; // nsamples - 2
 100           return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kCrude, maxf, timebinOffset,
 101                                     timebinOffset, chi2, ndf, AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
 102         }
 103       else
 104         {
 105
 106           for(int i=0; i < 5 ; i++)
 107             {
 108               fNNInput[i]  = fReversed[maxrev-2 +i]/(maxamp -ped);
 109             }
 110
 111
 112           double amp = (maxamp - ped)*fNeuralNet->Value( 0,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
 113           double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + timebinOffset ) ;
 114
 115           // use local-array time for chi2 estimate
 116           chi2 = CalculateChi2(amp, tof-timebinOffset+maxrev, first, last);
 117           ndf = last - first - 1; // nsamples - 2
 118           return AliCaloFitResults( maxamp, ped , AliCaloFitResults::kFitPar, amp , tof, timebinOffset, chi2, ndf,
 119                                     AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
 120
 121         }
 122     }
 123   chi2 = CalculateChi2(maxf, maxrev, first, last);
 124   ndf = last - first - 1; // nsamples - 2
 125   return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kCrude, maxf, timebinOffset,
 126                             timebinOffset, chi2, ndf, AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
 127
 128 }
 129
 130