Factorization of the different raw fitting algorithms in EMCAL (Per Thomas)
[u/mrichter/AliRoot.git] / EMCAL / AliCaloRawAnalyzerFastFit.cxx
index e914cf5..f8ba8c8 100644 (file)
@@ -1,3 +1,4 @@
+// -*- mode: c++ -*-
 /**************************************************************************
  * This file is property of and copyright by the Experimental Nuclear     *
  * Physics Group, Dep. of Physics                                         *
 #include "AliCaloFastAltroFitv0.h"
 #include "AliCaloFitResults.h"
 #include "AliCaloBunchInfo.h"
-
+#include "TMath.h"
 #include <iostream>
 
+
 using namespace std;
 
+#include "AliCaloConstants.h"
+//using namespace CaloConstants::FitAlgorithm;
+//using namespace CaloConstants::ReturnCodes;
+
 ClassImp( AliCaloRawAnalyzerFastFit )
 
-AliCaloRawAnalyzerFastFit::AliCaloRawAnalyzerFastFit() : AliCaloRawAnalyzer("Fast Fit (Alexei)")
+AliCaloRawAnalyzerFastFit::AliCaloRawAnalyzerFastFit() : AliCaloRawAnalyzer("Fast Fit (Alexei)", "FF")
 {
   // Comment
+  fAlgo= Algo::kFastFit;
 
   for(int i=0; i <  1008; i++)
     {
@@ -64,56 +71,61 @@ AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector
   if( index >= 0)
     {
       Float_t ped = ReverseAndSubtractPed( &(bunchvector.at(index))  ,  altrocfg1, altrocfg2, fReversed  );
-      int first;
-      int last;
-      int maxrev =  maxampindex -  bunchvector.at(index).GetStartBin();
-
-      double maxf =  maxamp - ped;
+      Float_t maxf = TMath::MaxElement( bunchvector.at(index).GetLength(),  fReversed );
+      short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
 
-      if ( maxf > fAmpCut )
+      if(  maxf < fAmpCut  ||  ( maxamp - ped) > fOverflowCut  ) // (maxamp - ped) > fOverflowCut = Close to saturation (use low gain then)
        {
-         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(), maxrev , &first, &last);
-         int nsamples =  last - first;
+         return  AliCaloFitResults( maxamp, ped, Algo::kCrude, maxf, timebinOffset);
+       }
+      else if ( maxf >= fAmpCut ) // no if statement needed really; keep for readability
+       {
+         int first = 0;
+         int last = 0;
+         int maxrev =  maxampindex -  bunchvector.at(index).GetStartBin();
 
-         //amp  = dAmp;
-         //      time = dTime * GetRawFormatTimeBinWidth();
+         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(), maxrev , &first, &last, fFitArrayCut);
 
-         //      int length =  bunchvector.at(index).GetLength(); 
+         int nsamples =  last - first + 1;
 
          if( ( nsamples  )  >= fNsampleCut )  
            {
              Double_t ordered[1008];
 
-             /*
-             cout << __FILE__ << __LINE__ << "!!!!!!! USING these samples" << endl; 
              for(int i=0; i < nsamples ; i++ )
                {
-                 ordered[i] = fReversed[first + nsamples -i -1];
-                 cout << ordered[i] << "\t" ;
+                 ordered[i] = fReversed[first + i];
                }
-             cout << __FILE__ << __LINE__ << "!!!!!!! Done printing" << endl; 
-             */
 
              Double_t eSignal = 1; // nominal 1 ADC error
              Double_t dAmp = maxf; 
              Double_t eAmp = 0;
-             Double_t dTime = 0;
+             Double_t dTime0 = 0;
              Double_t eTime = 0;
              Double_t chi2 = 0;
-             Double_t fTau = 0.235;
-             
-             //  AliCaloFastAltroFitv0::FastFit(fXAxis, &fReversed[first] , nsamples,
-             //                                     eSignal, fTau, dAmp, eAmp, dTime, eTime, chi2);
+             Double_t dTau = 2.35; // time-bin units
              
              AliCaloFastAltroFitv0::FastFit(fXAxis, ordered , nsamples,
-                                            eSignal, fTau, dAmp, eAmp, dTime, eTime, chi2);
+                                            eSignal, dTau, dAmp, eAmp, dTime0, eTime, chi2);
           
-             // return AliCaloFitResults( maxamp, ped , -1, fAmpA[tmpindex], tof, -2, -3 );  
-             return AliCaloFitResults(maxamp, ped, -1,  dAmp, dTime*100E-9,  -2,  -3 );
+             Double_t dTimeMax = dTime0 + timebinOffset - (maxrev - first) // abs. t0
+               + dTau; // +tau, makes sum tmax
+             return AliCaloFitResults(maxamp, ped, Ret::kFitPar,  dAmp, dTimeMax, timebinOffset, chi2,  Ret::kDummy,
+                                      Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+           } // samplecut
+         else 
+           {
+             Float_t chi2 = CalculateChi2(maxf, maxrev, first, last);
+             Int_t ndf = last - first - 1; // nsamples - 2
+             return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
+                                       timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) ); 
            }
+       } // ampcut
+    } // bunch index    
+
+  return AliCaloFitResults( Ret::kInvalid , Ret::kInvalid );
 
-       }
-    }    
+  //  return AliCaloFitResults( kInvalid , kInvalid, 
+  //                       kInvalid, kInvalid, kInvalid );
   
-  return AliCaloFitResults(9999 , 9999 , 9999,  9999, 9999, 9999, 9999 );
 }