X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCCalibPedestal.cxx;h=c47c8926319c16725e16211e5cd2d4c771ef2cac;hb=83decb5f97a9170379eec64cef3179390406e806;hp=7444be3b66ef8005794f6985f9b48f0693591108;hpb=f1b14fa24afa848b054f407ed5236dfa0bcea436;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCCalibPedestal.cxx b/TPC/AliTPCCalibPedestal.cxx index 7444be3b66e..c47c8926319 100644 --- a/TPC/AliTPCCalibPedestal.cxx +++ b/TPC/AliTPCCalibPedestal.cxx @@ -26,6 +26,7 @@ #include #include #include +#include //AliRoot includes #include "AliRawReader.h" #include "AliRawReaderRoot.h" @@ -133,8 +134,10 @@ // // - Accessing the calibration storage objects: // -// AliTPCCalROC *GetCalRocPedestal(Int_t sector); - for the pedestal values -// AliTPCCalROC *GetCalRocNoise(Int_t sector); - for the Noise values +// AliTPCCalROC *GetCalRocPedestal(Int_t sector); - for the pedestal values, mean from gaus fit +// AliTPCCalROC *GetCalRocSigma(Int_t sector); - for the Noise values, sigma from guas fit +// AliTPCCalROC *GetCalRocMean(Int_t sector); - for the pedestal values, truncated mean +// AliTPCCalROC *GetCalRocRMS(Int_t sector); - for the Noise values, rms from truncated mean // // example for visualisation: // if the file "PedestalData.root" was created using the above example one could do the following: @@ -174,61 +177,112 @@ ped.GetCalRocPedestal(36)->Draw("colz"); c2->cd(4); ped.GetCalRocRMS(36)->Draw("colz"); - - */ - +// +// Time dependent pedestals: +// +// If wished there is the possibility to calculate for each channel and time bin +// the mean pedestal [pedestals(t)]. This is done by +// +// 1) setting SetTimeAnalysis(kTRUE), +// 2) processing the data by looping over the events using ProcessEvent(..) +// 3) calling the Analyse() and AnalyseTime(nevents) functions (providing nevents) +// 4) getting the pedestals(t) using TArrayF **timePed = calibPedestal.GetTimePedestals(); +// 5) looking at values using timePed[row][pad].At(timebin) +// +// This functionality is intended to be used on an LDC bu the detector algorithm +// (TPCPEDESTALda) to generate a data set used for configuration of the pattern +// memory for baseline subtraction in the ALTROs. Later the information should also +// be stored as reference data. +// ClassImp(AliTPCCalibPedestal) -AliTPCCalibPedestal::AliTPCCalibPedestal() : /*FOLD00*/ - TObject(), - fFirstTimeBin(60), - fLastTimeBin(1000), +AliTPCCalibPedestal::AliTPCCalibPedestal() : + AliTPCCalibRawBase(), fAdcMin(1), fAdcMax(100), - fOldRCUformat(kTRUE), - fROC(AliTPCROC::Instance()), + fAnaMeanDown(0.), + fAnaMeanUp(1.), + fTimeAnalysis(kFALSE), fCalRocArrayPedestal(72), - fCalRocArrayRMS(72), - fHistoPedestalArray(72) + fCalRocArraySigma(72), + fHistoPedestalArray(72), + fTimeSignal(NULL), + fCalRocArrayMean(72), + fCalRocArrayRMS(72) { - // - // default constructor - // + // + // default constructor + // + SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal"); + fFirstTimeBin=60; + fLastTimeBin=1000; } + + //_____________________________________________________________________ -AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : /*FOLD00*/ - TObject(ped), - fFirstTimeBin(ped.GetFirstTimeBin()), - fLastTimeBin(ped.GetLastTimeBin()), +AliTPCCalibPedestal::AliTPCCalibPedestal(const AliTPCCalibPedestal &ped) : + AliTPCCalibRawBase(ped), fAdcMin(ped.GetAdcMin()), fAdcMax(ped.GetAdcMax()), - fOldRCUformat(kTRUE), - fROC(AliTPCROC::Instance()), + fAnaMeanDown(ped.fAnaMeanDown), + fAnaMeanUp(ped.fAnaMeanUp), + fTimeAnalysis(ped.fTimeAnalysis), fCalRocArrayPedestal(72), - fCalRocArrayRMS(72), - fHistoPedestalArray(72) + fCalRocArraySigma(72), + fHistoPedestalArray(72), + fTimeSignal(ped.fTimeSignal), + fCalRocArrayMean(72), + fCalRocArrayRMS(72) { - // - // copy constructor - // - for (Int_t iSec = 0; iSec < 72; ++iSec){ - const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec); - const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec); - const TH2F *hPed = (TH2F*)ped.fHistoPedestalArray.UncheckedAt(iSec); - - if ( calPed != 0x0 ) fCalRocArrayPedestal.AddAt(new AliTPCCalROC(*calPed), iSec); - if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec); - - if ( hPed != 0x0 ){ - TH2F *hNew = new TH2F(*hPed); - hNew->SetDirectory(0); - fHistoPedestalArray.AddAt(hNew,iSec); - } + // + // copy constructor + // + for (Int_t iSec = 0; iSec < 72; ++iSec){ + const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec); + const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec); + const TH2F *hPed = (TH2F*)ped.fHistoPedestalArray.UncheckedAt(iSec); + + if ( calPed != 0x0 ) fCalRocArrayPedestal.AddAt(new AliTPCCalROC(*calPed), iSec); + if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec); + + if ( hPed != 0x0 ){ + TH2F *hNew = new TH2F(*hPed); + hNew->SetDirectory(0); + fHistoPedestalArray.AddAt(hNew,iSec); } + } } +AliTPCCalibPedestal::AliTPCCalibPedestal(const TMap *config): + AliTPCCalibRawBase(), + fAdcMin(1), + fAdcMax(100), + fAnaMeanDown(0.), + fAnaMeanUp(1.), + fTimeAnalysis(kFALSE), + fCalRocArrayPedestal(72), + fCalRocArraySigma(72), + fHistoPedestalArray(72), + fTimeSignal(NULL), + fCalRocArrayMean(72), + fCalRocArrayRMS(72) +{ + // + // 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()); +} + + //_____________________________________________________________________ AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const AliTPCCalibPedestal &source) { @@ -240,146 +294,156 @@ AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const AliTPCCalibPedestal return *this; } + + //_____________________________________________________________________ -AliTPCCalibPedestal::~AliTPCCalibPedestal() /*FOLD00*/ +AliTPCCalibPedestal::~AliTPCCalibPedestal() { // // destructor // - fCalRocArrayPedestal.Delete(); - fCalRocArrayRMS.Delete(); - fHistoPedestalArray.Delete(); - delete fROC; -} -//_____________________________________________________________________ -Int_t AliTPCCalibPedestal::Update(const Int_t icsector, /*FOLD00*/ - const Int_t icRow, - const Int_t icPad, - const Int_t icTimeBin, - const Float_t csignal) -{ - // - // Signal filling methode - // + fCalRocArrayPedestal.Delete(); + fCalRocArrayRMS.Delete(); + fCalRocArraySigma.Delete(); + fHistoPedestalArray.Delete(); - //return if we are out of the specified time bin or adc range - if ( (icTimeBin>fLastTimeBin) || (icTimeBinfAdcMax) || ((Int_t)csignalGetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector + // do not delete fMapping, because we do not own it. - // fast filling methode. - // Attention: the entry counter of the histogram is not increased - // this means that e.g. the colz draw option gives an empty plot - Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1); +} - GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++; - return 0; -} //_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEvent(AliTPCRawStream *rawStream) +void AliTPCCalibPedestal::SetTimeAnalysis(Bool_t time) { // - // Event Processing loop - AliTPCRawStream + // Use time dependent analysis: Pedestals are analysed as a function + // of the drift time. There is one mean value generated for each time + // bin and each channel. It can be used as reference data and for + // configuration of the ALTRO pattern memory for baseline subtraction. + // + // ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data + // only from one sector. For the full TPC we would need a lot of + // memory (36*159*140*1024*4bytes = 3.3GB)! // - rawStream->SetOldRCUFormat(fOldRCUformat); - - Bool_t withInput = kFALSE; - - while (rawStream->Next()) { + fTimeAnalysis = time; - 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 + if ( !fTimeAnalysis ) return; - Update(isector,iRow,iPad,iTimeBin,signal); - withInput = kTRUE; + // prepare array for one sector (159*140*1024*4bytes = 92MB): + fTimeSignal = new TArrayF*[159]; + for (Int_t i = 0; i < 159; i++) { // padrows + fTimeSignal[i] = new TArrayF[140]; + for (Int_t j = 0; j < 140; j++) { // pads per row + fTimeSignal[i][j].Set(1024); + for (Int_t k = 0; k < 1024; k++) { // time bins per pad + fTimeSignal[i][j].AddAt(0., k); + } + } } - - return withInput; } + + //_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::ProcessEvent(AliRawReader *rawReader) +Int_t AliTPCCalibPedestal::Update(const Int_t icsector, + const Int_t icRow, + const Int_t icPad, + const Int_t icTimeBin, + const Float_t csignal) { // - // Event processing loop - AliRawReader + // Signal filling method // + if (icRow<0) return 0; + if (icPad<0) return 0; + if (icTimeBin<0) return 0; + + // Time dependent pedestals + if ( fTimeAnalysis ) { + if ( icsector < 36 ) // IROC + fTimeSignal[icRow][icPad].AddAt(fTimeSignal[icRow][icPad].At(icTimeBin)+csignal, icTimeBin); + else + fTimeSignal[icRow+63][icPad].AddAt(fTimeSignal[icRow+63][icPad].At(icTimeBin)+csignal, icTimeBin); + } + //return if we are out of the specified time bin or adc range + if ( (icTimeBin>fLastTimeBin) || (icTimeBinfAdcMax) || ((Int_t)csignalGetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector - AliTPCRawStream rawStream(rawReader); + // fast filling method + // Attention: the entry counter of the histogram is not increased + // this means that e.g. the colz draw option gives an empty plot + Int_t bin = (iChannel+1)*(fAdcMax-fAdcMin+2)+((Int_t)csignal-fAdcMin+1); - rawReader->Select("TPC"); + GetHistoPedestal(icsector,kTRUE)->GetArray()[bin]++; - 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; + return 0; } + + //_____________________________________________________________________ -Bool_t AliTPCCalibPedestal::TestEvent() /*FOLD00*/ +Bool_t AliTPCCalibPedestal::TestEvent() { // // Test event loop // 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; } + + //_____________________________________________________________________ -TH2F* AliTPCCalibPedestal::GetHisto(Int_t sector, TObjArray *arr, /*FOLD00*/ - Int_t nbinsY, Float_t ymin, Float_t ymax, - Char_t *type, Bool_t force) +TH2F* AliTPCCalibPedestal::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 (TH2F*)arr->UncheckedAt(sector); + return (TH2F*)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;ADC channel;Channel (pad)",type,sector); - // new histogram with Q calib information. One value for each pad! - TH2F* hist = new TH2F(name,title, - nbinsY, ymin, ymax, - fROC->GetNChannels(sector),0,fROC->GetNChannels(sector) - ); + TH2F* hist = new TH2F(Form("hCalib%s%.2d",type,sector), + Form("%s calibration histogram sector %.2d;ADC channel;Channel (pad)",type,sector), + nbinsY, ymin, ymax, + fROC->GetNChannels(sector),0,fROC->GetNChannels(sector) + ); hist->SetDirectory(0); arr->AddAt(hist,sector); return hist; } + + //_____________________________________________________________________ -TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) /*FOLD00*/ +TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) { // // return pointer to T0 histogram @@ -388,8 +452,10 @@ TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force) /*FOLD00 TObjArray *arr = &fHistoPedestalArray; return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force); } + + //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) { // // return pointer to ROC Calibration @@ -405,113 +471,182 @@ AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_ arr->AddAt(croc,sector); return croc; } + + //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force) { // - // return pointer to Carge ROC Calibration + // return pointer to ROC with Pedestal data // if force is true create a new histogram if it doesn't exist allready // TObjArray *arr = &fCalRocArrayPedestal; return GetCalRoc(sector, arr, force); } + + //_____________________________________________________________________ -AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPedestal::GetCalRocSigma(Int_t sector, Bool_t force) { // - // return pointer to signal width ROC Calibration + // return pointer to ROC with signal witdth in sigma // if force is true create a new histogram if it doesn't exist allready // - TObjArray *arr = &fCalRocArrayRMS; + TObjArray *arr = &fCalRocArraySigma; return GetCalRoc(sector, arr, force); } //_____________________________________________________________________ -void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal *ped) +AliTPCCalROC* AliTPCCalibPedestal::GetCalRocMean(Int_t sector, Bool_t force) { - // - // Merge reference histograms of sig to the current AliTPCCalibSignal - // - - //merge histograms - for (Int_t iSec=0; iSec<72; ++iSec){ - TH2F *hRefPedMerge = ped->GetHistoPedestal(iSec); - - - if ( hRefPedMerge ){ - TDirectory *dir = hRefPedMerge->GetDirectory(); hRefPedMerge->SetDirectory(0); - TH2F *hRefPed = GetHistoPedestal(iSec); - if ( hRefPed ) hRefPed->Add(hRefPedMerge); - else { - TH2F *hist = new TH2F(*hRefPedMerge); - hist->SetDirectory(0); - fHistoPedestalArray.AddAt(hist, iSec); - } - hRefPedMerge->SetDirectory(dir); - } - } + // + // return pointer to ROC with signal mean information + // if force is true create a new histogram if it doesn't exist allready + // + TObjArray *arr = &fCalRocArrayMean; + return GetCalRoc(sector, arr, force); } + //_____________________________________________________________________ -void AliTPCCalibPedestal::Analyse() /*FOLD00*/ +AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force) { - // - // Calculate calibration constants - // - - Int_t nbinsAdc = fAdcMax-fAdcMin; - - TVectorD param(3); - TMatrixD dummy(3,3); - - Float_t *array_hP=0; - - - for (Int_t iSec=0; iSec<72; ++iSec){ - TH2F *hP = GetHistoPedestal(iSec); - if ( !hP ) continue; + // + // 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); +} - AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE); - AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE); - array_hP = hP->GetArray(); - UInt_t nChannels = fROC->GetNChannels(iSec); +//_____________________________________________________________________ +void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal * const ped) +{ + // + // Merge reference histograms of sig to the current AliTPCCalibSignal + // + MergeBase(ped); + // merge histograms + for (Int_t iSec=0; iSec<72; ++iSec){ + TH2F *hRefPedMerge = ped->GetHistoPedestal(iSec); + + if ( hRefPedMerge ){ + TDirectory *dir = hRefPedMerge->GetDirectory(); hRefPedMerge->SetDirectory(0); + TH2F *hRefPed = GetHistoPedestal(iSec); + if ( hRefPed ) hRefPed->Add(hRefPedMerge); + else { + TH2F *hist = new TH2F(*hRefPedMerge); + hist->SetDirectory(0); + fHistoPedestalArray.AddAt(hist, iSec); + } + hRefPedMerge->SetDirectory(dir); + } + } + + // merge array + // ... + +} - for (UInt_t iChannel=0; iChannelSetValue(iChannel,param[1]); - rocRMS->SetValue(iChannel,param[2]); - } +//_____________________________________________________________________ +Long64_t AliTPCCalibPedestal::Merge(TCollection * const list) +{ + // + // Merge all objects of this type in list + // + + Long64_t nmerged=1; + + TIter next(list); + AliTPCCalibPedestal *ce=0; + TObject *o=0; + + while ( (o=next()) ){ + ce=dynamic_cast(o); + if (ce){ + Merge(ce); + ++nmerged; } + } + + return nmerged; } + //_____________________________________________________________________ -void AliTPCCalibPedestal::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/ +void AliTPCCalibPedestal::Analyse() { - // - // Write class to file - // + // + // Calculate calibration constants + // - TString sDir(dir); - TString option; + Int_t nbinsAdc = fAdcMax-fAdcMin; + + TVectorD param(4); + TMatrixD dummy(3,3); + + TH1F *hChannel=new TH1F("hChannel","hChannel",nbinsAdc,fAdcMin,fAdcMax); + + Float_t *arrayhP=0; + + for (Int_t iSec=0; iSec<72; ++iSec){ + TH2F *hP = GetHistoPedestal(iSec); + if ( !hP ) continue; + + AliTPCCalROC *rocPedestal = GetCalRocPedestal(iSec,kTRUE); + AliTPCCalROC *rocSigma = GetCalRocSigma(iSec,kTRUE); + AliTPCCalROC *rocMean = GetCalRocMean(iSec,kTRUE); + AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE); + + arrayhP = hP->GetArray(); + UInt_t nChannels = fROC->GetNChannels(iSec); + + for (UInt_t iChannel=0; iChannelfAdcMax ){ + param[1]=0; + param[2]=0; + } + rocPedestal->SetValue(iChannel,param[1]); + rocSigma->SetValue(iChannel,param[2]); + //calculate mean and RMS using a truncated means + hChannel->Set(nbinsAdc+2,arrayhP+offset-1); + hChannel->SetEntries(param[3]); + param[1]=0; + param[2]=0; + if ( param[3]>0 ) AliMathBase::TruncatedMean(hChannel,¶m,fAnaMeanDown,fAnaMeanUp); + rocMean->SetValue(iChannel,param[1]); + rocRMS->SetValue(iChannel,param[2]); + } + } + delete hChannel; +} - 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(); +//_____________________________________________________________________ +void AliTPCCalibPedestal::AnalyseTime(Int_t nevents) +{ + // + // Calculate for each channel and time bin the mean pedestal. This + // is used on LDC by TPCPEDESTALda to generate data used for configuration + // of the pattern memory for baseline subtraction in the ALTROs. + // - if ( backup ) backup->cd(); + if ( nevents <= 0 ) return; + if ( fTimeAnalysis ) { + for (Int_t i = 0; i < 159; i++) { // padrows + for (Int_t j = 0; j < 140; j++) { // pads per row + for (Int_t k = 0; k < 1024; k++) { // time bins per pad + fTimeSignal[i][j].AddAt(fTimeSignal[i][j].At(k)/(Float_t)nevents, k); + } + } + } + } }