add new class to hold info on bins used in fitting + standardize result return codes...
authordsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 11 Mar 2010 19:27:18 +0000 (19:27 +0000)
committerdsilverm <dsilverm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 11 Mar 2010 19:27:18 +0000 (19:27 +0000)
15 files changed:
EMCAL/AliCaloFitResults.cxx
EMCAL/AliCaloFitResults.h
EMCAL/AliCaloFitSubarray.cxx [new file with mode: 0644]
EMCAL/AliCaloFitSubarray.h [new file with mode: 0644]
EMCAL/AliCaloRawAnalyzer.cxx
EMCAL/AliCaloRawAnalyzer.h
EMCAL/AliCaloRawAnalyzerCrude.cxx
EMCAL/AliCaloRawAnalyzerFastFit.cxx
EMCAL/AliCaloRawAnalyzerLMS.cxx
EMCAL/AliCaloRawAnalyzerLMS.h
EMCAL/AliCaloRawAnalyzerNN.cxx
EMCAL/AliCaloRawAnalyzerPeakFinder.cxx
EMCAL/AliEMCALRawUtils.cxx
EMCAL/EMCALUtilsLinkDef.h
EMCAL/libEMCALUtils.pkg

index 07317e1..2d0348b 100644 (file)
 // The signal was fitted sucessfully. fStatus might have a different meaning If other 
 // procedures than  A different meaning Fitting is applied 
 AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped, 
-                                      const Short_t fitstatus, const Float_t  amp,  
-                                      const Float_t t0,  const Float_t chi,  
-                                      const Int_t ndf, Int_t minSig ) : fMaxSig(maxSig),
-                                                                              fPed(ped), 
-                                                                              fStatus(fitstatus),
-                                                                              fAmpSig(amp),
-                                                                              fT0(t0),
-                                                                              fChi2Sig(chi),
-                                                                              fNdfSig(ndf),
-                                                                              fMinSig(minSig) 
+                                    const Short_t fitstatus, const Float_t  amp,  
+                                    const Float_t t0,  const Float_t chi,  
+                                    const Int_t ndf, Int_t minSig,
+                                    const AliCaloFitSubarray fitSubarray) : 
+  fMaxSig(maxSig),
+  fPed(ped), 
+  fStatus(fitstatus),
+  fAmpSig(amp),
+  fT0(t0),
+  fChi2Sig(chi),
+  fNdfSig(ndf),
+  fMinSig(minSig),
+  fFitSubarray(fitSubarray) 
 {
 }
 
 
+AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped, 
+                                    const Short_t fitstatus, const Float_t  amp,  
+                                    const Float_t t0,  const Float_t chi,  
+                                    const Int_t ndf, Int_t minSig ) : 
+  fMaxSig(maxSig),
+  fPed(ped), 
+  fStatus(fitstatus),
+  fAmpSig(amp),
+  fT0(t0),
+  fChi2Sig(chi),
+  fNdfSig(ndf),
+  fMinSig(minSig),
+  fFitSubarray(kDummy)  
+{
+
+}
 
 
-AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Int_t minSig) : fMaxSig(maxSig),
-                                                                                      fPed(-98),
-                                                                                      fStatus( -1 ),
-                                                                                      fAmpSig( -1 ), 
-                                                                                      fT0(-99),  
-                                                                                      fChi2Sig( -1 ),
-                                                                                      fNdfSig( -1),
-                                                                                      fMinSig (minSig)
+
+
+AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Int_t minSig) : 
+  fMaxSig(maxSig),
+  fPed(kNoFit),
+  fStatus( kNoFit ),
+  fAmpSig( kNoFit ), 
+  fT0(kNoFit),  
+  fChi2Sig( kNoFit ),
+  fNdfSig( kNoFit),
+  fMinSig (minSig),
+  fFitSubarray(kNoFit)  
 {
-  
+
 }
 
 
index 38378c2..bd141bf 100644 (file)
 
 #include "Rtypes.h"
 
+#include "AliCaloFitSubarray.h"
+
 // Container class to hold results from fitting 
 // as well as other methods for
 // raw data signals extraction
 class  AliCaloFitResults
 {
  public:
+  enum kReturnCode {kDummy=-1, kCrude=-9, kNoFit=-99, kInvalid=-9999};// possible return values
+
+  explicit AliCaloFitResults( const Int_t maxSig, 
+                             const Float_t ped, 
+                             const Short_t fitStatus, 
+                             const Float_t  amp, 
+                             const Float_t t0,
+                             const Float_t chi, 
+                             const Int_t ndf, 
+                             const Int_t minSig, 
+                             const AliCaloFitSubarray fitSubarray); 
+
   explicit AliCaloFitResults( const Int_t maxSig, 
                              const Float_t ped, 
                              const Short_t fitStatus, 
@@ -35,7 +49,7 @@ class  AliCaloFitResults
                              const Float_t t0,
                              const Float_t chi, 
                              const Int_t ndf, 
-                             const Int_t minSig = -99); 
+                             const Int_t minSig = kDummy); 
 
   explicit AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
   //AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
@@ -50,6 +64,7 @@ class  AliCaloFitResults
   Float_t   GetTof() const {  return fT0; }; 
   Float_t   GetChisSquare() const { return fChi2Sig;};
   Int_t  GetNdf() const { return fNdfSig; };
+  AliCaloFitSubarray  GetFitSubarray() const { return fFitSubarray; };
   
  private:
   AliCaloFitResults();
@@ -61,6 +76,7 @@ class  AliCaloFitResults
   Float_t    fChi2Sig;  //Chi Square of fit 
   Int_t   fNdfSig;   //Number of degrees of freedom of fit
   Int_t   fMinSig;   //Pedestal 
+  AliCaloFitSubarray fFitSubarray; // info on time-bin array used for the fitting
 };
 
 #endif
diff --git a/EMCAL/AliCaloFitSubarray.cxx b/EMCAL/AliCaloFitSubarray.cxx
new file mode 100644 (file)
index 0000000..bf75654
--- /dev/null
@@ -0,0 +1,60 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id: $ */
+
+#include "AliCaloFitSubarray.h"
+
+
+// Container class to hold info from bunches/samples
+// selected for signal fitting.
+// Variables are:
+//  Int_t   fBunchIndex;  // Index for selected bunch
+//  Int_t   fMaxRev;      // Max index in reversed array
+//  Int_t   fFirst;   // first index in array used for fit
+//  Int_t   fLast;    // last index in array used for fit
+
+AliCaloFitSubarray::AliCaloFitSubarray(const Int_t bunchIndex, 
+                                      const Int_t maxrev, 
+                                      const Int_t first, 
+                                      const Int_t last ) : 
+  fBunchIndex(bunchIndex),
+  fMaxRev(maxrev), 
+  fFirst(first), 
+  fLast(last)   
+{
+}
+
+AliCaloFitSubarray::AliCaloFitSubarray(const AliCaloFitSubarray & fitS) :
+  fBunchIndex( fitS.fBunchIndex ),
+  fMaxRev( fitS.fMaxRev ), 
+  fFirst( fitS.fFirst ), 
+  fLast( fitS.fLast )   
+{
+}
+
+AliCaloFitSubarray::AliCaloFitSubarray(const Int_t init) : 
+  fBunchIndex(init),
+  fMaxRev(init), 
+  fFirst(init), 
+  fLast(init)   
+{
+}
+
+
+AliCaloFitSubarray::~AliCaloFitSubarray()
+{
+}
+
diff --git a/EMCAL/AliCaloFitSubarray.h b/EMCAL/AliCaloFitSubarray.h
new file mode 100644 (file)
index 0000000..ccf6a60
--- /dev/null
@@ -0,0 +1,51 @@
+#ifndef ALICALOFITSUBARRAY_H
+#define ALICALOFITSUBARRAY_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: $ */
+
+#include "Rtypes.h"
+
+// Container class to hold info from bunches/samples
+// selected for signal fitting.
+// Variables are:
+//  Int_t   fBunchIndex;  // Index for selected bunch
+//  Int_t   fMaxRev;      // Max index in reversed array
+//  Int_t   fFirst;   // first index in array used for fit
+//  Int_t   fLast;    // last index in array used for fit
+
+class  AliCaloFitSubarray
+{
+ public:
+  explicit AliCaloFitSubarray( const Int_t bunchIndex, 
+                              const Int_t maxrev, 
+                              const Int_t first, 
+                              const Int_t last ); 
+
+  explicit AliCaloFitSubarray(const Int_t init);
+
+  AliCaloFitSubarray(const AliCaloFitSubarray &fitSubarray);
+
+  virtual  ~AliCaloFitSubarray();
+
+  void SetBunchIndex(Int_t i) { fBunchIndex = i;};
+  void SetMaxRev(Int_t i) { fMaxRev = i;};
+  void SetFirst(Int_t i) { fFirst = i; };
+  void SetLast(Int_t i) { fLast = i; };
+  
+  Int_t GetBunchIndex() const  { return fBunchIndex;};
+  Int_t GetMaxRev() const { return fMaxRev;};
+  Int_t GetFirst() const { return fFirst; };
+  Int_t GetLast() const { return fLast; };
+  
+ private:
+
+  Int_t   fBunchIndex;  // Index for selected bunch
+  Int_t   fMaxRev;      // Max index in reversed array
+  Int_t   fFirst;   // first index in array used for fit
+  Int_t   fLast;    // last index in array used for fit
+};
+
+#endif
index cefad88..4dbd2c6 100644 (file)
@@ -40,6 +40,7 @@ AliCaloRawAnalyzer::AliCaloRawAnalyzer(const char *name, const char *nameshort)
                                                                                   fFitArrayCut(5),
                                                                                   fAmpCut(4),
                                                                                   fNsampleCut(5),
+                                                                                  fNsamplePed(3),
                                                                                   fIsZerosupressed( false ),
                                                                                   fVerbose( false )
 {
@@ -106,13 +107,22 @@ AliCaloRawAnalyzer::SelectSubarray( const Double_t *fData, const int length, con
       tmpfirst -- ;
     }
   
-  while(( tmplast ) <  length   && ( fData [tmplast] >  fFitArrayCut ))
+  while(( tmplast ) <  (length-1)   && ( fData [tmplast] >  fFitArrayCut ))
     {
       tmplast ++;
     }
-  
+
+
   *first = tmpfirst +1;
   *last =  tmplast -1;
+
+  int nsamples = *last - *first + 1;
+  if (nsamples < fNsampleCut) {
+    // keep edge bins (below threshold) also, for low # of samples case    
+    *first = tmpfirst;
+    *last =  tmplast; 
+  }
+
 }
 
 
@@ -145,16 +155,14 @@ AliCaloRawAnalyzer::EvaluatePedestal(const UShort_t * const data, const int /*le
 
   if( fIsZerosupressed == false ) 
     {
-      for(int i=0; i < 5; i++ )
+      for(int i=0; i < fNsamplePed; i++ )
        {
          tmp += data[i];
        }
-    }
+   }
 
-  //  cout << __FILE__ << __LINE__ << "XXXXXXXXXXX returning " <<   tmp/5 << endl;
-
-  return  tmp/5;
-}
+  return  tmp/fNsamplePed;
+ }
 
 
 short  
@@ -269,9 +277,10 @@ AliCaloRawAnalyzer::Evaluate( const vector<AliCaloBunchInfo>  &/*bunchvector*/,
 
 
 int
-AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, Float_t & maxf, short & maxamp, short & maxampindex, Float_t & ped, int & first, int & last)
+AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2, Int_t & index, Float_t & maxf, short & maxamp, short & maxrev, Float_t & ped, int & first, int & last)
 { // method to do the selection of what should possibly be fitted
   int nsamples  = 0;
+  short maxampindex = 0;
   index = SelectBunch( bunchvector,  &maxampindex,  &maxamp ); // select the bunch with the highest amplitude unless any time constraints is set
 
   
@@ -284,12 +293,12 @@ AliCaloRawAnalyzer::PreFitEvaluateSamples( const vector<AliCaloBunchInfo>  &bunc
       if ( maxf > fAmpCut ) // possibly significant signal
        {
          // select array around max to possibly be used in fit
-         maxampindex -= bunchvector.at(index).GetStartBin(); // PTH - why isn't this index also reversed for call below?
-         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxampindex , &first, &last);
+         maxrev = maxampindex - bunchvector.at(index).GetStartBin(); 
+         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev, &first, &last);
 
          // sanity check: maximum should not be in first or last bin
          // if we should do a fit
-         if (first!=maxampindex && last!=maxampindex) {
+         if (first!=maxrev && last!=maxrev) {
            // calculate how many samples we have 
            nsamples =  last - first + 1;         
          }
index 315a142..2575d3b 100644 (file)
@@ -66,12 +66,18 @@ class  AliCaloRawAnalyzer : public TObject
   void SetAmpCut(const Float_t cut) { fAmpCut = cut ; } ;
   void SetFitArrayCut(const Int_t cut) { fFitArrayCut = cut ; } ;
   void SetNsampleCut(const Int_t cut) { fNsampleCut = cut ; } ;
+  void SetNsamplePed(const Int_t i) { fNsamplePed = i ; } ;
+
+  bool GetIsZeroSuppressed() const { return fIsZerosupressed;} ;
+  Float_t GetAmpCut() const { return fAmpCut; } ;
+  Int_t GetFitArrayCut() const { return fFitArrayCut; } ;
+  Int_t GetNsampleCut() const { return fNsampleCut; } ;
+  Int_t GetNsamplePed() const { return fNsamplePed; } ;
 
   // access to array info
   Double_t GetReversed(const int i) const { return fReversed[i]; }
   const char * GetAlgoName() const { return fName;  };
   const char * GetAlgoAbbr() const { return fNameShort;  };
-  bool GetIsZeroSuppressed() const { return fIsZerosupressed;} ;
 
  protected:
   short Max( const AliCaloBunchInfo *const bunch, int *const maxindex) const;
@@ -90,13 +96,14 @@ class  AliCaloRawAnalyzer : public TObject
   int fFitArrayCut;  //Cut on ADC value (after ped. subtraction) for signals used for fit
   Float_t fAmpCut;   //Max ADC - pedestal must be higher than this befor attemting to extract the amplitude 
   int fNsampleCut;   //Minimum number of sample require before attemting to extract signal parameters 
+  int fNsamplePed;   //Number of samples used for pedestal calculation (first in bunch) 
   bool fIsZerosupressed; //Wether or not the data is zeros supressed, by default its assumed that the baseline is also subtracted if set to true
   bool fVerbose;     //Print debug information to std out if set to true
 
   char fName[256]; // Name of the algorithm
   char fNameShort[256]; // Abbrevation for the name
 
-  ClassDef(AliCaloRawAnalyzer, 1)  
+  ClassDef(AliCaloRawAnalyzer, 2)  
 
 };
 
index d40f471..2cf79c8 100644 (file)
@@ -48,7 +48,7 @@ AliCaloRawAnalyzerCrude::Evaluate(const vector<AliCaloBunchInfo> &bunchvector, c
   // Evaluation of signal parameters
   if( bunchvector.size()  <=  0 )
     {
-      return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+      return AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid , AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid );
     }
 
   Int_t amp = 0;
@@ -72,7 +72,7 @@ AliCaloRawAnalyzerCrude::Evaluate(const vector<AliCaloBunchInfo> &bunchvector, c
 
   //:EvaluatePedestal(const UShort_t * const data, const int length )
   //  double ped = EvaluatePedestal(sig, length) ;
-  return  AliCaloFitResults(amp, ped, 9999, amp - ped, tof, 9999, 9999 );
+  return  AliCaloFitResults(amp, ped, AliCaloFitResults::kNoFit, amp - ped, tof, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit );
   
 } //end Crude
 
index d6d8738..ae3a20d 100644 (file)
@@ -27,7 +27,7 @@
 #include "AliCaloFastAltroFitv0.h"
 #include "AliCaloFitResults.h"
 #include "AliCaloBunchInfo.h"
-
+#include "TMath.h"
 #include <iostream>
 
 using namespace std;
@@ -64,23 +64,17 @@ AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector
   if( index >= 0)
     {
       Float_t ped = ReverseAndSubtractPed( &(bunchvector.at(index))  ,  altrocfg1, altrocfg2, fReversed  );
-      int first;
-      int last;
+      int first = 0;
+      int last = 0;
+      Float_t maxf = TMath::MaxElement( bunchvector.at(index).GetLength(),  fReversed );
       int maxrev =  maxampindex -  bunchvector.at(index).GetStartBin();
       short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
 
-      double maxf =  maxamp - ped;
-
       if ( maxf > fAmpCut )
        {
          SelectSubarray( fReversed,  bunchvector.at(index).GetLength(), maxrev , &first, &last);
          int nsamples =  last - first + 1;
 
-         //amp  = dAmp;
-         //      time = dTime * GetRawFormatTimeBinWidth();
-
-         //      int length =  bunchvector.at(index).GetLength(); 
-
          if( ( nsamples  )  >= fNsampleCut )  
            {
              Double_t ordered[1008];
@@ -89,15 +83,6 @@ AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector
                {
                  ordered[i] = fReversed[first + i];
                }
-             /*
-             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" ;
-               }
-             cout << __FILE__ << __LINE__ << "!!!!!!! Done printing" << endl; 
-             */
 
              Double_t eSignal = 1; // nominal 1 ADC error
              Double_t dAmp = maxf; 
@@ -110,11 +95,20 @@ AliCaloRawAnalyzerFastFit::Evaluate( const vector<AliCaloBunchInfo> &bunchvector
              AliCaloFastAltroFitv0::FastFit(fXAxis, ordered , nsamples,
                                             eSignal, dTau, dAmp, eAmp, dTime, eTime, chi2);
           
-             return AliCaloFitResults(maxamp, ped, -1,  dAmp, dTime+timebinOffset,  chi2,  -3 );
+             return AliCaloFitResults(maxamp, ped, AliCaloFitResults::kDummy,  dAmp, dTime+timebinOffset,  chi2,  AliCaloFitResults::kDummy,
+                                      AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+           } // samplecut
+         else 
+           {
+             return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit,
+                                       AliCaloFitResults::kNoFit, AliCaloFitSubarray(index, maxrev, first, last) ); 
            }
-
+       } // ampcut
+      else 
+       {
+         return AliCaloFitResults( maxamp , ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit);
        }
-    }    
-  
-  return AliCaloFitResults(9999 , 9999 , 9999,  9999, 9999, 9999, 9999 );
+    } // bunch index    
+
+  return AliCaloFitResults(AliCaloFitResults::kInvalid , AliCaloFitResults::kInvalid);
 }
index 88f577a..38c345e 100644 (file)
@@ -44,7 +44,9 @@ ClassImp( AliCaloRawAnalyzerLMS )
 AliCaloRawAnalyzerLMS::AliCaloRawAnalyzerLMS() : AliCaloRawAnalyzer("Chi Square Fit", "LMS"),
                                                 fkEulerSquared(7.389056098930650227),
                                                 fSig(0),
-                                                fTf1(0)
+                                                fTf1(0),
+                                                fTau(2.35),
+                                                fFixTau(kTRUE)
 {
   //comment
   for(int i=0; i < MAXSAMPLES; i++)
@@ -52,9 +54,15 @@ AliCaloRawAnalyzerLMS::AliCaloRawAnalyzerLMS() : AliCaloRawAnalyzer("Chi Square
       fXaxis[i] = i;
     }
   
-  fTf1 = new TF1( "myformula", "[0]*((x - [1])/2.35)^2*exp(-2*(x -[1])/2.35)",  0, 30 ); 
-  //  fTf1 = new TF1( "myformula", "[0]*((x - [1])/[2])^[3]*exp(-[3]*(x -[1])/[2])",  0, 30 ); 
-
+  fTf1 = new TF1( "myformula", "[0]*((x - [1])/[2])^2*exp(-2*(x -[1])/[2])",  0, 30 ); 
+  if (fFixTau) {
+    fTf1->FixParameter(2, fTau);
+  }
+  else {
+    fTf1->ReleaseParameter(2); // allow par. to vary
+    fTf1->SetParameter(2, fTau);
+  }
 }
 
 
@@ -79,29 +87,31 @@ AliCaloRawAnalyzerLMS::Evaluate( const vector<AliCaloBunchInfo>  &bunchvector, c
       int first;
       int last;
       Float_t maxf = TMath::MaxElement( bunchvector.at(index).GetLength(),  fReversed );
+      short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
+      short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
 
       if ( maxf > fAmpCut )
        {
-         short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
-         short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
          SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev, &first, &last);
          int nsamples =  last - first + 1;
          
-         if( ( nsamples  )  > fNsampleCut )
+         if( ( nsamples  )  >= fNsampleCut )
            {
              
              TGraph *graph =  new TGraph(  nsamples, fXaxis,  &fReversed[first] );
              fTf1->SetParameter(0, maxf*fkEulerSquared );
              fTf1->SetParameter(1, 0.2);
-             //              fTf1->SetParameter(2,  2);
-             //              fTf1->SetParameter(2,  3); 
-           
-             //     return   AliCaloFitResults( -1 , -1 , -1, -1, -1, -1 , -1); 
+
+             if (fFixTau) {
+               fTf1->FixParameter(2, fTau);
+             }
+             else {
+               fTf1->ReleaseParameter(2); // allow par. to vary
+               fTf1->SetParameter(2, fTau);
+             }
 
              Short_t tmpStatus =  graph->Fit(fTf1, "Q0RW");
             
-             //       return   AliCaloFitResults( -1 , -1 , -1, -1, -1, -1 , -1); 
              if( fVerbose == true )
                {
                  AliCaloRawAnalyzer::PrintBunch( bunchvector.at(index) ); 
@@ -110,31 +120,28 @@ AliCaloRawAnalyzerLMS::Evaluate( const vector<AliCaloBunchInfo>  &bunchvector, c
              
                delete graph;
                return AliCaloFitResults( maxamp, ped ,    tmpStatus,  
-                                        fTf1->GetParameter(0)/fkEulerSquared, 
-                                        fTf1->GetParameter(1) + timebinOffset,  
-                                        fTf1->GetChisquare(), 
-                                        fTf1->GetNDF());
-               
-               
+                                         fTf1->GetParameter(0)/fkEulerSquared, 
+                                         fTf1->GetParameter(1) + timebinOffset,  
+                                         fTf1->GetChisquare(), 
+                                         fTf1->GetNDF(),
+                                         AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+                               
                //     delete graph;
        
            }
          else
            {
-             return AliCaloFitResults( maxamp, ped, -1, maxf, -1, -1, -1 );
+             return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit,
+                                       AliCaloFitResults::kNoFit, AliCaloFitSubarray(index, maxrev, first, last) ); 
            }
        }
       else
        {
-         return AliCaloFitResults( maxamp , ped, -1, maxf, -1, -1, -1 );
+         return AliCaloFitResults( maxamp , ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit);
        }       
     }
-  else
-    {
-      return AliCaloFitResults( -99, -99 );
-    }
 
-  return AliCaloFitResults( -99, -99 );
+  return AliCaloFitResults( AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid );
   
 }
 
@@ -151,3 +158,4 @@ AliCaloRawAnalyzerLMS::PrintFitResult(const TF1 *f) const
   //  cout << __FILE__ << __LINE__ << "STATUS = " << f->GetStatus()  << ",.. !!!!" << endl << endl;
   cout << endl << endl;
 }
+
index 31c4817..8e078f2 100644 (file)
@@ -37,6 +37,12 @@ class  AliCaloRawAnalyzerLMS : public AliCaloRawAnalyzer
   virtual AliCaloFitResults  Evaluate( const vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1,  const UInt_t altrocfg2 );
   void PrintFitResult(const TF1 *f) const;
   
+  // shaper tau value, in time-bins, and flag for keeping tau fixed
+  Float_t GetTau() const { return fTau;};
+  void SetTau(Float_t f) { fTau = f; }; 
+  Bool_t GetFixTau() const { return fFixTau; }; 
+  void SetFixTau(Bool_t b) { fFixTau = b; }; 
+
  private:
   AliCaloRawAnalyzerLMS(const AliCaloRawAnalyzerLMS & );
   AliCaloRawAnalyzerLMS  & operator = (const AliCaloRawAnalyzerLMS  &);
@@ -46,7 +52,10 @@ class  AliCaloRawAnalyzerLMS : public AliCaloRawAnalyzer
   TGraph *fSig;  // Signale holding the data to be fitted.
   TF1 *fTf1;     // Analytical formula of the Semi Gaussian to be fitted
 
-  ClassDef(AliCaloRawAnalyzerLMS, 1)
+  Float_t fTau; // shaper tau, in time bins
+  Bool_t fFixTau; // flag if tau should be fix
+
+  ClassDef(AliCaloRawAnalyzerLMS, 2)
 
 };
 
index 8e101d5..ac4565a 100644 (file)
@@ -62,34 +62,36 @@ 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 );
+      return AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid , AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid, AliCaloFitResults::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 );
+      return AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid);
     }
   
   int first = 0;
   int last = 0;
  
-  Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( bindex ) )  ,  altrocfg1, altrocfg2, fReversed  );
+  Float_t ped = ReverseAndSubtractPed( &(bunchvector.at( index ) )  ,  altrocfg1, altrocfg2, fReversed  );
   
-  short maxrev = maxindex  -  bunchvector.at(bindex).GetStartBin();
-  short timebinOffset = maxindex - (bunchvector.at(bindex).GetLength()-1);
-  
-  SelectSubarray( fReversed,  bunchvector.at(bindex).GetLength(),  maxrev , &first, &last);
+  short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
+  short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
+  double maxf =  maxamp - ped;
+
+  SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxrev , &first, &last);
 
   if(maxrev  < 1000 )
     {
       if (  ( maxrev   - first) < 2  &&  (last -   maxrev ) < 2)
        {
-         return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+         return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit,
+                                   AliCaloFitResults::kNoFit, AliCaloFitSubarray(index, maxrev, first, last) ); 
        }
       else
        {
@@ -103,11 +105,13 @@ AliCaloRawAnalyzerNN::Evaluate( const vector<AliCaloBunchInfo> &bunchvector,
          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]) + timebinOffset ) ;
 
-         return AliCaloFitResults( maxamp, ped , -1, amp , tof, -2, -3 ); 
+         return AliCaloFitResults( maxamp, ped , AliCaloFitResults::kDummy, amp , tof, AliCaloFitResults::kDummy, AliCaloFitResults::kDummy,
+                                   AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
 
        }
     }
-  return AliCaloFitResults(9999, 9999, 9999, 9999 , 9999, 9999, 9999 );
+  return AliCaloFitResults( maxamp, ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit,
+                           AliCaloFitResults::kNoFit, AliCaloFitSubarray(index, maxrev, first, last) ); 
 }
 
 
index cd5cf73..7891011 100644 (file)
@@ -127,21 +127,21 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
     {
       Float_t ped = ReverseAndSubtractPed( &(bunchvector.at(index))  ,  altrocfg1, altrocfg2, fReversed  );
       Float_t maxf = TMath::MaxElement(   bunchvector.at(index).GetLength(),  fReversed );
-      
+      short maxrev = maxampindex  -  bunchvector.at(index).GetStartBin();
+      short timebinOffset = maxampindex - (bunchvector.at( index ).GetLength()-1); 
+            
       if(  maxf < fAmpCut  ||  ( maxamp - ped) > 900  )         // (maxamp - ped) > 900 = Close to saturation (use low gain then)
        {
          //      cout << __FILE__ << __LINE__ <<":, maxamp = " << maxamp << ", ped = "<< ped  << ",. maxf = "<< maxf << ", maxampindex = "<< maxampindex  << endl;
-         return  AliCaloFitResults( maxamp, ped,  -1, maxf,   maxampindex, -1, -1 );
+         return  AliCaloFitResults( maxamp, ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit );
        }
       
       int first;
       int last;
       
       if ( maxf > fAmpCut )
-       {
-         
-
-         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(),  maxampindex -  bunchvector.at(index).GetStartBin(), &first, &last);
+       {         
+         SelectSubarray( fReversed,  bunchvector.at(index).GetLength(), maxrev, &first, &last);
          int nsamples =  last - first;
          if( ( nsamples  )  >= fNsampleCut )
            {
@@ -150,8 +150,6 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
              int pfindex = n - fNsampleCut; 
              pfindex = pfindex > SAMPLERANGE ? SAMPLERANGE : pfindex;
 
-             short timebinOffset = maxampindex - (bunchvector.at( index ).GetLength()-1); 
-            
              int dt =  maxampindex - startbin -2; 
 
              //    cout << __FILE__ << __LINE__ <<"\t The coarse estimated t0 is " << ScanCoarse( &fReversed[dt] , n ) << endl;
@@ -222,17 +220,23 @@ AliCaloRawAnalyzerPeakFinder::Evaluate( const vector<AliCaloBunchInfo> &bunchvec
              
              //      tof = tof/fAmpA[tmpindex];
 
-  
-             return AliCaloFitResults( maxamp, ped , -1, fAmpA[tmpindex], tof, -2, -3 ); 
+             
+             return AliCaloFitResults( maxamp, ped , AliCaloFitResults::kDummy, fAmpA[tmpindex], tof, AliCaloFitResults::kDummy, AliCaloFitResults::kDummy,
+                                       AliCaloFitResults::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );  
            }
          else
            {
-             return AliCaloFitResults( maxamp, ped , -5, maxf, -6, -7, -8 ); 
+             return AliCaloFitResults( maxamp, ped , AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit,
+                                       AliCaloFitResults::kNoFit, AliCaloFitSubarray(index, maxrev, first, last) ); 
            }
        }
+      else 
+       {
+         return AliCaloFitResults( maxamp , ped, AliCaloFitResults::kNoFit, maxf, maxrev+timebinOffset, AliCaloFitResults::kNoFit, AliCaloFitResults::kNoFit);
+       }
     }
    //  cout << __FILE__ << __LINE__ <<  "WARNING, returning amp = -1 "  <<  endl;
-  return  AliCaloFitResults(-1, -1);
+  return  AliCaloFitResults(AliCaloFitResults::kInvalid, AliCaloFitResults::kInvalid);
 }
 
 
@@ -271,7 +275,7 @@ AliCaloRawAnalyzerPeakFinder::LoadVectors()
            {
              for(int m = 0; m < n ; m++ )
                {
-                 cout << __FILE__ << __LINE__ << "i="<<i <<"\tj=" <<j << "\tm=" << m << endl;
+                 // cout << __FILE__ << __LINE__ << "i="<<i <<"\tj=" <<j << "\tm=" << m << endl;
  
                  fscanf(fp, "%lf\t", &fPFAmpVectors[i][j][m] );
                  //              fPFAmpVectorsCoarse[i][j][m] = 1;
index 537af71..09b92c7 100644 (file)
@@ -332,6 +332,7 @@ void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray *digitsArr,
   reader->Select("EMCAL",0,43); // 43 = AliEMCALGeoParams::fgkLastAltroDDL
 
   // fRawAnalyzer setup
+  fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done
   fRawAnalyzer->SetAmpCut(fNoiseThreshold);
   fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
   fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
@@ -409,11 +410,14 @@ void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray *digitsArr,
        
        if (ampEstimate > fNoiseThreshold) { // something worth looking at
          
-         time = timeEstimate; 
+         time = timeEstimate; // maxrev in AliCaloRawAnalyzer speak; comes with an offset w.r.t. real timebin
+         Int_t timebinOffset = bunchlist.at(bunchIndex).GetStartBin() - (bunchlist.at(bunchIndex).GetLength()-1); 
+
          amp = ampEstimate; 
          
          if ( nsamples > 1 ) { // possibly something to fit
            FitRaw(first, last, amp, time);
+           time += timebinOffset;
          }
          
          if ( amp>0 && time>0 ) { // brief sanity check of fit results
@@ -558,7 +562,7 @@ void AliEMCALRawUtils::FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin,
       TGraph *gSig =  new TGraph( nsamples); 
       for (int i=0; i<nsamples; i++) {
        Int_t timebin = firstTimeBin + i;    
-       gSig->SetPoint(timebin, timebin, fRawAnalyzer->GetReversed(timebin)); 
+       gSig->SetPoint(i, timebin, fRawAnalyzer->GetReversed(timebin)); 
       }
 
       TF1 * signalF = new TF1("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
index 1acdbbd..3effc9d 100644 (file)
@@ -13,6 +13,7 @@
 #pragma link C++ class AliCaloRawAnalyzer+;
 #pragma link C++ class AliCaloBunchInfo+;
 #pragma link C++ class AliCaloFitResults+;
+#pragma link C++ class AliCaloFitSubarray+;
 #pragma link C++ class AliCaloRawAnalyzerCrude+;
 #pragma link C++ class AliCaloRawAnalyzerNN+;
 #pragma link C++ class AliCaloRawAnalyzerLMS+;
index 1c23749..658e32e 100644 (file)
@@ -10,6 +10,7 @@ AliCaloNeuralFit.cxx \
 AliCaloRawAnalyzer.cxx \
 AliCaloBunchInfo.cxx \
 AliCaloFitResults.cxx \
+AliCaloFitSubarray.cxx \
 AliCaloRawAnalyzerCrude.cxx \
 AliCaloRawAnalyzerLMS.cxx \
 AliCaloRawAnalyzerPeakFinder.cxx \