fLastSector(-1),
fOldRCUformat(kTRUE),
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),
fLastSector(-1),
fOldRCUformat(kTRUE),
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),
//
fCalRocArrayT0.Delete();
+ fCalRocArrayT0Err.Delete();
fCalRocArrayQ.Delete();
fCalRocArrayRMS.Delete();
fCalRocArrayOutliers.Delete();
if ( fDebugStreamer) delete fDebugStreamer;
// if ( fHTime0 ) delete fHTime0;
- delete fROC;
+// delete fROC;
delete fParam;
}
//_____________________________________________________________________
// no extra analysis necessary. Assumes knowledge of the signal shape!
// assumes that it is looped over consecutive time bins of one pad
//
+
+ if (icRow<0) return 0;
+ if (icPad<0) return 0;
+ if (icTimeBin<0) return 0;
if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin) ) return 0;
Int_t iChannel = fROC->GetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector
//
// Find local maxima on the pad signal and Histogram them
//
- Float_t ceThreshold = 5.*fPadNoise; // threshold for the signal
+ Float_t ceThreshold = 5.*TMath::Max(fPadNoise,Float_t(1.)); // threshold for the signal
Int_t count = 0;
Int_t tminus = 2;
Int_t tplus = 3;
FindLocalMaxima(maxima);
if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return; // return because we don't have Time0 info for the CE yet
-
-
TVectorD param(3);
Float_t qSum;
FindCESignal(param, qSum, maxima);
time0Side[1]/=time0SideCount[1];
// end find time0 offset
+ Int_t nSecMeanT=0;
//loop over all ROCs, fill CE Time histogram corrected for the mean Time0 of each ROC
for ( Int_t iSec = 0; iSec<72; ++iSec ){
//find median and then calculate the mean around it
TH1S *hMeanT = GetHistoTmean(iSec); //histogram with local maxima position information
if ( !hMeanT ) continue;
+ //continue if not enough data is filled in the meanT histogram. This is the case if we do not have a laser event.
+ if ( hMeanT->GetEntries() < fROC->GetNChannels(iSec)*2/3 ){
+ hMeanT->Reset();
+ continue;
+ }
Double_t entries = hMeanT->GetEntries();
Double_t sum = 0;
Int_t ibin=0;
for ( ibin=0; ibin<hMeanT->GetNbinsX(); ++ibin){
sum+=arr[ibin];
- if ( sum>=(entries/2) ) break;
+ if ( sum>=(entries/2.) ) break;
}
Int_t delta = 4;
Int_t firstBin = fFirstTimeBin+ibin-delta;
vMeanTime->ResizeTo(vSize+100);
vMeanTime->GetMatrixArray()[fNevents]=median;
+ nSecMeanT++;
// end find median
-
+
TVectorF *vTimes = GetPadTimesEvent(iSec);
if ( !vTimes ) continue; //continue if no time information for this sector is available
}
//----------------------------- Debug end ------------------------------
}// end channel loop
- hMeanT->Reset();
TVectorD paramPol1(3);
TVectorD paramPol2(6);
GetParamArrayPol1(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol1), fNevents);
GetParamArrayPol2(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol2), fNevents);
}
-// printf("events: %d -- size: %d\n",fNevents,GetParamArrayPol1(iSec)->GetSize());
//------------------------------- Debug start ------------------------------
if ( fDebugLevel>0 ){
"\n";
}
//------------------------------- Debug end ------------------------------
+ hMeanT->Reset();
}// end sector loop
-
+ //return if no sector has a valid mean time
+ if ( nSecMeanT == 0 ) return;
+
+
// fTMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanTime),fNevents);
// fQMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanQ),fNevents);
if ( fVEventTime.GetNrows() < fNevents+1 ) {
Int_t isector = rawStreamFast->GetSector(); // current sector
Int_t iRow = rawStreamFast->GetRow(); // current row
Int_t iPad = rawStreamFast->GetPad(); // current pad
- Int_t startTbin = (Int_t)rawStreamFast->GetStartTimeBin();
- Int_t endTbin = (Int_t)rawStreamFast->GetEndTimeBin();
while ( rawStreamFast->NextBunch() ){
- for (Int_t iTimeBin = startTbin; iTimeBin < endTbin; iTimeBin++){
+ 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;
}
fEventId = *rawReader->GetEventId();
- AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader);
+ AliTPCRawStreamFast *rawStreamFast = new AliTPCRawStreamFast(rawReader, (AliAltroMapping**)fMapping);
Bool_t res=ProcessEventFast(rawStreamFast);
delete rawStreamFast;
return res;
//
- AliTPCRawStream rawStream(rawReader);
+ AliTPCRawStream rawStream(rawReader,(AliAltroMapping**)fMapping);
AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
if (eventHeader){
fTimeStamp = eventHeader->Get("Timestamp");
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!
+ // new histogram with calib information. One value for each pad!
TH1S* hist = new TH1S(name,title,
fLastTimeBin-fFirstTimeBin,fFirstTimeBin,fLastTimeBin);
hist->SetDirectory(0);
AliTPCCalROC* AliTPCCalibCE::GetCalRocT0(Int_t sector, Bool_t force)
{
//
- // return pointer to Carge ROC Calibration
+ // return pointer to Time 0 ROC Calibration
// if force is true create a new histogram if it doesn't exist allready
//
TObjArray *arr = &fCalRocArrayT0;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
+AliTPCCalROC* AliTPCCalibCE::GetCalRocT0Err(Int_t sector, Bool_t force)
+{
+ //
+ // return pointer to the error of Time 0 ROC Calibration
+ // if force is true create a new histogram if it doesn't exist allready
+ //
+ TObjArray *arr = &fCalRocArrayT0Err;
+ return GetCalRoc(sector, arr, force);
+}
+//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocQ(Int_t sector, Bool_t force)
{
//
arrPol2->Expand(fNevents+nCEevents);
}
if ( vMeanTimeCE && vMeanQCE ){
- vMeanTime = GetTMeanEvents(iSec);
- vMeanQCE = GetQMeanEvents(iSec);
+ vMeanTime = GetTMeanEvents(iSec,kTRUE);
+ vMeanQ = GetQMeanEvents(iSec,kTRUE);
vMeanTime->ResizeTo(fNevents+nCEevents);
vMeanQ->ResizeTo(fNevents+nCEevents);
}
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 *rocRMS = GetCalRocRMS(iSec,kTRUE);
- AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE);
+ 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);
Float_t cogTime0 = -1000;
Float_t cogQ = -1000;
Float_t cogRMS = -1000;
- Float_t cogOut = 0;
+ Float_t cogOut = 0;
+ Float_t rms = 0;
+ Float_t rmsT0 = 0;
Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
- cogQ = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ);
- cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0);
- cogRMS = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS);
-
-
+ cogQ = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ,&rms);
+ fMeanQrms+=rms;
+ cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0,&rmsT0);
+ fMeanT0rms+=rmsT0;
+ cogRMS = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS,&rms);
+ fMeanRMSrms+=rms;
+ channelCounter++;
/*
//outlier specifications
*/
rocQ->SetValue(iChannel, cogQ*cogQ);
rocT0->SetValue(iChannel, cogTime0);
+ rocT0Err->SetValue(iChannel, rmsT0);
rocRMS->SetValue(iChannel, cogRMS);
rocOut->SetValue(iChannel, cogOut);
}
}
+ if ( channelCounter>0 ){
+ fMeanT0rms/=channelCounter;
+ fMeanQrms/=channelCounter;
+ fMeanRMSrms/=channelCounter;
+ }
if ( fDebugStreamer ) fDebugStreamer->GetFile()->Write();
// delete fDebugStreamer;
// fDebugStreamer = 0x0;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff