X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCCalibPulser.cxx;h=5c1daa74beb42524a48dd6ab653e10ba11f4348b;hb=b3849ff32a9559a0639dd295e964d37c857f3692;hp=2faef43afe65fea73c0ae22064450c77f84e13cf;hpb=8a41288081606d636b96b106459abdca3bb8a194;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCCalibPulser.cxx b/TPC/AliTPCCalibPulser.cxx index 2faef43afe6..5c1daa74beb 100644 --- a/TPC/AliTPCCalibPulser.cxx +++ b/TPC/AliTPCCalibPulser.cxx @@ -15,41 +15,13 @@ /* $Id$ */ -//Root includes -#include -#include -#include -#include -#include - -#include -#include -#include - -//AliRoot includes -#include "AliRawReader.h" -#include "AliRawReaderRoot.h" -#include "AliRawReaderDate.h" -#include "AliTPCRawStream.h" -#include "AliTPCCalROC.h" -#include "AliTPCCalPad.h" -#include "AliTPCROC.h" -#include "AliTPCParam.h" -#include "AliTPCCalibPulser.h" -#include "AliTPCcalibDB.h" -#include "AliMathBase.h" -#include "TTreeStream.h" - -//date -#include "event.h" - - -/////////////////////////////////////////////////////////////////////////////////////// -// Implementation of the TPC pulser calibration -// -// Origin: Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch -// -// +///////////////////////////////////////////////////////////////////////////////////////// +// // +// Implementation of the TPC pulser calibration // +// // +// Origin: Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch // +// // +///////////////////////////////////////////////////////////////////////////////////////// /*************************************************************************** * Class Description * *************************************************************************** @@ -191,142 +163,253 @@ */ -ClassImp(AliTPCCalibPulser) /*FOLD00*/ +//Root includes +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -AliTPCCalibPulser::AliTPCCalibPulser() : /*FOLD00*/ - TObject(), - fFirstTimeBin(60), - fLastTimeBin(120), - fNbinsT0(200), - fXminT0(-2), - fXmaxT0(2), - fNbinsQ(200), - fXminQ(1), - fXmaxQ(40), - fNbinsRMS(100), - fXminRMS(0.1), - fXmaxRMS(5.1), - fLastSector(-1), - fOldRCUformat(kTRUE), - fROC(AliTPCROC::Instance()), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - 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), - fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(0) -{ - // - // AliTPCSignal default constructor - // +//AliRoot includes +#include "AliRawReader.h" +#include "AliRawReaderRoot.h" +#include "AliRawReaderDate.h" +#include "AliTPCRawStream.h" +#include "AliTPCRawStreamFast.h" +#include "AliTPCCalROC.h" +#include "AliTPCCalPad.h" +#include "AliTPCROC.h" +#include "AliTPCParam.h" +#include "AliTPCCalibPulser.h" +#include "AliTPCcalibDB.h" +#include "AliMathBase.h" +#include "AliLog.h" +#include "TTreeStream.h" -} -//_____________________________________________________________________ -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), - fLastSector(-1), - fOldRCUformat(kTRUE), - fROC(AliTPCROC::Instance()), - fParam(new AliTPCParam), - fPedestalTPC(0x0), - fPadNoiseTPC(0x0), - fPedestalROC(0x0), - fPadNoiseROC(0x0), - fCalRocArrayT0(72), - fCalRocArrayQ(72), - fCalRocArrayRMS(72), - fCalRocArrayOutliers(72), - fHistoQArray(72), - fHistoT0Array(72), - fHistoRMSArray(72), - 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), - fEvent(-1), - fDebugStreamer(0x0), - fDebugLevel(sig.fDebugLevel) -{ - // - // AliTPCSignal default constructor - // +//date +#include "event.h" - 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); - } +ClassImp(AliTPCCalibPulser) + +AliTPCCalibPulser::AliTPCCalibPulser() : +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 + // + SetNameTitle("AliTPCCalibPulser","AliTPCCalibPulser"); + fFirstTimeBin=60; + fLastTimeBin=900; + fParam->Update(); +} +//_____________________________________________________________________ +AliTPCCalibPulser::AliTPCCalibPulser(const AliTPCCalibPulser &sig) : +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]; + } + + if ( sig.fHMeanTimeSector ) fHMeanTimeSector=(TH2F*)sig.fHMeanTimeSector->Clone(); + fParam->Update(); +} +AliTPCCalibPulser::AliTPCCalibPulser(const TMap *config) : +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) +{ + // + // 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(); + if (config->GetValue("XminT0")) fXminT0 = ((TObjString*)config->GetValue("XminT0"))->GetString().Atof(); + if (config->GetValue("XmaxT0")) fXmaxT0 = ((TObjString*)config->GetValue("XmaxT0"))->GetString().Atof(); + if (config->GetValue("NbinsQ")) fNbinsQ = ((TObjString*)config->GetValue("NbinsQ"))->GetString().Atoi(); + if (config->GetValue("XminQ")) fXminQ = ((TObjString*)config->GetValue("XminQ"))->GetString().Atof(); + if (config->GetValue("XmaxQ")) fXmaxQ = ((TObjString*)config->GetValue("XmaxQ"))->GetString().Atof(); + 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(); } //_____________________________________________________________________ AliTPCCalibPulser& AliTPCCalibPulser::operator = (const AliTPCCalibPulser &source) @@ -336,71 +419,90 @@ AliTPCCalibPulser& AliTPCCalibPulser::operator = (const AliTPCCalibPulser &sour // if (&source == this) return *this; new (this) AliTPCCalibPulser(source); - + return *this; } //_____________________________________________________________________ AliTPCCalibPulser::~AliTPCCalibPulser() { - // - // destructor - // - - fCalRocArrayT0.Delete(); - fCalRocArrayQ.Delete(); - fCalRocArrayRMS.Delete(); - fCalRocArrayOutliers.Delete(); - - fHistoQArray.Delete(); - fHistoT0Array.Delete(); - fHistoRMSArray.Delete(); - - fPadTimesArrayEvent.Delete(); - fPadQArrayEvent.Delete(); - fPadRMSArrayEvent.Delete(); - fPadPedestalArrayEvent.Delete(); - - if ( fDebugStreamer) delete fDebugStreamer; - 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(); + + if (fHMeanTimeSector) delete fHMeanTimeSector; } //_____________________________________________________________________ -Int_t AliTPCCalibPulser::Update(const Int_t icsector, /*FOLD00*/ - const Int_t icRow, - const Int_t icPad, - const Int_t icTimeBin, - const Float_t csignal) +Int_t AliTPCCalibPulser::Update(const Int_t icsector, + const Int_t icRow, + const Int_t icPad, + const Int_t icTimeBin, + const Float_t csignal) { // - // Signal filling methode on the fly pedestal and Time offset correction if necessary. + // Signal filling methode on the fly pedestal and time offset correction if necessary. // no extra analysis necessary. Assumes knowledge of the signal shape! // assumes that it is looped over consecutive time bins of one pad // - if ( (icTimeBin>fLastTimeBin) || (icTimeBinGetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector - + + if (icRow<0) return 0; + if (icPad<0) return 0; + if (icTimeBin<0) return 0; + if ( (icTimeBin>fLastTimeBin) || (icTimeBinGetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector + //init first pad and sector in this event - if ( fCurrentChannel == -1 ) { - fCurrentChannel = iChannel; - fCurrentSector = icsector; - fCurrentRow = icRow; - } - + if ( fCurrentChannel == -1 ) { + fCurrentChannel = iChannel; + fCurrentSector = icsector; + fCurrentRow = icRow; + fCurrentPad = icPad; + } + //process last pad if we change to a new one - if ( iChannel != fCurrentChannel ){ - ProcessPad(); - fCurrentChannel = iChannel; - fCurrentSector = icsector; - fCurrentRow = icRow; - } - + if ( iChannel != fCurrentChannel ){ + ProcessPad(); + fLastSector=fCurrentSector; + fCurrentChannel = iChannel; + fCurrentSector = icsector; + fCurrentRow = icRow; + fCurrentPad = icPad; + } + //fill signals for current pad - fPadSignal[icTimeBin]=csignal; - if ( csignal > fMaxPadSignal ){ - fMaxPadSignal = csignal; - fMaxTimeBin = icTimeBin; - } - return 0; + fPadSignal[icTimeBin]=csignal; + if ( csignal > fMaxPadSignal ){ + fMaxPadSignal = csignal; + fMaxTimeBin = icTimeBin; + } + return 0; } //_____________________________________________________________________ void AliTPCCalibPulser::FindPedestal(Float_t part) @@ -409,455 +511,433 @@ void AliTPCCalibPulser::FindPedestal(Float_t part) // find pedestal and noise for the current pad. Use either database or // truncated mean with part*100% // - Bool_t noPedestal = kTRUE;; - if (fPedestalTPC&&fPadNoiseTPC){ + Bool_t noPedestal = kTRUE;; + if (fPedestalTPC&&fPadNoiseTPC){ //use pedestal database //only load new pedestals if the sector has changed - if ( fCurrentSector!=fLastSector ){ - fPedestalROC = fPedestalTPC->GetCalROC(fCurrentSector); - fPadNoiseROC = fPadNoiseTPC->GetCalROC(fCurrentSector); - fLastSector=fCurrentSector; - } - - if ( fPedestalROC&&fPadNoiseROC ){ - fPadPedestal = fPedestalROC->GetValue(fCurrentChannel); - fPadNoise = fPadNoiseROC->GetValue(fCurrentChannel); - noPedestal = kFALSE; - } - + if ( fCurrentSector!=fLastSector ){ + fPedestalROC = fPedestalTPC->GetCalROC(fCurrentSector); + fPadNoiseROC = fPadNoiseTPC->GetCalROC(fCurrentSector); } - + + if ( fPedestalROC&&fPadNoiseROC ){ + fPadPedestal = fPedestalROC->GetValue(fCurrentChannel); + fPadNoise = fPadNoiseROC->GetValue(fCurrentChannel); + noPedestal = kFALSE; + } + + } + //if we are not running with pedestal database, or for the current sector there is no information //available, calculate the pedestal and noise on the fly - if ( noPedestal ) { - const Int_t kPedMax = 100; //maximum pedestal value - Float_t max = 0; - Float_t maxPos = 0; - Int_t median = -1; - Int_t count0 = 0; - Int_t count1 = 0; - // - Float_t padSignal=0; + if ( noPedestal ) { + const Int_t kPedMax = 100; //maximum pedestal value + Float_t max = 0; + Float_t maxPos = 0; + Int_t median = -1; + Int_t count0 = 0; + Int_t count1 = 0; + // + Float_t padSignal=0; // - UShort_t histo[kPedMax]; - memset(histo,0,kPedMax*sizeof(UShort_t)); - - for (Int_t i=fFirstTimeBin; i<=fLastTimeBin; ++i){ - padSignal = fPadSignal.GetMatrixArray()[i]; - if (padSignal<=0) continue; - if (padSignal>max && i>10) { - max = padSignal; - maxPos = i; - } - if (padSignal>kPedMax-1) continue; - histo[Int_t(padSignal+0.5)]++; - count0++; - } - // - for (Int_t i=1; ikPedMax) continue; - if (count 0 ) { - mean/=count; - rms = TMath::Sqrt(TMath::Abs(rms/count-mean*mean)); - fPadPedestal = mean; - fPadNoise = rms; - } + UShort_t histo[kPedMax]; + memset(histo,0,kPedMax*sizeof(UShort_t)); + + for (Int_t i=fFirstTimeBin; i<=fLastTimeBin; ++i){ + padSignal = fPadSignal.GetMatrixArray()[i]; + if (padSignal<=0) continue; + if (padSignal>max && i>10) { + max = padSignal; + maxPos = i; + } + if (padSignal>kPedMax-1) continue; + histo[Int_t(padSignal+0.5)]++; + count0++; } + // + for (Int_t i=1; ikPedMax) continue; + if (count 0 ) { + mean/=count; + rms = TMath::Sqrt(TMath::Abs(rms/count-mean*mean)); + fPadPedestal = mean; + fPadNoise = rms; + } + } + fPadPedestal*=(Float_t)(!fIsZeroSuppressed); } //_____________________________________________________________________ void AliTPCCalibPulser::FindPulserSignal(TVectorD ¶m, Float_t &qSum) { - // +// // Find position, signal width and height of the CE signal (last signal) // param[0] = Qmax, param[1] = mean time, param[2] = rms; // maxima: array of local maxima of the pad signal use the one closest to the mean CE position // - - Float_t ceQmax =0, ceQsum=0, ceTime=0, ceRMS=0; - Int_t cemaxpos = fMaxTimeBin; - Float_t ceSumThreshold = 8.*fPadNoise; // threshold for the signal sum - const Int_t kCemin = 2; // range for the analysis of the ce signal +- channels from the peak - const Int_t kCemax = 7; - - if (cemaxpos!=0){ - ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal; - for (Int_t i=cemaxpos-kCemin; ifFirstTimeBin) && (i0) ){ - ceTime+=signal*(i+0.5); - ceRMS +=signal*(i+0.5)*(i+0.5); - ceQsum+=signal; - } - } + + Float_t ceQmax =0, ceQsum=0, ceTime=0, ceRMS=0; + 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 = 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; + qSum = ceQsum; + + if (cemaxpos>0){ + ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal; + if ( ceQmaxfFirstTimeBin) && (i0) ){ + ceTime+=signal*(i+0.5); + ceRMS +=signal*(i+0.5)*(i+0.5); + ceQsum+=signal; + } } - if (ceQmax&&ceQsum>ceSumThreshold) { - ceTime/=ceQsum; - ceRMS = TMath::Sqrt(TMath::Abs(ceRMS/ceQsum-ceTime*ceTime)); - fVTime0Offset.GetMatrixArray()[fCurrentSector]+=ceTime; // mean time for each sector - fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++; - - //Normalise Q to the pad area - Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow); - - ceQsum/=norm; + } + 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 + if ( !IsEdgePad(fCurrentSector,fCurrentRow,fCurrentPad) ){ + fVTime0Offset.GetMatrixArray()[fCurrentSector]+=ceTime; // mean time for each sector + fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++; + GetHistoTSec()->Fill(ceTime,fCurrentSector); + } } else { - ceQmax=0; - ceTime=0; - ceRMS =0; - ceQsum=0; + if ( !(fOutliers->GetCalROC(fCurrentSector)->GetValue(fCurrentChannel)) ){ + fVTime0Offset.GetMatrixArray()[fCurrentSector]+=ceTime; // mean time for each sector + fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++; + } } - param[0] = ceQmax; - param[1] = ceTime; - param[2] = ceRMS; - qSum = ceQsum; + + //Normalise Q to the 'cell-size': The wire density is the same in the IROC and OROC, therefore the + // the pick-up signal should scale with the pad area. In addition + // the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC), + // ratio 2/3. The pad area we express in mm2 (factor 100). We normalise the signal + // to the OROC signal (factor 2/3 for the IROCs). + Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow)*100; + if ( fCurrentSectorGetNInnerSector() ) norm*=3./2.; + + ceQsum/=norm; + } else { + ceQmax=0; + ceTime=0; + ceRMS =0; + ceQsum=0; + } + param[0] = ceQmax; + param[1] = ceTime; + param[2] = ceRMS; + qSum = ceQsum; } //_____________________________________________________________________ -void AliTPCCalibPulser::ProcessPad() /*FOLD00*/ +void AliTPCCalibPulser::ProcessPad() { - // - // Process data of current pad - // - - FindPedestal(); - TVectorD param(3); - Float_t Qsum; - FindPulserSignal(param, Qsum); - - Double_t meanT = param[1]; - Double_t sigmaT = param[2]; - - //Fill Event T0 counter - (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT; - - //Fill Q histogram - GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(Qsum), fCurrentChannel ); - - //Fill RMS histogram - GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel ); - - + // + // Process data of current pad + // + + FindPedestal(); + TVectorD param(3); + Float_t qSum; + FindPulserSignal(param, qSum); + + Double_t meanT = param[1]; + Double_t sigmaT = param[2]; + + + //Fill Event T0 counter + (*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT; + + //Fill Q histogram +// GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel ); //use linear scale, needs also a change in the Analyse funciton. + GetHistoQ(fCurrentSector,kTRUE)->Fill( qSum, fCurrentChannel ); + + //Fill RMS histogram + GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel ); + + //Fill debugging info - if ( fDebugLevel>0 ){ - (*GetPadPedestalEvent(fCurrentSector,kTRUE))[fCurrentChannel]=fPadPedestal; - (*GetPadRMSEvent(fCurrentSector,kTRUE))[fCurrentChannel]=sigmaT; - (*GetPadQEvent(fCurrentSector,kTRUE))[fCurrentChannel]=Qsum; + if ( GetStreamLevel()>0 ){ + TTreeSRedirector *streamer=GetDebugStreamer(); + if ( GetStreamLevel() == 1 ){ + if ( streamer ) { + Int_t padc = fCurrentPad-(fROC->GetNPads(fCurrentSector,fCurrentRow)/2); + (*streamer) << "PadSignals" << + "Event=" < 1 + (*GetPadPedestalEvent(fCurrentSector,kTRUE))[fCurrentChannel]=fPadPedestal; + (*GetPadRMSEvent(fCurrentSector,kTRUE))[fCurrentChannel]=sigmaT; + (*GetPadQEvent(fCurrentSector,kTRUE))[fCurrentChannel]=qSum; } - - ResetPad(); + } + ResetPad(); } //_____________________________________________________________________ -void AliTPCCalibPulser::EndEvent() /*FOLD00*/ +void AliTPCCalibPulser::EndEvent() { // // Process data of current event // - + //check if last pad has allready been processed, if not do so - if ( fMaxTimeBin>-1 ) ProcessPad(); - + if ( fMaxTimeBin>-1 ) ProcessPad(); + //loop over all ROCs, fill Time0 histogram corrected for the mean Time0 of each ROC - for ( Int_t iSec = 0; iSec<72; ++iSec ){ - TVectorF *vTimes = GetPadTimesEvent(iSec); - if ( !vTimes ) continue; - - for ( UInt_t iChannel=0; iChannelGetNChannels(iSec); ++iChannel ){ - Float_t Time0 = fVTime0Offset[iSec]/fVTime0OffsetCounter[iSec]; - Float_t Time = (*vTimes).GetMatrixArray()[iChannel]; - - GetHistoT0(iSec,kTRUE)->Fill( Time-Time0,iChannel ); - - - //Debug start - if ( fDebugLevel>0 ){ - 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); - - TH1F *h1 = new TH1F(Form("hSignalD%d.%d.%d",sector,row,pad), - Form("hSignalD%d.%d.%d",sector,row,pad), - fLastTimeBin-fFirstTimeBin, - fFirstTimeBin,fLastTimeBin); - h1->SetDirectory(0); - - for (Int_t i=fFirstTimeBin; iFill(i,fPadSignal(i)); - - (*fDebugStreamer) << "DataPad" << - "Event=" << fEvent << - "Sector="<< sector << - "Row=" << row<< - "Pad=" << pad << - "PadC=" << padc << - "PadSec="<< channel << - "Time0=" << Time0 << - "Time=" << Time << - "RMS=" << RMS << - "Sum=" << Q << - "hist.=" << h1 << - "\n"; - - delete h1; - } - //Debug end - - } + for ( Int_t iSec = 0; iSec<72; ++iSec ){ + TVectorF *vTimes = GetPadTimesEvent(iSec); + if ( !vTimes || fVTime0OffsetCounter[iSec]==0 ) continue; + Float_t time0 = fVTime0Offset[iSec]/fVTime0OffsetCounter[iSec]; + for ( UInt_t iChannel=0; iChannelGetNChannels(iSec); ++iChannel ){ + Float_t time = (*vTimes).GetMatrixArray()[iChannel]; + + GetHistoT0(iSec,kTRUE)->Fill( time-time0,iChannel ); + //GetHistoT0(iSec,kTRUE)->Fill( time,iChannel ); + + + //Debug start + 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=" << fNevents << + "Sector="<< sector << + "Row=" << row<< + "Pad=" << pad << + "PadC=" << padc << + "PadSec="<< channel << + "Time0=" << time0 << + "Time=" << time << + "RMS=" << rms << + "Sum=" << q << + "\n"; + } + } + //Debug end } - -} -//_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEvent(AliTPCRawStream *rawStream) /*FOLD00*/ -{ - // - // Event Processing loop - AliTPCRawStream - // - - rawStream->SetOldRCUFormat(fOldRCUformat); - - 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; + ++fNevents; } //_____________________________________________________________________ -Bool_t AliTPCCalibPulser::ProcessEvent(AliRawReader *rawReader) -{ - // - // Event processing loop - AliRawReader - // - - - AliTPCRawStream rawStream(rawReader); - - 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, /*FOLD00*/ - Int_t nbinsY, Float_t ymin, Float_t ymax, - Char_t *type, Bool_t force) +TH2S* AliTPCCalibPulser::GetHisto(Int_t sector, TObjArray *arr, + Int_t nbinsY, Float_t ymin, Float_t ymax, + const Char_t *type, Bool_t force) { // // return pointer to Q histogram // if force is true create a new histogram if it doesn't exist allready // - if ( !force || arr->UncheckedAt(sector) ) - return (TH2S*)arr->UncheckedAt(sector); - - // if we are forced and histogram doesn't yes exist create it - Char_t name[255], title[255]; - - sprintf(name,"hCalib%s%.2d",type,sector); - sprintf(title,"%s calibration histogram sector %.2d",type,sector); - - // new histogram with Q calib information. One value for each pad! - TH2S* hist = new TH2S(name,title, - nbinsY, ymin, ymax, - fROC->GetNChannels(sector),0,fROC->GetNChannels(sector)); - hist->SetDirectory(0); - arr->AddAt(hist,sector); - return hist; + if ( !force || arr->UncheckedAt(sector) ) + return (TH2S*)arr->UncheckedAt(sector); + + // if we are forced and histogram doesn't yes exist create it + // new histogram with Q calib information. One value for each pad! + TH2S* hist = new TH2S(Form("hCalib%s%.2d",type,sector),Form("%s calibration histogram sector %.2d",type,sector), + nbinsY, ymin, ymax, + fROC->GetNChannels(sector),0,fROC->GetNChannels(sector)); + hist->SetDirectory(0); + arr->AddAt(hist,sector); + return hist; } //_____________________________________________________________________ -TH2S* AliTPCCalibPulser::GetHistoT0(Int_t sector, Bool_t force) /*FOLD00*/ +TH2S* AliTPCCalibPulser::GetHistoT0(Int_t sector, Bool_t force) { // // return pointer to T0 histogram // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fHistoT0Array; - return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force); + TObjArray *arr = &fHistoT0Array; + return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force); } //_____________________________________________________________________ -TH2S* AliTPCCalibPulser::GetHistoQ(Int_t sector, Bool_t force) /*FOLD00*/ +TH2S* AliTPCCalibPulser::GetHistoQ(Int_t sector, Bool_t force) { // // return pointer to Q histogram // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fHistoQArray; - return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force); + TObjArray *arr = &fHistoQArray; + return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force); } //_____________________________________________________________________ -TH2S* AliTPCCalibPulser::GetHistoRMS(Int_t sector, Bool_t force) /*FOLD00*/ +TH2S* AliTPCCalibPulser::GetHistoRMS(Int_t sector, Bool_t force) { // // return pointer to Q histogram // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fHistoRMSArray; - return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force); + TObjArray *arr = &fHistoRMSArray; + return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force); } //_____________________________________________________________________ -TVectorF* AliTPCCalibPulser::GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force) /*FOLD00*/ +TH2F* AliTPCCalibPulser::GetHistoTSec() +{ + // + // return the pointer to the abs time distribution per sector + // create it if it does not exist + // + if ( !fHMeanTimeSector ) //!!!if you change the binning here, you should also change it in the Analyse Function!! + fHMeanTimeSector = new TH2F("fHMeanTimeSector","Abs mean time per sector", + 20*(fLastTimeBin-fFirstTimeBin), fFirstTimeBin, fLastTimeBin, + 72,0,72); + return fHMeanTimeSector; +} +//_____________________________________________________________________ +TVectorF* AliTPCCalibPulser::GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force) { // // return pointer to Pad Info from 'arr' for the current event and sector // if force is true create it if it doesn't exist allready // - if ( !force || arr->UncheckedAt(sector) ) - return (TVectorF*)arr->UncheckedAt(sector); - - TVectorF *vect = new TVectorF(fROC->GetNChannels(sector)); - arr->AddAt(vect,sector); - return vect; + if ( !force || arr->UncheckedAt(sector) ) + return (TVectorF*)arr->UncheckedAt(sector); + + TVectorF *vect = new TVectorF(fROC->GetNChannels(sector)); + arr->AddAt(vect,sector); + return vect; } //_____________________________________________________________________ -TVectorF* AliTPCCalibPulser::GetPadTimesEvent(Int_t sector, Bool_t force) /*FOLD00*/ +TVectorF* AliTPCCalibPulser::GetPadTimesEvent(Int_t sector, Bool_t force) { // // return pointer to Pad Times Array for the current event and sector // if force is true create it if it doesn't exist allready // - TObjArray *arr = &fPadTimesArrayEvent; - return GetPadInfoEvent(sector,arr,force); + TObjArray *arr = &fPadTimesArrayEvent; + return GetPadInfoEvent(sector,arr,force); } //_____________________________________________________________________ -TVectorF* AliTPCCalibPulser::GetPadQEvent(Int_t sector, Bool_t force) /*FOLD00*/ +TVectorF* AliTPCCalibPulser::GetPadQEvent(Int_t sector, Bool_t force) { // // return pointer to Pad Q Array for the current event and sector // if force is true create it if it doesn't exist allready // for debugging purposes only // - - TObjArray *arr = &fPadQArrayEvent; - return GetPadInfoEvent(sector,arr,force); + + TObjArray *arr = &fPadQArrayEvent; + return GetPadInfoEvent(sector,arr,force); } //_____________________________________________________________________ -TVectorF* AliTPCCalibPulser::GetPadRMSEvent(Int_t sector, Bool_t force) /*FOLD00*/ +TVectorF* AliTPCCalibPulser::GetPadRMSEvent(Int_t sector, Bool_t force) { // // return pointer to Pad RMS Array for the current event and sector // if force is true create it if it doesn't exist allready // for debugging purposes only // - TObjArray *arr = &fPadRMSArrayEvent; - return GetPadInfoEvent(sector,arr,force); + TObjArray *arr = &fPadRMSArrayEvent; + return GetPadInfoEvent(sector,arr,force); } //_____________________________________________________________________ -TVectorF* AliTPCCalibPulser::GetPadPedestalEvent(Int_t sector, Bool_t force) /*FOLD00*/ +TVectorF* AliTPCCalibPulser::GetPadPedestalEvent(Int_t sector, Bool_t force) { // // return pointer to Pad RMS Array for the current event and sector // if force is true create it if it doesn't exist allready // for debugging purposes only // - TObjArray *arr = &fPadPedestalArrayEvent; - return GetPadInfoEvent(sector,arr,force); + TObjArray *arr = &fPadPedestalArrayEvent; + return GetPadInfoEvent(sector,arr,force); } //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPulser::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPulser::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const { // // return pointer to ROC Calibration // if force is true create a new histogram if it doesn't exist allready // - if ( !force || arr->UncheckedAt(sector) ) - return (AliTPCCalROC*)arr->UncheckedAt(sector); - + if ( !force || arr->UncheckedAt(sector) ) + return (AliTPCCalROC*)arr->UncheckedAt(sector); + // if we are forced and histogram doesn't yes exist create it - + // new AliTPCCalROC for T0 information. One value for each pad! - AliTPCCalROC *croc = new AliTPCCalROC(sector); - arr->AddAt(croc,sector); - return croc; + AliTPCCalROC *croc = new AliTPCCalROC(sector); + arr->AddAt(croc,sector); + return croc; } //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPulser::GetCalRocT0(Int_t sector, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPulser::GetCalRocT0(Int_t sector, Bool_t force) { // // return pointer to Carge ROC Calibration // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fCalRocArrayT0; - return GetCalRoc(sector, arr, force); + TObjArray *arr = &fCalRocArrayT0; + return GetCalRoc(sector, arr, force); } //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPulser::GetCalRocQ(Int_t sector, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPulser::GetCalRocQ(Int_t sector, Bool_t force) { // // return pointer to T0 ROC Calibration // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fCalRocArrayQ; - return GetCalRoc(sector, arr, force); + TObjArray *arr = &fCalRocArrayQ; + return GetCalRoc(sector, arr, force); } //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPulser::GetCalRocRMS(Int_t sector, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPulser::GetCalRocRMS(Int_t sector, Bool_t force) { // // return pointer to signal width ROC Calibration // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fCalRocArrayRMS; - return GetCalRoc(sector, arr, force); + TObjArray *arr = &fCalRocArrayRMS; + return GetCalRoc(sector, arr, force); } //_____________________________________________________________________ AliTPCCalROC* AliTPCCalibPulser::GetCalRocOutliers(Int_t sector, Bool_t force) @@ -866,290 +946,319 @@ AliTPCCalROC* AliTPCCalibPulser::GetCalRocOutliers(Int_t sector, Bool_t force) // return pointer to Outliers // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fCalRocArrayOutliers; - return GetCalRoc(sector, arr, force); + TObjArray *arr = &fCalRocArrayOutliers; + return GetCalRoc(sector, arr, force); } //_____________________________________________________________________ -void AliTPCCalibPulser::ResetEvent() /*FOLD00*/ +void AliTPCCalibPulser::ResetEvent() { // // Reset global counters -- Should be called before each event is processed // - fLastSector=-1; - fCurrentSector=-1; - fCurrentRow=-1; - fCurrentChannel=-1; - - ResetPad(); - - fPadTimesArrayEvent.Delete(); - fPadQArrayEvent.Delete(); - fPadRMSArrayEvent.Delete(); - fPadPedestalArrayEvent.Delete(); - - for ( Int_t i=0; i<72; ++i ){ - fVTime0Offset[i]=0; - fVTime0OffsetCounter[i]=0; - } + fLastSector=-1; + fCurrentSector=-1; + fCurrentRow=-1; + fCurrentPad=-1; + fCurrentChannel=-1; + + ResetPad(); + + fPadTimesArrayEvent.Delete(); + + fPadQArrayEvent.Delete(); + fPadRMSArrayEvent.Delete(); + fPadPedestalArrayEvent.Delete(); + + for ( Int_t i=0; i<72; ++i ){ + fVTime0Offset[i]=0; + fVTime0OffsetCounter[i]=0; + } } //_____________________________________________________________________ -void AliTPCCalibPulser::ResetPad() /*FOLD00*/ +void AliTPCCalibPulser::ResetPad() { // // Reset pad infos -- Should be called after a pad has been processed // - for (Int_t i=fFirstTimeBin; iGetHistoQ(iSec); - TH2S *hRefT0merge = sig->GetHistoT0(iSec); - TH2S *hRefRMSmerge = sig->GetHistoRMS(iSec); - - - if ( hRefQmerge ){ - TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0); - TH2S *hRefQ = GetHistoQ(iSec); - if ( hRefQ ) hRefQ->Add(hRefQmerge); - else { - TH2S *hist = new TH2S(*hRefQmerge); - hist->SetDirectory(0); - fHistoQArray.AddAt(hist, iSec); - } - hRefQmerge->SetDirectory(dir); - } - if ( hRefT0merge ){ - TDirectory *dir = hRefT0merge->GetDirectory(); hRefT0merge->SetDirectory(0); - TH2S *hRefT0 = GetHistoT0(iSec); - if ( hRefT0 ) hRefT0->Add(hRefT0merge); - else { - TH2S *hist = new TH2S(*hRefT0merge); - hist->SetDirectory(0); - fHistoT0Array.AddAt(hist, iSec); - } - hRefT0merge->SetDirectory(dir); - } - if ( hRefRMSmerge ){ - TDirectory *dir = hRefRMSmerge->GetDirectory(); hRefRMSmerge->SetDirectory(0); - TH2S *hRefRMS = GetHistoRMS(iSec); - if ( hRefRMS ) hRefRMS->Add(hRefRMSmerge); - else { - TH2S *hist = new TH2S(*hRefRMSmerge); - hist->SetDirectory(0); - fHistoRMSArray.AddAt(hist, iSec); - } - hRefRMSmerge->SetDirectory(dir); - } - - } + Int_t edge1 = 0; + Int_t edge2 = fROC->GetNPads(sector,row)-1; + if ( pad == edge1 || pad == edge2 ) return kTRUE; + + return kFALSE; } //_____________________________________________________________________ -void AliTPCCalibPulser::Analyse() /*FOLD00*/ +void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig) { - // - // Calculate calibration constants - // - - TVectorD paramQ(3); - TVectorD paramT0(3); - TVectorD paramRMS(3); - TMatrixD dummy(3,3); - - 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 *rocRMS = GetCalRocRMS(iSec,kTRUE); - AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE); - - TH2S *hQ = GetHistoQ(iSec); - TH2S *hRMS = GetHistoRMS(iSec); - - Short_t *array_hQ = hQ->GetArray(); - Short_t *array_hT0 = hT0->GetArray(); - Short_t *array_hRMS = 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; - } -*/ - rocQ->SetValue(iChannel, cogQ*cogQ); - rocT0->SetValue(iChannel, cogTime0); - rocRMS->SetValue(iChannel, cogRMS); - rocOut->SetValue(iChannel, cogOut); - - - //debug - if ( fDebugLevel > 0 ){ - 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 - } - - 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); + // + // Merge reference histograms of sig to the current AliTPCCalibPulser + // - (*fDebugStreamer) << "DataEnd" << - "Sector=" << iSec << - "Pad=" << pad << - "PadC=" << padc << - "Row=" << row << - "PadSec=" << iChannel << - "Q=" << cogQ << - "T0=" << cogTime0 << - "RMS=" << cogRMS << - "\n"; - } - //! debug + MergeBase(sig); + //merge histograms + for (Int_t iSec=0; iSec<72; ++iSec){ + TH2S *hRefQmerge = sig->GetHistoQ(iSec); + TH2S *hRefT0merge = sig->GetHistoT0(iSec); + TH2S *hRefRMSmerge = sig->GetHistoRMS(iSec); + + + if ( hRefQmerge ){ + TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0); + TH2S *hRefQ = GetHistoQ(iSec); + if ( hRefQ ) hRefQ->Add(hRefQmerge); + else { + TH2S *hist = new TH2S(*hRefQmerge); + hist->SetDirectory(0); + fHistoQArray.AddAt(hist, iSec); + } + hRefQmerge->SetDirectory(dir); + } + if ( hRefT0merge ){ + TDirectory *dir = hRefT0merge->GetDirectory(); hRefT0merge->SetDirectory(0); + TH2S *hRefT0 = GetHistoT0(iSec); + if ( hRefT0 ) hRefT0->Add(hRefT0merge); + else { + TH2S *hist = new TH2S(*hRefT0merge); + hist->SetDirectory(0); + fHistoT0Array.AddAt(hist, iSec); + } + hRefT0merge->SetDirectory(dir); + } + if ( hRefRMSmerge ){ + TDirectory *dir = hRefRMSmerge->GetDirectory(); hRefRMSmerge->SetDirectory(0); + TH2S *hRefRMS = GetHistoRMS(iSec); + if ( hRefRMS ) hRefRMS->Add(hRefRMSmerge); + else { + TH2S *hist = new TH2S(*hRefRMSmerge); + hist->SetDirectory(0); + fHistoRMSArray.AddAt(hist, iSec); + } + hRefRMSmerge->SetDirectory(dir); + } + + } + if ( sig->fHMeanTimeSector ){ + TDirectory *dir = sig->fHMeanTimeSector->GetDirectory(); sig->fHMeanTimeSector->SetDirectory(0); + if ( fHMeanTimeSector ) fHMeanTimeSector->Add(sig->fHMeanTimeSector); + else { + fHMeanTimeSector = new TH2F(*sig->fHMeanTimeSector); + fHMeanTimeSector->SetDirectory(0); + } + sig->fHMeanTimeSector->SetDirectory(dir); + } +} - } +//_____________________________________________________________________ +Long64_t AliTPCCalibPulser::Merge(TCollection * const list) +{ + // + // Merge all objects of this type in list + // + + Long64_t nmerged=1; + + TIter next(list); + AliTPCCalibPulser *ce=0; + TObject *o=0; + + while ( (o=next()) ){ + ce=dynamic_cast(o); + if (ce){ + Merge(ce); + ++nmerged; } - delete fDebugStreamer; - fDebugStreamer = 0x0; + } + + return nmerged; } + //_____________________________________________________________________ -void AliTPCCalibPulser::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) +void AliTPCCalibPulser::Analyse() { - // - // 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); + // + // Calculate calibration constants + // + + TVectorD paramQ(3); + TVectorD paramT0(3); + TVectorD paramRMS(3); + TMatrixD dummy(3,3); + //calculate mean time for each sector and mean time for each side + TH1F hMeanTsec("hMeanTsec","hMeanTsec",20*(fLastTimeBin-fFirstTimeBin),fFirstTimeBin,fLastTimeBin); + fVMeanTimeSector.Zero(); + + for (Int_t iSec=0; iSec<72; ++iSec){ + TH2S *hT0 = GetHistoT0(iSec); + if (!hT0 ) continue; + //calculate sector mean T + if ( fHMeanTimeSector ){ + Int_t nbinsT = fHMeanTimeSector->GetNbinsX(); + Int_t offset = (nbinsT+2)*(iSec+1); + Float_t *arrP=fHMeanTimeSector->GetArray()+offset; + Int_t entries=0; + for ( Int_t i=0; i0 ) AliMathBase::TruncatedMean(&hMeanTsec,¶mT0,0.05,.95); + fVMeanTimeSector[iSec]=paramT0[1]; } - this->Write(); - f.Close(); - - if ( backup ) backup->cd(); + + AliTPCCalROC *rocQ = GetCalRocQ (iSec,kTRUE); + AliTPCCalROC *rocT0 = GetCalRocT0 (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); + Float_t meanTsec = fVMeanTimeSector[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; + } +*/ +// rocQ->SetValue(iChannel, cogQ*cogQ); // changed to linear scale again + rocQ->SetValue(iChannel, cogQ); + rocT0->SetValue(iChannel, cogTime0+meanTsec); //offset by mean time of the sector + rocRMS->SetValue(iChannel, cogRMS); + rocOut->SetValue(iChannel, cogOut); + //debug + 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"; + } + } + //! debug + } + + + } } //_____________________________________________________________________ //_________________________ Test Functions ___________________________ //_____________________________________________________________________ TObjArray* AliTPCCalibPulser::TestBinning() { - // - // Function to test the binning of the reference histograms - // type: T0, Q or RMS - // mode: 0 - number of filled bins per channel - // 1 - number of empty bins between filled bins in one ROC - // returns TObjArray with the test histograms type*2+mode: - // position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ... - - - TObjArray *histArray = new TObjArray(6); - const Char_t *type[] = {"T0","Q","RMS"}; - Int_t fNbins[3] = {fNbinsT0,fNbinsQ,fNbinsRMS}; - - for (Int_t itype = 0; itype<3; ++itype){ - for (Int_t imode=0; imode<2; ++imode){ - Int_t icount = itype*2+imode; - histArray->AddAt(new TH1F(Form("hTestBinning%s%d",type[itype],imode), - Form("Test Binning of '%s', mode - %d",type[itype],imode), - 72,0,72), - icount); - } + // + // Function to test the binning of the reference histograms + // type: T0, Q or RMS + // mode: 0 - number of filled bins per channel + // 1 - number of empty bins between filled bins in one ROC + // returns TObjArray with the test histograms type*2+mode: + // position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ... + + + TObjArray *histArray = new TObjArray(6); + const Char_t *type[] = {"T0","Q","RMS"}; + Int_t fNbins[3] = {fNbinsT0,fNbinsQ,fNbinsRMS}; + + for (Int_t itype = 0; itype<3; ++itype){ + for (Int_t imode=0; imode<2; ++imode){ + Int_t icount = itype*2+imode; + histArray->AddAt(new TH1F(Form("hTestBinning%s%d",type[itype],imode), + Form("Test Binning of '%s', mode - %d",type[itype],imode), + 72,0,72), + icount); } - - - TH2S *hRef=0x0; - Short_t *array=0x0; - for (Int_t itype = 0; itype<3; ++itype){ - for (Int_t iSec=0; iSec<72; ++iSec){ - if ( itype == 0 ) hRef = GetHistoT0(iSec); - if ( itype == 1 ) hRef = GetHistoQ(iSec); - if ( itype == 2 ) hRef = GetHistoRMS(iSec); - if ( hRef == 0x0 ) continue; - array = (hRef->GetArray()); - UInt_t nChannels = fROC->GetNChannels(iSec); - - Int_t nempty=0; - for (UInt_t iChannel=0; iChannel0 ) { - nfilled++; - if ( c1 && c2 ) nempty++; - else c1 = 1; - } - else if ( c1 ) c2 = 1; - - } - ((TH1F*)histArray->At(itype*2))->Fill(nfilled); - } - ((TH1F*)histArray->At(itype*2+1))->Fill(iSec,nempty); - } + } + + + TH2S *hRef=0x0; + Short_t *array=0x0; + for (Int_t itype = 0; itype<3; ++itype){ + for (Int_t iSec=0; iSec<72; ++iSec){ + if ( itype == 0 ) hRef = GetHistoT0(iSec); + if ( itype == 1 ) hRef = GetHistoQ(iSec); + if ( itype == 2 ) hRef = GetHistoRMS(iSec); + if ( hRef == 0x0 ) continue; + array = (hRef->GetArray()); + UInt_t nChannels = fROC->GetNChannels(iSec); + + Int_t nempty=0; + for (UInt_t iChannel=0; iChannel0 ) { + nfilled++; + if ( c1 && c2 ) nempty++; + else c1 = 1; + } + else if ( c1 ) c2 = 1; + + } + ((TH1F*)histArray->At(itype*2))->Fill(nfilled); + } + ((TH1F*)histArray->At(itype*2+1))->Fill(iSec,nempty); } - return histArray; + } + return histArray; }