X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=EMCAL%2FAliCaloRawAnalyzerKStandard.cxx;h=1752a1d011faa4c28aebb1bd5c63e3914023d6ba;hb=7330f0e52a55c9762ac260712cb54cd9446b876d;hp=091e293a21b895b4968a11c95baf9684d86d5df4;hpb=d44019b74b2e25aa89817c6c6860fa93ee095d4c;p=u%2Fmrichter%2FAliRoot.git

diff --git a/EMCAL/AliCaloRawAnalyzerKStandard.cxx b/EMCAL/AliCaloRawAnalyzerKStandard.cxx
index 091e293a21b..1752a1d011f 100644
--- a/EMCAL/AliCaloRawAnalyzerKStandard.cxx
+++ b/EMCAL/AliCaloRawAnalyzerKStandard.cxx
@@ -16,7 +16,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
+//
 // Extraction of amplitude and peak position
 // FRom CALO raw data using
 // least square fit for the
@@ -35,6 +35,9 @@
 #include "TGraph.h"
 #include "TRandom.h"
 
+#include "AliEMCALRawResponse.h"
+
+
 using namespace std;
 
 ClassImp( AliCaloRawAnalyzerKStandard )
@@ -56,6 +59,7 @@ AliCaloRawAnalyzerKStandard::~AliCaloRawAnalyzerKStandard()
 AliCaloFitResults
 AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlist, const UInt_t altrocfg1,  const UInt_t altrocfg2 )
 {
+  //Evaluation Amplitude and TOF
   Float_t pedEstimate  = 0;
   short maxADC = 0;
   Int_t first = 0;
@@ -69,7 +73,7 @@ AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlis
   Int_t ndf = 0;
   Bool_t fitDone = kFALSE;
   int nsamples = PreFitEvaluateSamples( bunchlist, altrocfg1, altrocfg2, bunchIndex, ampEstimate, 
-					maxADC, timeEstimate, pedEstimate, first, last,   fAmpCut ); 
+					maxADC, timeEstimate, pedEstimate, first, last,   (int)fAmpCut ); 
   
   
   if (ampEstimate >= fAmpCut  ) 
@@ -108,13 +112,12 @@ AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo>  &bunchlis
       time -= fL1Phase;
 
       return AliCaloFitResults( -99, -99, fAlgo , amp, time,
-				time, chi2, ndf, Ret::kDummy );
+				(int)time, chi2, ndf, Ret::kDummy );
      }
   return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid );
 }
 
 	
-//____________________________________________________________________________ 
 void
  AliCaloRawAnalyzerKStandard::FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const 
 { 
@@ -130,8 +133,9 @@ void
       Int_t timebin = firstTimeBin + i;    
       gSig->SetPoint(i, timebin, GetReversed(timebin)); 
     }
-      
-  TF1 * signalF = new TF1("signal", RawResponseFunction, 0, TIMEBINS , 5);
+  
+  TF1 * signalF = new TF1("signal", AliEMCALRawResponse::RawResponseFunction, 0, TIMEBINS , 5);
+  
   signalF->SetParameters(10.,5., TAU  ,ORDER,0.); //set all defaults once, just to be safe
   signalF->SetParNames("amp","t0","tau","N","ped");
   signalF->FixParameter(2,TAU); 
@@ -149,10 +153,11 @@ void
     chi2 = signalF->GetChisquare();
     fitDone = kTRUE;
   }
-  catch (const std::exception & e) {
-    AliError( Form("TGraph Fit exception %s", e.what()) ); 
-    // stay with default amp and time in case of exception, i.e. no special action required
-    fitDone = kFALSE;
+  catch (const std::exception & e) 
+    {
+      AliError( Form("TGraph Fit exception %s", e.what()) ); 
+      // stay with default amp and time in case of exception, i.e. no special action required
+      fitDone = kFALSE;
   }
 
   delete signalF;
@@ -161,86 +166,3 @@ void
 }
 
 
-//__________________________________________________________________
-void 
-AliCaloRawAnalyzerKStandard::FitParabola(const TGraph *gSig, Float_t & amp) const 
-{
-  //BEG YS alternative methods to calculate the amplitude
-  Double_t * ymx = gSig->GetX() ; 
-  Double_t * ymy = gSig->GetY() ; 
-  const Int_t kN = 3 ; 
-  Double_t ymMaxX[kN] = {0., 0., 0.} ; 
-  Double_t ymMaxY[kN] = {0., 0., 0.} ; 
-  Double_t ymax = 0. ; 
-  // find the maximum amplitude
-  Int_t ymiMax = 0 ;  
-  for (Int_t ymi = 0; ymi < gSig->GetN(); ymi++) {
-    if (ymy[ymi] > ymMaxY[0] ) {
-      ymMaxY[0] = ymy[ymi] ; //<========== This is the maximum amplitude
-      ymMaxX[0] = ymx[ymi] ;
-      ymiMax = ymi ; 
-    }
-  }
-  // find the maximum by fitting a parabola through the max and the two adjacent samples
-  if ( ymiMax < gSig->GetN()-1 && ymiMax > 0) {
-    ymMaxY[1] = ymy[ymiMax+1] ;
-    ymMaxY[2] = ymy[ymiMax-1] ; 
-    ymMaxX[1] = ymx[ymiMax+1] ;
-    ymMaxX[2] = ymx[ymiMax-1] ; 
-    if (ymMaxY[0]*ymMaxY[1]*ymMaxY[2] > 0) {
-      //fit a parabola through the 3 points y= a+bx+x*x*x
-      Double_t sy = 0 ; 
-      Double_t sx = 0 ; 
-      Double_t sx2 = 0 ; 
-      Double_t sx3 = 0 ; 
-      Double_t sx4 = 0 ; 
-      Double_t sxy = 0 ; 
-      Double_t sx2y = 0 ; 
-      for (Int_t i = 0; i < kN ; i++) {
-        sy += ymMaxY[i] ; 
-        sx += ymMaxX[i] ; 		
-        sx2 += ymMaxX[i]*ymMaxX[i] ; 
-        sx3 += ymMaxX[i]*ymMaxX[i]*ymMaxX[i] ; 
-        sx4 += ymMaxX[i]*ymMaxX[i]*ymMaxX[i]*ymMaxX[i] ; 
-        sxy += ymMaxX[i]*ymMaxY[i] ; 
-        sx2y += ymMaxX[i]*ymMaxX[i]*ymMaxY[i] ; 
-      }
-      Double_t cN = (sx2y*kN-sy*sx2)*(sx3*sx-sx2*sx2)-(sx2y*sx-sxy*sx2)*(sx3*kN-sx*sx2); 
-      Double_t cD = (sx4*kN-sx2*sx2)*(sx3*sx-sx2*sx2)-(sx4*sx-sx3*sx2)*(sx3*kN-sx*sx2) ;
-      Double_t c  = cN / cD ; 
-      Double_t b  = ((sx2y*kN-sy*sx2)-c*(sx4*kN-sx2*sx2))/(sx3*kN-sx*sx2) ;
-      Double_t a  = (sy-b*sx-c*sx2)/kN  ;
-      Double_t xmax = -b/(2*c) ; 
-      ymax = a + b*xmax + c*xmax*xmax ;//<========== This is the maximum amplitude
-      amp = ymax;
-    }
-  }
-  
-  Double_t diff = TMath::Abs(1-ymMaxY[0]/amp) ; 
-  if (diff > 0.1) 
-    {
-      amp = ymMaxY[0] ; 
-    }
-
-  return;
-}
-
-
-//__________________________________________________________________
-Double_t 
-AliCaloRawAnalyzerKStandard::RawResponseFunction(Double_t *x, Double_t *par)
-{
-  Double_t signal = 0.;
-  Double_t tau    = par[2];
-  Double_t n      = par[3];
-  Double_t ped    = par[4];
-  Double_t xx     = ( x[0] - par[1] + tau ) / tau ;
-
-  if (xx <= 0) 
-    signal = ped ;  
-  else {  
-    signal = ped + par[0] * TMath::Power(xx , n) * TMath::Exp(n * (1 - xx )) ; 
-  }
-  return signal ;  
-}
-