From 880c338207b37951c7c0139ec44fee59ad27af18 Mon Sep 17 00:00:00 2001 From: marian Date: Tue, 27 Jan 2009 14:04:15 +0000 Subject: [PATCH] Jens changes - common base class for the Raw data calibration AliTPCCalibCE.cxx.diff Include usage of base class, add possibility to set peak integration range for COG determination AliTPCCalibCE.h.diff Include usage of base class, add possibility to set peak integration range for COG determination AliTPCCalibPedestal.cxx.diff Include usage of base class AliTPCCalibPedestal.h.diff Include usage of base class AliTPCCalibPulser.cxx.diff Include usage of base class, add possibility to set peak integration range for COG determination AliTPCCalibPulser.h.diff Include usage of base class, add possibility to set peak integration range for COG determination AliTPCCalibRawBase.cxx Base class for raw data processing, to be used in the basic calibration components AliTPCCalibRawBase.h Base class for raw data processing, to be used in the basic calibration components AliTPCcalibLaser.cxx.diff Added common IROC/OROC linear fit model, added rotation of associated track the laser track ref. frame libTPCbase.pkg.diff Added raw data calibration base class TPCbaseLinkDef.h.diff Added raw data calibration base class --- TPC/AliTPCCalibCE.cxx | 892 +++++++++++++++--------------------- TPC/AliTPCCalibCE.h | 420 ++++++++--------- TPC/AliTPCCalibPedestal.cxx | 174 +------ TPC/AliTPCCalibPedestal.h | 30 +- TPC/AliTPCCalibPulser.cxx | 609 ++++++++++-------------- TPC/AliTPCCalibPulser.h | 308 ++++++------- TPC/AliTPCCalibRawBase.cxx | 262 +++++++++++ TPC/AliTPCCalibRawBase.h | 112 +++++ TPC/AliTPCcalibLaser.cxx | 97 +++- TPC/TPCbaseLinkDef.h | 1 + TPC/libTPCbase.pkg | 2 +- 11 files changed, 1417 insertions(+), 1490 deletions(-) create mode 100644 TPC/AliTPCCalibRawBase.cxx create mode 100644 TPC/AliTPCCalibRawBase.h diff --git a/TPC/AliTPCCalibCE.cxx b/TPC/AliTPCCalibCE.cxx index 4618d84a1c8..7c945a18435 100644 --- a/TPC/AliTPCCalibCE.cxx +++ b/TPC/AliTPCCalibCE.cxx @@ -297,156 +297,150 @@ ClassImp(AliTPCCalibCE) AliTPCCalibCE::AliTPCCalibCE() : - TObject(), - fFirstTimeBin(650), - fLastTimeBin(1000), - fNbinsT0(200), - fXminT0(-5), - fXmaxT0(5), - fNbinsQ(200), - fXminQ(1), - fXmaxQ(40), - fNbinsRMS(100), - fXminRMS(0.1), - fXmaxRMS(5.1), - fPeakMinus(2), - fPeakPlus(3), - fNoiseThresholdMax(5.), - fNoiseThresholdSum(8.), - fIsZeroSuppressed(kFALSE), - fLastSector(-1), - fSecRejectRatio(.4), - fROC(AliTPCROC::Instance()), - fMapping(NULL), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayT0Err(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - fMeanT0rms(0), - fMeanQrms(0), - fMeanRMSrms(0), - fHistoTmean(72), - fParamArrayEventPol1(72), - fParamArrayEventPol2(72), - fTMeanArrayEvent(72), - fQMeanArrayEvent(72), - fVEventTime(10), - fVEventNumber(10), - fNevents(0), - fTimeStamp(0), - fEventId(-1), - fRunNumber(-1), - fOldRunNumber(-1), - fPadTimesArrayEvent(72), - fPadQArrayEvent(72), - fPadRMSArrayEvent(72), - fPadPedestalArrayEvent(72), - fCurrentChannel(-1), - fCurrentSector(-1), - fCurrentRow(-1), - fMaxPadSignal(-1), - fMaxTimeBin(-1), - fPadSignal(1024), - fPadPedestal(0), - fPadNoise(0), - fVTime0Offset(72), - fVTime0OffsetCounter(72), - fVMeanQ(72), - fVMeanQCounter(72), - fCurrentCETimeRef(0), -// fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(0) + AliTPCCalibRawBase(), + fNbinsT0(200), + fXminT0(-5), + fXmaxT0(5), + fNbinsQ(200), + fXminQ(1), + fXmaxQ(40), + fNbinsRMS(100), + fXminRMS(0.1), + fXmaxRMS(5.1), + fPeakDetMinus(2), + fPeakDetPlus(3), + fPeakIntMinus(2), + fPeakIntPlus(2), + fNoiseThresholdMax(5.), + fNoiseThresholdSum(8.), + fIsZeroSuppressed(kFALSE), + fLastSector(-1), + fSecRejectRatio(.4), + fParam(new AliTPCParam), + fPedestalTPC(0x0), + fPadNoiseTPC(0x0), + fPedestalROC(0x0), + fPadNoiseROC(0x0), + fCalRocArrayT0(72), + fCalRocArrayT0Err(72), + fCalRocArrayQ(72), + fCalRocArrayRMS(72), + fCalRocArrayOutliers(72), + fHistoQArray(72), + fHistoT0Array(72), + fHistoRMSArray(72), + fMeanT0rms(0), + fMeanQrms(0), + fMeanRMSrms(0), + fHistoTmean(72), + fParamArrayEventPol1(72), + fParamArrayEventPol2(72), + fTMeanArrayEvent(72), + fQMeanArrayEvent(72), + fVEventTime(1000), + fVEventNumber(1000), + fVTime0SideA(1000), + fVTime0SideC(1000), + fTimeStamp(0), + fEventId(-1), + fRunNumber(-1), + fOldRunNumber(-1), + fPadTimesArrayEvent(72), + fPadQArrayEvent(72), + fPadRMSArrayEvent(72), + fPadPedestalArrayEvent(72), + fCurrentChannel(-1), + fCurrentSector(-1), + fCurrentRow(-1), + fMaxPadSignal(-1), + fMaxTimeBin(-1), + fPadSignal(1024), + fPadPedestal(0), + fPadNoise(0), + fVTime0Offset(72), + fVTime0OffsetCounter(72), + fVMeanQ(72), + fVMeanQCounter(72), + fCurrentCETimeRef(0) { - // - // AliTPCSignal default constructor - // -// fHTime0 = new TH1F("hTime0Event","hTime0Event",(fLastTimeBin-fFirstTimeBin)*10,fFirstTimeBin,fLastTimeBin); - fParam->Update(); + // + // AliTPCSignal default constructor + // + SetNameTitle("AliTPCCalibCE","AliTPCCalibCE"); + fFirstTimeBin=650; + fLastTimeBin=1000; + fParam->Update(); } //_____________________________________________________________________ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) : - TObject(sig), - fFirstTimeBin(sig.fFirstTimeBin), - fLastTimeBin(sig.fLastTimeBin), - fNbinsT0(sig.fNbinsT0), - fXminT0(sig.fXminT0), - fXmaxT0(sig.fXmaxT0), - fNbinsQ(sig.fNbinsQ), - fXminQ(sig.fXminQ), - fXmaxQ(sig.fXmaxQ), - fNbinsRMS(sig.fNbinsRMS), - fXminRMS(sig.fXminRMS), - fXmaxRMS(sig.fXmaxRMS), - fPeakMinus(sig.fPeakMinus), - fPeakPlus(sig.fPeakPlus), - fNoiseThresholdMax(sig.fNoiseThresholdMax), - fNoiseThresholdSum(sig.fNoiseThresholdSum), - fIsZeroSuppressed(sig.fIsZeroSuppressed), - fLastSector(-1), - fSecRejectRatio(.4), - fROC(AliTPCROC::Instance()), - fMapping(NULL), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayT0Err(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - fMeanT0rms(sig.fMeanT0rms), - fMeanQrms(sig.fMeanQrms), - fMeanRMSrms(sig.fMeanRMSrms), - fHistoTmean(72), - fParamArrayEventPol1(72), - fParamArrayEventPol2(72), - fTMeanArrayEvent(72), - fQMeanArrayEvent(72), - fVEventTime(1000), - fVEventNumber(1000), - fNevents(sig.fNevents), - fTimeStamp(0), - fEventId(-1), - fRunNumber(-1), - fOldRunNumber(-1), - fPadTimesArrayEvent(72), - fPadQArrayEvent(72), - fPadRMSArrayEvent(72), - fPadPedestalArrayEvent(72), - fCurrentChannel(-1), - fCurrentSector(-1), - fCurrentRow(-1), - fMaxPadSignal(-1), - fMaxTimeBin(-1), - fPadSignal(1024), - fPadPedestal(0), - fPadNoise(0), - fVTime0Offset(72), - fVTime0OffsetCounter(72), - fVMeanQ(72), - fVMeanQCounter(72), - fCurrentCETimeRef(0), -// fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(sig.fDebugLevel) + AliTPCCalibRawBase(sig), + fNbinsT0(sig.fNbinsT0), + fXminT0(sig.fXminT0), + fXmaxT0(sig.fXmaxT0), + fNbinsQ(sig.fNbinsQ), + fXminQ(sig.fXminQ), + fXmaxQ(sig.fXmaxQ), + fNbinsRMS(sig.fNbinsRMS), + fXminRMS(sig.fXminRMS), + fXmaxRMS(sig.fXmaxRMS), + fPeakDetMinus(sig.fPeakDetMinus), + fPeakDetPlus(sig.fPeakDetPlus), + fPeakIntMinus(sig.fPeakIntMinus), + fPeakIntPlus(sig.fPeakIntPlus), + fNoiseThresholdMax(sig.fNoiseThresholdMax), + fNoiseThresholdSum(sig.fNoiseThresholdSum), + fIsZeroSuppressed(sig.fIsZeroSuppressed), + fLastSector(-1), + fSecRejectRatio(.4), + fParam(new AliTPCParam), + fPedestalTPC(0x0), + fPadNoiseTPC(0x0), + fPedestalROC(0x0), + fPadNoiseROC(0x0), + fCalRocArrayT0(72), + fCalRocArrayT0Err(72), + fCalRocArrayQ(72), + fCalRocArrayRMS(72), + fCalRocArrayOutliers(72), + fHistoQArray(72), + fHistoT0Array(72), + fHistoRMSArray(72), + fMeanT0rms(sig.fMeanT0rms), + fMeanQrms(sig.fMeanQrms), + fMeanRMSrms(sig.fMeanRMSrms), + fHistoTmean(72), + fParamArrayEventPol1(72), + fParamArrayEventPol2(72), + fTMeanArrayEvent(72), + fQMeanArrayEvent(72), + fVEventTime(sig.fVEventTime), + fVEventNumber(sig.fVEventNumber), + fVTime0SideA(sig.fVTime0SideA), + fVTime0SideC(sig.fVTime0SideC), + fTimeStamp(0), + fEventId(-1), + fRunNumber(-1), + fOldRunNumber(-1), + fPadTimesArrayEvent(72), + fPadQArrayEvent(72), + fPadRMSArrayEvent(72), + fPadPedestalArrayEvent(72), + fCurrentChannel(-1), + fCurrentSector(-1), + fCurrentRow(-1), + fMaxPadSignal(-1), + fMaxTimeBin(-1), + fPadSignal(1024), + fPadPedestal(0), + fPadNoise(0), + fVTime0Offset(72), + fVTime0OffsetCounter(72), + fVMeanQ(72), + fVMeanQCounter(72), + fCurrentCETimeRef(0) { // - // AliTPCSignal copy constructor + // AliTPCSignal copy constructor // for (Int_t iSec = 0; iSec < 72; ++iSec){ @@ -465,32 +459,23 @@ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) : if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec); if ( hQ != 0x0 ){ -// TDirectory *dir = hQ->GetDirectory(); -// hQ->SetDirectory(0); TH2S *hNew = new TH2S(*hQ); hNew->SetDirectory(0); fHistoQArray.AddAt(hNew,iSec); -// hQ->SetDirectory(dir); } if ( hT0 != 0x0 ){ -// TDirectory *dir = hT0->GetDirectory(); -// hT0->SetDirectory(0); TH2S *hNew = new TH2S(*hT0); hNew->SetDirectory(0); fHistoT0Array.AddAt(hNew,iSec); -// hT0->SetDirectory(dir); } if ( hRMS != 0x0 ){ -// TDirectory *dir = hRMS->GetDirectory(); -// hRMS->SetDirectory(0); TH2S *hNew = new TH2S(*hRMS); hNew->SetDirectory(0); fHistoRMSArray.AddAt(hNew,iSec); -// hRMS->SetDirectory(dir); } } - //copy fit parameters event by event + //copy fit parameters event by event TObjArray *arr=0x0; for (Int_t iSec=0; iSec<72; ++iSec){ arr = (TObjArray*)sig.fParamArrayEventPol1.UncheckedAt(iSec); @@ -529,9 +514,7 @@ AliTPCCalibCE::AliTPCCalibCE(const AliTPCCalibCE &sig) : } //_____________________________________________________________________ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) : - TObject(), - fFirstTimeBin(650), - fLastTimeBin(1000), + AliTPCCalibRawBase(), fNbinsT0(200), fXminT0(-5), fXmaxT0(5), @@ -541,15 +524,15 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) : fNbinsRMS(100), fXminRMS(0.1), fXmaxRMS(5.1), - fPeakMinus(2), - fPeakPlus(3), + fPeakDetMinus(2), + fPeakDetPlus(3), + fPeakIntMinus(2), + fPeakIntPlus(2), fNoiseThresholdMax(5.), fNoiseThresholdSum(8.), fIsZeroSuppressed(kFALSE), fLastSector(-1), fSecRejectRatio(.4), - fROC(AliTPCROC::Instance()), - fMapping(NULL), fParam(new AliTPCParam), fPedestalTPC(0x0), fPadNoiseTPC(0x0), @@ -571,9 +554,10 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) : fParamArrayEventPol2(72), fTMeanArrayEvent(72), fQMeanArrayEvent(72), - fVEventTime(10), - fVEventNumber(10), - fNevents(0), + fVEventTime(1000), + fVEventNumber(1000), + fVTime0SideA(1000), + fVTime0SideC(1000), fTimeStamp(0), fEventId(-1), fRunNumber(-1), @@ -594,14 +578,14 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) : fVTime0OffsetCounter(72), fVMeanQ(72), fVMeanQCounter(72), - fCurrentCETimeRef(0), - // fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(0) + fCurrentCETimeRef(0) { // // constructor which uses a tmap as input to set some specific parameters // + SetNameTitle("AliTPCCalibCE","AliTPCCalibCE"); + fFirstTimeBin=650; + fLastTimeBin=1000; if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi(); if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi(); if (config->GetValue("NbinsT0")) fNbinsT0 = ((TObjString*)config->GetValue("NbinsT0"))->GetString().Atoi(); @@ -613,11 +597,14 @@ AliTPCCalibCE::AliTPCCalibCE(const TMap *config) : if (config->GetValue("NbinsRMS")) fNbinsRMS = ((TObjString*)config->GetValue("NbinsRMS"))->GetString().Atoi(); if (config->GetValue("XminRMS")) fXminRMS = ((TObjString*)config->GetValue("XminRMS"))->GetString().Atof(); if (config->GetValue("XmaxRMS")) fXmaxRMS = ((TObjString*)config->GetValue("XmaxRMS"))->GetString().Atof(); - if (config->GetValue("PeakMinus")) fPeakMinus = ((TObjString*)config->GetValue("PeakMinus"))->GetString().Atoi(); - if (config->GetValue("PeakPlus")) fPeakPlus = ((TObjString*)config->GetValue("PeakPlus"))->GetString().Atoi(); + if (config->GetValue("PeakDetMinus")) fPeakDetMinus = ((TObjString*)config->GetValue("PeakDetMinus"))->GetString().Atoi(); + if (config->GetValue("PeakDetPlus")) fPeakDetPlus = ((TObjString*)config->GetValue("PeakDetPlus"))->GetString().Atoi(); + if (config->GetValue("PeakIntMinus")) fPeakIntMinus = ((TObjString*)config->GetValue("PeakIntMinus"))->GetString().Atoi(); + if (config->GetValue("PeakIntPlus")) fPeakIntPlus = ((TObjString*)config->GetValue("PeakIntPlus"))->GetString().Atoi(); if (config->GetValue("NoiseThresholdMax")) fNoiseThresholdMax = ((TObjString*)config->GetValue("NoiseThresholdMax"))->GetString().Atof(); if (config->GetValue("NoiseThresholdSum")) fNoiseThresholdSum = ((TObjString*)config->GetValue("NoiseThresholdSum"))->GetString().Atof(); if (config->GetValue("IsZeroSuppressed")) fIsZeroSuppressed = (Bool_t)((TObjString*)config->GetValue("IsZeroSuppressed"))->GetString().Atoi(); + if (config->GetValue("UseL1Phase")) fUseL1Phase = (Bool_t)((TObjString*)config->GetValue("UseL1Phase"))->GetString().Atoi(); if (config->GetValue("SecRejectRatio")) fSecRejectRatio = ((TObjString*)config->GetValue("SecRejectRatio"))->GetString().Atof(); fParam->Update(); @@ -663,9 +650,7 @@ AliTPCCalibCE::~AliTPCCalibCE() fPadRMSArrayEvent.Delete(); fPadPedestalArrayEvent.Delete(); - if ( fDebugStreamer) delete fDebugStreamer; // if ( fHTime0 ) delete fHTime0; -// delete fROC; delete fParam; } //_____________________________________________________________________ @@ -830,8 +815,8 @@ void AliTPCCalibCE::FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF Float_t ceQmax =0, ceQsum=0, ceTime=0, ceRMS=0; Int_t cemaxpos = 0; Float_t ceSumThreshold = fNoiseThresholdSum*fPadNoise; // threshold for the signal sum - const Int_t kCemin = 4; // range for the analysis of the ce signal +- channels from the peak - const Int_t kCemax = 7; + const Int_t kCemin = fPeakIntMinus; // range for the analysis of the ce signal +- channels from the peak + const Int_t kCemax = fPeakIntPlus; Float_t minDist = 25; //initial minimum distance betweek roc mean ce signal and pad ce signal @@ -844,10 +829,10 @@ void AliTPCCalibCE::FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF cemaxpos = (Int_t)maxima[imax]; } } - +// printf("L1 phase TB: %f\n",GetL1PhaseTB()); if (cemaxpos!=0){ ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal; - for (Int_t i=cemaxpos-kCemin; ifFirstTimeBin) && (i0) { @@ -861,6 +846,7 @@ void AliTPCCalibCE::FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF if (ceQmax&&ceQsum>ceSumThreshold) { ceTime/=ceQsum; ceRMS = TMath::Sqrt(TMath::Abs(ceRMS/ceQsum-ceTime*ceTime)); + ceTime-=GetL1PhaseTB(); fVTime0Offset.GetMatrixArray()[fCurrentSector]+=ceTime; // mean time for each sector fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++; @@ -882,7 +868,7 @@ void AliTPCCalibCE::FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF ceQsum=0; } param[0] = ceQmax; - param[1] = ceTime; + param[1] = ceTime; param[2] = ceRMS; qSum = ceQsum; } @@ -913,8 +899,8 @@ void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima) Int_t count = 0; // Int_t tminus = 2; // Int_t tplus = 3; - for (Int_t i=fLastTimeBin-fPeakPlus-1; i>=fFirstTimeBin+fPeakMinus; --i){ - if ( (fPadSignal[i]-fPadPedestal)>ceThreshold && IsPeak(i,fPeakMinus,fPeakPlus) ){ + for (Int_t i=fLastTimeBin-fPeakDetPlus-1; i>=fFirstTimeBin+fPeakDetMinus; --i){ + if ( (fPadSignal[i]-fPadPedestal)>ceThreshold && IsPeak(i,fPeakDetMinus,fPeakDetPlus) ){ if (countFill(i); @@ -925,44 +911,44 @@ void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima) //_____________________________________________________________________ void AliTPCCalibCE::ProcessPad() { - // - // Process data of current pad - // - FindPedestal(); - - TVectorF maxima(15); // the expected maximum number of maxima in the complete TPC should be 8 laser beam layers + // + // Process data of current pad + // + FindPedestal(); + + TVectorF maxima(15); // the expected maximum number of maxima in the complete TPC should be 8 laser beam layers // + central electrode and possibly post peaks from the CE signal // however if we are on a high noise pad a lot more peaks due to the noise might occur - FindLocalMaxima(maxima); - if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return; // return because we don't have Time0 info for the CE yet - - UpdateCETimeRef(); // update the time refenrence for the current sector - if ( fCurrentCETimeRef==0 ) return; //return if we don't have time 0 info, eg if only one side has laser - TVectorD param(3); - Float_t qSum; - FindCESignal(param, qSum, maxima); - - Double_t meanT = param[1]; - Double_t sigmaT = param[2]; - + FindLocalMaxima(maxima); + if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return; // return because we don't have Time0 info for the CE yet + + UpdateCETimeRef(); // update the time refenrence for the current sector + if ( fCurrentCETimeRef==0 ) return; //return if we don't have time 0 info, eg if only one side has laser + TVectorD param(3); + Float_t qSum; + FindCESignal(param, qSum, maxima); + + Double_t meanT = param[1]; + Double_t sigmaT = param[2]; + //Fill Event T0 counter - (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT; - + (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT; + //Fill Q histogram - GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel ); - + GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel ); + //Fill RMS histogram - GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel ); - - + GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel ); + + //Fill debugging info - if ( fDebugLevel>0 ){ - (*GetPadPedestalEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=fPadPedestal; - (*GetPadRMSEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=sigmaT; - (*GetPadQEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=qSum; - } - - ResetPad(); + if ( GetStreamLevel()>0 ){ + (*GetPadPedestalEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=fPadPedestal; + (*GetPadRMSEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=sigmaT; + (*GetPadQEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=qSum; + } + + ResetPad(); } //_____________________________________________________________________ void AliTPCCalibCE::EndEvent() @@ -1035,6 +1021,15 @@ void AliTPCCalibCE::EndEvent() if ( vSize < fNevents+1 ){ vMeanTime->ResizeTo(vSize+100); } + + // store mean time for the readout sides + vSize=fVTime0SideA.GetNrows(); + if ( vSize < fNevents+1 ){ + fVTime0SideA.ResizeTo(vSize+100); + fVTime0SideC.ResizeTo(vSize+100); + } + fVTime0SideA.GetMatrixArray()[fNevents]=time0Side[0]; + fVTime0SideC.GetMatrixArray()[fNevents]=time0Side[1]; vMeanTime->GetMatrixArray()[fNevents]=median; nSecMeanT++; @@ -1075,28 +1070,23 @@ void AliTPCCalibCE::EndEvent() //------------------------------- Debug start ------------------------------ - if ( fDebugLevel>0 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("debugCalibCE.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer - } - - Int_t row=0; - Int_t pad=0; - Int_t padc=0; - - Float_t q = (*GetPadQEvent(iSec))[iChannel]; - Float_t rms = (*GetPadRMSEvent(iSec))[iChannel]; - - UInt_t channel=iChannel; - Int_t sector=iSec; - - while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++; - pad = channel-fROC->GetRowIndexes(sector)[row]; - padc = pad-(fROC->GetNPads(sector,row)/2); - + if ( GetStreamLevel()>0 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if (streamer){ + Int_t row=0; + Int_t pad=0; + Int_t padc=0; + + Float_t q = (*GetPadQEvent(iSec))[iChannel]; + Float_t rms = (*GetPadRMSEvent(iSec))[iChannel]; + + UInt_t channel=iChannel; + Int_t sector=iSec; + + while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++; + pad = channel-fROC->GetRowIndexes(sector)[row]; + padc = pad-(fROC->GetNPads(sector,row)/2); + // TH1F *h1 = new TH1F(Form("hSignalD%d.%d.%d",sector,row,pad), // Form("hSignalD%d.%d.%d",sector,row,pad), // fLastTimeBin-fFirstTimeBin, @@ -1105,12 +1095,12 @@ void AliTPCCalibCE::EndEvent() // // for (Int_t i=fFirstTimeBin; iFill(i,fPadSignal(i)); - - Double_t t0Sec = 0; - if (fVTime0OffsetCounter.GetMatrixArray()[iSec]>0) - t0Sec = fVTime0Offset.GetMatrixArray()[iSec]/fVTime0OffsetCounter.GetMatrixArray()[iSec]; - Double_t t0Side = time0Side[(iSec/18)%2]; - (*fDebugStreamer) << "DataPad" << + + Double_t t0Sec = 0; + if (fVTime0OffsetCounter.GetMatrixArray()[iSec]>0) + t0Sec = fVTime0Offset.GetMatrixArray()[iSec]/fVTime0OffsetCounter.GetMatrixArray()[iSec]; + Double_t t0Side = time0Side[(iSec/18)%2]; + (*streamer) << "DataPad" << "Event=" << fNevents << "RunNumber=" << fRunNumber << "TimeStamp=" << fTimeStamp << @@ -1125,13 +1115,13 @@ void AliTPCCalibCE::EndEvent() "RMS=" << rms << "Sum=" << q << "MeanQ=" << meanQ << - // "hist.=" << h1 << + // "hist.=" << h1 << "\n"; - - // delete h1; - + + // delete h1; + } } - //----------------------------- Debug end ------------------------------ + //----------------------------- Debug end ------------------------------ }// end channel loop TVectorD paramPol1(3); @@ -1155,14 +1145,10 @@ void AliTPCCalibCE::EndEvent() } //------------------------------- Debug start ------------------------------ - if ( fDebugLevel>0 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("debugCalibCE.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer - } - (*fDebugStreamer) << "DataRoc" << + if ( GetStreamLevel()>0 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( streamer ) { + (*streamer) << "DataRoc" << // "Event=" << fEvent << "RunNumber=" << fRunNumber << "TimeStamp=" << fTimeStamp << @@ -1176,6 +1162,7 @@ void AliTPCCalibCE::EndEvent() "chi2Pol1=" << chi2Pol1 << "chi2Pol2=" << chi2Pol2 << "\n"; + } } //------------------------------- Debug end ------------------------------ hMeanT->Reset(); @@ -1201,121 +1188,6 @@ void AliTPCCalibCE::EndEvent() AliDebug(3, Form("EndEvent() - End; Event: %05d", fNevents)); } //_____________________________________________________________________ -Bool_t AliTPCCalibCE::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast) -{ - // - // Event Processing loop - AliTPCRawStreamFast - // - ResetEvent(); - Bool_t withInput = kFALSE; - while ( rawStreamFast->NextDDL() ){ - while ( rawStreamFast->NextChannel() ){ - Int_t isector = rawStreamFast->GetSector(); // current sector - Int_t iRow = rawStreamFast->GetRow(); // current row - Int_t iPad = rawStreamFast->GetPad(); // current pad - - while ( rawStreamFast->NextBunch() ){ - Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin(); - Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin(); - for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){ - Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin]; - Update(isector,iRow,iPad,iTimeBin+1,signal); - withInput = kTRUE; - } - } - } - } - if (withInput){ - EndEvent(); - } - return withInput; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibCE::ProcessEventFast(AliRawReader *rawReader) -{ - // - // Event processing loop using the fast raw stream algorithm- AliRawReader - // - - //printf("ProcessEventFast - raw reader\n"); - - AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader(); - if (eventHeader){ - fTimeStamp = eventHeader->Get("Timestamp"); - fRunNumber = eventHeader->Get("RunNb"); - } - fEventId = *rawReader->GetEventId(); - - AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader, (AliAltroMapping**)fMapping); - Bool_t res=ProcessEventFast(rawStreamFast); - delete rawStreamFast; - return res; - -} -//_____________________________________________________________________ -Bool_t AliTPCCalibCE::ProcessEvent(AliTPCRawStream *rawStream) -{ - // - // Event Processing loop - AliTPCRawStream - // The Function 'SetTimeStamp' should be called for each event to set the event time stamp!!! - // - - ResetEvent(); - - Bool_t withInput = kFALSE; - - while (rawStream->Next()) { - - Int_t isector = rawStream->GetSector(); // current sector - Int_t iRow = rawStream->GetRow(); // current row - Int_t iPad = rawStream->GetPad(); // current pad - Int_t iTimeBin = rawStream->GetTime(); // current time bin - Float_t signal = rawStream->GetSignal(); // current ADC signal - - Update(isector,iRow,iPad,iTimeBin,signal); - withInput = kTRUE; - } - - if (withInput){ - EndEvent(); - } - - return withInput; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibCE::ProcessEvent(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - - - AliTPCRawStream rawStream(rawReader,(AliAltroMapping**)fMapping); - AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader(); - if (eventHeader){ - fTimeStamp = eventHeader->Get("Timestamp"); - fRunNumber = eventHeader->Get("RunNb"); - } - fEventId = *rawReader->GetEventId(); - - - rawReader->Select("TPC"); - - return ProcessEvent(&rawStream); -} -//_____________________________________________________________________ -Bool_t AliTPCCalibCE::ProcessEvent(eventHeaderStruct *event) -{ - // - // Event processing loop - date event - // - AliRawReader *rawReader = new AliRawReaderDate((void*)event); - Bool_t result=ProcessEvent(rawReader); - delete rawReader; - return result; - -} -//_____________________________________________________________________ TH2S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr, Int_t nbinsY, Float_t ymin, Float_t ymax, const Char_t *type, Bool_t force) @@ -1742,6 +1614,7 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT { // // Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector' + // or side (-1: A-Side, -2: C-Side) // xVariable: 0-event time, 1-event id, 2-internal event counter // fitType: 0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q // fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y), @@ -1759,30 +1632,32 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT // sanity checks if ( !GetHistoT0(sector) ) return 0x0; //Sector has not been filled - if ( (sector<0) || (sector>71) ) return 0x0; + if ( (sector<-2) || (sector>71) ) return 0x0; if ( (xVariable<0) || (xVariable>2) ) return 0x0; if ( (fitType<0) || (fitType>3) ) return 0x0; - if ( !GetTMeanEvents(sector) ) return 0x0; //no mean time information available - - if ( fitType==0 ){ - if ( (fitParameter<0) || (fitParameter>2) ) return 0x0; - aType = &fParamArrayEventPol1; - if ( aType->At(sector)==0x0 ) return 0x0; - } - else if ( fitType==1 ){ - if ( (fitParameter<0) || (fitParameter>5) ) return 0x0; - aType = &fParamArrayEventPol2; - if ( aType->At(sector)==0x0 ) return 0x0; - } - + if ( sector>=0&&!GetTMeanEvents(sector) ) return 0x0; //no mean time information available + if ( sector<0 && fitType!=2) return 0x0; + + if (sector>=0){ + if ( fitType==0 ){ + if ( (fitParameter<0) || (fitParameter>2) ) return 0x0; + aType = &fParamArrayEventPol1; + if ( aType->At(sector)==0x0 ) return 0x0; + } + else if ( fitType==1 ){ + if ( (fitParameter<0) || (fitParameter>5) ) return 0x0; + aType = &fParamArrayEventPol2; + if ( aType->At(sector)==0x0 ) return 0x0; + } + } if ( xVariable == 0 ) xVar = &fVEventTime; if ( xVariable == 1 ) xVar = &fVEventNumber; if ( xVariable == 2 ) { xVar = new TVectorD(fNevents); for ( Int_t i=0;iAt(sector)); @@ -1791,7 +1666,10 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT if ( (v!=0x0) && ((*xVar)[ievent]>0) ) { x[npoints]=(*xVar)[ievent]; y[npoints]=(*v)[fitParameter]; npoints++;} } else if (fitType == 2) { Double_t xValue=(*xVar)[ievent]; - Double_t yValue=(*GetTMeanEvents(sector))[ievent]; + Double_t yValue=0; + if (sector>=0) yValue = (*GetTMeanEvents(sector))[ievent]; + else if (sector==-1) yValue=fVTime0SideA(ievent); + else if (sector==-2) yValue=fVTime0SideC(ievent); if ( yValue>0 && xValue>0 ) { x[npoints]=xValue; y[npoints]=yValue;npoints++;} }else if (fitType == 3) { Double_t xValue=(*xVar)[ievent]; @@ -1818,146 +1696,120 @@ TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitT //_____________________________________________________________________ void AliTPCCalibCE::Analyse() { - // - // Calculate calibration constants - // - - TVectorD paramQ(3); - TVectorD paramT0(3); - TVectorD paramRMS(3); - TMatrixD dummy(3,3); - - Float_t channelCounter=0; - fMeanT0rms=0; - fMeanQrms=0; - fMeanRMSrms=0; - - for (Int_t iSec=0; iSec<72; ++iSec){ - TH2S *hT0 = GetHistoT0(iSec); - if (!hT0 ) continue; - - AliTPCCalROC *rocQ = GetCalRocQ (iSec,kTRUE); - AliTPCCalROC *rocT0 = GetCalRocT0 (iSec,kTRUE); - AliTPCCalROC *rocT0Err = GetCalRocT0Err (iSec,kTRUE); - AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE); - AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE); - - TH2S *hQ = GetHistoQ(iSec); - TH2S *hRMS = GetHistoRMS(iSec); - - Short_t *arrayhQ = hQ->GetArray(); - Short_t *arrayhT0 = hT0->GetArray(); - Short_t *arrayhRMS = hRMS->GetArray(); - - UInt_t nChannels = fROC->GetNChannels(iSec); - - //debug - Int_t row=0; - Int_t pad=0; - Int_t padc=0; - //! debug - - for (UInt_t iChannel=0; iChannelGetArray(); + Short_t *arrayhT0 = hT0->GetArray(); + Short_t *arrayhRMS = hRMS->GetArray(); + + UInt_t nChannels = fROC->GetNChannels(iSec); + + //debug + Int_t row=0; + Int_t pad=0; + Int_t padc=0; + //! debug + + for (UInt_t iChannel=0; iChannel ??) && (cogTime0??) ){ - cogOut = 1; - cogTime0 = 0; - cogQ = 0; - cogRMS = 0; - } + if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0??) ){ + cogOut = 1; + cogTime0 = 0; + cogQ = 0; + cogRMS = 0; + } */ - rocQ->SetValue(iChannel, cogQ*cogQ); - rocT0->SetValue(iChannel, cogTime0); - rocT0Err->SetValue(iChannel, rmsT0); - rocRMS->SetValue(iChannel, cogRMS); - rocOut->SetValue(iChannel, cogOut); - - - //debug - if ( fDebugLevel > 0 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("debugCalibCEAnalysis.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer - } - - while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++; - pad = iChannel-fROC->GetRowIndexes(iSec)[row]; - padc = pad-(fROC->GetNPads(iSec,row)/2); - - (*fDebugStreamer) << "DataEnd" << - "Sector=" << iSec << - "Pad=" << pad << - "PadC=" << padc << - "Row=" << row << - "PadSec=" << iChannel << - "Q=" << cogQ << - "T0=" << cogTime0 << - "RMS=" << cogRMS << - "\n"; - } - //! debug - - } - - } - if ( channelCounter>0 ){ - fMeanT0rms/=channelCounter; - fMeanQrms/=channelCounter; - fMeanRMSrms/=channelCounter; + rocQ->SetValue(iChannel, cogQ*cogQ); + rocT0->SetValue(iChannel, cogTime0); + rocT0Err->SetValue(iChannel, rmsT0); + rocRMS->SetValue(iChannel, cogRMS); + rocOut->SetValue(iChannel, cogOut); + + + //debug + if ( GetStreamLevel() > 0 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( streamer ) { + + while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++; + pad = iChannel-fROC->GetRowIndexes(iSec)[row]; + padc = pad-(fROC->GetNPads(iSec,row)/2); + + (*streamer) << "DataEnd" << + "Sector=" << iSec << + "Pad=" << pad << + "PadC=" << padc << + "Row=" << row << + "PadSec=" << iChannel << + "Q=" << cogQ << + "T0=" << cogTime0 << + "RMS=" << cogRMS << + "\n"; + } + } + //! debug + } - if ( fDebugStreamer ) fDebugStreamer->GetFile()->Write(); + + } + if ( channelCounter>0 ){ + fMeanT0rms/=channelCounter; + fMeanQrms/=channelCounter; + fMeanRMSrms/=channelCounter; + } +// if ( fDebugStreamer ) fDebugStreamer->GetFile()->Write(); // delete fDebugStreamer; // fDebugStreamer = 0x0; -} -//_____________________________________________________________________ -void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) -{ - // - // Write class to file - // - - TString sDir(dir); - TString option; - - if ( append ) - option = "update"; - else - option = "recreate"; - - TDirectory *backup = gDirectory; - TFile f(filename,option.Data()); - f.cd(); - if ( !sDir.IsNull() ){ - f.mkdir(sDir.Data()); - f.cd(sDir); - } - this->Write(); - f.Close(); - - if ( backup ) backup->cd(); + fVEventTime.ResizeTo(fNevents); + fVEventNumber.ResizeTo(fNevents); + fVTime0SideA.ResizeTo(fNevents); + fVTime0SideC.ResizeTo(fNevents); } diff --git a/TPC/AliTPCCalibCE.h b/TPC/AliTPCCalibCE.h index 11a5f7ccd18..fca7b049463 100644 --- a/TPC/AliTPCCalibCE.h +++ b/TPC/AliTPCCalibCE.h @@ -10,7 +10,7 @@ //////////////////////////////////////////////////////////////////////////////////////// #include -#include +#include "AliTPCCalibRawBase.h" class TH1S; class TH2S; class TH1F; @@ -23,244 +23,210 @@ class AliRawReader; class AliTPCRawStream; class AliTPCRawStreamFast; class TGraph; -class AliTPCAltroMapping; class TMap; struct eventHeaderStruct; -class AliTPCCalibCE : public TObject { - +class AliTPCCalibCE : public AliTPCCalibRawBase { + public: - AliTPCCalibCE(); - AliTPCCalibCE(const AliTPCCalibCE &sig); - AliTPCCalibCE(const TMap *config); - virtual ~AliTPCCalibCE(); - - AliTPCCalibCE& operator = (const AliTPCCalibCE &source); - - Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast); - Bool_t ProcessEventFast(AliRawReader *rawReader); - - - Bool_t ProcessEvent(AliTPCRawStream *rawStream); - Bool_t ProcessEvent(AliRawReader *rawReader); - Bool_t ProcessEvent(eventHeaderStruct *event); - - Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, - const Int_t iTimeBin, const Float_t signal); - void Analyse(); - // - AliTPCAltroMapping **GetAltroMapping() { return fMapping; }; - void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; }; - + AliTPCCalibCE(); + AliTPCCalibCE(const AliTPCCalibCE &sig); + AliTPCCalibCE(const TMap *config); + virtual ~AliTPCCalibCE(); + + AliTPCCalibCE& operator = (const AliTPCCalibCE &source); + + virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, + const Int_t iTimeBin, const Float_t signal); + virtual void Analyse(); + // - AliTPCCalROC* GetCalRocT0 (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocT0Err(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - - const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object - const TObjArray* GetCalPadT0Err() const { return &fCalRocArrayT0Err; } // get calibration object - const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object - const TObjArray* GetCalPadRMS() const { return &fCalRocArrayRMS;} // get calibration object - const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object - - TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram - TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram - TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram - - Float_t GetMeanT0rms() const {return fMeanT0rms;} - Float_t GetMeanQrms() const {return fMeanQrms;} - Float_t GetMeanRMSrms() const {return fMeanRMSrms;} - - Int_t GetPeakDetectionMinus() const {return fPeakMinus;} - Int_t GetPeakDetectionPlus() const {return fPeakPlus;} - Float_t GetNnoiseThresholdMax() const {return fNoiseThresholdMax;} - Float_t GetNnoiseThresholdSum() const {return fNoiseThresholdSum;} - - TH1S* GetHistoTmean(Int_t sector, Bool_t force=kFALSE); // get refernce histogram - + AliTPCCalROC* GetCalRocT0 (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocT0Err(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + + const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object + const TObjArray* GetCalPadT0Err() const { return &fCalRocArrayT0Err; } // get calibration object + const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object + const TObjArray* GetCalPadRMS() const { return &fCalRocArrayRMS;} // get calibration object + const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object + + TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram + TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram + TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram + + Float_t GetMeanT0rms() const {return fMeanT0rms;} + Float_t GetMeanQrms() const {return fMeanQrms;} + Float_t GetMeanRMSrms() const {return fMeanRMSrms;} + + Int_t GetPeakDetectionMinus() const {return fPeakDetMinus;} + Int_t GetPeakDetectionPlus() const {return fPeakDetPlus;} + Int_t GetPeakIntRangeMinus() const {return fPeakIntMinus;} + Int_t GetPeakIntRangePlus() const {return fPeakIntPlus;} + Float_t GetNnoiseThresholdMax() const {return fNoiseThresholdMax;} + Float_t GetNnoiseThresholdSum() const {return fNoiseThresholdSum;} + + TH1S* GetHistoTmean(Int_t sector, Bool_t force=kFALSE); // get refernce histogram + //needed here to merge ClibCE objects - TObjArray* GetParamArrayPol1(Int_t sector, Bool_t force=kFALSE); - TObjArray* GetParamArrayPol2(Int_t sector, Bool_t force=kFALSE); - + TObjArray* GetParamArrayPol1(Int_t sector, Bool_t force=kFALSE); + TObjArray* GetParamArrayPol2(Int_t sector, Bool_t force=kFALSE); + // TObjArray* GetTMeanArrayEvent(){ return &fTMeanArrayEvent; } // TObjArray* GetQMeanArrayEvent(){ return &fQMeanArrayEvent; } - TVectorF* GetTMeanEvents(Int_t sector, Bool_t force=kFALSE); - TVectorF* GetQMeanEvents(Int_t sector, Bool_t force=kFALSE); - - TVectorD* GetEventTimes() { return &fVEventTime; } - TVectorD* GetEventIds() { return &fVEventNumber; } - - Short_t GetDebugLevel() const { return fDebugLevel; } - // - void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the pulser signal is expected - // - void SetRangeRefQ (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ = nBins; fXminQ = xMin; fXmaxQ = xMax; } //Set range for Q reference histograms - void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms - void SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; } //Set range for T0 reference histograms - // - void SetRangePeakDetection(Int_t minus, Int_t plus) { fPeakMinus=minus; fPeakPlus=plus;} - void SetNnoiseThresholdMax(Float_t n) {fNoiseThresholdMax=n;} - void SetNnoiseThresholdSum(Float_t n) {fNoiseThresholdSum=n;} - // - void SetTimeStampEvent(Double_t timestamp){ fTimeStamp = timestamp; } - void SetRunNumber(Double_t eventnumber){ fRunNumber = eventnumber; } - - void SetEventInfo(Double_t runNumber, Double_t timestamp, Double_t eventId){ fRunNumber=runNumber; fTimeStamp=timestamp; fEventId=eventId;} - - void SetDebugLevel(Short_t debug=1){ fDebugLevel = debug;} - - void SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;} - - void SetIsZeroSuppressed(Bool_t zs=kTRUE) { fIsZeroSuppressed=zs; } - - void SetSecRejectRatio(Float_t ratio) { fSecRejectRatio=ratio; } - - Int_t GetFirstTimeBin() const { return fFirstTimeBin; } - Int_t GetLastTimeBin() const { return fLastTimeBin; } - - Int_t GetNeventsProcessed() const { return fNevents; } - - Bool_t GetIsZeroSuppressed() const { return fIsZeroSuppressed; } - - Float_t GetSecRejectRatio() const { return fSecRejectRatio; } - - - void Merge(AliTPCCalibCE *ce); - - TGraph *MakeGraphTimeCE(Int_t sector, Int_t xVariable=0, Int_t fitType=0, Int_t fitParameter=0); - - void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE); - + TVectorF* GetTMeanEvents(Int_t sector, Bool_t force=kFALSE); + TVectorF* GetQMeanEvents(Int_t sector, Bool_t force=kFALSE); + + TVectorD* GetEventTimes() { return &fVEventTime; } + TVectorD* GetEventIds() { return &fVEventNumber; } + + // + void SetRangeRefQ (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ = nBins; fXminQ = xMin; fXmaxQ = xMax; } //Set range for Q reference histograms + void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms + void SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; } //Set range for T0 reference histograms + // + void SetRangePeakDetection(Int_t minus, Int_t plus) { fPeakDetMinus=minus; fPeakDetPlus=plus;} + void SetRangePeakIntegral(Int_t minus, Int_t plus) { fPeakIntMinus=minus; fPeakIntPlus=plus;} + void SetNnoiseThresholdMax(Float_t n) {fNoiseThresholdMax=n;} + void SetNnoiseThresholdSum(Float_t n) {fNoiseThresholdSum=n;} + // + void SetTimeStampEvent(Double_t timestamp){ fTimeStamp = timestamp; } + void SetRunNumber(Double_t eventnumber){ fRunNumber = eventnumber; } + void SetEventInfo(Double_t runNumber, Double_t timestamp, Double_t eventId){ fRunNumber=runNumber; fTimeStamp=timestamp; fEventId=eventId;} + // + void SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;} + void SetIsZeroSuppressed(Bool_t zs=kTRUE) { fIsZeroSuppressed=zs; } + void SetSecRejectRatio(Float_t ratio) { fSecRejectRatio=ratio; } + //Getters + Int_t GetNeventsProcessed() const { return fNevents; } + + Bool_t GetIsZeroSuppressed() const { return fIsZeroSuppressed; } + + Float_t GetSecRejectRatio() const { return fSecRejectRatio; } + + const TVectorF *GetTime0Side(Int_t side=0) const {return (side==0)?&fVTime0SideA:&fVTime0SideC;} + Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;} + Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;} + + + void Merge(AliTPCCalibCE *ce); + + TGraph *MakeGraphTimeCE(Int_t sector, Int_t xVariable=0, Int_t fitType=0, Int_t fitParameter=0); + private: - Int_t fFirstTimeBin; // First Time bin needed for analysis - Int_t fLastTimeBin; // Last Time bin needed for analysis - // reference histogram ranges - Int_t fNbinsT0; // Number of bins for T0 reference histogram - Float_t fXminT0; // xmin of T0 reference histogram - Float_t fXmaxT0; // xmax of T0 reference histogram - Int_t fNbinsQ; // Number of bins for T0 reference histogram - Float_t fXminQ; // xmin of T0 reference histogram - Float_t fXmaxQ; // xmax of T0 reference histogram - Int_t fNbinsRMS; // Number of bins for T0 reference histogram - Float_t fXminRMS; // xmin of T0 reference histogram - Float_t fXmaxRMS; // xmax of T0 reference histogram - Int_t fPeakMinus; // Consecutive timebins on rising edge to be regarded as a signal - Int_t fPeakPlus; // Consecutive timebins on falling edge to be regarded as a signal - Float_t fNoiseThresholdMax; // Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise - Float_t fNoiseThresholdSum; // Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise - - Bool_t fIsZeroSuppressed; // If data is Zero Suppressed -> Don't subtrakt pedestals! - - Int_t fLastSector; //! Last sector processed - - Float_t fSecRejectRatio; //! Needed percentage of signals in one chamber. Below it will be rejected + Int_t fNbinsT0; // Number of bins for T0 reference histogram + Float_t fXminT0; // xmin of T0 reference histogram + Float_t fXmaxT0; // xmax of T0 reference histogram + Int_t fNbinsQ; // Number of bins for T0 reference histogram + Float_t fXminQ; // xmin of T0 reference histogram + Float_t fXmaxQ; // xmax of T0 reference histogram + Int_t fNbinsRMS; // Number of bins for T0 reference histogram + Float_t fXminRMS; // xmin of T0 reference histogram + Float_t fXmaxRMS; // xmax of T0 reference histogram + Int_t fPeakDetMinus; // Consecutive timebins on rising edge to be regarded as a signal + Int_t fPeakDetPlus; // Consecutive timebins on falling edge to be regarded as a signal + Int_t fPeakIntMinus; // Peak integral range for COG determination. Bins used before max bin + Int_t fPeakIntPlus; // Peak integral range for COG determination. Bins used after max bin + Float_t fNoiseThresholdMax; // Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise + Float_t fNoiseThresholdSum; // Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise + + Bool_t fIsZeroSuppressed; // If data is Zero Suppressed -> Don't subtrakt pedestals! + + Int_t fLastSector; //! Last sector processed + + Float_t fSecRejectRatio; //! Needed percentage of signals in one chamber. Below it will be rejected // This is neede if we do not process a laser event - - AliTPCROC *fROC; //! ROC information - AliTPCAltroMapping **fMapping; //! Altro Mapping object - AliTPCParam *fParam; //! TPC information - - AliTPCCalPad *fPedestalTPC; //! Pedestal Information whole TPC - AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC - AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC - AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC - - TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration - TObjArray fCalRocArrayT0Err; // Array of AliTPCCalROC class for the error (rms) of Time0 calibration - TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration - TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration - TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers - - TObjArray fHistoQArray; // Calibration histograms for Charge distribution - TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution - TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution - - Float_t fMeanT0rms; // mean of the rms of all pad T0 fits, used as error estimation of T0 results - Float_t fMeanQrms; // mean of the rms of all pad Q fits, used as error estimation of Q results - Float_t fMeanRMSrms; // mean of the rms of all pad TMS fits, used as error estimation of RMS results - - TObjArray fHistoTmean; //! Calibration histograms of the mean CE position for all sectors - - TObjArray fParamArrayEventPol1; // Store mean arrival time parameters for each sector event by event from global plane fit - TObjArray fParamArrayEventPol2; // Store mean arrival time parameters for each sector event by event from global parabola fit - TObjArray fTMeanArrayEvent; // Store mean arrival time for each sector event by event - TObjArray fQMeanArrayEvent; // Store mean arrival Charge for each sector event by event - TVectorD fVEventTime; // Timestamps of the events - TVectorD fVEventNumber; // Eventnumbers of the events -// TVectorD fVTime0Side[2]; // Mean Time0 for each side for all events - Int_t fNevents; // Event counter - Double_t fTimeStamp; //! Timestamp of the current event - Double_t fEventId; //! Event Id of the current event - Double_t fRunNumber; //! Run Number of the current event - Double_t fOldRunNumber; //! Old Run Number - - TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections - TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer - TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer - TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer - - Int_t fCurrentChannel; //! current channel processed - Int_t fCurrentSector; //! current sector processed - Int_t fCurrentRow; //! current row processed - Float_t fMaxPadSignal; //! maximum bin of current pad - Int_t fMaxTimeBin; //! time bin with maximum value - TVectorF fPadSignal; //! signal of current Pad - Float_t fPadPedestal; //! Pedestal Value of current pad - Float_t fPadNoise; //! Noise Value of current pad - - TVectorD fVTime0Offset; //! Time0 Offset for each sector; - TVectorD fVTime0OffsetCounter; //! Time0 Offset counter for each sector; - TVectorD fVMeanQ; //! Mean Q for each sector; - TVectorD fVMeanQCounter; //! Mean Q counter for each sector; - - Float_t fCurrentCETimeRef; //! Time refernce of the current sector - //debugging -// Int_t fEvent; - TTreeSRedirector *fDebugStreamer; //! debug streamer - - - Short_t fDebugLevel; // debug level - //! debugging - - void FindPedestal(Float_t part=.6); - void UpdateCETimeRef(); //Get the time reference of the last valid measurement in sector - void FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF maxima); - void FindLocalMaxima(TVectorF &maxima); - Bool_t IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const; - - TH2S* GetHisto(Int_t sector, TObjArray *arr, - Int_t nbinsY, Float_t ymin, Float_t ymax, - const Char_t *type, Bool_t force); - TH1S* GetHisto(Int_t sector, TObjArray *arr, - const Char_t *type, Bool_t force); - - AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const; - - TVectorF* GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force=kFALSE) const; - TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE); - - TObjArray* GetParamArray(Int_t sector, TObjArray *arr, Bool_t force=kFALSE) const; - - void ResetEvent(); - void ResetPad(); - void ProcessPad(); - void EndEvent(); - - - //debug - TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE); - TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE); - TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE); - - ClassDef(AliTPCCalibCE,7) //Implementation of the TPC Central Electrode calibration - + + AliTPCParam *fParam; //! TPC information + + AliTPCCalPad *fPedestalTPC; //! Pedestal Information whole TPC + AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC + AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC + AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC + + TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration + TObjArray fCalRocArrayT0Err; // Array of AliTPCCalROC class for the error (rms) of Time0 calibration + TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration + TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration + TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers + + TObjArray fHistoQArray; // Calibration histograms for Charge distribution + TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution + TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution + + Float_t fMeanT0rms; // mean of the rms of all pad T0 fits, used as error estimation of T0 results + Float_t fMeanQrms; // mean of the rms of all pad Q fits, used as error estimation of Q results + Float_t fMeanRMSrms; // mean of the rms of all pad TMS fits, used as error estimation of RMS results + + TObjArray fHistoTmean; //! Calibration histograms of the mean CE position for all sectors + + TObjArray fParamArrayEventPol1; // Store mean arrival time parameters for each sector event by event from global plane fit + TObjArray fParamArrayEventPol2; // Store mean arrival time parameters for each sector event by event from global parabola fit + TObjArray fTMeanArrayEvent; // Store mean arrival time for each sector event by event + TObjArray fQMeanArrayEvent; // Store mean arrival Charge for each sector event by event + TVectorD fVEventTime; // Timestamps of the events + TVectorD fVEventNumber; // Eventnumbers of the events + TVectorF fVTime0SideA; // Mean Time0 for side A for all events + TVectorF fVTime0SideC; // Mean Time0 for side C for all events + Double_t fTimeStamp; //! Timestamp of the current event + Double_t fEventId; //! Event Id of the current event + Double_t fRunNumber; //! Run Number of the current event + Double_t fOldRunNumber; //! Old Run Number + + TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections + TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer + TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer + TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer + + Int_t fCurrentChannel; //! current channel processed + Int_t fCurrentSector; //! current sector processed + Int_t fCurrentRow; //! current row processed + Float_t fMaxPadSignal; //! maximum bin of current pad + Int_t fMaxTimeBin; //! time bin with maximum value + TVectorF fPadSignal; //! signal of current Pad + Float_t fPadPedestal; //! Pedestal Value of current pad + Float_t fPadNoise; //! Noise Value of current pad + + TVectorD fVTime0Offset; //! Time0 Offset for each sector; + TVectorD fVTime0OffsetCounter; //! Time0 Offset counter for each sector; + TVectorD fVMeanQ; //! Mean Q for each sector; + TVectorD fVMeanQCounter; //! Mean Q counter for each sector; + + Float_t fCurrentCETimeRef; //! Time refernce of the current sector + + void FindPedestal(Float_t part=.6); + void UpdateCETimeRef(); //Get the time reference of the last valid measurement in sector + void FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF maxima); + void FindLocalMaxima(TVectorF &maxima); + Bool_t IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const; + + TH2S* GetHisto(Int_t sector, TObjArray *arr, + Int_t nbinsY, Float_t ymin, Float_t ymax, + const Char_t *type, Bool_t force); + TH1S* GetHisto(Int_t sector, TObjArray *arr, + const Char_t *type, Bool_t force); + + AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const; + + TVectorF* GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force=kFALSE) const; + TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE); + + TObjArray* GetParamArray(Int_t sector, TObjArray *arr, Bool_t force=kFALSE) const; + + virtual void EndEvent(); + virtual void ResetEvent(); + void ResetPad(); + void ProcessPad(); + //debug + TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE); + TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE); + TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE); + + ClassDef(AliTPCCalibCE,8) //Implementation of the TPC Central Electrode calibration }; - - #endif - diff --git a/TPC/AliTPCCalibPedestal.cxx b/TPC/AliTPCCalibPedestal.cxx index 594d884fda7..74825e22e14 100644 --- a/TPC/AliTPCCalibPedestal.cxx +++ b/TPC/AliTPCCalibPedestal.cxx @@ -201,16 +201,12 @@ ClassImp(AliTPCCalibPedestal) AliTPCCalibPedestal::AliTPCCalibPedestal() : - TObject(), - fFirstTimeBin(60), - fLastTimeBin(1000), + AliTPCCalibRawBase(), fAdcMin(1), fAdcMax(100), fAnaMeanDown(0.), fAnaMeanUp(1.), fTimeAnalysis(kFALSE), - fROC(AliTPCROC::Instance()), - fMapping(NULL), fCalRocArrayPedestal(72), fCalRocArraySigma(72), fHistoPedestalArray(72), @@ -221,21 +217,20 @@ AliTPCCalibPedestal::AliTPCCalibPedestal() : // // default constructor // + SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal"); + fFirstTimeBin=60; + fLastTimeBin=1000; } //_____________________________________________________________________ AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : - TObject(ped), - fFirstTimeBin(ped.GetFirstTimeBin()), - fLastTimeBin(ped.GetLastTimeBin()), + AliTPCCalibRawBase(ped), fAdcMin(ped.GetAdcMin()), fAdcMax(ped.GetAdcMax()), fAnaMeanDown(ped.fAnaMeanDown), fAnaMeanUp(ped.fAnaMeanUp), fTimeAnalysis(ped.fTimeAnalysis), - fROC(AliTPCROC::Instance()), - fMapping(NULL), fCalRocArrayPedestal(72), fCalRocArraySigma(72), fHistoPedestalArray(72), @@ -262,16 +257,12 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : } } AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config): - TObject(), - fFirstTimeBin(60), - fLastTimeBin(1000), + AliTPCCalibRawBase(), fAdcMin(1), fAdcMax(100), fAnaMeanDown(0.), fAnaMeanUp(1.), fTimeAnalysis(kFALSE), - fROC(AliTPCROC::Instance()), - fMapping(NULL), fCalRocArrayPedestal(72), fCalRocArraySigma(72), fHistoPedestalArray(72), @@ -282,13 +273,14 @@ AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config): // // This constructor uses a TMap for setting some parametes // + SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal"); + fFirstTimeBin=60; + fLastTimeBin=1000; if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi(); if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi(); if (config->GetValue("AdcMin")) fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi(); if (config->GetValue("AdcMax")) fAdcMax = ((TObjString*)config->GetValue("AdcMax"))->GetString().Atoi(); if (config->GetValue("TimeAnalysis")) SetTimeAnalysis(((TObjString*)config->GetValue("TimeAnalysis"))->GetString().Atoi()); - - } @@ -401,99 +393,6 @@ Int_t AliTPCCalibPedestal::Update(const Int_t icsector, } -//_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast) -{ - // - // Event Processing loop - AliTPCRawStream - // - Bool_t withInput = kFALSE; - - while ( rawStreamFast->NextDDL() ){ - while ( rawStreamFast->NextChannel() ){ - Int_t isector = rawStreamFast->GetSector(); // current sector - Int_t iRow = rawStreamFast->GetRow(); // current row - Int_t iPad = rawStreamFast->GetPad(); // current pad - - while ( rawStreamFast->NextBunch() ){ - Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin(); - Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin(); - for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){ - Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin]; - Update(isector,iRow,iPad,iTimeBin+1,signal); - withInput = kTRUE; - } - } - } - } - - return withInput; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEventFast(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader, (AliAltroMapping**)fMapping); - Bool_t res=ProcessEventFast(rawStreamFast); - delete rawStreamFast; - return res; -} - -//_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream) -{ - // - // Event Processing loop - AliTPCRawStream - // - - Bool_t withInput = kFALSE; - - while (rawStream->Next()) { - - Int_t iSector = rawStream->GetSector(); // current ROC - Int_t iRow = rawStream->GetRow(); // current row - Int_t iPad = rawStream->GetPad(); // current pad - Int_t iTimeBin = rawStream->GetTime(); // current time bin - Float_t signal = rawStream->GetSignal(); // current ADC signal - - Update(iSector,iRow,iPad,iTimeBin,signal); - withInput = kTRUE; - } - - return withInput; -} - - -//_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - - // if fMapping is NULL the rawstream will crate its own mapping - AliTPCRawStream rawStream(rawReader, (AliAltroMapping**)fMapping); - rawReader->Select("TPC"); - return ProcessEvent(&rawStream); -} - - -//_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEvent(eventHeaderStruct *event) -{ - // - // process date event - // - - AliRawReader *rawReader = new AliRawReaderDate((void*)event); - Bool_t result=ProcessEvent(rawReader); - delete rawReader; - return result; -} - - //_____________________________________________________________________ Bool_t AliTPCCalibPedestal::TestEvent() { @@ -502,20 +401,20 @@ Bool_t AliTPCCalibPedestal::TestEvent() // fill one oroc and one iroc with random gaus // - gRandom->SetSeed(0); - - for (UInt_t iSec=0; iSec<72; ++iSec){ - if (iSec%36>0) continue; - for (UInt_t iRow=0; iRow < fROC->GetNRows(iSec); ++iRow){ - for (UInt_t iPad=0; iPad < fROC->GetNPads(iSec,iRow); ++iPad){ - for (UInt_t iTimeBin=0; iTimeBin<1024; ++iTimeBin){ - Float_t signal=(Int_t)(iRow+3+gRandom->Gaus(0,.7)); - if ( signal>0 )Update(iSec,iRow,iPad,iTimeBin,signal); - } - } - } + gRandom->SetSeed(0); + + for (UInt_t iSec=0; iSec<72; ++iSec){ + if (iSec%36>0) continue; + for (UInt_t iRow=0; iRow < fROC->GetNRows(iSec); ++iRow){ + for (UInt_t iPad=0; iPad < fROC->GetNPads(iSec,iRow); ++iPad){ + for (UInt_t iTimeBin=0; iTimeBin<1024; ++iTimeBin){ + Float_t signal=(Int_t)(iRow+3+gRandom->Gaus(0,.7)); + if ( signal>0 )Update(iSec,iRow,iPad,iTimeBin,signal); + } + } } - return kTRUE; + } + return kTRUE; } @@ -733,32 +632,3 @@ void AliTPCCalibPedestal::AnalyseTime(Int_t nevents) } } } - - -//_____________________________________________________________________ -void AliTPCCalibPedestal::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) -{ - // - // Write class to file - // - - TString sDir(dir); - TString option; - - if ( append ) - option = "update"; - else - option = "recreate"; - - TDirectory *backup = gDirectory; - TFile f(filename,option.Data()); - f.cd(); - if ( !sDir.IsNull() ){ - f.mkdir(sDir.Data()); - f.cd(sDir); - } - this->Write(); - f.Close(); - - if ( backup ) backup->cd(); -} diff --git a/TPC/AliTPCCalibPedestal.h b/TPC/AliTPCCalibPedestal.h index a56aff05129..e6bd0e1858c 100644 --- a/TPC/AliTPCCalibPedestal.h +++ b/TPC/AliTPCCalibPedestal.h @@ -3,10 +3,8 @@ /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ - - -#include #include +#include "AliTPCCalibRawBase.h" class TArrayF; class TH2F; @@ -21,7 +19,7 @@ class TMap; struct eventHeaderStruct; -class AliTPCCalibPedestal : public TObject { +class AliTPCCalibPedestal : public AliTPCCalibRawBase { public: AliTPCCalibPedestal(); @@ -31,16 +29,9 @@ public: AliTPCCalibPedestal& operator = (const AliTPCCalibPedestal &source); - Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast); - Bool_t ProcessEventFast(AliRawReader *rawReader); - - Bool_t ProcessEvent(AliTPCRawStream *rawStream); - Bool_t ProcessEvent(AliRawReader *rawReader); - Bool_t ProcessEvent(eventHeaderStruct *event); - - Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, + virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, const Int_t iTimeBin, const Float_t signal); - void Analyse(); + virtual void Analyse(); // AliTPCAltroMapping **GetAltroMapping() { return fMapping; }; void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; }; @@ -56,20 +47,16 @@ public: const TObjArray* GetCalPadRMS(){return &fCalRocArrayRMS;} // get calibration object TH2F* GetHistoPedestal (Int_t sector, Bool_t force=kFALSE); // get refernce histogram - void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE); // void SetTimeAnalysis(Bool_t time = kTRUE); // Use ONLY in TPCPEDESTALda on LDC for one sector! void AnalyseTime(Int_t nevents); // Makes sense only in TPCPEDESTALda on LDC! TArrayF **GetTimePedestals() const { return fTimeSignal; } // Get array with time dependent pedestals (for one sector!) // - Int_t GetFirstTimeBin() const { return fFirstTimeBin; } - Int_t GetLastTimeBin() const { return fLastTimeBin; } Int_t GetAdcMin() const { return fAdcMin; } Int_t GetAdcMax() const { return fAdcMax; } Float_t GetAnaMeanDown() const { return fAnaMeanDown; } Float_t GetAnaMeanUp() const { return fAnaMeanUp; } - void SetRangeTime(Int_t tMin, Int_t tMax){ fFirstTimeBin=tMin; fLastTimeBin=tMax; } // Set time bin range that is used for the pedestal calibration void SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; } // Set adc range for the pedestal calibration void SetAnalysisTruncationRange(Float_t down, Float_t up) {fAnaMeanDown=down; fAnaMeanUp=up;} //Set range for truncated mean analysis of the channel information @@ -78,10 +65,6 @@ public: Bool_t TestEvent(); // Test the fast approach to fill histogram - used for test purposes private: - - Int_t fFirstTimeBin; // First Time bin needed for analysis - Int_t fLastTimeBin; // Last Time bin needed for analysis - Int_t fAdcMin; // min adc channel of pedestal value Int_t fAdcMax; // max adc channel of pedestal value @@ -90,9 +73,6 @@ private: Bool_t fTimeAnalysis; //! Should we use the time dependent analysis? ONLY ON LDC! - AliTPCROC *fROC; //! ROC information - AliTPCAltroMapping **fMapping; //! Altro Mapping object - TObjArray fCalRocArrayPedestal; // Array of AliTPCCalROC class for pedestal values from gaus fit TObjArray fCalRocArraySigma; // Array of AliTPCCalROC class for noise values from gaus fit @@ -110,7 +90,7 @@ private: AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force); public: - ClassDef(AliTPCCalibPedestal, 6) // Implementation of the TPC pedestal and noise calibration + ClassDef(AliTPCCalibPedestal, 7) // Implementation of the TPC pedestal and noise calibration }; diff --git a/TPC/AliTPCCalibPulser.cxx b/TPC/AliTPCCalibPulser.cxx index 9530f84feab..938cfed0190 100644 --- a/TPC/AliTPCCalibPulser.cxx +++ b/TPC/AliTPCCalibPulser.cxx @@ -202,158 +202,148 @@ ClassImp(AliTPCCalibPulser) AliTPCCalibPulser::AliTPCCalibPulser() : - TObject(), - fFirstTimeBin(60), - fLastTimeBin(900), - fNbinsT0(200), - fXminT0(-2), - fXmaxT0(2), - fNbinsQ(200), - fXminQ(10), - fXmaxQ(40), - fNbinsRMS(100), - fXminRMS(0.1), - fXmaxRMS(5.1), - fIsZeroSuppressed(kFALSE), - fLastSector(-1), - fROC(AliTPCROC::Instance()), - fMapping(NULL), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fOutliers(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - fHMeanTimeSector(0x0), - fVMeanTimeSector(72), - fPadTimesArrayEvent(72), - fPadQArrayEvent(72), - fPadRMSArrayEvent(72), - fPadPedestalArrayEvent(72), - fCurrentChannel(-1), - fCurrentSector(-1), - fCurrentRow(-1), - fCurrentPad(-1), - fMaxPadSignal(-1), - fMaxTimeBin(-1), - fPadSignal(1024), - fPadPedestal(0), - fPadNoise(0), - fVTime0Offset(72), - fVTime0OffsetCounter(72), -// fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(0) + AliTPCCalibRawBase(), + fNbinsT0(200), + fXminT0(-2), + fXmaxT0(2), + fNbinsQ(200), + fXminQ(10), + fXmaxQ(40), + fNbinsRMS(100), + fXminRMS(0.1), + fXmaxRMS(5.1), + fPeakIntMinus(2), + fPeakIntPlus(2), + fIsZeroSuppressed(kFALSE), + fLastSector(-1), + fParam(new AliTPCParam), + fPedestalTPC(0x0), + fPadNoiseTPC(0x0), + fOutliers(0x0), + fPedestalROC(0x0), + fPadNoiseROC(0x0), + fCalRocArrayT0(72), + fCalRocArrayQ(72), + fCalRocArrayRMS(72), + fCalRocArrayOutliers(72), + fHistoQArray(72), + fHistoT0Array(72), + fHistoRMSArray(72), + fHMeanTimeSector(0x0), + fVMeanTimeSector(72), + fPadTimesArrayEvent(72), + fPadQArrayEvent(72), + fPadRMSArrayEvent(72), + fPadPedestalArrayEvent(72), + fCurrentChannel(-1), + fCurrentSector(-1), + fCurrentRow(-1), + fCurrentPad(-1), + fMaxPadSignal(-1), + fMaxTimeBin(-1), + fPadSignal(1024), + fPadPedestal(0), + fPadNoise(0), + fVTime0Offset(72), + fVTime0OffsetCounter(72) { - // - // AliTPCSignal default constructor - // - + // + // AliTPCSignal default constructor + // + SetNameTitle("AliTPCCalibPulser","AliTPCCalibPulser"); + fFirstTimeBin=60; + fLastTimeBin=900; fParam->Update(); } //_____________________________________________________________________ AliTPCCalibPulser::AliTPCCalibPulser(const AliTPCCalibPulser &sig) : - TObject(sig), - fFirstTimeBin(sig.fFirstTimeBin), - fLastTimeBin(sig.fLastTimeBin), - fNbinsT0(sig.fNbinsT0), - fXminT0(sig.fXminT0), - fXmaxT0(sig.fXmaxT0), - fNbinsQ(sig.fNbinsQ), - fXminQ(sig.fXminQ), - fXmaxQ(sig.fXmaxQ), - fNbinsRMS(sig.fNbinsRMS), - fXminRMS(sig.fXminRMS), - fXmaxRMS(sig.fXmaxRMS), - fIsZeroSuppressed(sig.fIsZeroSuppressed), - fLastSector(-1), - fROC(AliTPCROC::Instance()), - fMapping(NULL), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fOutliers(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - fHMeanTimeSector(0x0), - fVMeanTimeSector(72), - fPadTimesArrayEvent(72), - fPadQArrayEvent(72), - fPadRMSArrayEvent(72), - fPadPedestalArrayEvent(72), - fCurrentChannel(-1), - fCurrentSector(-1), - fCurrentRow(-1), - fCurrentPad(-1), - fMaxPadSignal(-1), - fMaxTimeBin(-1), - fPadSignal(1024), - fPadPedestal(0), - fPadNoise(0), - fVTime0Offset(72), - fVTime0OffsetCounter(72), -// fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(sig.fDebugLevel) + AliTPCCalibRawBase(sig), + fNbinsT0(sig.fNbinsT0), + fXminT0(sig.fXminT0), + fXmaxT0(sig.fXmaxT0), + fNbinsQ(sig.fNbinsQ), + fXminQ(sig.fXminQ), + fXmaxQ(sig.fXmaxQ), + fNbinsRMS(sig.fNbinsRMS), + fXminRMS(sig.fXminRMS), + fXmaxRMS(sig.fXmaxRMS), + fPeakIntMinus(sig.fPeakIntMinus), + fPeakIntPlus(sig.fPeakIntPlus), + fIsZeroSuppressed(sig.fIsZeroSuppressed), + fLastSector(-1), + fParam(new AliTPCParam), + fPedestalTPC(0x0), + fPadNoiseTPC(0x0), + fOutliers(0x0), + fPedestalROC(0x0), + fPadNoiseROC(0x0), + fCalRocArrayT0(72), + fCalRocArrayQ(72), + fCalRocArrayRMS(72), + fCalRocArrayOutliers(72), + fHistoQArray(72), + fHistoT0Array(72), + fHistoRMSArray(72), + fHMeanTimeSector(0x0), + fVMeanTimeSector(72), + fPadTimesArrayEvent(72), + fPadQArrayEvent(72), + fPadRMSArrayEvent(72), + fPadPedestalArrayEvent(72), + fCurrentChannel(-1), + fCurrentSector(-1), + fCurrentRow(-1), + fCurrentPad(-1), + fMaxPadSignal(-1), + fMaxTimeBin(-1), + fPadSignal(1024), + fPadPedestal(0), + fPadNoise(0), + fVTime0Offset(72), + fVTime0OffsetCounter(72) { - // - // AliTPCSignal default constructor - // - - for (Int_t iSec = 0; iSec < 72; ++iSec){ - const AliTPCCalROC *calQ = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec); - const AliTPCCalROC *calT0 = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec); - const AliTPCCalROC *calRMS = (AliTPCCalROC*)sig.fCalRocArrayRMS.UncheckedAt(iSec); - const AliTPCCalROC *calOut = (AliTPCCalROC*)sig.fCalRocArrayOutliers.UncheckedAt(iSec); - - const TH2S *hQ = (TH2S*)sig.fHistoQArray.UncheckedAt(iSec); - const TH2S *hT0 = (TH2S*)sig.fHistoT0Array.UncheckedAt(iSec); - const TH2S *hRMS = (TH2S*)sig.fHistoRMSArray.UncheckedAt(iSec); - - if ( calQ != 0x0 ) fCalRocArrayQ.AddAt(new AliTPCCalROC(*calQ), iSec); - if ( calT0 != 0x0 ) fCalRocArrayT0.AddAt(new AliTPCCalROC(*calT0), iSec); - if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec); - if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec); - - if ( hQ != 0x0 ){ - TH2S *hNew = new TH2S(*hQ); - hNew->SetDirectory(0); - fHistoQArray.AddAt(hNew,iSec); - } - if ( hT0 != 0x0 ){ - TH2S *hNew = new TH2S(*hT0); - hNew->SetDirectory(0); - fHistoQArray.AddAt(hNew,iSec); - } - if ( hRMS != 0x0 ){ - TH2S *hNew = new TH2S(*hRMS); - hNew->SetDirectory(0); - fHistoQArray.AddAt(hNew,iSec); - } - fVMeanTimeSector[iSec]=sig.fVMeanTimeSector[iSec]; + // + // AliTPCSignal default constructor + // + + for (Int_t iSec = 0; iSec < 72; ++iSec){ + const AliTPCCalROC *calQ = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec); + const AliTPCCalROC *calT0 = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec); + const AliTPCCalROC *calRMS = (AliTPCCalROC*)sig.fCalRocArrayRMS.UncheckedAt(iSec); + const AliTPCCalROC *calOut = (AliTPCCalROC*)sig.fCalRocArrayOutliers.UncheckedAt(iSec); + + const TH2S *hQ = (TH2S*)sig.fHistoQArray.UncheckedAt(iSec); + const TH2S *hT0 = (TH2S*)sig.fHistoT0Array.UncheckedAt(iSec); + const TH2S *hRMS = (TH2S*)sig.fHistoRMSArray.UncheckedAt(iSec); + + if ( calQ != 0x0 ) fCalRocArrayQ.AddAt(new AliTPCCalROC(*calQ), iSec); + if ( calT0 != 0x0 ) fCalRocArrayT0.AddAt(new AliTPCCalROC(*calT0), iSec); + if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec); + if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec); + + if ( hQ != 0x0 ){ + TH2S *hNew = new TH2S(*hQ); + hNew->SetDirectory(0); + fHistoQArray.AddAt(hNew,iSec); } - - if ( sig.fHMeanTimeSector ) fHMeanTimeSector=(TH2F*)sig.fHMeanTimeSector->Clone(); - fParam->Update(); + if ( hT0 != 0x0 ){ + TH2S *hNew = new TH2S(*hT0); + hNew->SetDirectory(0); + fHistoQArray.AddAt(hNew,iSec); + } + if ( hRMS != 0x0 ){ + TH2S *hNew = new TH2S(*hRMS); + hNew->SetDirectory(0); + fHistoQArray.AddAt(hNew,iSec); + } + fVMeanTimeSector[iSec]=sig.fVMeanTimeSector[iSec]; + } + + if ( sig.fHMeanTimeSector ) fHMeanTimeSector=(TH2F*)sig.fHMeanTimeSector->Clone(); + fParam->Update(); } AliTPCCalibPulser::AliTPCCalibPulser(const TMap *config) : - TObject(), - fFirstTimeBin(60), - fLastTimeBin(900), + AliTPCCalibRawBase(), fNbinsT0(200), fXminT0(-2), fXmaxT0(2), @@ -363,10 +353,10 @@ AliTPCCalibPulser::AliTPCCalibPulser(const TMap *config) : fNbinsRMS(100), fXminRMS(0.1), fXmaxRMS(5.1), + fPeakIntMinus(2), + fPeakIntPlus(2), fIsZeroSuppressed(kFALSE), fLastSector(-1), - fROC(AliTPCROC::Instance()), - fMapping(NULL), fParam(new AliTPCParam), fPedestalTPC(0x0), fPadNoiseTPC(0x0), @@ -396,14 +386,14 @@ AliTPCCalibPulser::AliTPCCalibPulser(const TMap *config) : fPadPedestal(0), fPadNoise(0), fVTime0Offset(72), - fVTime0OffsetCounter(72), - // fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(0) + fVTime0OffsetCounter(72) { // // This constructor uses a TMap for setting some parametes // + SetNameTitle("AliTPCCalibPulser","AliTPCCalibPulser"); + fFirstTimeBin=60; + fLastTimeBin=900; if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi(); if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi(); if (config->GetValue("NbinsT0")) fNbinsT0 = ((TObjString*)config->GetValue("NbinsT0"))->GetString().Atoi(); @@ -415,6 +405,8 @@ AliTPCCalibPulser::AliTPCCalibPulser(const TMap *config) : if (config->GetValue("NbinsRMS")) fNbinsRMS = ((TObjString*)config->GetValue("NbinsRMS"))->GetString().Atoi(); if (config->GetValue("XminRMS")) fXminRMS = ((TObjString*)config->GetValue("XminRMS"))->GetString().Atof(); if (config->GetValue("XmaxRMS")) fXmaxRMS = ((TObjString*)config->GetValue("XmaxRMS"))->GetString().Atof(); + if (config->GetValue("PeakIntMinus")) fPeakIntMinus = (Int_t)((TObjString*)config->GetValue("PeakIntMinus"))->GetString().Atof(); + if (config->GetValue("PeakIntPlus")) fPeakIntPlus = (Int_t)((TObjString*)config->GetValue("PeakIntPlus"))->GetString().Atof(); if (config->GetValue("IsZeroSuppressed")) fIsZeroSuppressed = (Bool_t)((TObjString*)config->GetValue("IsZeroSuppressed"))->GetString().Atoi(); fParam->Update(); @@ -433,35 +425,32 @@ AliTPCCalibPulser& AliTPCCalibPulser::operator = (const AliTPCCalibPulser &sour //_____________________________________________________________________ AliTPCCalibPulser::~AliTPCCalibPulser() { - // - // destructor - // - - Reset(); - - if ( fDebugStreamer) delete fDebugStreamer; - delete fROC; - delete fParam; + // + // destructor + // + + Reset(); + delete fParam; } void AliTPCCalibPulser::Reset() { - // - // Delete all information: Arrays, Histograms, CalRoc objects - // - fCalRocArrayT0.Delete(); - fCalRocArrayQ.Delete(); - fCalRocArrayRMS.Delete(); - fCalRocArrayOutliers.Delete(); - - fHistoQArray.Delete(); - fHistoT0Array.Delete(); - fHistoRMSArray.Delete(); - - fPadTimesArrayEvent.Delete(); - fPadQArrayEvent.Delete(); - fPadRMSArrayEvent.Delete(); - fPadPedestalArrayEvent.Delete(); - + // + // Delete all information: Arrays, Histograms, CalRoc objects + // + fCalRocArrayT0.Delete(); + fCalRocArrayQ.Delete(); + fCalRocArrayRMS.Delete(); + fCalRocArrayOutliers.Delete(); + + fHistoQArray.Delete(); + fHistoT0Array.Delete(); + fHistoRMSArray.Delete(); + + fPadTimesArrayEvent.Delete(); + fPadQArrayEvent.Delete(); + fPadRMSArrayEvent.Delete(); + fPadPedestalArrayEvent.Delete(); + if (fHMeanTimeSector) delete fHMeanTimeSector; } //_____________________________________________________________________ @@ -611,8 +600,8 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD ¶m, Float_t &qSum) Int_t cemaxpos = fMaxTimeBin; Float_t ceSumThreshold = 10.*TMath::Max(fPadNoise,Float_t(1.)); // threshold for the signal sum Float_t ceMaxThreshold = 5.*TMath::Max(fPadNoise,Float_t(1.)); // threshold for the signal max - const Int_t kCemin = 2; // range for the analysis of the ce signal +- channels from the peak - const Int_t kCemax = 7; + const Int_t kCemin = fPeakIntMinus; // range for the analysis of the ce signal +- channels from the peak + const Int_t kCemax = fPeakIntPlus; param[0] = ceQmax; param[1] = ceTime; param[2] = ceRMS; @@ -621,7 +610,7 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD ¶m, Float_t &qSum) if (cemaxpos>0){ ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal; if ( ceQmaxfFirstTimeBin) && (i0) ){ ceTime+=signal*(i+0.5); @@ -633,6 +622,7 @@ void AliTPCCalibPulser::FindPulserSignal(TVectorD ¶m, Float_t &qSum) if (ceQsum>ceSumThreshold) { ceTime/=ceQsum; ceRMS = TMath::Sqrt(TMath::Abs(ceRMS/ceQsum-ceTime*ceTime)); + ceTime-=GetL1PhaseTB(); //only fill the Time0Offset if pad was not marked as an outlier! if ( !fOutliers ){ //skip edge pads for calculating the mean time @@ -696,25 +686,22 @@ void AliTPCCalibPulser::ProcessPad() //Fill debugging info - if ( fDebugLevel>0 ){ - if ( fDebugLevel == 1 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("debPulserPadSignals.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer + if ( GetStreamLevel()>0 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( GetStreamLevel() == 1 ){ + if ( streamer ) { + Int_t padc = fCurrentPad-(fROC->GetNPads(fCurrentSector,fCurrentRow)/2); + (*streamer) << "PadSignals" << + "Sector=" <GetNPads(fCurrentSector,fCurrentRow)/2); - (*fDebugStreamer) << "PadSignals" << - "Sector=" < 1 (*GetPadPedestalEvent(fCurrentSector,kTRUE))[fCurrentChannel]=fPadPedestal; (*GetPadRMSEvent(fCurrentSector,kTRUE))[fCurrentChannel]=sigmaT; @@ -746,137 +733,40 @@ void AliTPCCalibPulser::EndEvent() //Debug start - if ( fDebugLevel>1 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("deb2.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer - } - - Int_t row=0; - Int_t pad=0; - Int_t padc=0; - - Float_t q = (*GetPadQEvent(iSec)).GetMatrixArray()[iChannel]; - Float_t rms = (*GetPadRMSEvent(iSec)).GetMatrixArray()[iChannel]; - - UInt_t channel=iChannel; - Int_t sector=iSec; - - while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++; - pad = channel-fROC->GetRowIndexes(sector)[row]; - padc = pad-(fROC->GetNPads(sector,row)/2); - - (*fDebugStreamer) << "DataPad" << + if ( GetStreamLevel()>1 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( streamer ) { + Int_t row=0; + Int_t pad=0; + Int_t padc=0; + + Float_t q = (*GetPadQEvent(iSec)).GetMatrixArray()[iChannel]; + Float_t rms = (*GetPadRMSEvent(iSec)).GetMatrixArray()[iChannel]; + + UInt_t channel=iChannel; + Int_t sector=iSec; + + while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++; + pad = channel-fROC->GetRowIndexes(sector)[row]; + padc = pad-(fROC->GetNPads(sector,row)/2); + + (*streamer) << "DataPad" << // "Event=" << fEvent << - "Sector="<< sector << - "Row=" << row<< - "Pad=" << pad << - "PadC=" << padc << - "PadSec="<< channel << - "Time0=" << time0 << - "Time=" << time << - "RMS=" << rms << - "Sum=" << q << - "\n"; - } - //Debug end - } - } -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast) -{ - // - // Event Processing loop - AliTPCRawStream - // - ResetEvent(); - Bool_t withInput = kFALSE; - while ( rawStreamFast->NextDDL() ){ - while ( rawStreamFast->NextChannel() ){ - Int_t isector = rawStreamFast->GetSector(); // current sector - Int_t iRow = rawStreamFast->GetRow(); // current row - Int_t iPad = rawStreamFast->GetPad(); // current pad - - while ( rawStreamFast->NextBunch() ){ - Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin(); - Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin(); - for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){ - Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin]; - Update(isector,iRow,iPad,iTimeBin+1,signal); - withInput = kTRUE; + "Sector="<< sector << + "Row=" << row<< + "Pad=" << pad << + "PadC=" << padc << + "PadSec="<< channel << + "Time0=" << time0 << + "Time=" << time << + "RMS=" << rms << + "Sum=" << q << + "\n"; } } + //Debug end } } - if (withInput){ - EndEvent(); - } - return withInput; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEventFast(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader, (AliAltroMapping**)fMapping); - Bool_t res=ProcessEventFast(rawStreamFast); - delete rawStreamFast; - return res; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEvent(AliTPCRawStream *rawStream) -{ - // - // Event Processing loop - AliTPCRawStream - // - - ResetEvent(); - - Bool_t withInput = kFALSE; - - while (rawStream->Next()) { - Int_t isector = rawStream->GetSector(); // current sector - Int_t iRow = rawStream->GetRow(); // current row - Int_t iPad = rawStream->GetPad(); // current pad - Int_t iTimeBin = rawStream->GetTime(); // current time bin - Float_t signal = rawStream->GetSignal(); // current ADC signal - - Update(isector,iRow,iPad,iTimeBin,signal); - withInput = kTRUE; - } - if (withInput){ - EndEvent(); - } - return withInput; -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEvent(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - - - AliTPCRawStream rawStream(rawReader, (AliAltroMapping**)fMapping); - - rawReader->Select("TPC"); - - return ProcessEvent(&rawStream); -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEvent(eventHeaderStruct *event) -{ - // - // Event processing loop - date event - // - AliRawReader *rawReader = new AliRawReaderDate((void*)event); - Bool_t result=ProcessEvent(rawReader); - delete rawReader; - return result; - } //_____________________________________________________________________ TH2S* AliTPCCalibPulser::GetHisto(Int_t sector, TObjArray *arr, @@ -1174,9 +1064,9 @@ void AliTPCCalibPulser::Merge(AliTPCCalibPulser *sig) //_____________________________________________________________________ void AliTPCCalibPulser::Analyse() { - // - // Calculate calibration constants - // + // + // Calculate calibration constants + // TVectorD paramQ(3); TVectorD paramT0(3); @@ -1260,66 +1150,31 @@ void AliTPCCalibPulser::Analyse() rocT0->SetValue(iChannel, cogTime0+meanTsec); //offset by mean time of the sector rocRMS->SetValue(iChannel, cogRMS); rocOut->SetValue(iChannel, cogOut); - - //debug - if ( fDebugLevel > 2 ){ - if ( !fDebugStreamer ) { - //debug stream - TDirectory *backup = gDirectory; - fDebugStreamer = new TTreeSRedirector("deb2.root"); - if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer + if ( GetStreamLevel() > 2 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( streamer ) { + while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++; + pad = iChannel-fROC->GetRowIndexes(iSec)[row]; + padc = pad-(fROC->GetNPads(iSec,row)/2); + + (*streamer) << "DataEnd" << + "Sector=" << iSec << + "Pad=" << pad << + "PadC=" << padc << + "Row=" << row << + "PadSec=" << iChannel << + "Q=" << cogQ << + "T0=" << cogTime0 << + "RMS=" << cogRMS << + "\n"; } - - while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++; - pad = iChannel-fROC->GetRowIndexes(iSec)[row]; - padc = pad-(fROC->GetNPads(iSec,row)/2); - - (*fDebugStreamer) << "DataEnd" << - "Sector=" << iSec << - "Pad=" << pad << - "PadC=" << padc << - "Row=" << row << - "PadSec=" << iChannel << - "Q=" << cogQ << - "T0=" << cogTime0 << - "RMS=" << cogRMS << - "\n"; } //! debug } } - delete fDebugStreamer; - fDebugStreamer = 0x0; -} -//_____________________________________________________________________ -void AliTPCCalibPulser::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) -{ - // - // Write class to file - // - - TString sDir(dir); - TString option; - - if ( append ) - option = "update"; - else - option = "recreate"; - - TDirectory *backup = gDirectory; - TFile f(filename,option.Data()); - f.cd(); - if ( !sDir.IsNull() ){ - f.mkdir(sDir.Data()); - f.cd(sDir); - } - this->Write(); - f.Close(); - - if ( backup ) backup->cd(); } //_____________________________________________________________________ //_________________________ Test Functions ___________________________ diff --git a/TPC/AliTPCCalibPulser.h b/TPC/AliTPCCalibPulser.h index 5e064a94779..67f7ee35da1 100644 --- a/TPC/AliTPCCalibPulser.h +++ b/TPC/AliTPCCalibPulser.h @@ -10,7 +10,7 @@ ///////////////////////////////////////////////////////////////////////////////////////// #include -#include +#include "AliTPCCalibRawBase.h" #include class TH2S; class TH2F; @@ -27,178 +27,154 @@ class TMap; struct eventHeaderStruct; -class AliTPCCalibPulser : public TObject { +class AliTPCCalibPulser : public AliTPCCalibRawBase { public: - AliTPCCalibPulser(); - AliTPCCalibPulser(const AliTPCCalibPulser &sig); - AliTPCCalibPulser(const TMap *config); - virtual ~AliTPCCalibPulser(); - - void Reset(); - - AliTPCCalibPulser& operator = (const AliTPCCalibPulser &source); - - Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast); - Bool_t ProcessEventFast(AliRawReader *rawReader); - - - Bool_t ProcessEvent(AliTPCRawStream *rawStream); - Bool_t ProcessEvent(AliRawReader *rawReader); - Bool_t ProcessEvent(eventHeaderStruct *event); - - Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, - const Int_t iTimeBin, const Float_t signal); - void Analyse(); + AliTPCCalibPulser(); + AliTPCCalibPulser(const AliTPCCalibPulser &sig); + AliTPCCalibPulser(const TMap *config); + virtual ~AliTPCCalibPulser(); + + void Reset(); + + AliTPCCalibPulser& operator = (const AliTPCCalibPulser &source); + + + virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad, + const Int_t iTimeBin, const Float_t signal); + virtual void Analyse(); // - AliTPCAltroMapping **GetAltroMapping() { return fMapping; }; - void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; }; + AliTPCCalROC* GetCalRocT0 (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector + + const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object + const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object + const TObjArray* GetCalPadRMS() const{ return &fCalRocArrayRMS;} // get calibration object + const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object + + TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram + TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram + TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram + + TH2F* GetHistoTSec(); // mean abs time distribution histogram + + Float_t GetMeanTimeSector(Int_t sector) const {return fVMeanTimeSector[sector];} + const TVectorF* GetMeanTimeSectorArray() const {return &fVMeanTimeSector;} + + Short_t GetDebugLevel() const { return fDebugLevel; } // - AliTPCCalROC* GetCalRocT0 (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector - - const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object - const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object - const TObjArray* GetCalPadRMS() const{ return &fCalRocArrayRMS;} // get calibration object - const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object - - TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram - TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram - TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram - - TH2F* GetHistoTSec(); // mean abs time distribution histogram - - Float_t GetMeanTimeSector(Int_t sector) const {return fVMeanTimeSector[sector];} - const TVectorF* GetMeanTimeSectorArray() const {return &fVMeanTimeSector;} - - Short_t GetDebugLevel() const { return fDebugLevel; } - // - void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the pulser signal is expected + void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the pulser signal is expected // - void SetRangeRefQ (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ = nBins; fXminQ = xMin; fXmaxQ = xMax; } //Set range for Q reference histograms - void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms - void SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; } //Set range for T0 reference histograms - - void SetDebugLevel(Short_t debug=1){ fDebugLevel = debug;} - - void SetIsZeroSuppressed(Bool_t zs=kTRUE){ fIsZeroSuppressed=zs;} - - void SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;} - void SetOutliers(AliTPCCalPad *outliers) {fOutliers = outliers;} - - Int_t GetFirstTimeBin() const { return fFirstTimeBin; } - Int_t GetLastTimeBin() const { return fLastTimeBin; } - - Bool_t GetIsZeroSupperssed() const { return fIsZeroSuppressed; } - - void Merge(AliTPCCalibPulser *sig); - - void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE); - // - // Test functions - TObjArray* TestBinning(); - + void SetRangeRefQ (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ = nBins; fXminQ = xMin; fXmaxQ = xMax; } //Set range for Q reference histograms + void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms + void SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; } //Set range for T0 reference histograms + void SetRangePeakIntegral(Int_t minus, Int_t plus) { fPeakIntMinus=minus; fPeakIntPlus=plus;} + + void SetDebugLevel(Short_t debug=1){ fDebugLevel = debug;} + + void SetIsZeroSuppressed(Bool_t zs=kTRUE){ fIsZeroSuppressed=zs;} + + void SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;} + void SetOutliers(AliTPCCalPad *outliers) {fOutliers = outliers;} + + Bool_t GetIsZeroSupperssed() const { return fIsZeroSuppressed; } + + Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;} + Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;} + + void Merge(AliTPCCalibPulser *sig); + // + // Test functions + TObjArray* TestBinning(); + private: - Int_t fFirstTimeBin; // First Time bin needed for analysis - Int_t fLastTimeBin; // Last Time bin needed for analysis - // reference histogram ranges - Int_t fNbinsT0; // Number of bins for T0 reference histogram - Float_t fXminT0; // xmin of T0 reference histogram - Float_t fXmaxT0; // xmax of T0 reference histogram - Int_t fNbinsQ; // Number of bins for T0 reference histogram - Float_t fXminQ; // xmin of T0 reference histogram - Float_t fXmaxQ; // xmax of T0 reference histogram - Int_t fNbinsRMS; // Number of bins for T0 reference histogram - Float_t fXminRMS; // xmin of T0 reference histogram - Float_t fXmaxRMS; // xmax of T0 reference histogram - - Bool_t fIsZeroSuppressed; // if data is zero suppressed - - Int_t fLastSector; //! Last sector processed - - - AliTPCROC *fROC; //! ROC information - AliTPCAltroMapping **fMapping; //! Altro Mapping object - AliTPCParam *fParam; //! TPC information - - AliTPCCalPad *fPedestalTPC; //! Pedestal Information - AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC - AliTPCCalPad *fOutliers; //! Outlier information. Those will not be used for calculating the T0 - AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC - AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC -// Bool_t fBpedestal; //! are we running with pedestal substraction - - - TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration - TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration - TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration - TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers - - TObjArray fHistoQArray; // Calibration histograms for Charge distribution - TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution - TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution - - TH2F *fHMeanTimeSector; // Timing distribution per sector - TVectorF fVMeanTimeSector; // Mean time per sector from analysis of fHMeanTimeSector - - TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections - TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer - TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer - TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer - - Int_t fCurrentChannel; //! current channel processed - Int_t fCurrentSector; //! current sector processed - Int_t fCurrentRow; //! current row processed - Int_t fCurrentPad; //! current pad processed - Float_t fMaxPadSignal; //! maximum bin of current pad - Int_t fMaxTimeBin; //! time bin with maximum value - TVectorF fPadSignal; //! signal of current Pad - Float_t fPadPedestal; //! Pedestal Value of current pad - Float_t fPadNoise; //! Noise Value of current pad - - TVectorF fVTime0Offset; //! Time0 Offset from preprocessing for each sector; - TVectorF fVTime0OffsetCounter; //! Time0 Offset from preprocessing for each sector; - - - //debugging -// Int_t fEvent; // Number of events processed - TTreeSRedirector *fDebugStreamer; //! debug streamer - - Short_t fDebugLevel; // debug Level - //! debugging - - void FindPedestal(Float_t part=.6); - void FindPulserSignal(TVectorD ¶m, Float_t &qSum); - - TH2S* GetHisto(Int_t sector, TObjArray *arr, - Int_t nbinsY, Float_t ymin, Float_t ymax, - const Char_t *type, Bool_t force); - - - AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const; - - TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE); - - Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad); - - void ResetEvent(); - void ResetPad(); - void ProcessPad(); - void EndEvent(); - - - //debug - TVectorF* GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force=kFALSE); - TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE); - TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE); - TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE); - - - - ClassDef(AliTPCCalibPulser,4) //Implementation of the TPC pulser calibration + Int_t fNbinsT0; // Number of bins for T0 reference histogram + Float_t fXminT0; // xmin of T0 reference histogram + Float_t fXmaxT0; // xmax of T0 reference histogram + Int_t fNbinsQ; // Number of bins for T0 reference histogram + Float_t fXminQ; // xmin of T0 reference histogram + Float_t fXmaxQ; // xmax of T0 reference histogram + Int_t fNbinsRMS; // Number of bins for T0 reference histogram + Float_t fXminRMS; // xmin of T0 reference histogram + Float_t fXmaxRMS; // xmax of T0 reference histogram + Int_t fPeakIntMinus; // Peak integral range for COG determination. Bins used before max bin + Int_t fPeakIntPlus; // Peak integral range for COG determination. Bins used after max bin + + Bool_t fIsZeroSuppressed; // if data is zero suppressed + + Int_t fLastSector; //! Last sector processed + + AliTPCParam *fParam; //! TPC information + + AliTPCCalPad *fPedestalTPC; //! Pedestal Information + AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC + AliTPCCalPad *fOutliers; //! Outlier information. Those will not be used for calculating the T0 + AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC + AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC + + TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration + TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration + TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration + TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers + + TObjArray fHistoQArray; // Calibration histograms for Charge distribution + TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution + TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution + + TH2F *fHMeanTimeSector; // Timing distribution per sector + TVectorF fVMeanTimeSector; // Mean time per sector from analysis of fHMeanTimeSector + + TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections + TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer + TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer + TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer + + Int_t fCurrentChannel; //! current channel processed + Int_t fCurrentSector; //! current sector processed + Int_t fCurrentRow; //! current row processed + Int_t fCurrentPad; //! current pad processed + Float_t fMaxPadSignal; //! maximum bin of current pad + Int_t fMaxTimeBin; //! time bin with maximum value + TVectorF fPadSignal; //! signal of current Pad + Float_t fPadPedestal; //! Pedestal Value of current pad + Float_t fPadNoise; //! Noise Value of current pad + + TVectorF fVTime0Offset; //! Time0 Offset from preprocessing for each sector; + TVectorF fVTime0OffsetCounter; //! Time0 Offset from preprocessing for each sector; + + + void FindPedestal(Float_t part=.6); + void FindPulserSignal(TVectorD ¶m, Float_t &qSum); + + TH2S* GetHisto(Int_t sector, TObjArray *arr, + Int_t nbinsY, Float_t ymin, Float_t ymax, + const Char_t *type, Bool_t force); + + + AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const; + + TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE); + + Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad); + + virtual void ResetEvent(); + virtual void EndEvent(); + void ResetPad(); + void ProcessPad(); + + + //debug + TVectorF* GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force=kFALSE); + TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE); + TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE); + TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE); + + + + ClassDef(AliTPCCalibPulser,5) //Implementation of the TPC pulser calibration }; diff --git a/TPC/AliTPCCalibRawBase.cxx b/TPC/AliTPCCalibRawBase.cxx new file mode 100644 index 00000000000..954d67c9faf --- /dev/null +++ b/TPC/AliTPCCalibRawBase.cxx @@ -0,0 +1,262 @@ + /************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +/* $Id: AliTPCCalibRawBase.cxx */ + +///////////////////////////////////////////////////////////////////////////////////////// +// // +// Base class for the calibration algorithms using raw data as input // +// // +// Origin: Jens Wiechula J.Wiechula@gsi.de // +// // +///////////////////////////////////////////////////////////////////////////////////////// + +//Root includes +#include +#include + +//Aliroot includes +#include "AliRawReaderDate.h" +#include "AliRawReader.h" +#include "AliRawEventHeaderBase.h" +#include "AliAltroMapping.h" +#include "AliAltroRawStream.h" +#include "AliTPCROC.h" +#include "AliTPCRawStreamFast.h" +#include "AliTPCRawStream.h" +#include "TTreeStream.h" +#include "event.h" + +#include "AliTPCCalibRawBase.h" + +ClassImp(AliTPCCalibRawBase) + +AliTPCCalibRawBase::AliTPCCalibRawBase() : + TNamed(), + fFirstTimeBin(0), + fLastTimeBin(1000), + fNevents(0), + fDebugLevel(0), + fStreamLevel(0), + fTimeStamp(0), + fRunNumber(0), + fEventType(0), + fAltroL1Phase(0), + fAltroL1PhaseTB(0), + fUseL1Phase(kTRUE), + fDebugStreamer(0x0), + fAltroRawStream(0x0), + fMapping(0x0), + fROC(AliTPCROC::Instance()) +{ + // + // default ctor + // + +} +//_____________________________________________________________________ +AliTPCCalibRawBase::AliTPCCalibRawBase(const AliTPCCalibRawBase &calib) : + TNamed(calib), + fFirstTimeBin(calib.fFirstTimeBin), + fLastTimeBin(calib.fLastTimeBin), + fNevents(calib.fNevents), + fDebugLevel(calib.fDebugLevel), + fStreamLevel(calib.fStreamLevel), + fTimeStamp(0), + fRunNumber(0), + fEventType(0), + fAltroL1Phase(0), + fAltroL1PhaseTB(0), + fUseL1Phase(kTRUE), + fDebugStreamer(0x0), + fAltroRawStream(0x0), + fMapping(0x0), + fROC(AliTPCROC::Instance()) +{ + // + // copy ctor + // + +} +//_____________________________________________________________________ +AliTPCCalibRawBase::~AliTPCCalibRawBase() +{ + // + // dtor + // + if (fDebugStreamer) delete fDebugStreamer; +} +//_____________________________________________________________________ + AliTPCCalibRawBase& AliTPCCalibRawBase::operator = (const AliTPCCalibRawBase &source) + { + // + // assignment operator + // + if (&source == this) return *this; + new (this) AliTPCCalibRawBase(source); + + return *this; + } +//_____________________________________________________________________ +Bool_t AliTPCCalibRawBase::ProcessEventFast(AliTPCRawStreamFast *rawStreamFast) +{ + // + // Event Processing loop - AliTPCRawStreamFast + // + ResetEvent(); + Bool_t withInput = kFALSE; + while ( rawStreamFast->NextDDL() ){ + while ( rawStreamFast->NextChannel() ){ + Int_t isector = rawStreamFast->GetSector(); // current sector + Int_t iRow = rawStreamFast->GetRow(); // current row + Int_t iPad = rawStreamFast->GetPad(); // current pad + + while ( rawStreamFast->NextBunch() ){ + Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin(); + Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin(); + for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){ + Float_t signal=(Float_t)rawStreamFast->GetSignals()[iTimeBin-startTbin]; + Update(isector,iRow,iPad,iTimeBin+1,signal); + withInput = kTRUE; + } + } + } + } + if (withInput){ + EndEvent(); + } + return withInput; +} +//_____________________________________________________________________ +Bool_t AliTPCCalibRawBase::ProcessEventFast(AliRawReader *rawReader) +{ + // + // Event processing loop - AliRawReader + // + AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader(); + if (eventHeader){ + fTimeStamp = eventHeader->Get("Timestamp"); + fRunNumber = eventHeader->Get("RunNb"); + fEventType = eventHeader->Get("Type"); + } + AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader, (AliAltroMapping**)fMapping); + Bool_t res=ProcessEventFast(rawStreamFast); + delete rawStreamFast; + return res; +} +//_____________________________________________________________________ +Bool_t AliTPCCalibRawBase::ProcessEvent(AliTPCRawStream *rawStream) +{ + // + // Event Processing loop - AliTPCRawStream + // + + ResetEvent(); + + Bool_t withInput = kFALSE; + fAltroL1Phase=0; + fAltroL1PhaseTB=0; + fAltroRawStream = static_cast(rawStream); + while (rawStream->Next()) { + if (fUseL1Phase){ + fAltroL1Phase = fAltroRawStream->GetL1Phase(); + fAltroL1PhaseTB = (fAltroL1Phase*1e09/100.); + } + Int_t isector = rawStream->GetSector(); // current sector + Int_t iRow = rawStream->GetRow(); // current row + Int_t iPad = rawStream->GetPad(); // current pad + Int_t iTimeBin = rawStream->GetTime(); // current time bin + Float_t signal = rawStream->GetSignal(); // current ADC signal + + Update(isector,iRow,iPad,iTimeBin,signal); + withInput = kTRUE; + } + fAltroRawStream=0x0; + if (withInput){ + EndEvent(); + } + return withInput; +} +//_____________________________________________________________________ +Bool_t AliTPCCalibRawBase::ProcessEvent(AliRawReader *rawReader) +{ + // + // Event processing loop - AliRawReader + // + AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader(); + if (eventHeader){ + fTimeStamp = eventHeader->Get("Timestamp"); + fRunNumber = eventHeader->Get("RunNb"); + fEventType = eventHeader->Get("Type"); + } + + AliTPCRawStream rawStream(rawReader, (AliAltroMapping**)fMapping); + rawReader->Select("TPC"); + return ProcessEvent(&rawStream); +} +//_____________________________________________________________________ +Bool_t AliTPCCalibRawBase::ProcessEvent(eventHeaderStruct *event) +{ + // + // Event processing loop - date event + // + AliRawReader *rawReader = new AliRawReaderDate((void*)event); + Bool_t result=ProcessEvent(rawReader); + delete rawReader; + return result; + +} +//_____________________________________________________________________ +void AliTPCCalibRawBase::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) +{ + // + // Write class to file + // + + TString sDir(dir); + TString option; + + if ( append ) + option = "update"; + else + option = "recreate"; + + TDirectory *backup = gDirectory; + TFile f(filename,option.Data()); + f.cd(); + if ( !sDir.IsNull() ){ + f.mkdir(sDir.Data()); + f.cd(sDir); + } + this->Write(); + f.Close(); + + if ( backup ) backup->cd(); +} +//_____________________________________________________________________ +TTreeSRedirector *AliTPCCalibRawBase::GetDebugStreamer(){ + // + // Get Debug streamer + // In case debug streamer not yet initialized and StreamLevel>0 create new one + // + if (fStreamLevel==0) return 0; + if (fDebugStreamer) return fDebugStreamer; + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + fDebugStreamer = new TTreeSRedirector(dsName.Data()); + return fDebugStreamer; +} diff --git a/TPC/AliTPCCalibRawBase.h b/TPC/AliTPCCalibRawBase.h new file mode 100644 index 00000000000..77551ff5964 --- /dev/null +++ b/TPC/AliTPCCalibRawBase.h @@ -0,0 +1,112 @@ +#ifndef ALITPCCALIBRAWBASE_H +#define ALITPCCALIBRAWBASE_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +///////////////////////////////////////////////////////////////////////////////////////// +// // +// Raw data processing base class // +// // +///////////////////////////////////////////////////////////////////////////////////////// + +#include + +class AliAltroMapping; +class AliAltroRawStream; +class AliRawReader; +class AliTPCAltroMapping; +class AliTPCRawStreamFast; +class AliTPCRawStream; +class AliTPCROC; +class TTreeSRedirector; +struct eventHeaderStruct; + +class AliTPCCalibRawBase : public TNamed { + + +public: + AliTPCCalibRawBase(); + AliTPCCalibRawBase(const AliTPCCalibRawBase &calib); + + AliTPCCalibRawBase& operator = (const AliTPCCalibRawBase &source); + + virtual ~AliTPCCalibRawBase(); + + + Bool_t ProcessEventFast(AliTPCRawStreamFast *rawStreamFast); + Bool_t ProcessEventFast(AliRawReader *rawReader); + + Bool_t ProcessEvent(AliTPCRawStream *rawStream); + Bool_t ProcessEvent(AliRawReader *rawReader); + Bool_t ProcessEvent(eventHeaderStruct *event); + + virtual Int_t Update(const Int_t /*isector*/, const Int_t /*iRow*/, const Int_t /*iPad*/, + const Int_t /*iTimeBin*/, const Float_t /*signal*/) { return 0; } + virtual void Analyse(){ return; } + + //Setters + void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the signal is expected + void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; } + // + void SetUseL1Phase(Bool_t useL1Phase=kTRUE) {fUseL1Phase=useL1Phase;} + // + Int_t GetFirstTimeBin() const { return fFirstTimeBin; } + Int_t GetLastTimeBin() const { return fLastTimeBin; } + Int_t GetNevents() const { return fNevents; } + // + Double_t GetL1Phase() const {return fAltroL1Phase;} + Double_t GetL1PhaseTB() const {return fAltroL1PhaseTB;} + Bool_t GetUseL1Phase()const {return fUseL1Phase;} +// + UInt_t GetTimeStamp() const {return fTimeStamp;} + UInt_t GetRunNumber() const {return fRunNumber;} + UInt_t GetEventType() const {return fEventType;} + // + AliTPCAltroMapping **GetAltroMapping() { return fMapping; } + const AliAltroRawStream *GetAltroRawStream() {return fAltroRawStream;} + const AliTPCROC *GetTPCROC() {return fROC;} + // + void IncrementNevents(){++fNevents;} + // + void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE); + // debug and debug streamer support + TTreeSRedirector *GetDebugStreamer(); + void SetStreamLevel(Int_t streamLevel){fStreamLevel=streamLevel;} + void SetDebugLevel(Int_t level) {fDebugLevel = level;} + Int_t GetStreamLevel() const {return fStreamLevel;} + Int_t GetDebugLevel() const {return fDebugLevel;} + +protected: + Int_t fFirstTimeBin; // First Time bin used for analysis + Int_t fLastTimeBin; // Last Time bin used for analysis + + Int_t fNevents; // Number of processed events + + Int_t fDebugLevel; //! debug level + Int_t fStreamLevel; //! level of streamer output + // + UInt_t fTimeStamp; //! time stamp from event header + UInt_t fRunNumber; //! current run number from event header + UInt_t fEventType; //! current event Type from event header + // + Double_t fAltroL1Phase; //! L1 Phase + Float_t fAltroL1PhaseTB; //! L1 Phase in time bins + Bool_t fUseL1Phase; // use L1 Phase information? + // + TTreeSRedirector *fDebugStreamer; //! debug streamer + // + AliAltroRawStream *fAltroRawStream; //! pointer to the altro object + AliTPCAltroMapping **fMapping; //! Altro Mapping object + + AliTPCROC *fROC; //! ROC information + + virtual void EndEvent() {++fNevents; return; } //fNevents should be updated in the derived classes in a proper place + virtual void ResetEvent(){ return; } //Reset Event counters + + + ClassDef(AliTPCCalibRawBase,1) // Calibration base class for raw data processing + +}; + +#endif + diff --git a/TPC/AliTPCcalibLaser.cxx b/TPC/AliTPCcalibLaser.cxx index e97e8f79501..bdfd4eb0458 100644 --- a/TPC/AliTPCcalibLaser.cxx +++ b/TPC/AliTPCcalibLaser.cxx @@ -34,7 +34,7 @@ // // To make laser scan the user interaction neccessary // - .x ~/UliStyle.C + .x ~/NimStyle.C gSystem->Load("libANALYSIS"); gSystem->Load("libTPCcalib"); TFile fcalib("CalibObjects.root"); @@ -490,11 +490,6 @@ void AliTPCcalibLaser::Process(AliESDEvent * event) { fClusterCounter[id]=0; fClusterSatur[id]=0; } - static Bool_t init=kFALSE; - if (!init){ - init = kTRUE; // way around for PROOF - to be investigated - MakeFitHistos(); - } // Int_t n=fESD->GetNumberOfTracks(); Int_t counter=0; @@ -517,6 +512,11 @@ void AliTPCcalibLaser::Process(AliESDEvent * event) { FitDriftV(); if (!fFullCalib) return; + static Bool_t init=kFALSE; + if (!init){ + init = kTRUE; // way around for PROOF - to be investigated + MakeFitHistos(); + } // for (Int_t id=0; id<336; id++){ // @@ -687,7 +687,14 @@ void AliTPCcalibLaser::FitDriftV(){ fdriftA.GetParameters(fitA); npointsA= fdriftA.GetNpoints(); chi2A = fdriftA.GetChisquare()/fdriftA.GetNpoints(); - if (chi2AGetNoElements()<5) fFitAside->ResizeTo(5); + (*fFitAside)[0] = fitA[0]; + (*fFitAside)[1] = fitA[1]; + (*fFitAside)[2] = fitA[2]; + (*fFitAside)[3] = fdriftA.GetNpoints(); + (*fFitAside)[4] = chi2A; + } } if (fdriftC.GetNpoints()>10){ fdriftC.Eval(); @@ -697,7 +704,14 @@ void AliTPCcalibLaser::FitDriftV(){ fdriftC.GetParameters(fitC); npointsC= fdriftC.GetNpoints(); chi2C = fdriftC.GetChisquare()/fdriftC.GetNpoints(); - if (chi2CGetNoElements()<5) fFitCside->ResizeTo(5); + (*fFitCside)[0] = fitC[0]; + (*fFitCside)[1] = fitC[1]; + (*fFitCside)[2] = fitC[2]; + (*fFitCside)[3] = fdriftC.GetNpoints(); + (*fFitCside)[4] = chi2C; + } } if (fdriftAC.GetNpoints()>10&&fdriftC.GetNpoints()>10&&fdriftA.GetNpoints()>10){ @@ -904,6 +918,7 @@ Int_t AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){ // Float_t radius=TMath::Abs(ltrp->GetX()); AliTracker::PropagateTrackTo(¶m,radius,0.10566,0.01,kTRUE); + param.Rotate(ltrp->GetAlpha()); // if (!fTracksMirror.At(id)) fTracksMirror.AddAt(ltrp,id); Bool_t accept=kTRUE; @@ -1040,11 +1055,13 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ //=============================================// // Linear Fitters for the Different Approaches // //=============================================// - //linear fit model in y and z; inner - outer sector + //linear fit model in y and z; inner - outer sector, combined with offset static TLinearFitter fy1I(2,"hyp1"); static TLinearFitter fy1O(2,"hyp1"); static TLinearFitter fz1I(2,"hyp1"); static TLinearFitter fz1O(2,"hyp1"); + static TLinearFitter fy1IO(3,"hyp2"); + static TLinearFitter fz1IO(3,"hyp2"); //quadratic fit model in y and z; inner - sector static TLinearFitter fy2I(3,"hyp2"); static TLinearFitter fy2O(3,"hyp2"); @@ -1089,6 +1106,7 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ TVectorD vecy1resOuter(2),vecz1resOuter(2); //pol1 fit parameters outer TVectorD vecy2resOuter(3),vecz2resOuter(3); //pol2 fit parameters outer TVectorD vecy4res(5),vecz4res(5); + TVectorD vecy1resIO(3),vecz1resIO(3); // cluster and track positions for each row - used for residuals TVectorD vecgX(159); // global X TVectorD vecgY(159); // global Y @@ -1099,6 +1117,8 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ TVectorD vecZkalman(159); // z from kalman fit TVectorD vecY1(159); // y from pol1 fit per ROC TVectorD vecZ1(159); // z from pol1 fit per ROC + TVectorD vecY1IO(159); // y from pol1 fit per ROC + TVectorD vecZ1IO(159); // z from pol1 fit per ROC TVectorD vecY2(159); // y from pol2 fit per ROC TVectorD vecZ2(159); // z from pol2 fit per ROC TVectorD vecY4(159); // y from sector fit @@ -1112,6 +1132,8 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ Double_t chi2I1y=0; // chi2 of pol1 fit in y (inner) Double_t chi2O1z=0; // chi2 of pol1 fit in z (outer) Double_t chi2O1y=0; // chi2 of pol1 fit in y (outer) + Double_t chi2IO1z=0; // chi2 of pol1 fit in z (outer) + Double_t chi2IO1y=0; // chi2 of pol1 fit in y (outer) Double_t chi2I2z=0; // chi2 of pol2 fit in z (inner) Double_t chi2I2y=0; // chi2 of pol2 fit in y (inner) Double_t chi2O2z=0; // chi2 of pol2 fit in z (outer) @@ -1235,9 +1257,11 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ // Double_t x2[2]={x,x*x}; //linear and parabolic parameters Double_t x4[4]={0,0,0,0}; //hyp4 parameters + Double_t xIO[2]={0,x}; //common linear + offset IROC-OROC if ( roc == innerSector ) { x4[0]=1; //offset inner - outer sector x4[1]=x; //slope parameter inner sector + xIO[0]=1; } else { x4[2]=x; //slope parameter outer sector } @@ -1273,6 +1297,8 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ } fy4.AddPoint(x4,y); fz4.AddPoint(x4,z); + fy1IO.AddPoint(xIO,y); + fz1IO.AddPoint(xIO,z); } if (nclI>0) { msigmaYIn/=nclI; @@ -1328,6 +1354,16 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ fz4.GetParameters(vecz4res); chi2IOz=fz4.GetChisquare()/(fz4.GetNpoints()-5); } + if (fy1IO.GetNpoints()>0) { + fy1IO.Eval(); + fy1IO.GetParameters(vecy1resIO); + chi2IO1y=fy1IO.GetChisquare()/(fy1IO.GetNpoints()-3); + } + if (fz1IO.GetNpoints()>0) { + fz1IO.Eval(); + fz1IO.GetParameters(vecz1resIO); + chi2IO1z=fz1IO.GetChisquare()/(fz1IO.GetNpoints()-3); + } } //clear points fy4.ClearPoints(); fz4.ClearPoints(); @@ -1335,6 +1371,7 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ fz1I.ClearPoints(); fz1O.ClearPoints(); fy2I.ClearPoints(); fy2O.ClearPoints(); fz2I.ClearPoints(); fz2O.ClearPoints(); + fy1IO.ClearPoints(); fz1IO.ClearPoints(); //==============================// // calculate tracklet positions // //==============================// @@ -1371,6 +1408,8 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ // Double_t yoffInner=0; Double_t zoffInner=0; + Double_t yoffInner1=0; + Double_t zoffInner1=0; Double_t yslopeInner=0; Double_t yslopeOuter=0; Double_t zslopeInner=0; @@ -1391,10 +1430,14 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ vecY2[irow]=vecy2resInner[0]+vecy2resInner[1]*xref+vecy2resInner[2]*xref*xref; vecZ2[irow]=vecz2resInner[0]+vecz2resInner[1]*xref+vecz2resInner[2]*xref*xref; yoffInner=vecy4res[1]; - zoffInner=vecz4res[1]; + zoffInner=vecz4res[1]; + yoffInner1=vecy1resIO[1]; + zoffInner1=vecz1resIO[1]; yslopeInner=vecy4res[2]; zslopeInner=vecz4res[2]; } + vecY1IO[irow]=vecy1resIO[0]+yoffInner1+vecy1resIO[2]*xref; + vecZ1IO[irow]=vecz1resIO[0]+zoffInner1+vecz1resIO[2]*xref; vecY4[irow]=vecy4res[0]+yoffInner+yslopeInner*xref+yslopeOuter*xref+vecy4res[4]*xref*xref; vecZ4[irow]=vecz4res[0]+zoffInner+zslopeInner*xref+zslopeOuter*xref+vecz4res[4]*xref*xref; //positions of kalman fits @@ -1438,9 +1481,11 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ "dEdx=" << dedx << "LTr.=" << ltrp << "Tr.=" << extparam << - "yPol1In.=" << &vecy1resInner << - "zPol1In.=" << &vecz1resInner << - "yPol2In.=" << &vecy2resInner << + "yPol1In.=" << &vecy1resInner << + "zPol1In.=" << &vecz1resInner << + "yPol1InOut.="<< &vecy1resIO << + "zPol1InOut.="<< &vecz1resIO << + "yPol2In.=" << &vecy2resInner << "zPol2In.=" << &vecz2resInner << "yPol1Out.=" << &vecy1resOuter << "zPol1Out.=" << &vecz1resOuter << @@ -1448,9 +1493,11 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ "zPol2Out.=" << &vecz2resOuter << "yInOut.=" << &vecy4res << "zInOut.=" << &vecz4res << - "chi2y1In=" << chi2I1y << - "chi2z1In=" << chi2I1z << - "chi2y1Out=" << chi2O1y << + "chi2y1In=" << chi2I1y << + "chi2z1In=" << chi2I1z << + "chi2y1InOut="<< chi2IO1y << + "chi2z1InOut="<< chi2IO1z << + "chi2y1Out=" << chi2O1y << "chi2z1Out=" << chi2O1z << "chi2y2In=" << chi2I2y << "chi2z2In=" << chi2I2z << @@ -1502,9 +1549,11 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ "TrZpol1.=" << &vecZ1 << "TrYpol2.=" << &vecY2 << "TrZpol2.=" << &vecZ2 << - "TrYInOut.=" << &vecY4 << - "TrZInOut.=" << &vecZ4 << - "ClY.=" << &vecClY << + "TrYpol1InOut.="<< &vecY1IO << + "TrZpol1InOut.="<< &vecZ1IO << + "TrYInOut.=" << &vecY4 << + "TrZInOut.=" << &vecZ4 << + "ClY.=" << &vecClY << "ClZ.=" << &vecClZ << "isReject.=" << &isReject<< "sec.=" << &vecSec << @@ -1525,7 +1574,9 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ "chi2z1In=" << chi2I1z << "chi2y1Out=" << chi2O1y << "chi2z1Out=" << chi2O1z << - "chi2y2In=" << chi2I2y << + "chi2y1InOut="<< chi2IO1y << + "chi2z1InOut="<< chi2IO1z << + "chi2y2In=" << chi2I2y << "chi2z2In=" << chi2I2z << "chi2y2Out=" << chi2O2y << "chi2z2Out=" << chi2O2z << @@ -1538,7 +1589,9 @@ void AliTPCcalibLaser::RefitLaserJW(Int_t id){ "zPol2In.=" << &vecz2resInner << "yPol1Out.=" << &vecy1resOuter << "zPol1Out.=" << &vecz1resOuter << - "yPol2Out.=" << &vecy2resOuter << + "yPol1InOut.="<< &vecy1resIO << + "zPol1InOut.="<< &vecz1resIO << + "yPol2Out.=" << &vecy2resOuter << "zPol2Out.=" << &vecz2resOuter << "\n"; @@ -1707,7 +1760,7 @@ void AliTPCcalibLaser::DumpMeanInfo(Float_t bfield, Int_t run){ Double_t gphiP1 = fg.GetParameter(1); Double_t gphiP2 = fg.GetParameter(2); // - hisZ->Fit(&fg,"","",hisZ->GetMean()-4*hisZ->GetRMS(),hisZ->GetMean()+4*hisZ->GetRMS()); + hisZ->Fit(&fg,"","",hisZ->GetMean()-4*hisZ->GetRMS()-0.1,hisZ->GetMean()+4*hisZ->GetRMS()+0.1); Double_t gz1 = fg.GetParameter(1); Double_t gz2 = fg.GetParameter(2); // diff --git a/TPC/TPCbaseLinkDef.h b/TPC/TPCbaseLinkDef.h index 7a74a6fa733..2d593b23e64 100644 --- a/TPC/TPCbaseLinkDef.h +++ b/TPC/TPCbaseLinkDef.h @@ -47,6 +47,7 @@ #pragma link C++ class AliTPCRawStreamFast+; #pragma link C++ class AliTPCeventInfo+; +#pragma link C++ class AliTPCCalibRawBase+; #pragma link C++ class AliTPCCalibPedestal+; #pragma link C++ class AliTPCCalibPulser+; #pragma link C++ class AliTPCCalibCE+; diff --git a/TPC/libTPCbase.pkg b/TPC/libTPCbase.pkg index 72d6ec092d0..453c3fec87d 100644 --- a/TPC/libTPCbase.pkg +++ b/TPC/libTPCbase.pkg @@ -11,7 +11,7 @@ SRCS:= AliSegmentID.cxx AliSegmentArray.cxx AliDigits.cxx AliH2F.cxx \ AliTPCcalibDB.cxx \ AliTPCAltroMapping.cxx AliTPCRawStream.cxx AliTPCRawStreamFast.cxx \ AliTPCLaserTracks.cxx AliTPCSensorTemp.cxx AliTPCSensorTempArray.cxx \ - AliTPCCalibPedestal.cxx AliTPCCalibPulser.cxx AliTPCCalibCE.cxx \ + AliTPCCalibRawBase.cxx AliTPCCalibPedestal.cxx AliTPCCalibPulser.cxx AliTPCCalibCE.cxx \ AliTPCPreprocessor.cxx AliTPCPreprocessorOnline.cxx \ AliTPCCalibViewer.cxx AliTPCCalibViewerGUI.cxx \ AliTPCGenDBTemp.cxx AliTPCGenDBConf.cxx \ -- 2.43.0