}
//_____________________________________________________________________________
-void AliTRDclusterizer::Copy(const TObject &c) const
+void AliTRDclusterizer::Copy(TObject &c) const
{
//
// Copy function
// ResetRecPoints();
//}
- // No compress just remove
- fDigitsManager->RemoveDigits(i);
- fDigitsManager->RemoveDictionaries(i);
- fDigitsManager->ClearIndexes(i);
+ // Clear arrays of this chamber, to prepare for next event
+ fDigitsManager->ClearArrays(i);
}
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
else
fRawStream->SetReader(rawReader);
- if(fReconstructor->IsHLT())
+ SetBit(kHLT, fReconstructor->IsHLT());
+
+ if(TestBit(kHLT)){
fRawStream->SetSharedPadReadout(kFALSE);
+ fRawStream->SetNoErrorWarning();
+ }
- AliInfo(Form("Stream version: %s", fRawStream->IsA()->GetName()));
+ AliDebug(1,Form("Stream version: %s", fRawStream->IsA()->GetName()));
Int_t det = 0;
while ((det = fRawStream->NextChamber(fDigitsManager,fTrackletContainer)) >= 0){
- Bool_t iclusterBranch = kFALSE;
- if (fDigitsManager->GetIndexes(det)->HasEntry()){
- iclusterBranch = MakeClusters(det);
- }
+ if (fDigitsManager->GetIndexes(det)->HasEntry())
+ MakeClusters(det);
fDigitsManager->ClearArrays(det);
if(!TestBit(knewDM)){
delete fDigitsManager;
fDigitsManager = NULL;
+ delete fRawStream;
+ fRawStream = NULL;
}
AliInfo(Form("Number of found clusters : %d", fNoOfClusters));
// Get the digits
fDigits = (AliTRDarrayADC *) fDigitsManager->GetDigits(det); //mod
- fBaseline = fDigitsManager->GetDigitsParam()->GetADCbaseline();
+ fBaseline = fDigitsManager->GetDigitsParam()->GetADCbaseline(det);
// This is to take care of switched off super modules
if (!fDigits->HasData()) return kFALSE;
return kFALSE;
}
- AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
+ AliTRDcalibDB* const calibration = AliTRDcalibDB::Instance();
if (!calibration) {
AliFatal("No AliTRDcalibDB instance available\n");
return kFALSE;
return kFALSE;
}
+ const AliTRDrecoParam *const recoParam = fReconstructor->GetRecoParam();
- fMaxThresh = fReconstructor->GetRecoParam()->GetClusMaxThresh();
- fSigThresh = fReconstructor->GetRecoParam()->GetClusSigThresh();
- fMinMaxCutSigma = fReconstructor->GetRecoParam()->GetMinMaxCutSigma();
- fMinLeftRightCutSigma = fReconstructor->GetRecoParam()->GetMinLeftRightCutSigma();
+ fMaxThresh = recoParam->GetClusMaxThresh();
+ fSigThresh = recoParam->GetClusSigThresh();
+ fMinMaxCutSigma = recoParam->GetMinMaxCutSigma();
+ fMinLeftRightCutSigma = recoParam->GetMinLeftRightCutSigma();
Int_t istack = fIndexes->GetStack();
fLayer = fIndexes->GetLayer();
AddTrackletsToArray();
fColMax = fDigits->GetNcol();
- //Int_t nRowMax = fDigits->GetNrow();
- fTimeTotal = fDigits->GetNtime();
+ fTimeTotal = fDigitsManager->GetDigitsParam()->GetNTimeBins(det);
+
+ // Check consistency between OCDB and raw data
+ Int_t nTimeOCDB = calibration->GetNumberOfTimeBinsDCS();
+ if(TestBit(kHLT)){
+ if((nTimeOCDB > -1) && (fTimeTotal != nTimeOCDB)){
+ AliWarning(Form("Number of timebins does not match OCDB value (RAW[%d] OCDB[%d]), using raw value"
+ ,fTimeTotal,nTimeOCDB));
+ }
+ }else{
+ if(nTimeOCDB == -1){
+ AliWarning("Undefined number of timebins in OCDB, using value from raw data.");
+ if(!fTimeTotal>0){
+ AliError("Number of timebins in raw data is negative, skipping chamber!");
+ return kFALSE;
+ }
+ }else if(nTimeOCDB == -2){
+ AliError("Mixed number of timebins in OCDB, no reconstruction of TRD data!");
+ return kFALSE;
+ }else if(fTimeTotal != nTimeOCDB){
+ AliError(Form("Number of timebins in raw data does not match OCDB value (RAW[%d] OCDB[%d]), skipping chamber!"
+ ,fTimeTotal,nTimeOCDB));
+ return kFALSE;
+ }
+ }
// Detector wise calibration object for the gain factors
const AliTRDCalDet *calGainFactorDet = calibration->GetGainFactorDet();
// Calibration object with the pad status
fCalPadStatusROC = calibration->GetPadStatusROC(fDet);
- SetBit(kLUT, fReconstructor->GetRecoParam()->UseLUT());
- SetBit(kGAUS, fReconstructor->GetRecoParam()->UseGAUS());
- SetBit(kHLT, fReconstructor->IsHLT());
-
firstClusterROC = -1;
fClusterROC = 0;
+ SetBit(kLUT, recoParam->UseLUT());
+ SetBit(kGAUS, recoParam->UseGAUS());
+
// Apply the gain and the tail cancelation via digital filter
- if(fReconstructor->GetRecoParam()->UseTailCancelation()) TailCancelation();
+ if(recoParam->UseTailCancelation()) TailCancelation(recoParam);
MaxStruct curr, last;
Int_t nMaximas = 0, nCorrupted = 0;
}
if(last.row>-1) CreateCluster(last);
- if(fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 2 && fReconstructor->IsDebugStreaming()){
+ if(recoParam->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 2 && fReconstructor->IsDebugStreaming()){
TTreeSRedirector* fDebugStream = fReconstructor->GetDebugStream(AliTRDrecoParam::kClusterizer);
(*fDebugStream) << "MakeClusters"
<< "Detector=" << det
}
//_____________________________________________________________________________
-void AliTRDclusterizer::TailCancelation()
+void AliTRDclusterizer::TailCancelation(const AliTRDrecoParam* const recoParam)
{
//
- // Applies the tail cancelation and gain factors:
- // Transform fDigits to fDigits
+ // Applies the tail cancelation
//
Int_t iRow = 0;
Int_t iCol = 0;
Int_t iTime = 0;
- Double_t *inADC = new Double_t[fTimeTotal]; // ADC data before tail cancellation
- Double_t *outADC = new Double_t[fTimeTotal]; // ADC data after tail cancellation
+ Float_t *arr = new Float_t[fTimeTotal]; // temp array containing the ADC signals
TTreeSRedirector *fDebugStream = fReconstructor->GetDebugStream(AliTRDrecoParam::kClusterizer);
- Bool_t debugStreaming = fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 7 && fReconstructor->IsDebugStreaming();
+ Bool_t debugStreaming = recoParam->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 7 && fReconstructor->IsDebugStreaming();
+ Int_t nexp = recoParam->GetTCnexp();
while(fIndexes->NextRCIndex(iRow, iCol))
{
- Bool_t corrupted = kFALSE;
- if (fCalPadStatusROC->GetStatus(iCol, iRow)) corrupted = kTRUE;
+ // if corrupted then don't make the tail cancallation
+ if (fCalPadStatusROC->GetStatus(iCol, iRow)) continue;
// Save data into the temporary processing array and substract the baseline,
// since DeConvExp does not expect a baseline
for (iTime = 0; iTime < fTimeTotal; iTime++)
- inADC[iTime] = fDigits->GetData(iRow,iCol,iTime)-fBaseline;
+ arr[iTime] = fDigits->GetData(iRow,iCol,iTime)-fBaseline;
if(debugStreaming){
for (iTime = 0; iTime < fTimeTotal; iTime++)
<< "col=" << iCol
<< "row=" << iRow
<< "time=" << iTime
- << "inADC=" << inADC[iTime]
- << "outADC=" << outADC[iTime]
- << "corrupted=" << corrupted
+ << "arr=" << arr[iTime]
<< "\n";
}
- if (!corrupted)
- {
- // Apply the tail cancelation via the digital filter
- // (only for non-coorupted pads)
- DeConvExp(&inADC[0],&outADC[0],fTimeTotal,fReconstructor->GetRecoParam() ->GetTCnexp());
- }
- else memcpy(&outADC[0],&inADC[0],fTimeTotal*sizeof(inADC[0]));
+ // Apply the tail cancelation via the digital filter
+ DeConvExp(arr,fTimeTotal,nexp);
// Save tailcancalled data and add the baseline
for(iTime = 0; iTime < fTimeTotal; iTime++)
- fDigits->SetData(iRow,iCol,iTime,(Short_t)(outADC[iTime] + fBaseline + 0.5));
+ fDigits->SetData(iRow,iCol,iTime,(Short_t)(arr[iTime] + fBaseline + 0.5f));
} // while irow icol
- delete [] inADC;
- delete [] outADC;
+ delete [] arr;
return;
}
//_____________________________________________________________________________
-void AliTRDclusterizer::DeConvExp(const Double_t *const source, Double_t *const target
- ,const Int_t n, const Int_t nexp)
+void AliTRDclusterizer::DeConvExp(Float_t *const arr, const Int_t nTime, const Int_t nexp)
{
//
// Tail cancellation by deconvolution for PASA v4 TRF
//
- Double_t rates[2];
- Double_t coefficients[2];
+ Float_t rates[2];
+ Float_t coefficients[2];
// Initialization (coefficient = alpha, rates = lambda)
- Double_t r1 = 1.0;
- Double_t r2 = 1.0;
- Double_t c1 = 0.5;
- Double_t c2 = 0.5;
+ Float_t r1 = 1.0;
+ Float_t r2 = 1.0;
+ Float_t c1 = 0.5;
+ Float_t c2 = 0.5;
if (nexp == 1) { // 1 Exponentials
r1 = 1.156;
Int_t i = 0;
Int_t k = 0;
- Double_t reminder[2];
- Double_t correction = 0.0;
- Double_t result = 0.0;
+ Float_t reminder[2];
+ Float_t correction = 0.0;
+ Float_t result = 0.0;
// Attention: computation order is important
for (k = 0; k < nexp; k++) {
reminder[k] = 0.0;
}
- for (i = 0; i < n; i++) {
+ for (i = 0; i < nTime; i++) {
- result = (source[i] - correction); // No rescaling
- target[i] = result;
+ result = (arr[i] - correction); // No rescaling
+ arr[i] = result;
for (k = 0; k < nexp; k++) {
reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
//
if (fRecPoints) {
- fRecPoints->Delete();
- delete fRecPoints;
+ fRecPoints->Clear();
+ fNoOfClusters = 0;
+ // delete fRecPoints;
}
}