]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - EMCAL/AliCaloRawAnalyzerNN.cxx
Fix Coverity
[u/mrichter/AliRoot.git] / EMCAL / AliCaloRawAnalyzerNN.cxx
index 997bd0dafe22c9aa7355924f6cf172c7177ca989..69825b6e0aa021198417e3163679be5efd1d9d72 100644 (file)
 #include "AliCaloNeuralFit.h"
 #include "AliCaloFitResults.h"
 #include "AliCaloBunchInfo.h"
-
 #include <iostream>
-
 using namespace std;
 
+#include "AliCaloConstants.h"
+
 ClassImp( AliCaloRawAnalyzerNN )
 
-AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network"), fNeuralNet(0)
+AliCaloRawAnalyzerNN::AliCaloRawAnalyzerNN() : AliCaloRawAnalyzer("Neural Network", "NN"), fNeuralNet(0)
 {
   // Comment
+  fAlgo=Algo::kNeuralNet;
 
   fNeuralNet = new AliCaloNeuralFit();
 
@@ -62,93 +63,77 @@ AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector,
   // The eveluation of  Peak position and amplitude using the Neural Network
   if( bunchvector.size()  <=  0 )
     {
-      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+      //  cout << __FILE__ << __LINE__<< " INVALID "<< endl;
+
+      return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
     } 
  
-  short maxindex;
+  short maxampindex;
   short maxamp;
 
-  int bindex = SelectBunch( bunchvector, &maxindex , &maxamp ) ;
+  int index = SelectBunch( bunchvector, &maxampindex , &maxamp ) ;
   
-  if( bindex   < 0 )
+  if( index   < 0 )
     {
-      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+      //  cout << __FILE__ << __LINE__<< "INVALID !!!!!!" << endl;
+      return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
     }
   
-  int first = 0;
-  int last = 0;
-  Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( bindex ) )  ,  altrocfg1, altrocfg2, fReversed  );
-  
-  //  SelectSubarray ( fReversed,  bunchvector.at(bindex).GetLength(), &first, &last );
-  
-  short maxrev = maxindex  -  bunchvector.at(bindex).GetStartBin();
+  Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( index ) )  ,  altrocfg1, altrocfg2, fReversed  );  
+  short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
+  double maxf =  maxamp - ped;
 
-  
-  SelectSubarray( fReversed,  bunchvector.at(bindex).GetLength(),  maxrev , &first, &last);
+  if(  maxf < fAmpCut  ||  ( maxamp - ped) > fOverflowCut  ) // (maxamp - ped) > fOverflowCut = Close to saturation (use low gain then)
+    {
+      //   cout << __FILE__ << __LINE__<< ":  timebinOffset = " <<  timebinOffset  << "  maxf "<< maxf  << endl; 
+      return  AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset);
+    }
 
-  //  cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " << maxindex << ", first = " << first << ", last = " << last << endl;
-  // cout << __FILE__ << __LINE__ << ":" << fName << ", maxindex = " <<  maxrev    << ", first = " << first << ", last = " << last << endl;
-  
+  int first = 0;
+  int last = 0; 
+  short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
+  SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev , &first, &last, fFitArrayCut );
+
+  Float_t chi2 = 0;
+  Int_t ndf = 0;
   if(maxrev  < 1000 )
     {
       if (  ( maxrev   - first) < 2  &&  (last -   maxrev ) < 2)
        {
-         return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+         chi2 = CalculateChi2(maxf, maxrev, first, last);
+         ndf = last - first - 1; // nsamples - 2
+         //      cout << __FILE__ << __LINE__<< ":  timebinOffset = " <<  timebinOffset << "  maxf\t"<< maxf <<endl;
+         return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
+                                   timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) ); 
        }
       else
        {
-         /*
-         cout << __FILE__ << __LINE__ << "!!!!!!!!:\t" << fReversed[maxrev -2 ]<< "\t" <<  
-           fReversed[ maxrev  -1 ] << "\t" <<  fReversed[maxrev  ]  <<   "\t" <<
-           fReversed[ maxrev  +1 ] << "\t" <<  fReversed[maxrev +2]  << endl;
-         */
 
          for(int i=0; i < 5 ; i++)
            {
              fNNInput[i]  = fReversed[maxrev-2 +i]/(maxamp -ped);
            } 
 
-         
-
-         //      double amp = fNeuralNet->Value( 0,  fReversed[maxrev-2], fReversed[maxrev -1],  fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
-         //  double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2], fReversed[maxrev -1],  fReversed[maxrev], fReversed[maxrev+1], fReversed[maxrev+2]);
-         
-         //      double amp = fNeuralNet->Value( 0,  fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
-         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev+2]/maxamp, fReversed[maxrev +1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev-1]/maxamp, fReversed[maxrev-2]/maxamp);
-         
-         //      double amp = maxamp*fNeuralNet->Value( 0,  fReversed[maxrev-2]/(maxamp -ped), fReversed[maxrev -1]/(maxamp -ped),  fReversed[maxrev]/(maxamp-ped), fReversed[maxrev+1]/(maxamp -ped), fReversed[maxrev+2]/(maxamp-ped));
-         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp); 
-        
-
-         //      double amp = maxamp*fNeuralNet->Value( 0,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
-         //      double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + maxrev )*256 ;
-         
+                 
          double amp = (maxamp - ped)*fNeuralNet->Value( 0,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]);
-         double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + maxrev ) ;
-
-
-         //      double tof = fNeuralNet->Value( 1,  fReversed[maxrev-2]/maxamp, fReversed[maxrev -1]/maxamp,  fReversed[maxrev]/maxamp, fReversed[maxrev+1]/maxamp, fReversed[maxrev+2]/maxamp);  
+         double tof = (fNeuralNet->Value( 1,  fNNInput[0],  fNNInput[1], fNNInput[2], fNNInput[3], fNNInput[4]) + timebinOffset ) ;
 
-         return AliCaloFitResults( maxamp, ped , -1, amp , tof, -2, -3 ); 
+         // use local-array time for chi2 estimate
+         chi2 = CalculateChi2(amp, tof-timebinOffset+maxrev, first, last);
+         ndf = last - first - 1; // nsamples - 2
+         //cout << __FILE__ << __LINE__<< ":  tof = " <<  tof << "   amp" << amp <<endl;
+         return AliCaloFitResults( maxamp, ped , Ret::kFitPar, amp , tof, timebinOffset, chi2, ndf,
+                                   Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
 
        }
     }
-  return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
-}
-
-//amp = exportNN.Value(0,input[0],input[1],input[2],input[3],input[4])*(globMaxSig - pedEstimate);
-//time = (exportNN.Value(1,input[0],input[1],input[2],input[3],input[4])+globMaxId) * fgTimeBins;
-
-
-
-//SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxampindex -  bunchvector.at(index).GetStartBin(), &first, &last);
+  chi2 = CalculateChi2(maxf, maxrev, first, last);
+  ndf = last - first - 1; // nsamples - 2
+  
+  // cout << __FILE__ << __LINE__<< ":  timebinOffset = " << timebinOffset <<  "   maxf ="<< maxf  << endl;
+  return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
+                           timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) ); 
 
+}
 
-/*
-void 
-AliCaloRawAnalyzerNN::SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const  first, int *const last ) const
-{
 
-}
-*/