,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
((AliTRDclusterizer &) c).fDigits = NULL;
((AliTRDclusterizer &) c).fIndexes = NULL;
((AliTRDclusterizer &) c).fMaxThresh = 0;
+ ((AliTRDclusterizer &) c).fMaxThreshTest = 0;
((AliTRDclusterizer &) c).fSigThresh = 0;
((AliTRDclusterizer &) c).fMinMaxCutSigma= 0;
((AliTRDclusterizer &) c).fMinLeftRightCutSigma = 0;
return kTRUE;
}
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizer::OpenTrackletOutput()
-{
- //
- // Tracklet writing
- //
-
- if (fReconstructor->IsWritingTracklets()){
- TString evfoldname = AliConfig::GetDefaultEventFolderName();
- fRunLoader = AliRunLoader::GetRunLoader(evfoldname);
-
- if (!fRunLoader) {
- fRunLoader = AliRunLoader::Open("galice.root");
- }
- if (!fRunLoader) {
- AliError(Form("Can not open session for file galice.root."));
- return kFALSE;
- }
-
- UInt_t **leaves = new UInt_t *[2];
- AliDataLoader *dl = fRunLoader->GetLoader("TRDLoader")->GetDataLoader("tracklets");
- if (!dl) {
- AliError("Could not get the tracklets data loader!");
- dl = new AliDataLoader("TRD.Tracklets.root","tracklets", "tracklets");
- fRunLoader->GetLoader("TRDLoader")->AddDataLoader(dl);
- }
- fTrackletTree = dl->Tree();
- if (!fTrackletTree)
- {
- dl->MakeTree();
- fTrackletTree = dl->Tree();
- }
- TBranch *trkbranch = fTrackletTree->GetBranch("trkbranch");
- if (!trkbranch)
- fTrackletTree->Branch("trkbranch",leaves[0],"det/i:side/i:tracklets[256]/i");
- }
-
- return kTRUE;
-}
-
//_____________________________________________________________________________
Bool_t AliTRDclusterizer::OpenInput(Int_t nEvent)
{
ioArray->AddLast(c);
}
fClusterTree->Fill();
+ ioArray->Clear();
} else {
-
- Int_t detOld = -1;
+ Int_t detOld = -1, nw(0);
for (Int_t i = 0; i < nRecPoints; i++) {
AliTRDcluster *c = (AliTRDcluster *) RecPoints()->UncheckedAt(i);
if(c->GetDetector() != detOld){
+ nw += ioArray->GetEntriesFast();
fClusterTree->Fill();
ioArray->Clear();
detOld = c->GetDetector();
}
ioArray->AddLast(c);
}
+ if(ioArray->GetEntriesFast()){
+ nw += ioArray->GetEntriesFast();
+ fClusterTree->Fill();
+ ioArray->Clear();
+ }
+ AliDebug(2, Form("Clusters FOUND[%d] WRITTEN[%d] STATUS[%s]", nRecPoints, nw, nw==nRecPoints?"OK":"FAILED"));
}
delete ioArray;
return kTRUE;
-
}
//_____________________________________________________________________________
}
}
- AliDataLoader *dl = fRunLoader->GetLoader("TRDLoader")->GetDataLoader("tracklets");
- dl->WriteData("OVERWRITE");
+// AliDataLoader *dl = fRunLoader->GetLoader("TRDLoader")->GetDataLoader("tracklets"); //jkl: wrong here
+// dl->WriteData("OVERWRITE"); //jkl: wrong here
//dl->Unload();
delete [] leaves;
// 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);
fDigitsManager->SetUseDictionaries(TestBit(kLabels));
+ // ----- preparing tracklet output -----
+ if (fReconstructor->IsWritingTracklets()) {
+ AliDataLoader *trklLoader = AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets");
+ if (!trklLoader) {
+ AliError("Could not get the tracklets data loader, adding it now!");
+ trklLoader = new AliDataLoader("TRD.Tracklets.root","tracklets", "tracklets");
+ AliRunLoader::Instance()->GetLoader("TRDLoader")->AddDataLoader(trklLoader);
+ }
+ if (!trklLoader->Tree())
+ AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets")->MakeTree();
+ }
+
// tracklet container for raw tracklet writing
if (!fTrackletContainer && ( fReconstructor->IsWritingTracklets() || fReconstructor->IsProcessingTracklets() )) {
// maximum tracklets for one HC
fTrackletContainer = new UInt_t *[2];
fTrackletContainer[0] = new UInt_t[kTrackletChmb];
fTrackletContainer[1] = new UInt_t[kTrackletChmb];
+ memset(fTrackletContainer[0], 0, kTrackletChmb*sizeof(UInt_t)); //jkl
+ memset(fTrackletContainer[1], 0, kTrackletChmb*sizeof(UInt_t)); //jkl
}
if(!fRawStream)
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 (*(fTrackletContainer[0]) > 0 || *(fTrackletContainer[1]) > 0) WriteTracklets(det);
}
+ if (fReconstructor->IsWritingTracklets()) {
+ if (AliDataLoader *trklLoader = AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets")) {
+ trklLoader->WriteData("OVERWRITE");
+ trklLoader->Unload();
+ }
+ }
+
if (fTrackletContainer){
delete [] fTrackletContainer[0];
delete [] fTrackletContainer[1];
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;
}
- fMaxThresh = fReconstructor->GetRecoParam()->GetClusMaxThresh();
- fSigThresh = fReconstructor->GetRecoParam()->GetClusSigThresh();
- fMinMaxCutSigma = fReconstructor->GetRecoParam()->GetMinMaxCutSigma();
- fMinLeftRightCutSigma = fReconstructor->GetRecoParam()->GetMinLeftRightCutSigma();
+ const AliTRDrecoParam *const recoParam = fReconstructor->GetRecoParam();
+
+ fMaxThresh = (Short_t)recoParam->GetClusMaxThresh();
+ fMaxThreshTest = (Short_t)(recoParam->GetClusMaxThresh()/2+fBaseline);
+ fSigThresh = (Short_t)recoParam->GetClusSigThresh();
+ fMinMaxCutSigma = recoParam->GetMinMaxCutSigma();
+ fMinLeftRightCutSigma = recoParam->GetMinLeftRightCutSigma();
Int_t istack = fIndexes->GetStack();
fLayer = fIndexes->GetLayer();
return kFALSE;
}
+ AliDebug(2, Form("Det[%d] @ Sec[%d] Stk[%d] Ly[%d]", fDet, isector, istack, fLayer));
+
// TRD space point transformation
fTransform->SetDetector(det);
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;
for(curr.time = 0; curr.time < fTimeTotal; curr.time++){
while(fIndexes->NextRCIndex(curr.row, curr.col)){
- if(IsMaximum(curr, curr.padStatus, &curr.signals[0])){
+ if(fDigits->GetData(curr.row, curr.col, curr.time) > fMaxThreshTest && IsMaximum(curr, curr.padStatus, &curr.signals[0])){
if(last.row>-1){
if(curr.time==last.time && curr.row==last.row && curr.col==last.col+2) FivePadCluster(last, curr);
CreateCluster(last);
}
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
Float_t gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col,Max.row);
Signals[1] = (Short_t)((fDigits->GetData(Max.row, Max.col, Max.time) - fBaseline) / gain + 0.5f);
- if(Signals[1] < fMaxThresh) return kFALSE;
+ if(Signals[1] <= fMaxThresh) return kFALSE;
- Float_t noiseMiddleThresh = fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row);
- if (Signals[1] < noiseMiddleThresh) return kFALSE;
+ Short_t noiseMiddleThresh = (Short_t)(fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row));
+ if (Signals[1] <= noiseMiddleThresh) return kFALSE;
if (Max.col + 1 >= fColMax || Max.col < 1) return kFALSE;
if(!(status[0] | status[1] | status[2])) {//all pads are good
if ((Signals[2] <= Signals[1]) && (Signals[0] < Signals[1])) {
- if ((Signals[2] >= fSigThresh) || (Signals[0] >= fSigThresh)) {
+ if ((Signals[2] > fSigThresh) || (Signals[0] > fSigThresh)) {
if(Signals[0]<0)Signals[0]=0;
if(Signals[2]<0)Signals[2]=0;
- Float_t noiseSumThresh = fMinLeftRightCutSigma
- * fCalNoiseDetValue
- * fCalNoiseROC->GetValue(Max.col, Max.row);
- if ((Signals[2]+Signals[0]+Signals[1]) < noiseSumThresh) return kFALSE;
+ Short_t noiseSumThresh = (Short_t)(fMinLeftRightCutSigma * fCalNoiseDetValue
+ * fCalNoiseROC->GetValue(Max.col, Max.row));
+ if ((Signals[2]+Signals[0]+Signals[1]) <= noiseSumThresh) return kFALSE;
padStatus = 0;
return kTRUE;
}
} else { // at least one of the pads is bad, and reject candidates with more than 1 problematic pad
if(Signals[0]<0)Signals[0]=0;
if(Signals[2]<0)Signals[2]=0;
- if (status[2] && (!(status[0] || status[1])) && Signals[1] > Signals[0] && Signals[0] >= fSigThresh) {
+ if (status[2] && (!(status[0] || status[1])) && Signals[1] > Signals[0] && Signals[0] > fSigThresh) {
Signals[2]=0;
SetPadStatus(status[2], padStatus);
return kTRUE;
}
- else if (status[0] && (!(status[1] || status[2])) && Signals[1] >= Signals[2] && Signals[2] >= fSigThresh) {
+ else if (status[0] && (!(status[1] || status[2])) && Signals[1] >= Signals[2] && Signals[2] > fSigThresh) {
Signals[0]=0;
SetPadStatus(status[0], padStatus);
return kTRUE;
}
- else if (status[1] && (!(status[0] || status[2])) && ((Signals[2] >= fSigThresh) || (Signals[0] >= fSigThresh))) {
- Signals[1] = (Short_t)(fMaxThresh + 0.5f);
+ else if (status[1] && (!(status[0] || status[2])) && ((Signals[2] > fSigThresh) || (Signals[0] > fSigThresh))) {
+ Signals[1] = fMaxThresh;
SetPadStatus(status[1], padStatus);
return kTRUE;
}
}
//_____________________________________________________________________________
-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
-
- fIndexes->ResetCounters();
TTreeSRedirector *fDebugStream = fReconstructor->GetDebugStream(AliTRDrecoParam::kClusterizer);
+ 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;
-
- for (iTime = 0; iTime < fTimeTotal; iTime++)
- inADC[iTime] = fDigits->GetData(iRow,iCol,iTime);
-
- for (iTime = 0; iTime < fTimeTotal; iTime++)
- if(fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 7 && fReconstructor->IsDebugStreaming()){
- (*fDebugStream) << "TailCancellation"
- << "col=" << iCol
- << "row=" << iRow
- << "time=" << iTime
- << "inADC=" << inADC[iTime]
- << "outADC=" << outADC[iTime]
- << "corrupted=" << corrupted
- << "\n";
- }
+ // if corrupted then don't make the tail cancallation
+ if (fCalPadStatusROC->GetStatus(iCol, iRow)) continue;
+
+ if(debugStreaming){
+ for (iTime = 0; iTime < fTimeTotal; iTime++)
+ (*fDebugStream) << "TailCancellation"
+ << "col=" << iCol
+ << "row=" << iRow
+ << "\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]));
-
- for(iTime = 0; iTime < fTimeTotal; iTime++)
- fDigits->SetData(iRow,iCol,iTime,TMath::Nint(outADC[iTime]));
+ // Apply the tail cancelation via the digital filter
+ DeConvExp(fDigits->GetDataAddress(iRow,iCol),fTimeTotal,nexp);
} // while irow icol
- delete [] inADC;
- delete [] outADC;
-
return;
}
//_____________________________________________________________________________
-void AliTRDclusterizer::DeConvExp(const Double_t *const source, Double_t *const target
- ,const Int_t n, const Int_t nexp)
+void AliTRDclusterizer::DeConvExp(Short_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 - fBaseline; // No rescaling
+ arr[i] = (Short_t)(result + fBaseline + 0.5f);
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;
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff