set ( ELIBSDIR )
-set ( ELIBS MUONevaluation MUONmapping MUONshuttle MUONgraphics MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCbase TPCsim TPCrec TPCfast ITSbase ITSsim ITSrec PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec BCM STRUCT T0base T0sim T0rec FASTSIM microcern HLTbase TRIGGERbase STEER STAT CDB AOD STEERBase ESD RAWDatasim RAWDatarec RAWDatabase)
+set ( ELIBS MUONevaluation MUONmapping MUONshuttle MUONgraphics MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCbase TPCsim TPCrec TPCfast ITSbase ITSsim ITSrec PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec EMCALraw BCM STRUCT T0base T0sim T0rec FASTSIM microcern HLTbase TRIGGERbase STEER STAT CDB AOD STEERBase ESD RAWDatasim RAWDatarec RAWDatabase)
if(PYTHIA6)
list(APPEND ELIBS EVGEN)
* provided "as is" without express or implied warranty. *
**************************************************************************/
+
//
// Constants used by the HLT
// ALICE Offlinw
namespace CaloConstants
{
const int MAXHOSTS=20; // related to the emcal debug online display
+ const int TIMEBINS = 256; // number of sampling bins of the raw RO signal (we typically use 15-50; max is 1k+)
+ const double TIMEBINWITH = 100E-9 ; // each sample is 100 ns
+ const double TIMEBINMAX = TIMEBINS*TIMEBINWITH;
+ // const double TAU = 2.35;
+ // const int ORDER = 2;
+
+ const int OVERFLOWCUT = 950;
+
+ const double HGLGFACTOR = 16;
+ // const double ECENTRALHIT = 0.85; //Percentage of total enegry contain in a single tower for a central hit
+
namespace ALTROConstants
{
const int ALTROMAXSAMPLES = 1008; // The maximum number of samples of the ALTRO
const int LOWGAIN = 0; // Mnemonic for Low Gain
const int HG = HIGHGAIN; // Abbrevation for HIGHGAIN
const int LG = LOWGAIN; // Abbrevation for LOWGAIN
- }
+ }
//FEE constants common to PHOS EMCAL
const int CSPSPERFEE = 32; // Charge Sensitive Preamplifiers (CSPs) per FEE
namespace EMCALConstants
{
- const int NZROWSMOD = 48; // Number of rows per module
- const int NXCOLUMNSMOD = 24; // Number of columns per module
+ // const int NZROWSMOD = 48; // Number of rows per module
+ // const int NXCOLUMNSMOD = 24; // Number of columns per module
+ const double ECENTRALHIT = 0.845678; //Percentage of total enegry contain in a single tower for a central hit
+
+ const int NZROWSMOD = 24; // Number of rows per module
+ const int NXCOLUMNSMOD = 48; // Number of columns per module
+
+ const int NROWSMOD = NZROWSMOD; // Number of rows per module
+ const int NCOLUMNSMOD = NXCOLUMNSMOD; // Number of columns per module
+
+ // const int NZROWSMOD = 24; // Number of rows per module
+ // const int NXCOLUMNSMOD = 48; // Number of columns per module
+
const int NRCUSPERSECTOR = 4; // Number of RCUs per sector
const int NMODULES = 10; // Number of modules of the EMCAL detector
const int NRCUSPERMODULE = 2 ; // Number of RCUs per Module
const int NFEECS = 9; // Number of Frontend cards per branch*/
const int NZROWSRCU = 48; // Number of Rows per RCU
const int NXCOLUMNSRCU = 16; // Number of columns per RCU
+ const int ORDER = 2; // Order of shaping stages of the signal conditioning unit
+ const double TAU = 2.35; // approximate shaping time
+
}
-
-
+
namespace PHOSConstants
{
const int NZROWSMOD = 56; // Number of rows per module
namespace FitAlgorithm
{
enum fitAlgorithm { kStandard = 0, kCrude = 1, kPeakFinder = 2, kNeuralNet = 3, kFastFit= 4,
- kLogFit = 5, kLMS = 6, kNONE = 7}; // possible return values
+ kLogFit = 5, kLMS = 6, kLMSOffline = 7, kFakeAltro = 9, kNONE = 8}; // possible return values
}
namespace ReturnCodes
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-2010 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$ */
+
+/* History of cvs commits:
+ * $Log$
+ */
+
+//______________________________________________________
+// Author : Aleksei Pavlinov; IHEP, Protvino, Russia
+// Feb 17, 2009
+// Implementation of fit procedure from ALICE-INT-2008-026:
+// "Time and amplitude reconstruction from sampling
+// measurements of the PHOS signal profile"
+// M.Yu.Bogolyubsky and ..
+//
+// Fit by function en*x*x*exp(-2.*x): x = (t-t0)/tau.
+// The main goal is fast estimation of amplitude and t0.
+//
+
+// --- AliRoot header files ---
+#include "AliCaloFastAltroFitv0.h"
+
+#include <TH1.h>
+#include <TF1.h>
+#include <TCanvas.h>
+#include <TGraphErrors.h>
+#include <TMath.h>
+
+#include <math.h>
+
+ClassImp(AliCaloFastAltroFitv0)
+
+//____________________________________________________________________________
+ AliCaloFastAltroFitv0::AliCaloFastAltroFitv0()
+: TNamed(),
+ fSig(0),fTau(0),fN(0),fPed(0), fAmp(0),fAmpErr(0),fT0(0),fT0Err(0),fChi2(0.),fNDF(0)
+,fNoFit(0),fNfit(0),fTfit(0),fAmpfit(0), fStdFun(0)
+{
+}
+
+//____________________________________________________________________________
+AliCaloFastAltroFitv0::AliCaloFastAltroFitv0(const char* name, const char* title,
+ const Double_t sig, const Double_t tau, const Double_t n)
+ : TNamed(name, title),
+ fSig(sig),fTau(tau),fN(n),fPed(0), fAmp(0),fAmpErr(0),fT0(0),fT0Err(0),fChi2(0.),fNDF(0)
+ ,fNoFit(0),fNfit(0),fTfit(0),fAmpfit(0), fStdFun(0)
+{
+ if(strlen(name)==0) SetName("CaloFastAltroFitv0");
+}
+
+//____________________________________________________________________________
+AliCaloFastAltroFitv0::AliCaloFastAltroFitv0(const AliCaloFastAltroFitv0 &obj)
+ : TNamed(obj),
+ fSig(0),fTau(0),fN(2.),fPed(0), fAmp(0),fAmpErr(0),fT0(0),fT0Err(0),fChi2(0.),fNDF(0)
+ ,fNoFit(0),fNfit(0),fTfit(0),fAmpfit(0), fStdFun(0)
+{
+}
+
+//____________________________________________________________________________
+AliCaloFastAltroFitv0::~AliCaloFastAltroFitv0()
+{
+ if(fTfit) delete [] fTfit;
+ if(fAmpfit) delete [] fAmpfit;
+}
+
+//____________________________________________________________________________
+AliCaloFastAltroFitv0& AliCaloFastAltroFitv0::operator= (const AliCaloFastAltroFitv0 &/*obj*/)
+{
+ // Not implemented yet
+ return (*this);
+}
+
+void AliCaloFastAltroFitv0::FastFit(Int_t* t, Int_t* y, Int_t nPoints, Double_t sig, Double_t tau,
+ Double_t /*n*/, Double_t ped, Double_t tMax)
+{
+ Reset();
+
+ fSig = sig;
+ fTau = tau;
+ fPed = ped;
+
+ Int_t ii=0;
+ CutRightPart(t,y,nPoints,tMax, ii);
+ nPoints = ii;
+
+ fNfit = 0;
+ fTfit = new Double_t[nPoints];
+ fAmpfit = new Double_t[nPoints];
+
+
+ DeductPedestal(t,y,nPoints, tau,ped, fTfit,fAmpfit,fNfit);
+ // printf(" n %i : fNfit %i : ped %f \n", n, fNfit, ped);
+ // for(int i=0; i<fNfit; i++)
+ // printf(" i %i : fAmpfit %7.2f : fTfit %7.2f \n", i, fAmpfit[i], fTfit[i]);
+
+ if(fNfit>=2) {
+ FastFit(fTfit,fAmpfit,fNfit,sig,tau, fAmp,fAmpErr, fT0,fT0Err,fChi2);
+
+ if(fChi2> 0.0) {
+ fNDF = fNfit - 2;
+ } else {
+ fNDF = 0;
+ fNoFit++;
+ }
+ } else if(fNfit==1){
+ Reset(); // What to do here => fT0 = fTfit[0]; fAmp = fAmpFit[0] ??
+ } else {
+ Reset();
+ }
+}
+
+//____________________________________________________________________________
+void AliCaloFastAltroFitv0::FastFit(TH1F* h, Double_t sig, Double_t tau, Double_t n,
+Double_t ped, Double_t tMax)
+{
+ // Service method for convinience only
+ // h - hist with altro response, could have empty bin
+ // and center of bin could be different from bin number
+ Reset();
+
+ if(h==0) return;
+ Int_t nPoints = h->GetNbinsX();
+ if(nPoints<2) return; // Sep 07, 09
+
+ Int_t* t = new Int_t[nPoints];
+ Int_t* y = new Int_t[nPoints];
+
+ Int_t nPositive=0;
+ for(Int_t i=0; i<nPoints; i++) {
+ if(h->GetBinContent(i+1) > 0.0){ // Get only positive
+ y[nPositive] = Int_t(h->GetBinContent(i+1));
+ t[nPositive] = Int_t(h->GetBinCenter(i+1)+0.0001);
+ nPositive++;
+ }
+ }
+
+ if(nPositive >= 2) {
+ FastFit(t,y,nPoints, sig,tau,n,ped, tMax);
+ }
+ if(fChi2<=0.0) fNoFit++;
+
+ delete [] t;
+ delete [] y;
+}
+
+void AliCaloFastAltroFitv0::Reset()
+{
+ // Reset variables
+ fSig = fTau = 0.0;
+ fAmp = fAmpErr = fT0 = fT0Err = 0.0;
+ fChi2 = -1.;
+ fNDF = fNfit = 0;
+
+ if(fTfit) delete [] fTfit;
+ if(fAmpfit) delete [] fAmpfit;
+ fTfit = fAmpfit = 0;
+}
+
+
+void AliCaloFastAltroFitv0::GetFitResult(Double_t &,Double_t &eamp,Double_t &t0,Double_t &et0,
+Double_t &chi2, Int_t &ndf) const
+{
+ // Return results of fitting procedure
+ amp = fAmp;
+ eamp = fAmpErr;
+ t0 = fT0;
+ et0 = fT0Err;
+ chi2 = fChi2;
+ ndf = fNDF;
+}
+
+void AliCaloFastAltroFitv0::GetFittedPoints(Int_t &nfit, Double_t* ar[2]) const
+{
+ nfit = fNfit;
+ ar[0] = fTfit;
+ ar[1] = fAmpfit;
+}
+//
+// static functions
+//
+void AliCaloFastAltroFitv0::CutRightPart(Int_t *t,Int_t *y,Int_t nPoints,Double_t tMax, Int_t &ii)
+{
+ // Cut right part of altro sample : static function
+ Int_t tt=0;
+ for(Int_t i=0; i<nPoints; i++) {
+ tt = t[i];
+ if(tMax && tt <= Int_t(tMax)) {
+ t[ii] = tt;
+ y[ii] = y[i];
+ ii++;
+ }
+ }
+ if(0) printf(" ii %i -> ii %i : tMax %7.2f \n", nPoints, ii, tMax);
+}
+
+void AliCaloFastAltroFitv0::DeductPedestal(Int_t* t, Int_t* y, Int_t nPoints, Double_t tau, Double_t ped,
+ Double_t* tn, Double_t* yn, Int_t &nPointsOut)
+{
+ // Pedestal deduction if ped is positive : static function
+ // Discard part od samle if it is not compact.
+ static Double_t yMinUnderPed=2.; // should be tune
+ Int_t ymax=0, nmax=0;
+ for(Int_t i=0; i<nPoints; i++){
+ if(y[i]>ymax) {
+ ymax = y[i];
+ nmax = i;
+ }
+ }
+ Int_t i1 = nmax - Int_t(tau);
+ //i1 = 0;
+ i1 = i1<0?0:i1;
+ Int_t i2 = nPoints;
+
+ nPointsOut = 0;
+ Double_t yd=0.0, tdiff=0.0;;
+ for(Int_t i=i1; i<i2; i++) {
+ if(ped>0.0) {
+ yd = Double_t(y[i]) - ped;
+ } else {
+ yd = Double_t(y[i]);
+ }
+ if(yd < yMinUnderPed) continue;
+
+ if(i>i1 && nPointsOut>0){
+ tdiff = t[i] - tn[nPointsOut-1];
+ // printf(" i %i : nPointsOut %i : tdiff %6.2f : tn[nPointsOut] %6.2f \n", i,nPointsOut, tdiff, tn[nPointsOut-1]);
+ if(tdiff>1.) {
+ // discard previous points if its are before maximum point and with gap>1
+ if(i<nmax ) {
+ nPointsOut = 0; // nPointsOut--;
+ // if point with gap after maximum - finish selection
+ } else if(i>=nmax ) {
+ break;
+ }
+ }
+ // Far away from maximum
+ //if(i-nmax > Int_t(5*tau)) break;
+ }
+ tn[nPointsOut] = Double_t(t[i]);
+ yn[nPointsOut] = yd;
+ //printf("i %i : nPointsOut %i : tn %6.2f : yn %6.2f \n", i, nPointsOut, tn[nPointsOut], yn[nPointsOut]);
+ nPointsOut++;
+ }
+ //printf(" nmax %i : nPointsIn %i :nPointsOut %i i1 %i \n", nmax, nPointsIn, nPointsOut, i1);
+}
+
+void AliCaloFastAltroFitv0::FastFit(const Double_t* t, const Double_t* y, const Int_t nPoints,
+ const Double_t sig, const Double_t tau,
+ Double_t &, Double_t &eamp, Double_t &t0, Double_t &et0, Double_t &chi2)
+{
+ // Static function
+ // It is case of n=k=2 : fnn = x*x*exp(2 - 2*x)
+ // Input:
+ //nPoints - number of points
+ // t[] - array of time bins
+ // y[] - array of amplitudes after pedestal subtractions;
+ // sig - error of amplitude measurement (one value for all channels)
+ // tau - filter time response (in timebin units)
+ // Output:
+ // amp - amplitude at t0;
+ // eamp - error of amplitude;
+ // t0 - time of max amplitude;
+ // et0 - error of t0;
+ // chi2 - chi2
+ static Double_t xx; // t/tau
+ static Double_t a, b, c;
+ static Double_t f02, f12, f22; // functions
+ static Double_t f02d, f12d, f22d; // functions derivations
+
+ chi2 = -1.;
+
+ if(nPoints<2) {
+ printf(" AliCaloFastAltroFitv0::FastFit : nPoints<=%i \n", nPoints);
+ return;
+ }
+
+ a = b = c = 0.0;
+ for(Int_t i=0; i<nPoints; i++){
+ xx = t[i]/tau;
+ f02 = exp(-2.*xx);
+ f12 = xx*f02;
+ f22 = xx*f12;
+ // Derivations
+ f02d = -2.*f02;
+ f12d = f02 - 2.*f12;
+ f22d = 2.*(f12 - f22);
+ //
+ a += f02d * y[i];
+ b -= 2.*f12d * y[i];
+ c += f22d * y[i];
+ }
+ Double_t t01=0.0, t02=0.0;
+ Double_t amp1=0.0, amp2=0.0, chi21=0.0, chi22=0.0;
+ if(QuadraticRoots(a,b,c, t01,t02)) {
+ t01 *= tau;
+ t02 *= tau;
+ Amplitude(t,y,nPoints, sig, tau, t01, amp1, chi21);
+ Amplitude(t,y,nPoints, sig, tau, t02, amp2, chi22);
+ if(0) {
+ printf(" t01 %f : t02 %f \n", t01, t02);
+ printf(" amp1 %f : amp2 %f \n", amp1, amp2);
+ printf(" chi21 %f : chi22 %f \n", chi21, chi22);
+ }
+ // t0 less on one tau with comparing with value from "canonical equation"
+ amp = amp1;
+ t0 = t01;
+ chi2 = chi21;
+ if(chi21 > chi22) {
+ amp = amp2;
+ t0 = t02;
+ chi2 = chi22;
+ }
+ if(tau<3.) { // EMCAL case : small tau
+ t0 += -0.03; // Discard bias in t0
+ Amplitude(t,y,nPoints, sig, tau, t0, amp, chi2);
+ }
+ CalculateParsErrors(t, y, nPoints, sig, tau, amp, t0, eamp, et0);
+
+ // Fill1();
+
+ // DrawFastFunction(amp, t0, fUtils->GetPedestalValue(), "1");
+ // DrawFastFunction(amp1, t01, fUtils->GetPedestalValue(), "1");
+ // DrawFastFunction(amp2, t02, fUtils->GetPedestalValue(), "2");
+ } else {
+ chi2 = t01; // no roots, bad fit - negative chi2
+ }
+}
+
+Bool_t AliCaloFastAltroFitv0::QuadraticRoots(const Double_t a, const Double_t b, const Double_t c,
+ Double_t &x1, Double_t &x2)
+{
+ // Resolve quadratic equations a*x**2 + b*x + c
+ //printf(" a %12.5e b %12.5e c %12.5e \n", a, b, c);
+ static Double_t dtmp = 0.0, dtmpCut = -1.e-6;
+ static Int_t iWarning=0, iNoSolution=0;
+ dtmp = b*b - 4.*a*c;
+
+ if(dtmp>=dtmpCut && dtmp<0.0) {
+ if(iWarning<5 || iWarning%1000==0)
+ printf("<W> %i small neg. sq. : dtmp %12.5e \n", iWarning, dtmp);
+ iWarning++;
+ dtmp = 0.0;
+ }
+ if(dtmp>=0.0) {
+ dtmp = sqrt(dtmp);
+ x1 = (-b + dtmp) / (2.*a);
+ x2 = (-b - dtmp) / (2.*a);
+
+ // printf(" x1 %f : x2 %f \n", x1, x2);
+ return kTRUE;
+ } else {
+ x1 = dtmp;
+ if(iNoSolution<5 || iNoSolution%1000==0)
+ printf("<No solution> %i neg. sq. : dtmp %12.5e \n", iNoSolution, dtmp);
+ iNoSolution++;
+ return kFALSE;
+ }
+}
+
+void AliCaloFastAltroFitv0::Amplitude(const Double_t* t,const Double_t* y,const Int_t nPoints,
+ const Double_t sig, const Double_t tau, const Double_t t0,
+ Double_t &, Double_t &chi2)
+{
+ // Calculate parameters error too - Mar 24,09
+ // sig is independent from points
+ amp = 0.;
+ Double_t x=0.0, f=0.0, den=0.0, f02;
+ for(Int_t i=0; i<nPoints; i++){
+ x = (t[i] - t0)/tau;
+ f02 = exp(-2.*x);
+ f = x*x*f02;
+ amp += f*y[i];
+ den += f*f;
+ }
+ if(den>0.0) amp /= den;
+ //
+ // chi2 calculation
+ //
+ Double_t dy=0.0;
+ chi2=0.;
+ for(Int_t i=0; i<nPoints; i++){
+ x = (t[i] - t0)/tau;
+ f02 = exp(-2.*x);
+ f = amp*x*x*f02;
+ dy = y[i]-f;
+ chi2 += dy*dy;
+ // printf(" %i : y %f -> f %f : dy %f \n", i, y[i], f, dy);
+ }
+ chi2 /= (sig*sig);
+}
+
+void AliCaloFastAltroFitv0::CalculateParsErrors(const Double_t* t, const Double_t* /*y*/, const Int_t nPoints,
+ const Double_t sig, const Double_t tau,
+ Double_t &, Double_t &t0, Double_t &eamp, Double_t &et0)
+{
+ // Remember that fmax = exp(-n);
+ // fmax_nk = (n/k)**n*exp(-n) => n=k=2 => exp(-n) = exp(-2.)
+ static Double_t cc = exp(-2.);
+ // static Double_t cc = exp(-fN); // mean(N)~1.5 ??
+
+ Double_t sumf2=0.0, sumfd2=0.0, x, f02, f12, f22, f22d;
+
+ for(Int_t i=0; i<nPoints; i++){
+ x = (t[i] - t0)/tau;
+ f02 = exp(-2.*x);
+ f12 = x*f02;
+ f22 = x*f12;
+ sumf2 += f22 * f22;
+ //
+ f22d = 2.*(f12 - f22);
+ sumfd2 += f22d * f22d;
+ }
+ et0 = (sig/amp)/sqrt(sumfd2);
+ eamp = sig/sqrt(sumf2);
+
+ amp *= cc;
+ eamp *= cc;
+}
+
+//
+// Drawing
+//
+TCanvas* AliCaloFastAltroFitv0::DrawFastFunction()
+{
+ // QA of fitting
+ if(fNfit<=0) return 0; // no points
+
+ static TCanvas *c = 0;
+ if(c==0) {
+ c = new TCanvas("fastFun","fastFun",800,600);
+ }
+
+ c->cd();
+
+ Double_t* eamp = new Double_t[fNfit];
+ Double_t* et = new Double_t[fNfit];
+
+ for(Int_t i=0; i<fNfit; i++) {
+ eamp[i] = fSig;
+ et[i] = 0.0;
+ }
+
+ TGraphErrors *gr = new TGraphErrors(fNfit, fTfit,fAmpfit, et,eamp);
+ gr->Draw("Ap");
+ gr->SetTitle(Form("Fast Fit : #chi^{2}/ndf = %8.2f / %i", GetChi2(), GetNDF()));
+ gr->GetHistogram()->SetXTitle(" time bin ");
+ gr->GetHistogram()->SetYTitle(" amplitude ");
+
+ if(fStdFun==0) {
+ fStdFun = new TF1("stdFun", StdResponseFunction, 0., fTfit[fNfit-1]+2., 5);
+ fStdFun->SetParNames("amp","t0","tau","N","ped");
+ }
+ fStdFun->SetParameter(0, GetEnergy());
+ fStdFun->SetParameter(1, GetTime() + GetTau());
+ fStdFun->SetParameter(2, GetTau()); //
+ fStdFun->SetParameter(3, GetN()); // 2
+ fStdFun->SetParameter(4, 0.); //
+
+ fStdFun->SetLineColor(kBlue);
+ fStdFun->SetLineWidth(1);
+
+ fStdFun->Draw("same");
+
+ delete [] eamp;
+ delete [] et;
+
+ c->Update();
+
+ return c;
+}
+
+Double_t AliCaloFastAltroFitv0::StdResponseFunction(const Double_t *x, const Double_t *par)
+{
+ // Static Standard Response Function :
+ // look to Double_t AliEMCALRawUtils::RawResponseFunction(Double_t *x, Double_t *par)
+ // Using for drawing only.
+ //
+ // Shape of the electronics raw reponse:
+ // It is a semi-gaussian, 2nd order Gamma function (n=2) of the general form
+ //
+ // t' = (t - t0 + tau) / tau
+ // F = A * t**N * exp( N * ( 1 - t) ) for t >= 0
+ // F = 0 for t < 0
+ //
+ // parameters:
+ // A: par[0] // Amplitude = peak value
+ // t0: par[1]
+ // tau: par[2]
+ // N: par[3]
+ // ped: par[4]
+ //
+ static Double_t signal , tau, n, ped, xx;
+
+ tau = par[2];
+ n = par[3];
+ ped = par[4];
+ 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 ;
+}
--- /dev/null
+//_________________________________________________________________________
+// Procedure of fast altro fitting
+//
+//*-- Author: Aleksei Pavlinov; IHEP, Protvino, Russia & WSU, Detroit, USA
+
+#ifndef ALICALOFASTALTROFITV0_H
+#define ALICALOFASTALTROFITV0_H
+/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+/* $Id$ */
+
+/* History of svn commits
+ * $Log$
+ */
+
+#include <TNamed.h>
+// --- ROOT system ---
+class TCanvas;
+class TVirtualPad;
+class TF1;
+class TH1F;
+
+class AliCaloFastAltroFitv0 : public TNamed {
+
+public:
+
+ AliCaloFastAltroFitv0();
+ AliCaloFastAltroFitv0(const char* name, const char* title,
+ const Double_t sig=1.3, const Double_t tau=2.35, const Double_t n=2.);
+ virtual ~AliCaloFastAltroFitv0();
+
+ virtual void FastFit(Int_t* t, Int_t* y, Int_t nPoints, Double_t sig, Double_t tau,
+ Double_t n, Double_t ped, Double_t tMax);
+
+ void FastFit(TH1F* h, Double_t sig, Double_t tau,
+ Double_t n, Double_t ped, Double_t tMax);
+
+ void Reset();
+ void SetSig(const Double_t sig) {fSig = sig;}
+ void SetTau(const Double_t tau) {fTau = tau;}
+ void SetN(const Double_t n) {fN = n;}
+ void SetParameters(const Double_t sig, const Double_t tau, const Double_t n)
+ {fSig = sig; fTau = tau; fN = n;}
+
+ Double_t GetSig() const {return fSig;}
+ Double_t GetTau() const {return fTau;}
+ Double_t GetN() const {return fN;}
+ Double_t GetPed() const {return fPed;}
+
+ Double_t GetEnergy() const {return fAmp;}
+ Double_t GetAmp() const {return GetEnergy();}
+ Double_t GetAmpErr() const {return fAmpErr;}
+ Double_t GetTime() const {return fT0;}
+ Double_t GetT0() const {return GetTime();}
+ Double_t GetT0Err() const {return fT0Err;}
+ Double_t GetChi2() const {return fChi2;}
+ Int_t GetNDF() const {return fNDF;}
+ Int_t GetNfit() const {return fNfit;}
+ Int_t GetNoFit() const {return fNoFit;}
+
+ void GetFitResult(Double_t &, Double_t &eamp, Double_t &t0, Double_t &et0,
+ Double_t &chi2,Int_t &ndf) const;
+ void GetFittedPoints(Int_t &nfit, Double_t* ar[2]) const;
+
+ // Drawing for QA
+ TCanvas* DrawFastFunction(); // *MENU*
+ static Double_t StdResponseFunction(const Double_t *x, const Double_t *par);
+
+ static void CutRightPart(Int_t *t,Int_t *y,Int_t nPoints, Double_t tMax, Int_t &ii);
+ static void DeductPedestal(Int_t* t, Int_t* y, Int_t nPointsIn, Double_t ped, Double_t tau,
+ Double_t* tn, Double_t* yn, Int_t &nPointsOut);
+
+ static void FastFit(const Double_t* t, const Double_t* y, const Int_t nPoints,
+ const Double_t sig, const Double_t tau,
+ Double_t &, Double_t &eamp, Double_t &t0, Double_t &et0, Double_t &chi2);
+ static Bool_t QuadraticRoots(const Double_t a, const Double_t b, const Double_t c,
+ Double_t &x1, Double_t &x2);
+ static void Amplitude(const Double_t* t, const Double_t* y, const Int_t nPoints,
+ const Double_t sig, const Double_t tau,
+ Double_t t0, Double_t &, Double_t &chi2);
+ static void CalculateParsErrors(const Double_t* t, const Double_t* y, const Int_t nPoints,
+ const Double_t sig, const Double_t tau,
+ Double_t &, Double_t &t0, Double_t &eamp, Double_t &et0);
+protected:
+ Double_t fSig; // error in amplitude - used in chi2 calculation
+ Double_t fTau; // first fixed parameter od fitting function (should be - filter time response
+ Double_t fN; // second fixed parameter od fitting function (should be positive)
+ Double_t fPed; // pedestal
+
+ Double_t fAmp; // amplitude
+ Double_t fAmpErr; // amplitude error
+ Double_t fT0; // time
+ Double_t fT0Err; // time error
+ Double_t fChi2; // chi square
+ Int_t fNDF; // number degree of freedom
+ Int_t fNoFit; // no solution for square equation
+
+ // Working variable
+ Int_t fNfit; //! number points for fit
+ Double_t* fTfit; //! points for fit after selection - time bins
+ Double_t* fAmpfit; //! - amplitudes
+ //
+ TF1* fStdFun; //! function for drawing
+
+private:
+ AliCaloFastAltroFitv0(const AliCaloFastAltroFitv0 &obj);
+ AliCaloFastAltroFitv0& operator= (const AliCaloFastAltroFitv0 &obj);
+
+ ClassDef(AliCaloFastAltroFitv0,1) // Class for fast altro fitting
+};
+
+#endif // ALICALOFASTALTROFITV0_H
#include "AliCaloFitResults.h"
#include "AliCaloConstants.h"
-AliCaloFitResults::AliCaloFitResults() : fMaxSig(-1),
+
+AliCaloFitResults::AliCaloFitResults() : fMaxSig(0),
fPed(-1),
fStatus(-1),
fAmpSig(-1),
fTime(-1),
fMaxTimebin(-1),
fChi2Sig(-1),
- fNdfSig(-1),
- fMinSig(-1),
+ fNdfSig(0),
+ fMinSig(0),
fFitSubarray(10)
{
// 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 time,
+ const double time,
const Int_t maxTimebin,
const Float_t chi,
const Int_t ndf,
}
+
AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped,
const Short_t fitstatus, const Float_t amp,
- const Float_t time, const Int_t maxTimebin, const Float_t chi,
+ const double time, const Int_t maxTimebin, const Float_t chi,
const Int_t ndf, Int_t minSig ) :
fMaxSig(maxSig),
fPed(ped),
}
+
AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped,
const Short_t fitstatus, const Float_t amp,
const Int_t maxTimebin) :
fTime(maxTimebin),
fMaxTimebin(maxTimebin),
fChi2Sig( Ret::kNoFit ),
- fNdfSig( Ret::kNoFit ),
- fMinSig( Ret::kNoFit ),
+ fNdfSig( 0 ),
+ fMinSig( 0 ),
fFitSubarray( Ret::kNoFit )
{
+
AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Int_t minSig) :
fMaxSig(maxSig),
fPed( Ret::kInvalid ),
fTime( Ret::kInvalid ),
fMaxTimebin( Ret::kInvalid ),
fChi2Sig( Ret::kInvalid ),
- fNdfSig( Ret::kInvalid),
+ fNdfSig( 0 ),
fMinSig (minSig),
fFitSubarray( Ret::kInvalid )
{
}
-
+
AliCaloFitResults::~AliCaloFitResults()
// kNoFit: maximum was used, exception handling for fit invoked
// kInvalid: could not even look for maximum
+
explicit AliCaloFitResults( const Int_t maxSig,
const Float_t ped,
const Short_t fitStatus,
const Float_t amp,
- const Float_t time,
+ const double time,
const Int_t maxTimebin,
// const Float_t chi,
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,
const Float_t amp,
- const Float_t time,
+ const double time,
const Int_t maxTimebin,
// const Float_t chi,
const Float_t chi,
// shorter interface when no fit is done
+
+
explicit AliCaloFitResults( const Int_t maxSig,
const Float_t ped,
const Short_t fitStatus,
const Float_t amp,
const Int_t maxTimebin);
+
// minimum interface
explicit AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
Int_t GetStatus() const { return fStatus;};
Float_t GetAmp() const { return fAmpSig; };
Float_t GetTof() const { return fTime; };
- Float_t GetTime() const { return fTime; };
+ double GetTime() const { return fTime; };
Int_t GetMaxTimebin() const { return fMaxTimebin; };
Float_t GetChi2() const { return fChi2Sig;};
UShort_t GetNdf() const { return fNdfSig; };
AliCaloFitSubarray GetFitSubarray() const { return fFitSubarray; };
-
-
+ void SetTime(Float_t time ) { fTime = time; };
+ void SetAmp(Float_t amp ) { fAmpSig = amp; };
+
private:
// AliCaloFitResults();
UShort_t fMaxSig; //Maximum sample value ( 0 - 1023 )
Float_t fPed; //Pedestal
Int_t fStatus; //Sucess or failure of fitting pocedure
Float_t fAmpSig; //Amplitude in entities of ADC counts
- Float_t fTime; //peak/max time of signal in entities of sample intervals
+ double fTime; //peak/max time of signal in entities of sample intervals
Int_t fMaxTimebin; //timebin with maximum ADC value
Float_t fChi2Sig; //Chi Square of fit
UShort_t fNdfSig; //Number of degrees of freedom of fit
fNsamplePed(3),
fIsZerosupressed( false ),
fVerbose( false ),
- fAlgo(Algo::kNONE)
+ fAlgo(Algo::kNONE),
+// fFp(0),
+ fL1Phase(0),
+ fAmp(0),
+ fTof(0)
{
//Comment
snprintf(fName, 256,"%s", name);
snprintf(fNameShort,256, "%s", nameshort);
- for(int i=0; i < MAXSAMPLES; i++ )
+ for(int i=0; i < ALTROMAXSAMPLES; i++ )
{
fReversed[i] = 0;
}
+
+ // fFp = fopen("amp2.txt", "w");
+
}
AliCaloRawAnalyzer::~AliCaloRawAnalyzer()
AliCaloRawAnalyzer::SetTimeConstraint(const int min, const int max )
{
//Require that the bin if the maximum ADC value is between min and max (timebin)
- if( ( min > max ) || min > MAXSAMPLES || max > MAXSAMPLES )
+ if( ( min > max ) || min > ALTROMAXSAMPLES || max > ALTROMAXSAMPLES )
{
AliWarning( Form( "Attempt to set Invalid time bin range (Min , Max) = (%d, %d), Ingored", min, max ) );
}
UShort_t
-AliCaloRawAnalyzer::Max(const UShort_t *data, const int length ) const
+AliCaloRawAnalyzer::Max(const UShort_t *data, const int length )
{
//------------
UShort_t tmpmax = data[0];
void
-AliCaloRawAnalyzer::SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const first, int *const last ) const
+AliCaloRawAnalyzer::SelectSubarray( const Double_t *data, const int length, const short maxindex, int *const first, int *const last, const int cut)
{
//Selection of subset of data from one bunch that will be used for fitting or
//Peak finding. Go to the left and right of index of the maximum time bin
//Until the ADC value is less that fFitArrayCut, or derivative changes sign (data jump)
int tmpfirst = maxindex;
int tmplast = maxindex;
- Double_t prevFirst = fData[maxindex];
- Double_t prevLast = fData[maxindex];
+ Double_t prevFirst = data[maxindex];
+ Double_t prevLast = data[maxindex];
bool firstJump = false;
bool lastJump = false;
- while( (tmpfirst >= 0) && (fData[tmpfirst] >= fFitArrayCut) && (!firstJump) )
+ while( (tmpfirst >= 0) && (data[tmpfirst] >= cut ) && (!firstJump) )
{
// jump check:
if (tmpfirst != maxindex) { // neighbor to maxindex can share peak with maxindex
- if (fData[tmpfirst] >= prevFirst) {
+ if ( data[tmpfirst] >= prevFirst) {
firstJump = true;
}
}
- prevFirst = fData[tmpfirst];
+ prevFirst = data[tmpfirst];
tmpfirst -- ;
}
- while( (tmplast < length) && (fData[tmplast] >= fFitArrayCut) && (!lastJump) )
+ while( (tmplast < length) && (data[tmplast] >= cut ) && (!lastJump) )
{
// jump check:
if (tmplast != maxindex) { // neighbor to maxindex can share peak with maxindex
- if (fData[tmplast] >= prevLast) {
+ if ( data[tmplast] >= prevLast) {
lastJump = true;
}
}
- prevLast = fData[tmplast];
+ prevLast = data[tmplast];
tmplast ++;
}
short
-AliCaloRawAnalyzer::Max( const AliCaloBunchInfo *const bunch , int *const maxindex ) const
+AliCaloRawAnalyzer::Max( const AliCaloBunchInfo *const bunch , int *const maxindex )
{
//comment
short tmpmax = -1;
int
-AliCaloRawAnalyzer::SelectBunch( const vector<AliCaloBunchInfo> &bunchvector,short *const maxampbin, short *const maxamplitude ) const
+AliCaloRawAnalyzer::SelectBunch( const vector<AliCaloBunchInfo> &bunchvector,short *const maxampbin, short *const maxamplitude )
{
//We select the bunch with the highest amplitude unless any time constraints is set
short max = -1;
for(unsigned int i=0; i < bunchvector.size(); i++ )
{
max = Max( &bunchvector.at(i), &indx ); // CRAP PTH, bug fix, trouble if more than one bunches
- if( IsInTimeRange( indx) )
+ if( IsInTimeRange( indx, fMaxTimeIndex, fMinTimeIndex) )
{
if( max > maxall )
{
bool
-AliCaloRawAnalyzer::IsInTimeRange( const int maxindex ) const
+AliCaloRawAnalyzer::IsInTimeRange( const int maxindex, const int maxtindx, const int mintindx )
{
// Ckeck if the index of the max ADC vaue is consistent with trigger.
- if( ( fMinTimeIndex < 0 && fMaxTimeIndex < 0) ||fMaxTimeIndex < 0 )
+ if( ( mintindx < 0 && maxtindx < 0) ||maxtindx < 0 )
{
return true;
}
- return ( maxindex < fMaxTimeIndex ) && ( maxindex > fMinTimeIndex ) ? true : false;
+ return ( maxindex < maxtindx ) && ( maxindex > mintindx ) ? true : false;
}
int
-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)
+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,const int acut )
{ // 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
- if( index >= 0 && maxamp >= fAmpCut) // something valid was found, and non-zero amplitude
+ if( index >= 0 && maxamp >= acut ) // something valid was found, and non-zero amplitude
{
// use more convenient numbering and possibly subtract pedestal
ped = ReverseAndSubtractPed( &(bunchvector.at(index)), altrocfg1, altrocfg2, fReversed );
maxf = TMath::MaxElement( bunchvector.at(index).GetLength(), fReversed );
- if ( maxf >= fAmpCut ) // possibly significant signal
+ if ( maxf >= acut ) // possibly significant signal
{
// select array around max to possibly be used in fit
maxrev = maxampindex - bunchvector.at(index).GetStartBin();
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last, acut );
// sanity check: maximum should not be in first or last bin
// if we should do a fit
- if (first!=maxrev && last!=maxrev) {
- // calculate how many samples we have
- nsamples = last - first + 1;
- }
+ if (first!=maxrev && last!=maxrev)
+ {
+ // calculate how many samples we have
+ nsamples = last - first + 1;
+ }
}
}
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
//Base class for extraction
//of signal amplitude and peak position
//From CALO Calorimeter RAW data
-
#include "Rtypes.h"
#include "TObject.h"
-#define MAXSAMPLES 1008 //CRAP PTH
+///#define MAXSAMPLES 1008 //CRAP PTH
#include <vector>
#include "AliCaloConstants.h"
+using namespace ALTRO;
+using namespace CALO;
-//using namespace CaloConstants::FitAlgorithm;
-//using CaloConstants::ReturnCodes;
class AliCaloBunchInfo;
#include "AliCaloFitResults.h"
class AliCaloRawAnalyzer : public TObject
{
+ friend class AliCaloRawAnalyzerFactory;
+
public:
AliCaloRawAnalyzer(const char *name="AliCaloRawAnalyzer", const char *nameshort="RawAna");
virtual ~AliCaloRawAnalyzer();
void PrintBunches( const std::vector<AliCaloBunchInfo> &bunchvector ) const;
void PrintBunch( const AliCaloBunchInfo &bunch ) const ;
-
virtual int PreFitEvaluateSamples( const std::vector<AliCaloBunchInfo> &bunchvector,
+ int PreFitEvaluateSamples( const std::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);
+ Float_t & maxf, short & maxamp, short & maxampindex,
+ Float_t & ped, int & first, int & last, const int acut);
+
void SetTimeConstraint(const int min, const int max );
void SetVerbose(bool verbose = true){ fVerbose = verbose; };
void SetIsZeroSuppressed(const bool iszs = true) { fIsZerosupressed = iszs; } ;
void CalculateMeanAndRMS(const Int_t first, const Int_t last,
Double_t & mean, Double_t & rms);
-
- protected:
+ void SetL1Phase(const Double_t phase) {fL1Phase = phase;};
+
+protected:
public: // PAI
- short Max( const AliCaloBunchInfo *const bunch, int *const maxindex) const;
- UShort_t Max(const UShort_t *data, const int length ) const;
+ short Max( const AliCaloBunchInfo *const bunch, int *const maxindex);
+ UShort_t Max(const UShort_t *data, const int length );
bool CheckBunchEdgesForMax( const AliCaloBunchInfo *const bunch) const;
- bool IsInTimeRange( const int maxindex ) const;
+ bool IsInTimeRange( const int maxindex, const int maxtime, const int mintime );
Float_t ReverseAndSubtractPed( const AliCaloBunchInfo *bunch, const UInt_t altrocfg1, const UInt_t altrocfg2, double *outarray ) const;
- int SelectBunch( const std::vector<AliCaloBunchInfo> &bunchvector, short *const maxampbin, short *const maxamplitude ) const;
- virtual void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const first, int *const last ) const;
+ int SelectBunch( const std::vector<AliCaloBunchInfo> &bunchvector, short *const maxampbin, short *const maxamplitude );
+ void SelectSubarray( const Double_t *date, const int length, const short maxindex, int *const first, int *const last, const int cut);
Float_t EvaluatePedestal(const UShort_t * const data, const int length ) const;
-
- Double_t fReversed[MAXSAMPLES]; //Reversed sequence of samples (pedestalsubtracted)
-
+ Double_t fReversed[ALTROMAXSAMPLES]; //Reversed sequence of samples (pedestalsubtracted)
// private:
int fMinTimeIndex; //The timebin of the max signal value must be between fMinTimeIndex and fMaxTimeIndex
int fMaxTimeIndex; //The timebin of the max signal value must be between fMinTimeIndex and fMaxTimeIndex
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
-
-
// CaloConstants fAlgo;
Algo::fitAlgorithm fAlgo;
+ // FILE *fFp;
+ Double_t fL1Phase;
+ Double_t fAmp; // The amplitude in entities of ADC counts
+ Double_t fTof; // The amplitude in entities of ADC counts
+
ClassDef(AliCaloRawAnalyzer, 2)
};
#include "TMath.h"
using namespace std;
-#include "AliCaloConstants.h"
+//#include "AliCaloConstants.h"
ClassImp(AliCaloRawAnalyzerCrude)
int first = 0;
int last = 0;
int maxrev = maxampindex - bunchvector.at(index).GetStartBin();
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last, fFitArrayCut );
Float_t chi2 = CalculateChi2(maxf, maxrev, first, last);
Int_t ndf = last - first - 1; // nsamples - 2
class AliCaloFitResults;
class AliCaloBunchInfo;
+//class AliEMCALQADataMakerRec
+
class AliCaloRawAnalyzerCrude : public AliCaloRawAnalyzer
{
+
+ //friend class AliEMCALQADataMakerRec;
+ friend class AliCaloRawAnalyzerFactory;
+ // friend class AliHLTPHOSRawAnalyzerCrudeComponent;
+ // friend class AliHLTEMCALRawAnalyzerCrudeComponent;
+
public:
+ AliCaloRawAnalyzerCrude();
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
const UInt_t altrocfg1, const UInt_t altrocfg2 );
-
- AliCaloRawAnalyzerCrude();
- virtual ~AliCaloRawAnalyzerCrude();
-
- ClassDef(AliCaloRawAnalyzerCrude, 1)
-
+ // AliCaloRawAnalyzerCrude();
+ virtual ~AliCaloRawAnalyzerCrude();
+
+ private:
+ //// AliCaloRawAnalyzerCrude();
+
+ ClassDef(AliCaloRawAnalyzerCrude, 1)
+
+
};
#endif
--- /dev/null
+// -*- mode: c++ -*-
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear *
+ * Physics Group, Dep. of Physics *
+ * University of Oslo, Norway, 2007 *
+ * *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to perthi@fys.uio.no *
+ * *
+ * 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. *
+ **************************************************************************/
+
+#include "AliCaloRawAnalyzerFactory.h"
+#include "AliCaloRawAnalyzerFastFit.h"
+#include "AliCaloRawAnalyzerNN.h"
+#include "AliCaloRawAnalyzerLMS.h"
+#include "AliCaloRawAnalyzerPeakFinder.h"
+#include "AliCaloRawAnalyzerCrude.h"
+#include "AliCaloRawAnalyzerLMSOffline.h"
+#include "AliCaloRawAnalyzerKStandard.h"
+#include "AliCaloRawAnalyzerFakeALTRO.h"
+
+AliCaloRawAnalyzerFactory::AliCaloRawAnalyzerFactory()
+{
+
+}
+
+AliCaloRawAnalyzerFactory::~AliCaloRawAnalyzerFactory()
+{
+
+}
+
+AliCaloRawAnalyzer*
+AliCaloRawAnalyzerFactory::CreateAnalyzer( const int algo )
+{
+ switch ( algo)
+ {
+ case kFastFit:
+ return new AliCaloRawAnalyzerFastFit();
+ break;
+ case kNeuralNet:
+ return new AliCaloRawAnalyzerNN();
+ break;
+ case kLMS:
+ //return new AliCaloRawAnalyzerLMS();
+ return new AliCaloRawAnalyzerLMSOffline();
+ break;
+ case kPeakFinder:
+ return new AliCaloRawAnalyzerPeakFinder();
+ break;
+ case kCrude:
+ return new AliCaloRawAnalyzerCrude();
+ break;
+ case kLMSOffline:
+ return new AliCaloRawAnalyzerLMSOffline();
+ break;
+ case kStandard:
+ return new AliCaloRawAnalyzerKStandard();
+ break;
+ case kFakeAltro:
+ return new AliCaloRawAnalyzerFakeALTRO();
+ break;
+ default:
+ return new AliCaloRawAnalyzerCrude();
+ break;
+ }
+}
+
+
+
+
+
--- /dev/null
+// -*- mode: c++ -*-
+
+#ifndef ALICALORAWANALYZERFACTORY_H
+#define ALICALORAWANALYZERFACTORY_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear *
+ * Physics Group, Yale University, US 2011 *
+ * *
+ * Author: Per Thomas Hille <perthomas.hille@yale.edu> for the ALICE *
+ * experiment. Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to perthomas.hille@yale.edu *
+ * *
+ * 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. *
+ **************************************************************************/
+
+#include "AliCaloConstants.h"
+using namespace Algo;
+
+class AliCaloRawAnalyzer;
+
+class AliCaloRawAnalyzerFactory
+{
+public:
+ virtual ~AliCaloRawAnalyzerFactory();
+ static AliCaloRawAnalyzer* CreateAnalyzer( const int algo );
+
+private:
+ AliCaloRawAnalyzerFactory();
+};
+
+#endif
fFixTau(kTRUE)
{
//comment
- for(int i=0; i < MAXSAMPLES; i++)
+ for(int i=0; i < ALTROMAXSAMPLES; i++)
{
fXaxis[i] = i;
}
{
int first = 0;
int last = 0;
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last, fFitArrayCut );
int nsamples = last - first + 1;
if( ( nsamples ) >= fNsampleCut )
class AliCaloRawAnalyzerFakeALTRO : public AliCaloRawAnalyzer
{
+ friend class AliCaloRawAnalyzerFactory;
+
public:
- AliCaloRawAnalyzerFakeALTRO();
+ //AliCaloRawAnalyzerFakeALTRO();
virtual ~AliCaloRawAnalyzerFakeALTRO();
-
+
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1, const UInt_t altrocfg2 );
void PrintFitResult(const TF1 *f) const;
TF1 * GetFit() const { return fTf1; };
private:
+ AliCaloRawAnalyzerFakeALTRO();
AliCaloRawAnalyzerFakeALTRO(const AliCaloRawAnalyzerFakeALTRO & );
AliCaloRawAnalyzerFakeALTRO & operator = (const AliCaloRawAnalyzerFakeALTRO &);
- double fXaxis[MAXSAMPLES]; //Axis if time bins, ( used by TGraph )
+ double fXaxis[ALTROMAXSAMPLES]; //Axis if time bins, ( used by TGraph )
const double fkEulerSquared; //e^2 = 7.389056098930650227
TF1 *fTf1; // Analytical formula of the Semi Gaussian to be fitted
int last = 0;
int maxrev = maxampindex - bunchvector.at(index).GetStartBin();
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last, fFitArrayCut);
+
int nsamples = last - first + 1;
if( ( nsamples ) >= fNsampleCut )
class AliCaloRawAnalyzerFastFit : public AliCaloRawAnalyzer
{
+ friend class AliCaloRawAnalyzerFactory;
public:
- AliCaloRawAnalyzerFastFit();
+ //AliCaloRawAnalyzerFastFit();
virtual ~AliCaloRawAnalyzerFastFit();
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
const UInt_t altrocfg1, const UInt_t altrocfg2 );
private:
+ AliCaloRawAnalyzerFastFit();
Double_t fXAxis[1008]; // Xaxis (time bins) corresponding to the ADC samples
ClassDef( AliCaloRawAnalyzerFastFit, 1 )
--- /dev/null
+/**************************************************************************
+ * This file is property of and copyright by *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009 *
+ * *
+ * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no> *
+ * *
+ * Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to p.t.hille@fys.uio.no *
+ * *
+ * 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. *
+ **************************************************************************/
+
+
+// Extraction of amplitude and peak position
+// FRom CALO raw data using
+// least square fit for the
+// Moment assuming identical and
+// independent errors (equivalent with chi square)
+//
+
+#include "AliCaloRawAnalyzerKStandard.h"
+#include "AliCaloBunchInfo.h"
+#include "AliCaloFitResults.h"
+#include "AliLog.h"
+#include "TMath.h"
+#include <stdexcept>
+#include <iostream>
+#include "TF1.h"
+#include "TGraph.h"
+#include "TRandom.h"
+
+
+using namespace std;
+
+
+#define BAD 4 //CRAP PTH
+
+ClassImp( AliCaloRawAnalyzerKStandard )
+
+
+AliCaloRawAnalyzerKStandard::AliCaloRawAnalyzerKStandard() : AliCaloRawAnalyzer("Chi Square ( kStandard )", "KStandard"),
+ fkEulerSquared(7.389056098930650227),
+ fTf1(0),
+ fTau(2.35),
+ fFixTau(kTRUE)
+{
+
+ fAlgo = Algo::kStandard;
+ //comment
+ for(int i=0; i < ALTROMAXSAMPLES; i++)
+ {
+ fXaxis[i] = i;
+ }
+
+ 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);
+ }
+}
+
+
+AliCaloRawAnalyzerKStandard::~AliCaloRawAnalyzerKStandard()
+{
+ delete fTf1;
+}
+
+
+
+AliCaloFitResults
+AliCaloRawAnalyzerKStandard::Evaluate( const vector<AliCaloBunchInfo> &bunchlist, const UInt_t altrocfg1, const UInt_t altrocfg2 )
+{
+
+ Float_t pedEstimate = 0;
+ short maxADC = 0;
+ Int_t first = 0;
+ Int_t last = 0;
+ Int_t bunchIndex = 0;
+ Float_t ampEstimate = 0;
+ short timeEstimate = 0;
+ Float_t time = 0;
+ Float_t amp=0;
+ Float_t chi2 = 0;
+ Int_t ndf = 0;
+ Bool_t fitDone = kFALSE;
+
+
+ int nsamples = PreFitEvaluateSamples( bunchlist, altrocfg1, altrocfg2, bunchIndex, ampEstimate,
+ maxADC, timeEstimate, pedEstimate, first, last, fAmpCut );
+
+
+ if (ampEstimate >= fAmpCut )
+ {
+ time = timeEstimate;
+ Int_t timebinOffset = bunchlist.at(bunchIndex).GetStartBin() - (bunchlist.at(bunchIndex).GetLength()-1);
+ amp = ampEstimate;
+
+ if ( nsamples > 1 && maxADC< OVERFLOWCUT )
+ {
+ FitRaw(first, last, amp, time, chi2, fitDone);
+ time += timebinOffset;
+ timeEstimate += timebinOffset;
+ ndf = nsamples - 2;
+ }
+ }
+ if ( fitDone )
+ {
+ Float_t ampAsymm = (amp - ampEstimate)/(amp + ampEstimate);
+ Float_t timeDiff = time - timeEstimate;
+
+ if ( (TMath::Abs(ampAsymm) > 0.1) || (TMath::Abs(timeDiff) > 2) )
+ {
+ amp = ampEstimate;
+ time = timeEstimate;
+ fitDone = kFALSE;
+ }
+ }
+ if (amp >= fAmpCut )
+ {
+ if ( ! fitDone)
+ {
+ amp += (0.5 - gRandom->Rndm());
+ }
+ //Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
+ // lowGain = in.IsLowGain();
+
+ time = time * TIMEBINWITH;
+
+ /////////////!!!!!!!!!time -= in.GetL1Phase();
+
+ time -= fL1Phase;
+
+ // AliDebug(2,Form("id %d lowGain %d amp %g", id, lowGain, amp));
+ // AddDigit(digitsArr, id, lowGain, amp, time, chi2, ndf);
+
+
+ return AliCaloFitResults( -99, -99, fAlgo , amp, time,
+ time, chi2, ndf, Ret::kDummy );
+
+
+ // AliCaloFitSubarray(index, maxrev, first, last));
+
+ }
+
+
+ return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid );
+}
+
+
+
+
+/*
+ return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset,
+ timebinOffset, chi2, ndf, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+ }
+ } // ampcut
+ }
+ return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid );
+*/
+
+
+/*
+ // Extracting signal parameters using fitting
+ short maxampindex; //index of maximum amplitude
+ short maxamp; //Maximum amplitude
+ int index = SelectBunch( bunchvector, &maxampindex, &maxamp );
+
+ if( index >= 0)
+ {
+ 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();
+ // timebinOffset is timebin value at maximum (maxrev)
+ short timebinOffset = maxampindex - (bunchvector.at(index).GetLength()-1);
+ if( maxf < fAmpCut || ( maxamp - ped) > fOverflowCut ) // (maxamp - ped) > fOverflowCut = Close to saturation (use low gain then)
+ {
+ return AliCaloFitResults( maxamp, ped, Ret::kCrude, maxf, timebinOffset);
+ }
+ else if ( maxf >= fAmpCut )
+ {
+ int first = 0;
+ int last = 0;
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last, fFitArrayCut);
+ int nsamples = last - first + 1;
+
+ if( ( nsamples ) >= fNsampleCut )
+ {
+ Float_t tmax = (maxrev - first); // local tmax estimate
+ TGraph *graph = new TGraph( nsamples, fXaxis, &fReversed[first] );
+ fTf1->SetParameter(0, maxf*fkEulerSquared );
+ fTf1->SetParameter(1, tmax - fTau);
+ // set rather loose parameter limits
+ fTf1->SetParLimits(0, 0.5*maxf*fkEulerSquared, 2*maxf*fkEulerSquared );
+ fTf1->SetParLimits(1, tmax - fTau - 4, tmax - fTau + 4);
+
+ if (fFixTau) {
+ fTf1->FixParameter(2, fTau);
+ }
+ else {
+ fTf1->ReleaseParameter(2); // allow par. to vary
+ fTf1->SetParameter(2, fTau);
+ }
+
+ Short_t tmpStatus = 0;
+ try {
+ tmpStatus = graph->Fit(fTf1, "Q0RW");
+ }
+ catch (const std::exception & e) {
+ AliError( Form("TGraph Fit exception %s", e.what()) );
+ return AliCaloFitResults( maxamp, ped, Ret::kNoFit, maxf, timebinOffset,
+ timebinOffset, Ret::kDummy, Ret::kDummy, Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+ }
+
+ if( fVerbose == true )
+ {
+ AliCaloRawAnalyzer::PrintBunch( bunchvector.at(index) );
+ PrintFitResult( fTf1 ) ;
+ }
+ // global tmax
+ tmax = fTf1->GetParameter(1) + timebinOffset - (maxrev - first) // abs. t0
+ + fTf1->GetParameter(2); // +tau, makes sum tmax
+
+ delete graph;
+ return AliCaloFitResults( maxamp, ped , Ret::kFitPar,
+ fTf1->GetParameter(0)/fkEulerSquared,
+ tmax,
+ timebinOffset,
+ fTf1->GetChisquare(),
+ fTf1->GetNDF(),
+ Ret::kDummy, AliCaloFitSubarray(index, maxrev, first, last) );
+
+ // delete graph;
+
+ }
+ 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
+ }
+ return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid );
+
+}
+*/
+
+
+
+void
+AliCaloRawAnalyzerKStandard::PrintFitResult(const TF1 *f) const
+{
+ //comment
+ cout << endl;
+ cout << __FILE__ << __LINE__ << "Using this samplerange we get" << endl;
+ cout << __FILE__ << __LINE__ << "AMPLITUDE = " << f->GetParameter(0)/fkEulerSquared << ",.. !!!!" << endl;
+ cout << __FILE__ << __LINE__ << "TOF = " << f->GetParameter(1) << ",.. !!!!" << endl;
+ cout << __FILE__ << __LINE__ << "NDF = " << f->GetNDF() << ",.. !!!!" << endl;
+ // cout << __FILE__ << __LINE__ << "STATUS = " << f->GetStatus() << ",.. !!!!" << endl << endl;
+ cout << endl << endl;
+}
+
+
+
+
+
+//____________________________________________________________________________
+void
+ AliCaloRawAnalyzerKStandard::FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const
+{ // Fits the raw signal time distribution
+
+ //--------------------------------------------------
+ //Do the fit, different fitting algorithms available
+ //--------------------------------------------------
+
+ // fprintf(fp, "%s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__ );
+
+ int nsamples = lastTimeBin - firstTimeBin + 1;
+ fitDone = kFALSE;
+
+ // switch(fFittingAlgorithm)
+ // {
+ // case Algo::kStandard:
+ // {
+ if (nsamples < 3) { return; } // nothing much to fit
+ //printf("Standard fitter \n");
+
+ // Create Graph to hold data we will fit
+
+ TGraph *gSig = new TGraph( nsamples);
+
+ for (int i=0; i<nsamples; i++)
+ {
+ Int_t timebin = firstTimeBin + i;
+ gSig->SetPoint(i, timebin, GetReversed(timebin));
+ }
+
+ TF1 * signalF = new TF1("signal", 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); // tau in units of time bin
+ signalF->FixParameter(3,ORDER); // order
+ signalF->FixParameter(4, 0); // pedestal should be subtracted when we get here
+ signalF->SetParameter(1, time);
+ signalF->SetParameter(0, amp);
+ // set rather loose parameter limits
+ signalF->SetParLimits(0, 0.5*amp, 2*amp );
+ signalF->SetParLimits(1, time - 4, time + 4);
+
+ try {
+ gSig->Fit(signalF, "QROW"); // Note option 'W': equal errors on all points
+ // assign fit results
+ amp = signalF->GetParameter(0);
+ time = signalF->GetParameter(1);
+ 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;
+ }
+ delete signalF;
+
+ //printf("Std : Amp %f, time %g\n",amp, time);
+ delete gSig; // delete TGraph
+
+ // break;
+ // }//kStandard Fitter
+ //----------------------------
+
+ /*
+ case Algo::kLogFit:
+ {
+ if (nsamples < 3) { return; } // nothing much to fit
+ //printf("LogFit \n");
+
+ // Create Graph to hold data we will fit
+ TGraph *gSigLog = new TGraph( nsamples);
+ for (int i=0; i<nsamples; i++) {
+ Int_t timebin = firstTimeBin + i;
+ gSigLog->SetPoint(timebin, timebin, TMath::Log(fRawAnalyzer->GetReversed(timebin) ) );
+ }
+
+ TF1 * signalFLog = new TF1("signalLog", RawResponseFunctionLog, 0, TIMEBINS , 5);
+ signalFLog->SetParameters(2.3, 5.,TAU,ORDER,0.); //set all defaults once, just to be safe
+ signalFLog->SetParNames("amplog","t0","tau","N","ped");
+ signalFLog->FixParameter(2,TAU); // tau in units of time bin
+ signalFLog->FixParameter(3, ORDER); // order
+ signalFLog->FixParameter(4, 0); // pedestal should be subtracted when we get here
+ signalFLog->SetParameter(1, time);
+ if (amp>=1) {
+ signalFLog->SetParameter(0, TMath::Log(amp));
+ }
+
+ gSigLog->Fit(signalFLog, "QROW"); // Note option 'W': equal errors on all points
+
+ // assign fit results
+ Double_t amplog = signalFLog->GetParameter(0); //Not Amp, but Log of Amp
+ amp = TMath::Exp(amplog);
+ time = signalFLog->GetParameter(1);
+ fitDone = kTRUE;
+
+ delete signalFLog;
+ //printf("LogFit: Amp %f, time %g\n",amp, time);
+ delete gSigLog;
+ break;
+ } //kLogFit
+ //----------------------------
+ //----------------------------
+ }//switch fitting algorithms
+ */
+ return;
+}
+
+
+//__________________________________________________________________
+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] ;
+ //printf("Yves : Amp %f, time %g\n",amp, time);
+ //END YS
+ return;
+}
+
+
+
+//__________________________________________________________________
+Double_t
+AliCaloRawAnalyzerKStandard::RawResponseFunction(Double_t *x, Double_t *par)
+{
+ // Matches version used in 2007 beam test
+ //
+ // Shape of the electronics raw reponse:
+ // It is a semi-gaussian, 2nd order Gamma function of the general form
+ //
+ // xx = (t - t0 + tau) / tau [xx is just a convenient help variable]
+ // F = A * (xx**N * exp( N * ( 1 - xx) ) for xx >= 0
+ // F = 0 for xx < 0
+ //
+ // parameters:
+ // A: par[0] // Amplitude = peak value
+ // t0: par[1]
+ // tau: par[2]
+ // N: par[3]
+ // ped: par[4]
+ //
+ 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 ;
+}
+
--- /dev/null
+#ifndef ALICALORAWANALYZERSTANDARD_H
+#define ALICALORAWANALYZERSTANDARD_H
+/**************************************************************************
+ * This file is property of and copyright by *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009 *
+ * *
+ * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no> *
+ * *
+ * Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to p.t.hille@fys.uio.no *
+ * *
+ * 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. *
+ **************************************************************************/
+
+
+// Extraction of amplitude and peak position
+// FRom CALO raw data using
+// Chi square fit
+
+#include "AliCaloRawAnalyzer.h"
+#include "AliCaloConstants.h"
+
+using namespace ALTRO;
+using namespace EMCAL;
+
+class TF1;
+class TGraph;
+
+class AliCaloRawAnalyzerKStandard : public AliCaloRawAnalyzer
+{
+ friend class AliCaloRawAnalyzerFactory;
+
+ public:
+ //AliCaloRawAnalyzerKStandard();
+ virtual ~AliCaloRawAnalyzerKStandard();
+ virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1, const UInt_t altrocfg2 );
+ void PrintFitResult(const TF1 *f) const;
+ static Double_t RawResponseFunction(Double_t *x, Double_t *par);
+ void FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time,
+ Float_t & chi2, Bool_t & fitDone) const ;
+
+ void FitParabola(const TGraph *gSig, Float_t & amp) 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; };
+
+ // extra interfaces
+ TF1 * GetFit() const { return fTf1; };
+
+ private:
+ AliCaloRawAnalyzerKStandard();
+ AliCaloRawAnalyzerKStandard(const AliCaloRawAnalyzerKStandard & );
+ AliCaloRawAnalyzerKStandard & operator = (const AliCaloRawAnalyzerKStandard &);
+
+ double fXaxis[ALTROMAXSAMPLES]; //Axis if time bins, ( used by TGraph )
+ const double fkEulerSquared; //e^2 = 7.389056098930650227
+ TF1 *fTf1; // Analytical formula of the Semi Gaussian to be fitted
+
+ Float_t fTau; // shaper tau, in time bins
+ Bool_t fFixTau; // flag if tau should be fix
+
+ ClassDef(AliCaloRawAnalyzerKStandard, 2)
+
+};
+
+#endif
#include "TF1.h"
#include "TGraph.h"
+
using namespace std;
fAlgo = Algo::kLMS;
//comment
- for(int i=0; i < MAXSAMPLES; i++)
+ for(int i=0; i < ALTROMAXSAMPLES; i++)
{
fXaxis[i] = i;
}
{
int first = 0;
int last = 0;
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last, fFitArrayCut);
int nsamples = last - first + 1;
if( ( nsamples ) >= fNsampleCut )
}
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,
// Chi square fit
#include "AliCaloRawAnalyzer.h"
+#include "AliCaloConstants.h"
+using namespace ALTRO;
class TF1;
class TGraph;
class AliCaloRawAnalyzerLMS : public AliCaloRawAnalyzer
{
+ friend class AliCaloRawAnalyzerFactory;
+
public:
- AliCaloRawAnalyzerLMS();
+ // AliCaloRawAnalyzerLMS();
virtual ~AliCaloRawAnalyzerLMS();
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector, const UInt_t altrocfg1, const UInt_t altrocfg2 );
void PrintFitResult(const TF1 *f) const;
TF1 * GetFit() const { return fTf1; };
private:
+ AliCaloRawAnalyzerLMS();
AliCaloRawAnalyzerLMS(const AliCaloRawAnalyzerLMS & );
AliCaloRawAnalyzerLMS & operator = (const AliCaloRawAnalyzerLMS &);
- double fXaxis[MAXSAMPLES]; //Axis if time bins, ( used by TGraph )
+ double fXaxis[ALTROMAXSAMPLES]; //Axis if time bins, ( used by TGraph )
const double fkEulerSquared; //e^2 = 7.389056098930650227
TF1 *fTf1; // Analytical formula of the Semi Gaussian to be fitted
--- /dev/null
+/**************************************************************************
+ * This file is property of and copyright by *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009 *
+ * *
+ * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no> *
+ * *
+ * Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to p.t.hille@fys.uio.no *
+ * *
+ * 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. *
+ **************************************************************************/
+
+// Extraction of amplitude and peak position
+// FRom CALO raw data using
+// least square fit for the
+// Moment assuming identical and
+// independent errors (equivalent with chi square)
+//
+
+#include "AliCaloRawAnalyzerLMSOffline.h"
+#include "AliCaloBunchInfo.h"
+#include "AliCaloFitResults.h"
+#include "AliLog.h"
+#include "TMath.h"
+#include <stdexcept>
+#include <iostream>
+#include "TF1.h"
+#include "TGraph.h"
+#include "AliEMCALRawUtils.h"
+#include <TRandom.h>
+
+//#include "AliCaloRawAnalyzerLMS.h"
+
+#include "AliCaloRawAnalyzerFactory.h"
+
+using namespace std;
+
+
+//#define BAD 4 //CRAP PTH
+
+ClassImp( AliCaloRawAnalyzerLMSOffline )
+
+
+AliCaloRawAnalyzerLMSOffline::AliCaloRawAnalyzerLMSOffline() : AliCaloRawAnalyzer("Chi Square Fit OFFLINE", "LMSOffline"),
+ fNoiseThreshold(0),
+ fRawAnalyzer(0), fSmearFactor()
+{
+ fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer(kLMS);
+ fAlgo = Algo::kLMSOffline;
+}
+
+
+AliCaloRawAnalyzerLMSOffline::~AliCaloRawAnalyzerLMSOffline()
+{
+ // delete fTf1;
+}
+
+
+AliCaloFitResults
+AliCaloRawAnalyzerLMSOffline::Evaluate( const vector<AliCaloBunchInfo> &bunchlist, const UInt_t altrocfg1, const UInt_t altrocfg2 )
+{
+ // fRawAnalyzer setup
+ fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done, for the new methods
+ fRawAnalyzer->SetOverflowCut(OVERFLOWCUT);
+ fRawAnalyzer->SetAmpCut(fNoiseThreshold);
+ fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
+
+ // fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
+
+ fRawAnalyzer->SetIsZeroSuppressed(fIsZerosupressed); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
+
+
+ AliCaloFitResults fitResults;
+ Float_t time = 0;
+ Float_t amp = 0;
+ short timeEstimate = 0;
+ Float_t ampEstimate = 0;
+ Bool_t fitDone = kFALSE;
+ fitResults = fRawAnalyzer->Evaluate( bunchlist, altrocfg1, altrocfg2 );
+ amp = fitResults.GetAmp();
+ time = fitResults.GetTime();
+ timeEstimate = fitResults.GetMaxTimebin();
+ ampEstimate = fitResults.GetMaxSig();
+
+ if (fitResults.GetStatus() == Ret::kFitPar)
+ {
+ fitDone = kTRUE;
+ }
+
+ if ( fitDone )
+ { // brief sanity check of fit results
+ Float_t ampAsymm = (amp - ampEstimate)/(amp + ampEstimate);
+ Float_t timeDiff = time - timeEstimate;
+
+ if ( (TMath::Abs(ampAsymm) > 0.1) || (TMath::Abs(timeDiff) > 2) )
+ {
+ amp = ampEstimate;
+ time = timeEstimate;
+ fitDone = kFALSE;
+ }
+ } // fitDone
+
+ if (amp >= fNoiseThreshold)
+ { // something to be stored
+ if ( ! fitDone)
+ { // smear ADC with +- 0.5 uniform (avoid discrete effects)
+ fSmearFactor = (0.5 - gRandom->Rndm() );
+ amp += fSmearFactor; // Rndm generates a number in ]0,1]
+ }
+ // go from time-bin units to physical time fgtimetrigger
+ time = time *TIMEBINWITH; // skip subtraction of fgTimeTrigger?
+ // subtract RCU L1 phase (L1Phase is in seconds) w.r.t. L0:
+ // time -= in.GetL1Phase();
+ time -= fL1Phase;
+ time = time/ TIMEBINWITH;
+ }
+ fitResults.SetTime(time);
+ fitResults.SetAmp(amp);
+ return fitResults ;
+}
+
--- /dev/null
+#ifndef ALICALORAWANALYZERLMSOFFLINE_H
+#define ALICALORAWANALYZERLMSOFFLINE_H
+/**************************************************************************
+ * This file is property of and copyright by *
+ * the Relativistic Heavy Ion Group (RHIG), Yale University, US, 2009 *
+ * *
+ * Primary Author: Per Thomas Hille <p.t.hille@fys.uio.no> *
+ * *
+ * Contributors are mentioned in the code where appropriate. *
+ * Please report bugs to p.t.hille@fys.uio.no *
+ * *
+ * 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. *
+ **************************************************************************/
+// Extraction of amplitude and peak position
+// FRom CALO raw data using
+// Chi square fit
+
+#include "AliCaloRawAnalyzer.h"
+
+class AliCaloRawAnalyzerLMS;
+
+
+class AliCaloRawAnalyzerLMSOffline : public AliCaloRawAnalyzer
+{
+ friend class AliCaloRawAnalyzerFactory;
+
+ public:
+ // AliCaloRawAnalyzerLMSOffline();
+ virtual ~AliCaloRawAnalyzerLMSOffline();
+ virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
+ const UInt_t altrocfg1, const UInt_t altrocfg2 );
+ Double_t GetSmearFactor() { return fSmearFactor; };
+
+ private:
+ AliCaloRawAnalyzerLMSOffline();
+ AliCaloRawAnalyzerLMSOffline(const AliCaloRawAnalyzerLMSOffline & );
+ AliCaloRawAnalyzerLMSOffline & operator = (const AliCaloRawAnalyzerLMSOffline &);
+ Int_t fNoiseThreshold; // threshold to consider signal or noise
+ AliCaloRawAnalyzer *fRawAnalyzer;
+ Double_t fSmearFactor;
+ ClassDef(AliCaloRawAnalyzerLMSOffline, 2)
+
+};
+
+#endif
// The eveluation of Peak position and amplitude using the Neural Network
if( bunchvector.size() <= 0 )
{
+ // cout << __FILE__ << __LINE__<< " INVALID "<< endl;
+
return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
}
if( index < 0 )
{
+ // cout << __FILE__ << __LINE__<< "INVALID !!!!!!" << endl;
return AliCaloFitResults( Ret::kInvalid, Ret::kInvalid);
}
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);
}
int first = 0;
int last = 0;
short maxrev = maxampindex - bunchvector.at(index).GetStartBin();
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev , &first, &last, fFitArrayCut );
Float_t chi2 = 0;
Int_t ndf = 0;
{
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) );
}
// 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) );
}
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) );
class AliCaloRawAnalyzerNN : public AliCaloRawAnalyzer
{
+ friend class AliCaloRawAnalyzerFactory;
public:
- AliCaloRawAnalyzerNN();
+ // AliCaloRawAnalyzerNN();
virtual ~AliCaloRawAnalyzerNN();
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
const UInt_t altrocfg1, const UInt_t altrocfg2 );
// virtual void SelectSubarray( const Double_t *fData, const int length, const short maxindex, int *const first, int *const last ) const;
private:
+ AliCaloRawAnalyzerNN();
AliCaloRawAnalyzerNN( const AliCaloRawAnalyzerNN & );
AliCaloRawAnalyzerNN & operator = ( const AliCaloRawAnalyzerNN & );
AliCaloNeuralFit *fNeuralNet; // pointer to the class whick actually implements the Neural Network for EMCAL
#include "TFile.h"
#include "AliCaloPeakFinderVectors.h"
#include <iostream>
+//#include "AliEMCALRawUtils.h"
+
using namespace std;
AliCaloRawAnalyzerPeakFinder::AliCaloRawAnalyzerPeakFinder() :AliCaloRawAnalyzer("Peak-Finder", "PF"),
- fAmp(0),
+// fAmp(0),
fPeakFinderVectors(0),
fRunOnAlien(false),
fIsInitialized(false)
int first = 0;
int last = 0;
short maxrev = maxampindex - bunchvector.at(index).GetStartBin();
- SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last);
+ SelectSubarray( fReversed, bunchvector.at(index).GetLength(), maxrev, &first, &last, fFitArrayCut);
int nsamples = last - first;
if( ( nsamples ) >= fNsampleCut ) // no if statement needed really; keep for readability
fAmp = maxf;
}
- tof = timebinOffset - 0.01*tof/fAmp; // clock ticks
+ // tof = timebinOffset - 0.01*tof/fAmp; // clock ticks
+ tof = timebinOffset - 0.01*tof/fAmp - fL1Phase/TIMEBINWITH; // clock
+
// use local-array time for chi2 estimate
Float_t chi2 = CalculateChi2(fAmp, tof-timebinOffset+maxrev, first, last);
Int_t ndf = last - first - 1; // nsamples - 2
class AliCaloRawAnalyzerPeakFinder : public AliCaloRawAnalyzer
{
+ friend class AliCaloRawAnalyzerFactory;
public:
- AliCaloRawAnalyzerPeakFinder();
+ // AliCaloRawAnalyzerPeakFinder( );
virtual ~AliCaloRawAnalyzerPeakFinder();
virtual AliCaloFitResults Evaluate( const std::vector<AliCaloBunchInfo> &bunchvector,
const UInt_t altrocfg1, const UInt_t altrocfg2 );
private:
+ AliCaloRawAnalyzerPeakFinder();
AliCaloRawAnalyzerPeakFinder( const AliCaloRawAnalyzerPeakFinder & );
AliCaloRawAnalyzerPeakFinder & operator = ( const AliCaloRawAnalyzerPeakFinder & );
void LoadVectorsASCII();
Double_t fPFTofVectorsCoarse[PF::MAXSTART][PF::SAMPLERANGE][100]; // Vectors for TOF extraction, first iteration
Double_t fPFAmpVectors[PF::MAXSTART][PF::SAMPLERANGE][100]; // Vectors for Amplitude extraction, second iteration
Double_t fPFTofVectors[PF::MAXSTART][PF::SAMPLERANGE][100]; // Vectors for TOF extraction, second iteration
- Double_t fAmp; // The amplitude in entities of ADC counts
+
+ //Double_t fAmp; // The amplitude in entities of ADC counts
+
AliCaloPeakFinderVectors *fPeakFinderVectors; // Collection of Peak-Fincer vectors
bool fRunOnAlien; // Wether or not we are running on the GRID
bool fIsInitialized;
#include "AliCaloRawAnalyzerPeakFinder.h"
#include "AliCaloRawAnalyzerCrude.h"
+#include "AliCaloRawAnalyzerFactory.h"
+
using namespace std;
ClassImp(AliEMCALQADataMakerRec)
{
// ctor
SetFittingAlgorithm(fitAlgo);
- fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
+
+ //fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
+
+ fRawAnalyzerTRU = ( AliCaloRawAnalyzerLMS*)AliCaloRawAnalyzerFactory::CreateAnalyzer(kLMS);
+
fRawAnalyzerTRU->SetFixTau(kTRUE);
fRawAnalyzerTRU->SetTau(2.5); // default for TRU shaper
// for (Int_t sm = 0 ; sm < fSuperModules ; sm++){
SetName((const char*)qadm.GetName()) ;
SetTitle((const char*)qadm.GetTitle());
SetFittingAlgorithm(qadm.GetFittingAlgorithm());
- fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
+
+ //fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
+ fRawAnalyzerTRU = (AliCaloRawAnalyzerLMS*)AliCaloRawAnalyzerFactory::CreateAnalyzer(kLMS);
fRawAnalyzerTRU->SetFixTau(kTRUE);
fRawAnalyzerTRU->SetTau(2.5); // default for TRU shaper
// for (Int_t sm = 0 ; sm < fSuperModules ; sm++){
{
//Set fitting algorithm and initialize it if this same algorithm was not set before.
//printf("**** Set Algorithm , number %d ****\n",fitAlgo);
+
+
+ // fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer(fitAlgo);
+ // fFittingAlgorithm = fitAlgo;
+
+ //CRAP PTH
+ fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer(kLMS);
+ fFittingAlgorithm = kLMS;
+
+
+ /*
if(fitAlgo == fFittingAlgorithm && fRawAnalyzer) {
//Do nothing, this same algorithm already set before.
//printf("**** Algorithm already set before, number %d, %s ****\n",fitAlgo, fRawAnalyzer->GetName());
}
return;
+ */
}
//_____________________________________________________________________________________
private:
void ConvertProfile2H(TProfile * p, TH2 * histo) ; //change the profile plot to a 2D histogram
- Int_t fFittingAlgorithm; // select the fitting algorithm
- AliCaloRawAnalyzer *fRawAnalyzer; // for signal fitting
- AliCaloRawAnalyzerLMS *fRawAnalyzerTRU; // for signal fitting, for TRU
+ Int_t fFittingAlgorithm; // select the fitting algorithm
+
+ AliCaloRawAnalyzer *fRawAnalyzer; // for signal fitting
+ AliCaloRawAnalyzerLMS *fRawAnalyzerTRU; // for signal fitting, for TRU
int fSuperModules; //The number of SuperModules activated
int fFirstPedestalSample; // first sample for pedestal calculation, in bunch
// No pedestal is added to the raw signal.
//*-- Author: Marco van Leeuwen (LBL)
+
#include "AliEMCALRawUtils.h"
-#include <stdexcept>
-
#include "TF1.h"
#include "TGraph.h"
#include <TRandom.h>
-class TSystem;
-
-class AliLog;
#include "AliRun.h"
#include "AliRunLoader.h"
-class AliCaloAltroMapping;
#include "AliAltroBuffer.h"
#include "AliRawReader.h"
#include "AliCaloRawStreamV3.h"
#include "AliDAQ.h"
-
#include "AliEMCALRecParam.h"
#include "AliEMCALLoader.h"
#include "AliEMCALGeometry.h"
-class AliEMCALDigitizer;
#include "AliEMCALDigit.h"
#include "AliEMCALRawDigit.h"
#include "AliEMCAL.h"
#include "AliCaloCalibPedestal.h"
-#include "AliCaloFastAltroFitv0.h"
-#include "AliCaloNeuralFit.h"
#include "AliCaloBunchInfo.h"
#include "AliCaloFitResults.h"
-#include "AliCaloRawAnalyzerFastFit.h"
-#include "AliCaloRawAnalyzerNN.h"
-#include "AliCaloRawAnalyzerLMS.h"
-#include "AliCaloRawAnalyzerPeakFinder.h"
-#include "AliCaloRawAnalyzerCrude.h"
#include "AliEMCALTriggerRawDigitMaker.h"
#include "AliEMCALTriggerSTURawStream.h"
#include "AliEMCALTriggerData.h"
+#include "AliCaloConstants.h"
+#include "AliCaloRawAnalyzer.h"
+#include "AliCaloRawAnalyzerFactory.h"
-ClassImp(AliEMCALRawUtils)
-
-// Signal shape parameters
-Int_t AliEMCALRawUtils::fgTimeBins = 256; // number of sampling bins of the raw RO signal (we typically use 15-50; theoretical max is 1k+)
-Double_t AliEMCALRawUtils::fgTimeBinWidth = 100E-9 ; // each sample is 100 ns
-Double_t AliEMCALRawUtils::fgTimeTrigger = 600E-9 ; // the time of the trigger as approximately seen in the data
+using namespace CALO;
+using namespace EMCAL;
-// some digitization constants
+Double_t AliEMCALRawUtils::fgTimeTrigger = 600E-9 ; // the time of the trigger as approximately seen in the data
Int_t AliEMCALRawUtils::fgThreshold = 1;
-Int_t AliEMCALRawUtils::fgDDLPerSuperModule = 2; // 2 ddls per SuperModule
Int_t AliEMCALRawUtils::fgPedestalValue = 0; // pedestal value for digits2raw, default generate ZS data
Double_t AliEMCALRawUtils::fgFEENoise = 3.; // 3 ADC channels of noise (sampled)
-AliEMCALRawUtils::AliEMCALRawUtils( Algo::fitAlgorithm fitAlgo)
- : fHighLowGainFactor(0.), fOrder(0), fTau(0.), fNoiseThreshold(0),
- fNPedSamples(0), fGeom(0), fOption(""),
- fRemoveBadChannels(kTRUE),fFittingAlgorithm(0),
- fTimeMin(-1.),fTimeMax(1.),
- fUseFALTRO(kFALSE),fRawAnalyzer(0),
- fTriggerRawDigitMaker(0x0)
-{
+ClassImp(AliEMCALRawUtils)
+
- //These are default parameters.
- //Can be re-set from without with setter functions
- //Already set in the OCDB and passed via setter in the AliEMCALReconstructor
- fHighLowGainFactor = 16. ; // Adjusted for a low gain range of 82 GeV (10 bits)
- fOrder = 2; // Order of gamma fn
- fTau = 2.35; // in units of timebin, from CERN 2007 testbeam
- fNoiseThreshold = 3; // 3 ADC counts is approx. noise level
- fNPedSamples = 4; // Less than this value => likely pedestal samples
- fRemoveBadChannels = kFALSE; // Do not remove bad channels before fitting
- fUseFALTRO = kTRUE; // Get the trigger FALTRO information and pass it to digits.
+AliEMCALRawUtils::AliEMCALRawUtils( Algo::fitAlgorithm fitAlgo) : fNoiseThreshold(3),
+ fNPedSamples(4),
+ fGeom(0),
+ fOption(""),
+ fRemoveBadChannels(kFALSE),
+ fFittingAlgorithm(0),
+ fTimeMin(-1.),
+ fTimeMax(1.),
+ fUseFALTRO(kTRUE),
+ fRawAnalyzer(0),
+ fTriggerRawDigitMaker(0x0)
+{
SetFittingAlgorithm(fitAlgo);
+ // SetFittingAlgorithm( Algo::kLMSOffline);
//Get Mapping RCU files from the AliEMCALRecParam
const TObjArray* maps = AliEMCALRecParam::GetMappings();
}
+
//____________________________________________________________________________
-AliEMCALRawUtils::AliEMCALRawUtils(AliEMCALGeometry *pGeometry, Algo::fitAlgorithm fitAlgo)
- : fHighLowGainFactor(0.), fOrder(0), fTau(0.), fNoiseThreshold(0),
- fNPedSamples(0), fGeom(pGeometry), fOption(""),
- fRemoveBadChannels(kTRUE),fFittingAlgorithm(0),
- fTimeMin(-1.),fTimeMax(1.),
- fUseFALTRO(kFALSE),fRawAnalyzer(),
- fTriggerRawDigitMaker(0x0)
+AliEMCALRawUtils::AliEMCALRawUtils(AliEMCALGeometry *pGeometry, Algo::fitAlgorithm fitAlgo) : //fHighLowGainFactor(16.),
+ //fOrder(2),
+ // fTau(2.35),
+ fNoiseThreshold(3),
+ fNPedSamples(4),
+ fGeom(pGeometry),
+ fOption(""),
+ fRemoveBadChannels(kFALSE),fFittingAlgorithm(0),
+ fTimeMin(-1.),fTimeMax(1.),
+ fUseFALTRO(kTRUE),fRawAnalyzer(0),
+ fTriggerRawDigitMaker(0x0)
{
- //
- // Initialize with the given geometry - constructor required by HLT
+
+
+ // Initialize with the given geometry - constructor required by HLT
// HLT does not use/support AliRunLoader(s) instances
// This is a minimum intervention solution
// Comment by MPloskon@lbl.gov
- //
-
- //These are default parameters.
- //Can be re-set from without with setter functions
- //Already set in the OCDB and passed via setter in the AliEMCALReconstructor
- fHighLowGainFactor = 16. ; // adjusted for a low gain range of 82 GeV (10 bits)
- fOrder = 2; // order of gamma fn
- fTau = 2.35; // in units of timebin, from CERN 2007 testbeam
- fNoiseThreshold = 3; // 3 ADC counts is approx. noise level
- fNPedSamples = 4; // Less than this value => likely pedestal samples
- fRemoveBadChannels = kFALSE; // Do not remove bad channels before fitting
- fUseFALTRO = kTRUE; // Get the trigger FALTRO information and pass it to digits.
SetFittingAlgorithm(fitAlgo);
-
+ // SetFittingAlgorithm( Algo::kLMSOffline);
//Get Mapping RCU files from the AliEMCALRecParam
const TObjArray* maps = AliEMCALRecParam::GetMappings();
if(!maps) AliFatal("Cannot retrieve ALTRO mappings!!");
-
- for(Int_t i = 0; i < 4; i++) {
- fMapping[i] = (AliAltroMapping*)maps->At(i);
- }
+
+ for(Int_t i = 0; i < 4; i++)
+ {
+ fMapping[i] = (AliAltroMapping*)maps->At(i);
+ }
if(!fGeom) AliFatal(Form("Could not get geometry!"));
-
fTriggerRawDigitMaker = new AliEMCALTriggerRawDigitMaker();
}
-//____________________________________________________________________________
-AliEMCALRawUtils::AliEMCALRawUtils(const AliEMCALRawUtils& rawU)
- : TObject(),
- fHighLowGainFactor(rawU.fHighLowGainFactor),
- fOrder(rawU.fOrder),
- fTau(rawU.fTau),
- fNoiseThreshold(rawU.fNoiseThreshold),
- fNPedSamples(rawU.fNPedSamples),
- fGeom(rawU.fGeom),
- fOption(rawU.fOption),
- fRemoveBadChannels(rawU.fRemoveBadChannels),
- fFittingAlgorithm(rawU.fFittingAlgorithm),
- fTimeMin(rawU.fTimeMin),fTimeMax(rawU.fTimeMax),
- fUseFALTRO(rawU.fUseFALTRO),
- fRawAnalyzer(rawU.fRawAnalyzer),
- fTriggerRawDigitMaker(rawU.fTriggerRawDigitMaker)
-{
- //copy ctor
- fMapping[0] = rawU.fMapping[0];
- fMapping[1] = rawU.fMapping[1];
- fMapping[2] = rawU.fMapping[2];
- fMapping[3] = rawU.fMapping[3];
-}
//____________________________________________________________________________
-AliEMCALRawUtils& AliEMCALRawUtils::operator =(const AliEMCALRawUtils &rawU)
+AliEMCALRawUtils::~AliEMCALRawUtils()
{
- //assignment operator
-
- if(this != &rawU) {
- fHighLowGainFactor = rawU.fHighLowGainFactor;
- fOrder = rawU.fOrder;
- fTau = rawU.fTau;
- fNoiseThreshold = rawU.fNoiseThreshold;
- fNPedSamples = rawU.fNPedSamples;
- fGeom = rawU.fGeom;
- fOption = rawU.fOption;
- fRemoveBadChannels = rawU.fRemoveBadChannels;
- fFittingAlgorithm = rawU.fFittingAlgorithm;
- fTimeMin = rawU.fTimeMin;
- fTimeMax = rawU.fTimeMax;
- fUseFALTRO = rawU.fUseFALTRO;
- fRawAnalyzer = rawU.fRawAnalyzer;
- fMapping[0] = rawU.fMapping[0];
- fMapping[1] = rawU.fMapping[1];
- fMapping[2] = rawU.fMapping[2];
- fMapping[3] = rawU.fMapping[3];
- fTriggerRawDigitMaker = rawU.fTriggerRawDigitMaker;
- }
-
- return *this;
-
-}
-
-//____________________________________________________________________________
-AliEMCALRawUtils::~AliEMCALRawUtils() {
//dtor
-
}
+
//____________________________________________________________________________
void AliEMCALRawUtils::Digits2Raw()
{
// convert digits of the current event to raw data
-
AliRunLoader *rl = AliRunLoader::Instance();
AliEMCALLoader *loader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
for (Int_t i=0; i < nDDL; i++)
buffers[i] = 0;
- TArrayI adcValuesLow(fgTimeBins);
- TArrayI adcValuesHigh(fgTimeBins);
+ TArrayI adcValuesLow( TIMEBINS );
+ TArrayI adcValuesHigh( TIMEBINS );
// loop over digits (assume ordered digits)
- for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
- AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
- if(!digit){
- AliFatal("NULL Digit");
- }
- else{
- if (digit->GetAmplitude() < fgThreshold)
- continue;
-
- //get cell indices
- Int_t nSM = 0;
- Int_t nIphi = 0;
- Int_t nIeta = 0;
- Int_t iphi = 0;
- Int_t ieta = 0;
- Int_t nModule = 0;
- fGeom->GetCellIndex(digit->GetId(), nSM, nModule, nIphi, nIeta);
- fGeom->GetCellPhiEtaIndexInSModule(nSM, nModule, nIphi, nIeta,iphi, ieta) ;
+ for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++)
+ {
+ AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
+ if(!digit)
+ {
+ AliFatal("NULL Digit");
+ }
+ else
+ {
+ if (digit->GetAmplitude() < fgThreshold)
+ {
+ continue;
+ }
+ //get cell indices
+ Int_t nSM = 0;
+ Int_t nIphi = 0;
+ Int_t nIeta = 0;
+ Int_t iphi = 0;
+ Int_t ieta = 0;
+ Int_t nModule = 0;
+ fGeom->GetCellIndex(digit->GetId(), nSM, nModule, nIphi, nIeta);
+ fGeom->GetCellPhiEtaIndexInSModule(nSM, nModule, nIphi, nIeta,iphi, ieta) ;
- //Check which is the RCU, 0 or 1, of the cell.
- Int_t iRCU = -111;
- //RCU0
+ //Check which is the RCU, 0 or 1, of the cell.
+ Int_t iRCU = -111;
+ //RCU0
if (0<=iphi&&iphi<8) iRCU=0; // first cable row
else if (8<=iphi&&iphi<16 && 0<=ieta&&ieta<24) iRCU=0; // first half;
//second cable row
Fatal("Digits2Raw()","Non-existent RCU number: %d", iRCU);
//Which DDL?
- Int_t iDDL = fgDDLPerSuperModule* nSM + iRCU;
+ Int_t iDDL = NRCUSPERMODULE*nSM + iRCU;
if (iDDL < 0 || iDDL >= nDDL){
Fatal("Digits2Raw()","Non-existent DDL board number: %d", iDDL);
}
}
// out of time range signal (?)
- if (digit->GetTimeR() > GetRawFormatTimeMax() ) {
+ if (digit->GetTimeR() > TIMEBINMAX ) {
AliInfo("Signal is out of time range.\n");
buffers[iDDL]->FillBuffer((Int_t)digit->GetAmplitude());
- buffers[iDDL]->FillBuffer(GetRawFormatTimeBins() ); // time bin
+ buffers[iDDL]->FillBuffer( TIMEBINS ); // time bin
buffers[iDDL]->FillBuffer(3); // bunch length
buffers[iDDL]->WriteTrailer(3, ieta, iphi, nSM); // trailer
// calculate the time response function
} else {
Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), digit->GetAmplitude(), adcValuesHigh.GetArray(), adcValuesLow.GetArray()) ;
if (lowgain)
- buffers[iDDL]->WriteChannel(ieta, iphi, 0, GetRawFormatTimeBins(), adcValuesLow.GetArray(), fgThreshold);
+ buffers[iDDL]->WriteChannel(ieta, iphi, 0, TIMEBINS, adcValuesLow.GetArray(), fgThreshold);
else
- buffers[iDDL]->WriteChannel(ieta,iphi, 1, GetRawFormatTimeBins(), adcValuesHigh.GetArray(), fgThreshold);
+ buffers[iDDL]->WriteChannel(ieta,iphi, 1, TIMEBINS, adcValuesHigh.GetArray(), fgThreshold);
}
}// iDDL under the limits
}//digit exists
loader->UnloadDigits();
}
+
+//____________________________________________________________________________
+void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time, Float_t chi2, Int_t ndf)
+{
+ AliEMCALDigit *digit = 0, *tmpdigit = 0;
+ TIter nextdigit(digitsArr);
+
+ while (digit == 0 && (tmpdigit = (AliEMCALDigit*) nextdigit()))
+ {
+ if (tmpdigit->GetId() == id) digit = tmpdigit;
+ }
+
+ if (!digit) { // no digit existed for this tower; create one
+ Int_t type = AliEMCALDigit::kHG; // use enum in AliEMCALDigit
+ if (lowGain)
+ {
+ amp *= HGLGFACTOR;
+ type = AliEMCALDigit::kLGnoHG;
+ }
+
+ Int_t idigit = digitsArr->GetEntries();
+ new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, type, idigit, chi2, ndf);
+ AliDebug(2,Form("Add digit Id %d for the first time, type %d", id, type));
+ }//digit added first time
+ else
+ { // a digit already exists, check range
+ // (use high gain if signal < cut value, otherwise low gain)
+ if (lowGain)
+ { // new digit is low gain
+ if (digit->GetAmplitude() > OVERFLOWCUT )
+ { // use if previously stored (HG) digit is out of range
+ digit->SetAmplitude( HGLGFACTOR * amp);
+ digit->SetTime(time);
+ digit->SetType(AliEMCALDigit::kLG);
+ AliDebug(2,Form("Add LG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
+ }
+ }//new low gain digit
+ else { // new digit is high gain
+
+ if (amp < OVERFLOWCUT )
+ { // new digit is high gain; use if not out of range
+ digit->SetAmplitude(amp);
+ digit->SetTime(time);
+ digit->SetType(AliEMCALDigit::kHG);
+ AliDebug(2,Form("Add HG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
+ }
+ else
+ { // HG out of range, just change flag value to show that HG did exist
+ digit->SetType(AliEMCALDigit::kLG);
+ AliDebug(2,Form("Change LG digit to HG, ID %d, type %d", digit->GetId(), digit->GetType()));
+ }
+ }//new high gain digit
+ }//digit existed replace it
+}
+
+
//____________________________________________________________________________
void AliEMCALRawUtils::Raw2Digits(AliRawReader* reader,TClonesArray *digitsArr, const AliCaloCalibPedestal* pedbadmap, TClonesArray *digitsTRG, AliEMCALTriggerData* trgData)
{
- // convert raw data of the current event to digits
-
+
if(digitsArr) digitsArr->Clear("C");
-
- if (!digitsArr) {
- Error("Raw2Digits", "no digits found !");
- return;
- }
- if (!reader) {
- Error("Raw2Digits", "no raw reader found !");
- return;
- }
-
+ if (!digitsArr) { Error("Raw2Digits", "no digits found !");return;}
+ if (!reader) {Error("Raw2Digits", "no raw reader found !");return;}
AliEMCALTriggerSTURawStream inSTU(reader);
-
AliCaloRawStreamV3 in(reader,"EMCAL",fMapping);
-
- // Select EMCAL DDL's;
reader->Select("EMCAL",0,43); // 43 = AliEMCALGeoParams::fgkLastAltroDDL
-
fTriggerRawDigitMaker->Reset();
fTriggerRawDigitMaker->SetIO(reader, in, inSTU, digitsTRG, trgData);
-
- // fRawAnalyzer setup
- fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done, for the new methods
- fRawAnalyzer->SetOverflowCut(fgkOverflowCut);
- fRawAnalyzer->SetAmpCut(fNoiseThreshold);
- fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
fRawAnalyzer->SetIsZeroSuppressed(true); // TMP - should use stream->IsZeroSuppressed(), or altro cfg registers later
-
- // channel info parameters
+
Int_t lowGain = 0;
Int_t caloFlag = 0; // low, high gain, or TRU, or LED ref.
- // start loop over input stream
- while (in.NextDDL()) {
-
- // if ( in.GetDDLNumber() != 0 && in.GetDDLNumber() != 2 ) continue;
-
- while (in.NextChannel()) {
-
- //Check if the signal is high or low gain and then do the fit,
- //if it is from TRU or LEDMon do not fit
- caloFlag = in.GetCaloFlag();
- // if (caloFlag != 0 && caloFlag != 1) continue;
- if (caloFlag > 2) continue; // Work with ALTRO and FALTRO
-
- //Do not fit bad channels of ALTRO
- if(caloFlag < 2 && fRemoveBadChannels && pedbadmap->IsBadChannel(in.GetModule(),in.GetColumn(),in.GetRow())) {
- //printf("Tower from SM %d, column %d, row %d is BAD!!! Skip \n", in.GetModule(),in.GetColumn(),in.GetRow());
- continue;
- }
-
- vector<AliCaloBunchInfo> bunchlist;
- while (in.NextBunch()) {
- bunchlist.push_back( AliCaloBunchInfo(in.GetStartTimeBin(), in.GetBunchLength(), in.GetSignals() ) );
- } // loop over bunches
- if (bunchlist.size() == 0) continue;
- if ( caloFlag < 2 )
- { // ALTRO
- Float_t time = 0;
- Float_t amp = 0;
- short timeEstimate = 0;
- Float_t ampEstimate = 0;
- Bool_t fitDone = kFALSE;
- Float_t chi2 = 0;
- Int_t ndf = 0;
-
- if ( fFittingAlgorithm == Algo::kFastFit || fFittingAlgorithm == Algo::kNeuralNet ||
- fFittingAlgorithm == Algo::kLMS || fFittingAlgorithm == Algo::kPeakFinder ||
- fFittingAlgorithm == Algo::kCrude) {
- // all functionality to determine amp and time etc is encapsulated inside the Evaluate call for these methods
- AliCaloFitResults fitResults = fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
-
- amp = fitResults.GetAmp();
- time = fitResults.GetTime();
- timeEstimate = fitResults.GetMaxTimebin();
- ampEstimate = fitResults.GetMaxSig();
- chi2 = fitResults.GetChi2();
- ndf = fitResults.GetNdf();
- if (fitResults.GetStatus() == Ret::kFitPar) {
- fitDone = kTRUE;
- }
- }
- else { // for the other methods we for now use the functionality of
- // AliCaloRawAnalyzer as well, to select samples and prepare for fits,
- // if it looks like there is something to fit
-
- // parameters init.
- Float_t pedEstimate = 0;
- short maxADC = 0;
- Int_t first = 0;
- Int_t last = 0;
- Int_t bunchIndex = 0;
- //
- // The PreFitEvaluateSamples + later call to FitRaw will hopefully
- // be replaced by a single Evaluate call or so soon, like for the other
- // methods, but this should be good enough for evaluation of
- // the methods for now (Jan. 2010)
- //
- int nsamples = fRawAnalyzer->PreFitEvaluateSamples( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2(), bunchIndex, ampEstimate, maxADC, timeEstimate, pedEstimate, first, last);
-
- if (ampEstimate >= fNoiseThreshold) { // something worth looking at
-
- 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 && maxADC<fgkOverflowCut ) { // possibly something to fit
- FitRaw(first, last, amp, time, chi2, fitDone);
- time += timebinOffset;
- timeEstimate += timebinOffset;
- ndf = nsamples - 2;
- }
-
- } // ampEstimate check
- } // method selection
-
- if ( fitDone ) { // brief sanity check of fit results
- Float_t ampAsymm = (amp - ampEstimate)/(amp + ampEstimate);
- Float_t timeDiff = time - timeEstimate;
- if ( (TMath::Abs(ampAsymm) > 0.1) || (TMath::Abs(timeDiff) > 2) ) {
- // AliDebug(2,Form("Fit results amp %f time %f not consistent with expectations amp %f time %d", amp, time, ampEstimate, timeEstimate));
-
- // for now just overwrite the fit results with the simple/initial estimate
- amp = ampEstimate;
- time = timeEstimate;
- fitDone = kFALSE;
- }
- } // fitDone
-
- if (amp >= fNoiseThreshold) { // something to be stored
- if ( ! fitDone) { // smear ADC with +- 0.5 uniform (avoid discrete effects)
- amp += (0.5 - gRandom->Rndm()); // Rndm generates a number in ]0,1]
- }
-
- Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
- lowGain = in.IsLowGain();
-
- // go from time-bin units to physical time fgtimetrigger
- time = time * GetRawFormatTimeBinWidth(); // skip subtraction of fgTimeTrigger?
- // subtract RCU L1 phase (L1Phase is in seconds) w.r.t. L0:
- time -= in.GetL1Phase();
-
- AliDebug(2,Form("id %d lowGain %d amp %g", id, lowGain, amp));
- // printf("Added tower: SM %d, row %d, column %d, amp %3.2f\n",in.GetModule(), in.GetRow(), in.GetColumn(),amp);
-
- AddDigit(digitsArr, id, lowGain, amp, time, chi2, ndf);
- }
-
- }//ALTRO
- else if(fUseFALTRO)
- {// Fake ALTRO
- fTriggerRawDigitMaker->Add( bunchlist );
- }//Fake ALTRO
- } // end while over channel
- } //end while over DDL's, of input stream
-
+ while (in.NextDDL())
+ {
+ // fprintf(fp," TP1\n");
+ while (in.NextChannel())
+ {
+ // fprintf(fp," TP2\n");
+ caloFlag = in.GetCaloFlag();
+ if (caloFlag > 2) continue; // Work with ALTRO and FALTRO
+ if(caloFlag < 2 && fRemoveBadChannels && pedbadmap->IsBadChannel(in.GetModule(),in.GetColumn(),in.GetRow()))
+ {
+ continue;
+ }
+ vector<AliCaloBunchInfo> bunchlist;
+ while (in.NextBunch())
+ {
+ bunchlist.push_back( AliCaloBunchInfo(in.GetStartTimeBin(), in.GetBunchLength(), in.GetSignals() ) );
+ }
+ if (bunchlist.size() == 0) continue;
+ if ( caloFlag < 2 )
+ { // ALTRO
+ Int_t id = fGeom->GetAbsCellIdFromCellIndexes(in.GetModule(), in.GetRow(), in.GetColumn()) ;
+ lowGain = in.IsLowGain();
+ fRawAnalyzer->SetL1Phase( in.GetL1Phase() );
+ AliCaloFitResults res = fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
+ if(res.GetAmp() >= fNoiseThreshold )
+ {
+ AddDigit(digitsArr, id, lowGain, res.GetAmp(), res.GetTime(), res.GetChi2(), res.GetNdf() );
+ }
+ }//ALTRO
+ else if(fUseFALTRO)
+ {// Fake ALTRO
+ fTriggerRawDigitMaker->Add( bunchlist );
+ }//Fake ALTRO
+ } // end while over channel
+ } //end while over DDL's, of input stream
fTriggerRawDigitMaker->PostProcess();
-
TrimDigits(digitsArr);
-
- return ;
}
-//____________________________________________________________________________
-void AliEMCALRawUtils::AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time, Float_t chi2, Int_t ndf) {
- //
- // Add a new digit.
- // This routine checks whether a digit exists already for this tower
- // and then decides whether to use the high or low gain info
- //
- // Called by Raw2Digits
-
- AliEMCALDigit *digit = 0, *tmpdigit = 0;
- TIter nextdigit(digitsArr);
- while (digit == 0 && (tmpdigit = (AliEMCALDigit*) nextdigit())) {
- if (tmpdigit->GetId() == id) digit = tmpdigit;
- }
-
- if (!digit) { // no digit existed for this tower; create one
- Int_t type = AliEMCALDigit::kHG; // use enum in AliEMCALDigit
- if (lowGain) {
- amp *= fHighLowGainFactor;
- type = AliEMCALDigit::kLGnoHG;
- }
- Int_t idigit = digitsArr->GetEntries();
- new((*digitsArr)[idigit]) AliEMCALDigit( -1, -1, id, amp, time, type, idigit, chi2, ndf);
- AliDebug(2,Form("Add digit Id %d for the first time, type %d", id, type));
- }//digit added first time
- else { // a digit already exists, check range
- // (use high gain if signal < cut value, otherwise low gain)
- if (lowGain) { // new digit is low gain
- if (digit->GetAmplitude() > fgkOverflowCut) { // use if previously stored (HG) digit is out of range
- digit->SetAmplitude(fHighLowGainFactor * amp);
- digit->SetTime(time);
- digit->SetType(AliEMCALDigit::kLG);
- AliDebug(2,Form("Add LG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
- }
- }//new low gain digit
- else { // new digit is high gain
- if (amp < fgkOverflowCut) { // new digit is high gain; use if not out of range
- digit->SetAmplitude(amp);
- digit->SetTime(time);
- digit->SetType(AliEMCALDigit::kHG);
- AliDebug(2,Form("Add HG digit ID %d for the second time, type %d", digit->GetId(), digit->GetType()));
- }
- else { // HG out of range, just change flag value to show that HG did exist
- digit->SetType(AliEMCALDigit::kLG);
- AliDebug(2,Form("Change LG digit to HG, ID %d, type %d", digit->GetId(), digit->GetType()));
- }
- }//new high gain digit
- }//digit existed replace it
-
-}
-//____________________________________________________________________________
void AliEMCALRawUtils::TrimDigits(TClonesArray *digitsArr)
{
- // Remove digits with only low gain and large time
-
AliEMCALDigit *digit = 0;
Int_t n = 0;
Int_t nDigits = digitsArr->GetEntriesFast();
TIter nextdigit(digitsArr);
while ((digit = (AliEMCALDigit*) nextdigit())) {
-
- //Check if only LG existed, remove if so
if (digit->GetType() == AliEMCALDigit::kLGnoHG) {
- AliDebug(10,Form("Remove digit with id %d, LGnoHG",digit->GetId()));
+ AliDebug(1,Form("Remove digit with id %d, LGnoHG",digit->GetId()));
digitsArr->Remove(digit);
}
- //Check if time is too large or too small, remove if so
else if(fTimeMin > digit->GetTime() || fTimeMax < digit->GetTime()) {
digitsArr->Remove(digit);
- AliDebug(10,Form("Remove digit with id %d, Bad Time %e",digit->GetId(), digit->GetTime()));
+ AliDebug(1,Form("Remove digit with id %d, Bad Time %e",digit->GetId(), digit->GetTime()));
}
- // Check if Chi2 is undefined
else if (0 > digit->GetChi2()) {
digitsArr->Remove(digit);
- AliDebug(10,Form("Remove digit with id %d, Bad Chi2 %e",digit->GetId(), digit->GetChi2()));
+ AliDebug(1,Form("Remove digit with id %d, Bad Chi2 %e",digit->GetId(), digit->GetChi2()));
}
- //Good digit, just reassign the index of the digit in case there was a previous removal
else {
digit->SetIndexInList(n);
n++;
digitsArr->Compress();
AliDebug(1,Form("N Digits before trimming : %d; after array compression %d",nDigits,digitsArr->GetEntriesFast()));
-
-}
-
-//____________________________________________________________________________
-void AliEMCALRawUtils::FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const
-{ // Fits the raw signal time distribution
-
- //--------------------------------------------------
- //Do the fit, different fitting algorithms available
- //--------------------------------------------------
- int nsamples = lastTimeBin - firstTimeBin + 1;
- fitDone = kFALSE;
-
- switch(fFittingAlgorithm) {
- case Algo::kStandard:
- {
- if (nsamples < 3) { return; } // nothing much to fit
- //printf("Standard fitter \n");
-
- // Create Graph to hold data we will fit
- TGraph *gSig = new TGraph( nsamples);
- for (int i=0; i<nsamples; i++) {
- Int_t timebin = firstTimeBin + i;
- gSig->SetPoint(i, timebin, fRawAnalyzer->GetReversed(timebin));
- }
-
- TF1 * signalF = new TF1("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
- signalF->SetParameters(10.,5.,fTau,fOrder,0.); //set all defaults once, just to be safe
- signalF->SetParNames("amp","t0","tau","N","ped");
- signalF->FixParameter(2,fTau); // tau in units of time bin
- signalF->FixParameter(3,fOrder); // order
- signalF->FixParameter(4, 0); // pedestal should be subtracted when we get here
- signalF->SetParameter(1, time);
- signalF->SetParameter(0, amp);
- // set rather loose parameter limits
- signalF->SetParLimits(0, 0.5*amp, 2*amp );
- signalF->SetParLimits(1, time - 4, time + 4);
-
- try {
- gSig->Fit(signalF, "QROW"); // Note option 'W': equal errors on all points
- // assign fit results
- amp = signalF->GetParameter(0);
- time = signalF->GetParameter(1);
- 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;
- }
- delete signalF;
-
- //printf("Std : Amp %f, time %g\n",amp, time);
- delete gSig; // delete TGraph
-
- break;
- }//kStandard Fitter
- //----------------------------
- case Algo::kLogFit:
- {
- if (nsamples < 3) { return; } // nothing much to fit
- //printf("LogFit \n");
-
- // Create Graph to hold data we will fit
- TGraph *gSigLog = new TGraph( nsamples);
- for (int i=0; i<nsamples; i++) {
- Int_t timebin = firstTimeBin + i;
- gSigLog->SetPoint(timebin, timebin, TMath::Log(fRawAnalyzer->GetReversed(timebin) ) );
- }
-
- TF1 * signalFLog = new TF1("signalLog", RawResponseFunctionLog, 0, GetRawFormatTimeBins(), 5);
- signalFLog->SetParameters(2.3, 5.,fTau,fOrder,0.); //set all defaults once, just to be safe
- signalFLog->SetParNames("amplog","t0","tau","N","ped");
- signalFLog->FixParameter(2,fTau); // tau in units of time bin
- signalFLog->FixParameter(3,fOrder); // order
- signalFLog->FixParameter(4, 0); // pedestal should be subtracted when we get here
- signalFLog->SetParameter(1, time);
- if (amp>=1) {
- signalFLog->SetParameter(0, TMath::Log(amp));
- }
-
- gSigLog->Fit(signalFLog, "QROW"); // Note option 'W': equal errors on all points
-
- // assign fit results
- Double_t amplog = signalFLog->GetParameter(0); //Not Amp, but Log of Amp
- amp = TMath::Exp(amplog);
- time = signalFLog->GetParameter(1);
- fitDone = kTRUE;
-
- delete signalFLog;
- //printf("LogFit: Amp %f, time %g\n",amp, time);
- delete gSigLog;
- break;
- } //kLogFit
- //----------------------------
-
- //----------------------------
- }//switch fitting algorithms
-
- return;
}
-//__________________________________________________________________
-void AliEMCALRawUtils::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] ;
- //printf("Yves : Amp %f, time %g\n",amp, time);
- //END YS
- return;
-}
-//__________________________________________________________________
-Double_t AliEMCALRawUtils::RawResponseFunction(Double_t *x, Double_t *par)
+Double_t
+AliEMCALRawUtils::RawResponseFunction(Double_t *x, Double_t *par)
{
- // Matches version used in 2007 beam test
- //
- // Shape of the electronics raw reponse:
- // It is a semi-gaussian, 2nd order Gamma function of the general form
- //
- // xx = (t - t0 + tau) / tau [xx is just a convenient help variable]
- // F = A * (xx**N * exp( N * ( 1 - xx) ) for xx >= 0
- // F = 0 for xx < 0
- //
- // parameters:
- // A: par[0] // Amplitude = peak value
- // t0: par[1]
- // tau: par[2]
- // N: par[3]
- // ped: par[4]
- //
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 )) ;
- }
+ else
+ {
+ signal = ped + par[0] * TMath::Power(xx , n) * TMath::Exp(n * (1 - xx )) ;
+ }
return signal ;
}
-//__________________________________________________________________
-Double_t AliEMCALRawUtils::RawResponseFunctionLog(Double_t *x, Double_t *par)
-{
- // Matches version used in 2007 beam test
- //
- // Shape of the electronics raw reponse:
- // It is a semi-gaussian, 2nd order Gamma function of the general form
- //
- // xx = (t - t0 + tau) / tau [xx is just a convenient help variable]
- // F = A * (xx**N * exp( N * ( 1 - xx) ) for xx >= 0
- // F = 0 for xx < 0
- //
- // parameters:
- // Log[A]: par[0] // Amplitude = peak value
- // t0: par[1]
- // tau: par[2]
- // N: par[3]
- // ped: par[4]
- //
- Double_t signal = 0. ;
- Double_t tau = par[2];
- Double_t n = par[3];
- //Double_t ped = par[4]; // not used
- Double_t xx = ( x[0] - par[1] + tau ) / tau ;
- if (xx < 0)
- signal = par[0] - n*TMath::Log(TMath::Abs(xx)) + n * (1 - xx ) ;
- else {
- signal = par[0] + n*TMath::Log(xx) + n * (1 - xx ) ;
- }
- return signal ;
-}
-
-//__________________________________________________________________
-Bool_t AliEMCALRawUtils::RawSampledResponse(const Double_t dtime, const Double_t damp, Int_t * adcH, Int_t * adcL, const Int_t keyErr) const
+Bool_t AliEMCALRawUtils::RawSampledResponse(const Double_t dtime, const Double_t damp, Int_t * adcH,
+ Int_t * adcL, const Int_t keyErr) const
{
- // for a start time dtime and an amplitude damp given by digit,
- // calculates the raw sampled response AliEMCAL::RawResponseFunction
Bool_t lowGain = kFALSE ;
-
- // A: par[0] // Amplitude = peak value
- // t0: par[1]
- // tau: par[2]
- // N: par[3]
- // ped: par[4]
-
- TF1 signalF("signal", RawResponseFunction, 0, GetRawFormatTimeBins(), 5);
+ TF1 signalF("signal", RawResponseFunction, 0, TIMEBINS, 5);
signalF.SetParameter(0, damp) ;
- signalF.SetParameter(1, (dtime + fgTimeTrigger)/fgTimeBinWidth) ;
- signalF.SetParameter(2, fTau) ;
- signalF.SetParameter(3, fOrder);
+ signalF.SetParameter(1, (dtime + fgTimeTrigger)/ TIMEBINWITH) ;
+ signalF.SetParameter(2, TAU) ;
+ signalF.SetParameter(3, ORDER);
signalF.SetParameter(4, fgPedestalValue);
Double_t signal=0.0, noise=0.0;
- for (Int_t iTime = 0; iTime < GetRawFormatTimeBins(); iTime++) {
+ for (Int_t iTime = 0; iTime < TIMEBINS; iTime++) {
signal = signalF.Eval(iTime) ;
- // Next lines commeted for the moment but in principle it is not necessary to add
- // extra noise since noise already added at the digits level.
-
- //According to Terry Awes, 13-Apr-2008
- //add gaussian noise in quadrature to each sample
- //Double_t noise = gRandom->Gaus(0.,fgFEENoise);
- //signal = sqrt(signal*signal + noise*noise);
- // March 17,09 for fast fit simulations by Alexei Pavlinov.
- // Get from PHOS analysis. In some sense it is open questions.
if(keyErr>0) {
noise = gRandom->Gaus(0.,fgFEENoise);
signal += noise;
}
adcH[iTime] = static_cast<Int_t>(signal + 0.5) ;
- if ( adcH[iTime] > fgkRawSignalOverflow ){ // larger than 10 bits
- adcH[iTime] = fgkRawSignalOverflow ;
+ if ( adcH[iTime] > MAXBINVALUE ){ // larger than 10 bits
+ adcH[iTime] = MAXBINVALUE ;
lowGain = kTRUE ;
}
-
- signal /= fHighLowGainFactor;
-
+ signal /= HGLGFACTOR;
adcL[iTime] = static_cast<Int_t>(signal + 0.5) ;
- if ( adcL[iTime] > fgkRawSignalOverflow) // larger than 10 bits
- adcL[iTime] = fgkRawSignalOverflow ;
-
+ if ( adcL[iTime] > MAXBINVALUE ) // larger than 10 bits
+ adcL[iTime] = MAXBINVALUE ;
}
-
return lowGain ;
}
+
//__________________________________________________________________
-void AliEMCALRawUtils::CalculateChi2(const Double_t* t, const Double_t* y, const Int_t nPoints,
-const Double_t sig, const Double_t tau, const Double_t amp, const Double_t t0, Double_t &chi2)
+Double_t AliEMCALRawUtils::RawResponseFunctionLog(Double_t *x, Double_t *par)
{
- // Input:
- // t[] - array of time bins
- // y[] - array of amplitudes after pedestal subtractions;
- // nPoints - number of points
- // sig - error of amplitude measurement (one value for all channels)
- // if sig<0 that mean sig=1.
- // tau - filter time response (in timebin units)
- // amp - amplitude at t0;
- // t0 - time of max amplitude;
- // Output:
- // chi2 - chi2
- // ndf = nPoints - 2 when tau fixed
- // ndf = nPoints - 3 when tau free
- static Double_t par[5]={0.0, 0.0, 0.0, 2.0, 0.0};
-
- par[0] = amp;
- par[1] = t0;
- par[2] = tau;
- // par[3]=n=2.; par[4]=ped=0.0
-
- Double_t dy = 0.0, x = 0.0, f=0.0;
- for(Int_t i=0; i<nPoints; i++){
- x = t[i];
- f = RawResponseFunction(&x, par);
- dy = y[i] - f;
- chi2 += dy*dy;
- //printf(" AliEMCALRawUtils::CalculateChi2 : %i : y %f -> f %f : dy %f \n", i, y[i], f, dy);
- }
- if(sig>0.0) chi2 /= (sig*sig);
+ Double_t signal = 0. ;
+ Double_t tau = par[2];
+ Double_t n = par[3];
+ Double_t xx = ( x[0] - par[1] + tau ) / tau ;
+
+ if (xx < 0)
+ {
+ signal = par[0] - n*TMath::Log(TMath::Abs(xx)) + n * (1 - xx ) ;
+ }
+ else
+ {
+ signal = par[0] + n*TMath::Log(xx) + n * (1 - xx ) ;
+ }
+ return signal ;
}
+
+
//__________________________________________________________________
void AliEMCALRawUtils::SetFittingAlgorithm(Int_t fitAlgo)
{
- //Set fitting algorithm and initialize it if this same algorithm was not set before.
- //printf("**** Set Algorithm , number %d ****\n",fitAlgo);
-
- if(fitAlgo == fFittingAlgorithm && fRawAnalyzer) {
- //Do nothing, this same algorithm already set before.
- //printf("**** Algorithm already set before, number %d, %s ****\n",fitAlgo, fRawAnalyzer->GetName());
- return;
- }
- //Initialize the requested algorithm
- AliDebug(1,Form("Fitting algorithm : %d\n", fFittingAlgorithm));
-
- if(fitAlgo != fFittingAlgorithm || !fRawAnalyzer) {
- //printf("**** Init Algorithm , number %d ****\n",fitAlgo);
-
- fFittingAlgorithm = fitAlgo;
- if (fRawAnalyzer) delete fRawAnalyzer; // delete prev. analyzer if existed.
-
- if (fitAlgo == Algo::kFastFit) {
- fRawAnalyzer = new AliCaloRawAnalyzerFastFit();
- }
- else if (fitAlgo == Algo::kNeuralNet) {
- fRawAnalyzer = new AliCaloRawAnalyzerNN();
- }
- else if (fitAlgo == Algo::kLMS) {
- fRawAnalyzer = new AliCaloRawAnalyzerLMS();
- }
- else if (fitAlgo == Algo::kPeakFinder) {
- fRawAnalyzer = new AliCaloRawAnalyzerPeakFinder();
- }
- else if (fitAlgo == Algo::kCrude) {
- fRawAnalyzer = new AliCaloRawAnalyzerCrude();
- }
- else {
- fRawAnalyzer = new AliCaloRawAnalyzer();
- //fRawAnalyzer = 0;
- }
- }
-
+ // fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer( Algo::kStandard );
+ fRawAnalyzer = AliCaloRawAnalyzerFactory::CreateAnalyzer( fitAlgo );
+ fRawAnalyzer->SetNsampleCut(5); // requirement for fits to be done, for the new methods
+ fRawAnalyzer->SetOverflowCut ( OVERFLOWCUT );
+ fRawAnalyzer->SetAmpCut(fNoiseThreshold);
+ fRawAnalyzer->SetFitArrayCut(fNoiseThreshold);
+ // return;
}
+
/* $Id$ */
+
//_________________________________________________________________________
// Utility Class for handling Raw data
// Does all transitions from Digits to Raw and vice versa,
#include <TString.h>
+class AliAnalysisManager;
class AliCaloRawStreamV3;
class AliAltroMapping;
class TGraph;
class AliEMCALGeometry;
class AliCaloCalibPedestal;
class AliCaloRawAnalyzer;
+class AliCaloRawAnalyzerLMSOffline;
class AliEMCALTriggerRawDigitMaker;
class AliEMCALTriggerData;
+
#include "AliCaloConstants.h"
+
class AliEMCALRawUtils : public TObject {
public:
- // enum fitAlgorithm {kStandard = 0, kFastFit= 1, kNeuralNet = 2, kLogFit = 3, kLMS = 4, kPeakFinder = 5, kCrude = 6};
-
AliEMCALRawUtils(Algo::fitAlgorithm fitAlgo = Algo::kStandard);
AliEMCALRawUtils(AliEMCALGeometry *pGeometry, Algo::fitAlgorithm fitAlgo = Algo::kStandard);
virtual ~AliEMCALRawUtils();
-
- AliEMCALRawUtils(const AliEMCALRawUtils& rawUtils); //copy ctor
- AliEMCALRawUtils& operator =(const AliEMCALRawUtils& rawUtils);
-
+
+ // void FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const ;
+ // void FitParabola(const TGraph *gSig, Float_t & amp) const ;
+
void Digits2Raw();
void Raw2Digits(AliRawReader *reader, TClonesArray *digitsArr, const AliCaloCalibPedestal* pedbadmap,
TClonesArray *digitsTRG=0x0, AliEMCALTriggerData* trgData = 0x0);
-
+ static Double_t RawResponseFunctionLog(Double_t *x, Double_t *par);
void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t lowGain, Float_t amp, Float_t time, Float_t chi2, Int_t ndf);
-// void AddDigit(TClonesArray *digitsArr, Int_t id, Int_t timeSamples[], Int_t nSamples);
void TrimDigits(TClonesArray *digitsArr);
-
- // Signal shape parameters
- Double_t GetRawFormatHighLowGainFactor() const { return fHighLowGainFactor ;}
- Int_t GetRawFormatOrder() const { return fOrder ; }
- Double_t GetRawFormatTau() const { return fTau ; }
Int_t GetNoiseThreshold() const { return fNoiseThreshold; }
Int_t GetNPedSamples() const { return fNPedSamples; }
-
- // get methods for fast fit simulation
Int_t GetPedestalValue() const {return fgPedestalValue;}
Double_t GetFEENoise() const {return fgFEENoise;}
-
Bool_t GetRemoveBadChannels() const {return fRemoveBadChannels;}
Int_t GetFittingAlgorithm() const {return fFittingAlgorithm; }
Float_t GetTimeMax() const {return fTimeMax ;}
Float_t GetTimeMin() const {return fTimeMin ;}
Bool_t UseFALTRO() const {return fUseFALTRO; }
-
- void SetRawFormatHighLowGainFactor(Double_t val) {fHighLowGainFactor=val;}
- void SetRawFormatOrder(Int_t val) {fOrder=val; }
- void SetRawFormatTau(Double_t val) {fTau=val; }
void SetNoiseThreshold(Int_t val) {fNoiseThreshold=val; }
void SetNPedSamples(Int_t val) {fNPedSamples=val; }
void SetRemoveBadChannels(Bool_t val) {fRemoveBadChannels=val; }
void SetTimeMin(Float_t t) {fTimeMin = t ;}
void SetTimeMax(Float_t t) {fTimeMax = t ;}
void SetFALTROUsage(Bool_t val) {fUseFALTRO=val; }
-
- // set methods for fast fit simulation
void SetFEENoise(Double_t val) {fgFEENoise = val;}
- void SetRawFormatTimeBins(Int_t val) {fgTimeBins = val;}
void SetPedestalValue(Int_t val) {fgPedestalValue = val;}
-
- static Int_t GetRawFormatTimeBins() { return fgTimeBins ; }
- static Double_t GetRawFormatTimeMax() { return fgTimeBins*fgTimeBinWidth; }
- static Double_t GetRawFormatTimeBinWidth() { return fgTimeBinWidth; }
- static Double_t GetRawFormatTimeBin()
- { return GetRawFormatTimeMax() / GetRawFormatTimeBins(); }
Double_t GetRawFormatTimeTrigger() const { return fgTimeTrigger ; }
Int_t GetRawFormatThreshold() const { return fgThreshold ; }
- Int_t GetRawFormatDDLPerSuperModule() const { return fgDDLPerSuperModule ; }
AliCaloRawAnalyzer *GetRawAnalyzer() const { return fRawAnalyzer;}
-
virtual Option_t* GetOption() const { return fOption.Data(); }
void SetOption(const Option_t* opt) { fOption = opt; }
-
- // Signal shape functions
-
- void FitRaw(const Int_t firstTimeBin, const Int_t lastTimeBin, Float_t & amp, Float_t & time, Float_t & chi2, Bool_t & fitDone) const ;
- void FitParabola(const TGraph *gSig, Float_t & amp) const ;
static Double_t RawResponseFunction(Double_t *x, Double_t *par);
- static Double_t RawResponseFunctionLog(Double_t *x, Double_t *par);
Bool_t RawSampledResponse(Double_t dtime, Double_t damp, Int_t * adcH, Int_t * adcL, const Int_t keyErr=0) const;
-
- static void CalculateChi2(const Double_t* t,const Double_t* y,const Int_t nPoints,
- const Double_t sig, const Double_t tau, const Double_t amp, const Double_t t0, Double_t &chi2);
-
- private:
- Double_t fHighLowGainFactor ; // high to low gain factor for the raw RO signal
- Int_t fOrder ; // order of the gamma function for the RO signal
- Double_t fTau ; // tau parameter of gamma function for the RO signal
+
+private:
+ AliEMCALRawUtils(const AliEMCALRawUtils& rawUtils); //copy ctor
+ AliEMCALRawUtils& operator =(const AliEMCALRawUtils& rawUtils);
Int_t fNoiseThreshold; // threshold to consider signal or noise
Int_t fNPedSamples; // number of samples to use in pedestal calculation
-
- static const Int_t fgkOverflowCut = 950; // cut to discriminate overflowed channels
- static const Int_t fgkRawSignalOverflow = 0x3FF; // maximum signal (10 bits)
- static Int_t fgTimeBins; // number of sampling bins of the raw RO signal
-
static Double_t fgTimeTrigger ; // time of the trigger for the RO signal
- static Double_t fgTimeBinWidth; // maximum sampled time of the raw RO signal
static Int_t fgThreshold; // threshold
- static Int_t fgDDLPerSuperModule; // number of DDL per SuperModule
static Int_t fgPedestalValue; // pedestal value for Digits2Raw
static Double_t fgFEENoise; // electronics noise in ADC units
-
AliEMCALGeometry* fGeom; // geometry
AliAltroMapping* fMapping[4]; // only two for now
-
- TString fOption; //! option passed from Reconstructor
-
+ TString fOption; // option passed from Reconstructor
Bool_t fRemoveBadChannels; // select if bad channels are removed before fitting
Int_t fFittingAlgorithm; // select the fitting algorithm
Float_t fTimeMin; // minimum threshold for the time of the signal
Float_t fTimeMax; // maximum threshold for the time of the signal
Bool_t fUseFALTRO; // use FALTRO and pass it to the digits
-
AliCaloRawAnalyzer *fRawAnalyzer; // e.g. for sample selection for fits
-
AliEMCALTriggerRawDigitMaker* fTriggerRawDigitMaker;
-
+
ClassDef(AliEMCALRawUtils,7) // utilities for raw signal fitting
+
};
#endif
//Called last because it sets the global position of the cluster?
//Do not call it when recalculating clusters out of standard reconstruction
- if(!justClusters) EvalLocal2TrackingCSTransform();
+ if(!justClusters){
+ printf("NOT JUST CLUSTERS\n");
+ EvalLocal2TrackingCSTransform();
+ }
}
//must be done here because, in constructor, option is not yet known
fgRawUtils->SetOption(GetOption());
- fgRawUtils->SetRawFormatHighLowGainFactor(GetRecParam()->GetHighLowGainFactor());
- fgRawUtils->SetRawFormatOrder(GetRecParam()->GetOrderParameter());
- fgRawUtils->SetRawFormatTau(GetRecParam()->GetTau());
+ // fgRawUtils->SetRawFormatHighLowGainFactor(GetRecParam()->GetHighLowGainFactor());
+
+ // fgRawUtils->SetRawFormatOrder(GetRecParam()->GetOrderParameter());
+ // fgRawUtils->SetRawFormatTau(GetRecParam()->GetTau());
fgRawUtils->SetNoiseThreshold(GetRecParam()->GetNoiseThreshold());
fgRawUtils->SetNPedSamples(GetRecParam()->GetNPedSamples());
fgRawUtils->SetRemoveBadChannels(GetRecParam()->GetRemoveBadChannels());
fgRawUtils->SetFittingAlgorithm(GetRecParam()->GetFittingAlgorithm());
fgRawUtils->SetFALTROUsage(GetRecParam()->UseFALTRO());
- fgRawUtils->SetTimeMin(GetRecParam()->GetTimeMin());
- fgRawUtils->SetTimeMax(GetRecParam()->GetTimeMax());
+
+ //fgRawUtils->SetTimeMin(GetRecParam()->GetTimeMin());
+ //fgRawUtils->SetTimeMax(GetRecParam()->GetTimeMax());
+
+ // fgRawUtils->SetTimeMin(-99999 );
+ // fgRawUtils->SetTimeMax( 99999 );
fgRawUtils->Raw2Digits(rawReader,fgDigitsArr,fPedestalData,digitsTrg,fTriggerData);
+
}//skip calibration event
else{
AliDebug(1," Calibration Event, skip!");
#include "AliEMCALGeometry.h"
#include "AliEMCALRawUtils.h"
#include "AliLog.h"
+#include "AliCaloConstants.h"
+
+using namespace CALO;
ClassImp(AliEMCALTrigger)
Float_t maxtimeR2 = -1 ;
Float_t maxtimeRn = -1 ;
static AliEMCALRawUtils rawUtil;
- Int_t nTimeBins = rawUtil.GetRawFormatTimeBins() ;
+ // Int_t nTimeBins = rawUtil.GetRawFormatTimeBins() ;
+ Int_t nTimeBins = TIMEBINS; //changed by PTH
//Set max of 2x2 amplitudes and select L0 trigger
if(max2[0] > f2x2MaxAmp ){
fADCValuesHigh2x2 = new Int_t[nTimeBins];
}
//printf(" maxtimeR2 %12.5e (1)\n", maxtimeR2);
- rawUtil.RawSampledResponse(maxtimeR2 * AliEMCALRawUtils::GetRawFormatTimeBin(),
- f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
-
+ // rawUtil.RawSampledResponse(maxtimeR2 * AliEMCALRawUtils::GetRawFormatTimeBin(),
+ // f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
+
+ rawUtil.RawSampledResponse(maxtimeR2*TIMEBINMAX/TIMEBINS,
+ f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
+
// Set Trigger Inputs, compare ADC time bins until threshold is attained
// Set L0
for(Int_t i = 0 ; i < nTimeBins ; i++){
fADCValuesHighnxn = new Int_t[nTimeBins];
fADCValuesLownxn = new Int_t[nTimeBins];
}
- rawUtil.RawSampledResponse(maxtimeRn * AliEMCALRawUtils::GetRawFormatTimeBin(),
+ // rawUtil.RawSampledResponse(maxtimeRn * AliEMCALRawUtils::GetRawFormatTimeBin(),
+ // fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
+ rawUtil.RawSampledResponse(maxtimeRn*TIMEBINMAX/TIMEBINS,
fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
-
+
+
//Set Trigger Inputs, compare ADC time bins until threshold is attained
//SetL1 Low
for(Int_t i = 0 ; i < nTimeBins ; i++){
#include "Riostream.h"
+#include "AliCaloRawAnalyzerFactory.h"
+
namespace
{
const Int_t kSTUEqId = 4652;
fGeometry = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
}
- fRawAnalyzer = new AliCaloRawAnalyzerFakeALTRO();
+ // fRawAnalyzer = new AliCaloRawAnalyzerFakeALTRO ();
+ fRawAnalyzer = (AliCaloRawAnalyzerFakeALTRO*)AliCaloRawAnalyzerFactory::CreateAnalyzer(kFakeAltro);
+
fDCSConfig = AliEMCALTriggerDCSConfigDB::Instance();
for (Int_t i=0; i<3072; i++) fRawDigitIndex[i] = -1;
# SHLIBS - Shared Libraries and objects for linking (Executables only) #
#--------------------------------------------------------------------------------#
-set ( SRCS AliEMCALGeoParams.cxx AliEMCALGeoUtils.cxx AliEMCALGeometry.cxx AliEMCALEMCGeometry.cxx AliEMCALShishKebabTrd1Module.cxx AliEMCALPIDUtils.cxx AliCaloNeuralFit.cxx AliCaloRawAnalyzer.cxx AliCaloBunchInfo.cxx AliCaloFitResults.cxx AliCaloFitSubarray.cxx AliCaloRawAnalyzerCrude.cxx AliCaloRawAnalyzerLMS.cxx AliCaloRawAnalyzerNN.cxx AliCaloPeakFinderVectors.cxx AliEMCALHistoUtilities.cxx AliEMCALRecoUtils.cxx AliEMCALTrack.cxx AliEMCALCalibTimeDepCorrection.cxx)
+set ( SRCS AliEMCALGeoParams.cxx AliEMCALGeoUtils.cxx AliEMCALGeometry.cxx AliEMCALEMCGeometry.cxx AliEMCALShishKebabTrd1Module.cxx AliEMCALPIDUtils.cxx AliEMCALHistoUtilities.cxx AliEMCALRecoUtils.cxx AliEMCALTrack.cxx AliEMCALCalibTimeDepCorrection.cxx)
string (REPLACE ".cxx" ".h" HDRS "${SRCS}")
set ( DHDR EMCALUtilsLinkDef.h)
-set ( EXPORT AliEMCALGeoParams.h AliEMCALGeoUtils.h AliEMCALEMCGeometry.h AliEMCALShishKebabTrd1Module.h AliEMCALPIDUtils.h AliCaloNeuralFit.h AliCaloRawAnalyzer.h AliCaloBunchInfo.h AliCaloFitResults.h AliCaloRawAnalyzerCrude.h AliCaloRawAnalyzerLMS.h AliCaloRawAnalyzerPeakFinder.h AliCaloRawAnalyzerNN.h AliEMCALGeometry.h AliEMCALRecoUtils.h AliEMCALTrack.h)
+set ( EXPORT AliEMCALGeoParams.h AliEMCALGeoUtils.h AliEMCALEMCGeometry.h AliEMCALShishKebabTrd1Module.h AliEMCALPIDUtils.h AliEMCALGeometry.h AliEMCALRecoUtils.h AliEMCALTrack.h)
set ( PACKCXXFLAGS "${CXXFLAGS} -D__EMCALUTIL__")
# SHLIBS - Shared Libraries and objects for linking (Executables only) #
#--------------------------------------------------------------------------------#
-set ( SRCS AliEMCALHit.cxx AliEMCALLoader.cxx AliEMCALWsuCosmicRaySetUp.cxx AliEMCALRecPoint.cxx AliEMCALSDigitizer.cxx AliEMCALDigitizer.cxx AliEMCALDigit.cxx AliEMCALCalibData.cxx AliEMCALCalibTimeDep.cxx AliEMCALPreprocessor.cxx AliEMCALSensorTemp.cxx AliEMCALSensorTempArray.cxx AliCaloCalibPedestal.cxx AliCaloCalibSignal.cxx AliEMCALSurvey.cxx AliEMCALRecParam.cxx AliEMCALSimParam.cxx AliEMCALQAChecker.cxx AliEMCALSpaceFrame.cxx AliEMCALBiasAPD.cxx AliEMCALCalibAbs.cxx AliEMCALCalibReference.cxx AliEMCALCalibMapAPD.cxx AliEMCALCalibTempCoeff.cxx SMcalib/AliEMCALCCUSBRawStream.cxx AliEMCALRawDigit.cxx AliEMCALTrigger.cxx AliEMCALTriggerSTURawStream.cxx AliEMCAL.cxx AliEMCALRawUtils.cxx AliCaloRawAnalyzerFastFit.cxx AliCaloRawAnalyzerPeakFinder.cxx AliEMCALTriggerDCSConfig.cxx AliEMCALTriggerTRUDCSConfig.cxx AliEMCALTriggerSTUDCSConfig.cxx AliEMCALTriggerDCSConfigDB.cxx AliEMCALTriggerRawDigitMaker.cxx AliCaloRawAnalyzerFakeALTRO.cxx AliEMCALTriggerRawDigit.cxx)
+set ( SRCS AliEMCALHit.cxx AliEMCALLoader.cxx AliEMCALWsuCosmicRaySetUp.cxx AliEMCALRecPoint.cxx AliEMCALSDigitizer.cxx AliEMCALDigitizer.cxx AliEMCALDigit.cxx AliEMCALCalibData.cxx AliEMCALCalibTimeDep.cxx AliEMCALPreprocessor.cxx AliEMCALSensorTemp.cxx AliEMCALSensorTempArray.cxx AliCaloCalibPedestal.cxx AliCaloCalibSignal.cxx AliEMCALSurvey.cxx AliEMCALRecParam.cxx AliEMCALSimParam.cxx AliEMCALQAChecker.cxx AliEMCALSpaceFrame.cxx AliEMCALBiasAPD.cxx AliEMCALCalibAbs.cxx AliEMCALCalibReference.cxx AliEMCALCalibMapAPD.cxx AliEMCALCalibTempCoeff.cxx AliEMCALRawDigit.cxx AliEMCALTrigger.cxx AliEMCALTriggerSTURawStream.cxx AliEMCAL.cxx AliEMCALRawUtils.cxx AliEMCALTriggerDCSConfig.cxx AliEMCALTriggerTRUDCSConfig.cxx AliEMCALTriggerSTUDCSConfig.cxx AliEMCALTriggerDCSConfigDB.cxx AliEMCALTriggerRawDigitMaker.cxx AliEMCALTriggerRawDigit.cxx)
string (REPLACE ".cxx" ".h" HDRS "${SRCS}")
if( ALICE_TARGET STREQUAL "win32gcc")
- set ( PACKSOFLAGS ${SOFLAGS} -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lEMCALUtils -lSTEERBase -lCDB -lSTEER -lRAWDatarec -lRAWDatabase -L${ROOTLIBDIR} -lVMC -lGeom -lMinuit)
+ set ( PACKSOFLAGS ${SOFLAGS} -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lEMCALUtils -lEMCALraw -lSTEERBase -lCDB -lSTEER -lRAWDatarec -lRAWDatabase -L${ROOTLIBDIR} -lVMC -lGeom -lMinuit)
endif( ALICE_TARGET STREQUAL "win32gcc")
--- /dev/null
+#--------------------------------------------------------------------------------#
+# Package File for EMCALbase #
+# Author : Johny Jose (johny.jose@cern.ch) #
+# Variables Defined : #
+# #
+# SRCS - C++ source files #
+# HDRS - C++ header files #
+# DHDR - ROOT Dictionary Linkdef header file #
+# CSRCS - C source files #
+# CHDRS - C header files #
+# EINCLUDE - Include directories #
+# EDEFINE - Compiler definitions #
+# ELIBS - Extra libraries to link #
+# ELIBSDIR - Extra library directories #
+# PACKFFLAGS - Fortran compiler flags for package #
+# PACKCXXFLAGS - C++ compiler flags for package #
+# PACKCFLAGS - C compiler flags for package #
+# PACKSOFLAGS - Shared library linking flags #
+# PACKLDFLAGS - Module linker flags #
+# PACKBLIBS - Libraries to link (Executables only) #
+# EXPORT - Header files to be exported #
+# CINTHDRS - Dictionary header files #
+# CINTAUTOLINK - Set automatic dictionary generation #
+# ARLIBS - Archive Libraries and objects for linking (Executables only) #
+# SHLIBS - Shared Libraries and objects for linking (Executables only) #
+#--------------------------------------------------------------------------------#
+
+set ( SRCS AliCaloRawAnalyzerFastFit.cxx AliCaloRawAnalyzerPeakFinder.cxx AliCaloRawAnalyzerLMSOffline.cxx AliCaloRawAnalyzerLMS.cxx AliCaloRawAnalyzerFakeALTRO.cxx AliCaloRawAnalyzerKStandard.cxx AliCaloRawAnalyzerNN.cxx AliCaloRawAnalyzerCrude.cxx AliCaloRawAnalyzerFactory.cxx AliCaloNeuralFit.cxx AliCaloPeakFinderVectors.cxx AliCaloFitSubarray.cxx AliCaloRawAnalyzer.cxx AliCaloBunchInfo.cxx AliCaloFitResults.cxx AliCaloFastAltroFitv0.cxx SMcalib/AliEMCALCCUSBRawStream.cxx )
+
+string (REPLACE ".cxx" ".h" HDRS "${SRCS}")
+
+set ( DHDR EMCALrawLinkDef.h)
+
+set ( EINCLUDE PYTHIA6 RAW EVGEN THijing EMCAL/SMcalib)
+
+if( ALICE_TARGET STREQUAL "win32gcc")
+
+ set ( PACKSOFLAGS ${SOFLAGS} -lRAWDatabase -L${ROOTLIBDIR} -lVMC -lGeom -lMinuit)
+
+endif( ALICE_TARGET STREQUAL "win32gcc")
if( ALICE_TARGET STREQUAL "win32gcc")
- set ( PACKSOFLAGS ${SOFLAGS} -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lEMCALUtils -lEMCALbase -lEMCALsim -lSTEER -lESD -lCDB -lSTEERBase -L${ROOTLIBDIR} -lMinuit)
+ set ( PACKSOFLAGS ${SOFLAGS} -L${ALICE_ROOT}/lib/tgt_${ALICE_TARGET} -lEMCALUtils -lEMCALbase -lEMCALraw -lEMCALsim -lSTEER -lESD -lCDB -lSTEERBase -L${ROOTLIBDIR} -lMinuit)
endif( ALICE_TARGET STREQUAL "win32gcc")
#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;
-
#pragma link C++ class AliEMCALGeoParams+;
#pragma link C++ class AliEMCALGeoUtils+;
#pragma link C++ class AliEMCALGeometry+;
#pragma link C++ class AliEMCALEMCGeometry+;
#pragma link C++ class AliEMCALShishKebabTrd1Module+;
#pragma link C++ class AliEMCALPIDUtils+;
-#pragma link C++ class AliCaloNeuralFit+;
-#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+;
-#pragma link C++ class AliCaloPeakFinderVectors+;
#pragma link C++ class AliEMCALHistoUtilities+;
#pragma link C++ class AliEMCALRecoUtils+;
#pragma link C++ class AliEMCALTrack+;
#pragma link C++ class AliEMCALSimParam+;
#pragma link C++ class AliEMCALQAChecker+;
#pragma link C++ class AliEMCALSpaceFrame+;
-#pragma link C++ class AliEMCALCCUSBRawStream+;
#pragma link C++ class AliEMCALBiasAPD+;
#pragma link C++ class AliEMCALCalibAbs+;
#pragma link C++ class AliEMCALCalibReference+;
#pragma link C++ class AliEMCALTrigger+;
#pragma link C++ class AliEMCALTriggerSTURawStream+;
#pragma link C++ class AliEMCALRawUtils+;
-#pragma link C++ class AliCaloRawAnalyzerFastFit+;
-#pragma link C++ class AliCaloRawAnalyzerPeakFinder+;
#pragma link C++ class AliEMCAL+;
#pragma link C++ class AliEMCALTriggerDCSConfig+;
#pragma link C++ class AliEMCALTriggerTRUDCSConfig+;
#pragma link C++ class AliEMCALTriggerSTUDCSConfig+;
#pragma link C++ class AliEMCALTriggerDCSConfigDB+;
#pragma link C++ class AliEMCALTriggerRawDigitMaker+;
-#pragma link C++ class AliCaloRawAnalyzerFakeALTRO+;
#pragma link C++ class AliEMCALTriggerRawDigit+;
#endif
--- /dev/null
+#ifdef __CINT__
+// for libEMCALbase.pkg
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+#pragma link C++ class AliCaloRawAnalyzerPeakFinder+;
+#pragma link C++ class AliCaloRawAnalyzerLMS+;
+#pragma link C++ class AliCaloRawAnalyzerLMSOffline+;
+#pragma link C++ class AliCaloRawAnalyzerNN+;
+#pragma link C++ class AliCaloRawAnalyzerFastFit+;
+#pragma link C++ class AliCaloRawAnalyzerPeakFinder+;
+#pragma link C++ class AliCaloRawAnalyzerKStandard+;
+#pragma link C++ class AliCaloRawAnalyzerFakeALTRO+;
+#pragma link C++ class AliCaloRawAnalyzerCrude+;
+#pragma link C++ class AliCaloNeuralFit+;
+#pragma link C++ class AliCaloPeakFinderVectors+;
+#pragma link C++ class AliCaloFitSubarray+;
+#pragma link C++ class AliCaloRawAnalyzer+;
+#pragma link C++ class AliCaloBunchInfo+;
+#pragma link C++ class AliCaloFitResults+;
+#pragma link C++ class AliCaloRawAnalyzerFakeALTRO+;
+#pragma link C++ class AliEMCALCCUSBRawStream+;
+#pragma link C++ class AliCaloFastAltroFitv0+;
+
+#endif
+
set ( EINCLUDE )
set ( ELIBSDIR )
-set ( ELIBS EveBase EveDet MONITOR MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCfast TPCsim TPCrec TPCbase ITSbase ITSsim ITSrec PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec BCM STRUCT T0base T0sim T0rec STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS THijing hijing THbtp TEPEMGEN FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase HLTbase XMLParser STAT)
+set ( ELIBS EveBase EveDet MONITOR MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCfast TPCsim TPCrec TPCbase ITSbase ITSsim ITSrec PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec EMCALraw BCM STRUCT T0base T0sim T0rec STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS THijing hijing THbtp TEPEMGEN FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase HLTbase XMLParser STAT)
if(PYTHIA6)
list (APPEND ELIBS EVGEN)
set ( EINCLUDE )
set ( ELIBSDIR )
-set ( ELIBS EveBase EveHLT EveDet MONITOR HLTbase HLTrec AliHLTUtil AliHLTEve AliHLTTPC TPCcalib AliHLTRCU AliHLTMUON TPCsim TPCrec TPCbase ITSbase ITSrec TRDbase TRDrec AliHLTTRD PHOSbase PHOSUtils EMCALbase EMCALUtils EMCALrec EMCALsim TRIGGERbase VZERObase VZEROrec VZEROsim TRIGGERbase MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase XMLParser STAT TOFbase TOFsim FMDbase FMDsim FMDrec PMDbase T0base)
+set ( ELIBS EveBase EveHLT EveDet MONITOR HLTbase HLTrec AliHLTUtil AliHLTEve AliHLTTPC TPCcalib AliHLTRCU AliHLTMUON TPCsim TPCrec TPCbase ITSbase ITSrec TRDbase TRDrec AliHLTTRD PHOSbase PHOSUtils EMCALbase EMCALraw EMCALUtils EMCALrec EMCALsim TRIGGERbase VZERObase VZEROrec VZEROsim TRIGGERbase MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase XMLParser STAT TOFbase TOFsim FMDbase FMDsim FMDrec PMDbase T0base)
set ( PACKBLIBS ${ROOTCLIBS} ${ROOTPLIBS} -lTreePlayer -lGeomPainter -lGed -lRGL -lEve ${SYSLIBS})
#include "AliLog.h"
#include "TStopwatch.h"
+#include "AliCaloRawAnalyzerFactory.h"
+
+//#include "AliCaloConstants.h"
+
+//#include "AliCaloRawAnalyzer.h"
+
+//using namespace Algo;
#include <vector>
using namespace std;
-AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det):AliHLTCaloProcessor(),
- AliHLTCaloConstantsHandler(det),
- fAnalyzerPtr(0),
- fMapperPtr(0),
- fCurrentSpec(-1),
- fDebug(false),
- fSanityInspectorPtr(0),
- fRawReaderMemoryPtr(0),
- fAltroRawStreamPtr(0),
- fAlgorithm(0),
- fOffset(0),
- fBunchSizeCut(0),
- fMinPeakPosition(0),
- fMaxPeakPosition(100),
- fDoPushBadRawData(false),
- fDoPushRawData(false),
- fRawDataWriter(0)
+AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det, fitAlgorithm algo ):AliHLTCaloProcessor(),
+ AliHLTCaloConstantsHandler(det),
+ fAnalyzerPtr(0),
+ fMapperPtr(0),
+ fCurrentSpec(-1),
+ fDebug(false),
+ fSanityInspectorPtr(0),
+ fRawReaderMemoryPtr(0),
+ fAltroRawStreamPtr(0),
+ fAlgorithm(0),
+ fOffset(0),
+ fBunchSizeCut(0),
+ fMinPeakPosition(0),
+ fMaxPeakPosition(100),
+ fDoPushBadRawData(false),
+ fDoPushRawData(false),
+ fRawDataWriter(0)
{
//Constructor
+
+ fAnalyzerPtr = AliCaloRawAnalyzerFactory::CreateAnalyzer(algo);
+ fAnalyzerPtr->SetIsZeroSuppressed(true);
fSanityInspectorPtr = new AliHLTCaloSanityInspector();
if( fDoPushRawData == true )
#include "AliHLTCaloConstantsHandler.h"
#include "AliHLTCaloProcessor.h"
+#include "AliCaloRawAnalyzer.h"
+#include "AliCaloConstants.h"
+using namespace Algo;
+
class AliHLTCaloMapper;
public:
/** Constructor must be initialized to specific calorimeter */
- AliHLTCaloRawAnalyzerComponentv3(TString det);
+ AliHLTCaloRawAnalyzerComponentv3(TString det, fitAlgorithm algo );
virtual ~AliHLTCaloRawAnalyzerComponentv3();
virtual int DoInit(int argc =0, const char** argv = 0) ;
virtual int DoDeinit();
#include "AliHLTEMCALMapper.h"
#include "AliHLTEMCALDefinitions.h"
+#include "AliCaloConstants.h"
+using namespace Algo;
-AliHLTEMCALRawAnalyzerComponent::AliHLTEMCALRawAnalyzerComponent() : AliHLTCaloRawAnalyzerComponentv3("EMCAL")
+AliHLTEMCALRawAnalyzerComponent::AliHLTEMCALRawAnalyzerComponent( fitAlgorithm algo ) : AliHLTCaloRawAnalyzerComponentv3("EMCAL", algo)
{
//fDebug = true;
fDebug = false;
class AliHLTEMCALRawAnalyzerComponent : public AliHLTCaloRawAnalyzerComponentv3
{
public:
- AliHLTEMCALRawAnalyzerComponent();
+ AliHLTEMCALRawAnalyzerComponent( fitAlgorithm algo );
virtual ~AliHLTEMCALRawAnalyzerComponent();
void GetInputDataTypes( vector <AliHLTComponentDataType>& list);
AliHLTComponentDataType GetOutputDataType();
virtual AliHLTComponent* Spawn() = 0;
private:
+ AliHLTEMCALRawAnalyzerComponent();
AliHLTEMCALRawAnalyzerComponent(const AliHLTEMCALRawAnalyzerComponent & );
AliHLTEMCALRawAnalyzerComponent & operator = (const AliHLTEMCALRawAnalyzerComponent &);
virtual void InitMapping( const int specification );
//AliHLTEMCALRawAnalyzerCrudeComponent::AliHLTEMCALRawAnalyzerCrudeComponent : AliHLTEMCALRawAnalyzerComponent()
-AliHLTEMCALRawAnalyzerCrudeComponent::AliHLTEMCALRawAnalyzerCrudeComponent() : AliHLTEMCALRawAnalyzerComponent()
+AliHLTEMCALRawAnalyzerCrudeComponent::AliHLTEMCALRawAnalyzerCrudeComponent() : AliHLTEMCALRawAnalyzerComponent( kCrude )
{
// constructor
// fAnalyzerPtr = new AliHLTCaloRawAnalyzerCrude();
- fAnalyzerPtr = new AliCaloRawAnalyzerCrude();
+ // fAnalyzerPtr = new AliCaloRawAnalyzerCrude();
}
AliHLTEMCALRawAnalyzerCrudeComponent::~AliHLTEMCALRawAnalyzerCrudeComponent()
{
// destructor
+ /*
if (0 != fAnalyzerPtr)
{
delete fAnalyzerPtr;
fAnalyzerPtr = 0;
}
+ */
}
int
AliHLTEMCALRawAnalyzerFastFitComponent gAliHLTEMCALRawAnalyzerFastFitComponent;
-AliHLTEMCALRawAnalyzerFastFitComponent::AliHLTEMCALRawAnalyzerFastFitComponent() : AliHLTEMCALRawAnalyzerComponent()
+AliHLTEMCALRawAnalyzerFastFitComponent::AliHLTEMCALRawAnalyzerFastFitComponent() : AliHLTEMCALRawAnalyzerComponent(kFastFit)
{
// fAnalyzerPtr
- fAnalyzerPtr = new AliCaloRawAnalyzerFastFit();
+ // fAnalyzerPtr = new AliCaloRawAnalyzerFastFit();
}
AliHLTEMCALRawAnalyzerLMSComponent gAliHLTEMCALRawAnalyzerLMSComponent;
-AliHLTEMCALRawAnalyzerLMSComponent::AliHLTEMCALRawAnalyzerLMSComponent() : AliHLTEMCALRawAnalyzerComponent()
+AliHLTEMCALRawAnalyzerLMSComponent::AliHLTEMCALRawAnalyzerLMSComponent() : AliHLTEMCALRawAnalyzerComponent(kLMS)
{
// fAnalyzerPtr
- fAnalyzerPtr = new AliCaloRawAnalyzerLMS();
+ // fAnalyzerPtr = new AliCaloRawAnalyzerLMS();
}
AliHLTEMCALRawAnalyzerLMSComponent::~AliHLTEMCALRawAnalyzerLMSComponent()
{
- delete fAnalyzerPtr;
+ // delete fAnalyzerPtr;
}
AliHLTEMCALRawAnalyzerNNComponent gAliHLTEMCALRawAnalyzerNNComponent;
-AliHLTEMCALRawAnalyzerNNComponent::AliHLTEMCALRawAnalyzerNNComponent() : AliHLTEMCALRawAnalyzerComponent()
+AliHLTEMCALRawAnalyzerNNComponent::AliHLTEMCALRawAnalyzerNNComponent() : AliHLTEMCALRawAnalyzerComponent(kNeuralNet)
{
// fAnalyzerPtr
- fAnalyzerPtr = new AliCaloRawAnalyzerNN();
+ // fAnalyzerPtr = new AliCaloRawAnalyzerNN();
}
AliHLTEMCALRawAnalyzerNNComponent::~AliHLTEMCALRawAnalyzerNNComponent()
{
- delete fAnalyzerPtr;
+ // delete fAnalyzerPtr;
}
{
public:
- AliHLTEMCALRawAnalyzerNNComponent();
+ AliHLTEMCALRawAnalyzerNNComponent( );
virtual ~AliHLTEMCALRawAnalyzerNNComponent();
virtual const char* GetComponentID() ;
virtual AliHLTComponent* Spawn();
virtual int Deinit();
private:
+ // AliHLTEMCALRawAnalyzerNNComponent();
AliHLTEMCALRawAnalyzerNNComponent ( const AliHLTEMCALRawAnalyzerNNComponent &, TString det );
AliHLTEMCALRawAnalyzerNNComponent & operator = ( const AliHLTEMCALRawAnalyzerNNComponent );
// AliEMCALRawAnalyzerNN *fRawAnalyzer;
AliHLTEMCALRawAnalyzerPeakFinderComponent gAliHLTEMCALRawAnalyzerPeakFinderComponent;
-AliHLTEMCALRawAnalyzerPeakFinderComponent::AliHLTEMCALRawAnalyzerPeakFinderComponent (): AliHLTEMCALRawAnalyzerComponent()
+AliHLTEMCALRawAnalyzerPeakFinderComponent::AliHLTEMCALRawAnalyzerPeakFinderComponent (): AliHLTEMCALRawAnalyzerComponent(kPeakFinder)
{
-
// constructor
// fAnalyzerPtr = new AliCaloRawAnalyzerPeakFinder();
-
}
AliHLTEMCALRawAnalyzerPeakFinderComponent::~AliHLTEMCALRawAnalyzerPeakFinderComponent()
{
// destructor
+ /*
if (0 != fAnalyzerPtr)
{
delete fAnalyzerPtr;
fAnalyzerPtr = 0;
}
+ */
}
int
AliHLTEMCALRawAnalyzerPeakFinderComponent::DoInit(int argc, const char** argv)
{
- fAnalyzerPtr = new AliCaloRawAnalyzerPeakFinder();
+ // fAnalyzerPtr = new AliCaloRawAnalyzerPeakFinder();
return AliHLTCaloRawAnalyzerComponentv3::DoInit(argc, argv);
}
AliHLTEMCALRawAnalyzerPeakFinderComponent::DoDeinit()
{
//comment
+
+ /*
if (0 != fAnalyzerPtr)
{
delete fAnalyzerPtr;
fAnalyzerPtr = 0;
}
+ */
return AliHLTEMCALRawAnalyzerComponent::DoDeinit();
}
#include "AliHLTPHOSMapper.h"
-AliHLTPHOSRawAnalyzerComponentv3::AliHLTPHOSRawAnalyzerComponentv3() :
- AliHLTCaloRawAnalyzerComponentv3("PHOS")
+AliHLTPHOSRawAnalyzerComponentv3::AliHLTPHOSRawAnalyzerComponentv3( fitAlgorithm algo ) : AliHLTCaloRawAnalyzerComponentv3("PHOS", algo)
{
// See header file for class documentation
// InitMapping(0x1); //using 0x1 to avoid error message
*/
+//#include "AliCaloConstants.h"
+
+//using namespace Algo;
+
+
class AliHLTPHOSRawAnalyzerComponentv3 : public AliHLTCaloRawAnalyzerComponentv3
{
public:
- AliHLTPHOSRawAnalyzerComponentv3(); /** Standard constructor */
+ AliHLTPHOSRawAnalyzerComponentv3( fitAlgorithm algo ); /** Standard constructor */
virtual ~AliHLTPHOSRawAnalyzerComponentv3();
virtual void GetInputDataTypes( vector <AliHLTComponentDataType>& list);/** interface function, see @ref AliHLTComponent for description */
virtual AliHLTComponentDataType GetOutputDataType();/** interface function, see @ref AliHLTComponent for description */
virtual void InitMapping(const int specification);
private:
+ AliHLTPHOSRawAnalyzerComponentv3();
AliHLTPHOSRawAnalyzerComponentv3(const AliHLTPHOSRawAnalyzerComponentv3 & );
AliHLTPHOSRawAnalyzerComponentv3 & operator = (const AliHLTPHOSRawAnalyzerComponentv3 &);
#include "AliHLTPHOSRawAnalyzerCrudeComponent.h"
-#include "AliCaloRawAnalyzerCrude.h"
AliHLTPHOSRawAnalyzerCrudeComponent gAliHLTPHOSRawAnalyzerCrudeComponent;
//___________________________________________________________________________
-AliHLTPHOSRawAnalyzerCrudeComponent::AliHLTPHOSRawAnalyzerCrudeComponent()
+AliHLTPHOSRawAnalyzerCrudeComponent::AliHLTPHOSRawAnalyzerCrudeComponent() : AliHLTPHOSRawAnalyzerComponentv3(kCrude)
{
- fAnalyzerPtr = new AliCaloRawAnalyzerCrude();
- fAnalyzerPtr->SetIsZeroSuppressed(true);
+
}
+
//___________________________________________________________________________
AliHLTPHOSRawAnalyzerCrudeComponent::~AliHLTPHOSRawAnalyzerCrudeComponent()
{
-// if(fAnalyzerPtr)
-// {
-// delete fAnalyzerPtr;
-// fAnalyzerPtr = 0;
-// }
+
}
+
//___________________________________________________________________________
-AliHLTPHOSRawAnalyzerCrudeComponent::AliHLTPHOSRawAnalyzerCrudeComponent(const AliHLTPHOSRawAnalyzerCrudeComponent & ):AliHLTPHOSRawAnalyzerComponentv3()
+AliHLTPHOSRawAnalyzerCrudeComponent::AliHLTPHOSRawAnalyzerCrudeComponent(const AliHLTPHOSRawAnalyzerCrudeComponent & ):AliHLTPHOSRawAnalyzerComponentv3(kCrude)
{
}
+
int
AliHLTPHOSRawAnalyzerCrudeComponent::Deinit()
{
-
- if(fAnalyzerPtr)
- {
- delete fAnalyzerPtr;
- fAnalyzerPtr = 0;
- }
Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerCrudeComponent Deinit");
return 0;
}
+
//___________________________________________________________________________
const char*
AliHLTPHOSRawAnalyzerCrudeComponent::GetComponentID()
return "PhosRawCrude";
}
+
//___________________________________________________________________________
AliHLTComponent*
AliHLTPHOSRawAnalyzerCrudeComponent::Spawn()
* See cxx source for full Copyright notice */
-
class AliHLTPHOSRawAnalyzerCrudeComponent: public AliHLTPHOSRawAnalyzerComponentv3
//class AliHLTPHOSRawAnalyzerCrudeComponent: public AliHLTCaloRawAnalyzerComponentv3
{
# SHLIBS - Shared Libraries and objects for linking (Executables only) #
#--------------------------------------------------------------------------------#
-set ( SRCS AliFilter.cxx AliRawReader.cxx AliRawReaderFile.cxx AliRawReaderRoot.cxx AliRawReaderChain.cxx AliRawReaderDate.cxx AliRawReaderMemory.cxx AliRawHLTManager.cxx AliAltroRawStream.cxx AliCaloRawStream.cxx AliCaloRawStreamV3.cxx AliVMERawStream.cxx AliAltroDecoder.cxx AliAltroData.cxx AliAltroBunch.cxx AliAltroRawStreamFast.cxx AliAltroRawStreamV3.cxx AliCaloFastAltroFitv0.cxx)
+set ( SRCS AliFilter.cxx AliRawReader.cxx AliRawReaderFile.cxx AliRawReaderRoot.cxx AliRawReaderChain.cxx AliRawReaderDate.cxx AliRawReaderMemory.cxx AliRawHLTManager.cxx AliAltroRawStream.cxx AliCaloRawStream.cxx AliCaloRawStreamV3.cxx AliVMERawStream.cxx AliAltroDecoder.cxx AliAltroData.cxx AliAltroBunch.cxx AliAltroRawStreamFast.cxx AliAltroRawStreamV3.cxx )
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
#pragma link C++ class AliAltroRawStreamFast+;
#pragma link C++ class AliRawHLTManager+;
#pragma link C++ class AliAltroRawStreamV3+;
-#pragma link C++ class AliCaloFastAltroFitv0+;
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff