put different cluster parameters (time, n cells, n SM) in the AOD particle, recover...
[u/mrichter/AliRoot.git] / 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 #include <iostream>
32 using namespace std;
33
34 #include "AliCaloConstants.h"
35
36 ClassImp( AliCaloRawAnalyzerNN )
37
38 AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network", "NN"), fNeuralNet(0)
39 {
40   // Ctor
41   
42   fAlgo=Algo::kNeuralNet;
43
44   fNeuralNet = new AliCaloNeuralFit();
45
46   for(int i=0; i < 5 ; i++)
47     {
48       fNNInput[i]  = 0;
49     }
50
51 }
52
53
54 AliCaloRawAnalyzerNN::~AliCaloRawAnalyzerNN()
55 {
56   // Dtor
57   delete fNeuralNet;
58 }
59
60
61 AliCaloFitResults 
62 AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector, 
63                                 UInt_t altrocfg1,  UInt_t altrocfg2 )
64 {
65   // The eveluation of  Peak position and amplitude using the Neural Network
66   if( bunchvector.size()  <=  0 )
67     {
68       //  cout << __FILE__ << __LINE__<< " INVALID "<< endl;
69
70       return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
71     } 
72  
73   short maxampindex;
74   short maxamp;
75
76   int index = SelectBunch( bunchvector, &maxampindex , &maxamp ) ;
77   
78   if( index   < 0 )
79     {
80       //  cout << __FILE__ << __LINE__<< "INVALID !!!!!!" << endl;
81       return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
82     }
83   
84   Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( index ) )  ,  altrocfg1, altrocfg2, fReversed  );  
85   short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
86   double maxf =  maxamp - ped;
87
88   if(  maxf < fAmpCut  ||  ( maxamp - ped) > fOverflowCut  ) // (maxamp - ped) > fOverflowCut = Close to saturation (use low gain then)
89     {
90       //   cout << __FILE__ << __LINE__<< ":  timebinOffset = " <<  timebinOffset  << "  maxf "<< maxf  << endl; 
91       return  AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset);
92     }
93
94   int first = 0;
95   int last = 0; 
96   short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
97   SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev , &first, &last, fFitArrayCut );
98
99   Float_t chi2 = 0;
100   Int_t ndf = 0;
101   if(maxrev  < 1000 )
102     {
103       if (  ( maxrev   - first) < 2  &&  (last -   maxrev ) < 2)
104         {
105           chi2 = CalculateChi2(maxf, maxrev, first, last);
106           ndf = last - first - 1; // nsamples - 2
107           //      cout << __FILE__ << __LINE__<< ":  timebinOffset = " <<  timebinOffset << "  maxf\t"<< maxf <<endl;
108           return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
109                                     timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) ); 
110         }
111       else
112         {
113
114           for(int i=0; i < 5 ; i++)
115             {
116               fNNInput[i]  = fReversed[maxrev-2 +i]/(maxamp -ped);
117             } 
118
119                   
120           double amp = (maxamp - ped)*fNeuralNet->Value( 0,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
121           double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + timebinOffset ) ;
122
123           // use local-array time for chi2 estimate
124           chi2 = CalculateChi2(amp, tof-timebinOffset+maxrev, first, last);
125           ndf = last - first - 1; // nsamples - 2
126           //cout << __FILE__ << __LINE__<< ":  tof = " <<  tof << "   amp" << amp <<endl;
127           return AliCaloFitResults( maxamp, ped , Ret::kFitPar, amp , tof, timebinOffset, chi2, ndf,
128                                     Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
129
130         }
131     }
132   chi2 = CalculateChi2(maxf, maxrev, first, last);
133   ndf = last - first - 1; // nsamples - 2
134   
135   // cout << __FILE__ << __LINE__<< ":  timebinOffset = " << timebinOffset <<  "   maxf ="<< maxf  << endl;
136   return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
137                             timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) ); 
138
139 }
140
141