#include "AliRunLoader.h"
#include "AliLoader.h"
+#include "AliTreeLoader.h"
#include "AliAlignObj.h"
#include "AliTRDclusterizer.h"
#include "AliTRDcalibDB.h"
#include "AliTRDtransform.h"
#include "AliTRDSignalIndex.h"
-#include "AliTRDrawStreamBase.h"
+#include "AliTRDrawStream.h"
#include "AliTRDfeeParam.h"
#include "AliTRDtrackletWord.h"
+#include "AliTRDtrackletMCM.h"
+#include "AliTRDtrackGTU.h"
+#include "AliESDTrdTrack.h"
#include "TTreeStream.h"
#include "Cal/AliTRDCalROC.h"
#include "Cal/AliTRDCalDet.h"
#include "Cal/AliTRDCalSingleChamberStatus.h"
+#include "Cal/AliTRDCalOnlineGainTableROC.h"
ClassImp(AliTRDclusterizer)
,fClusterTree(NULL)
,fRecPoints(NULL)
,fTracklets(NULL)
+ ,fTracks(NULL)
,fTrackletTree(NULL)
,fDigitsManager(new AliTRDdigitsManager())
,fTrackletContainer(NULL)
,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
SetBit(kLabels, kTRUE);
SetBit(knewDM, kFALSE);
- AliTRDcalibDB *trd = 0x0;
- if (!(trd = AliTRDcalibDB::Instance())) {
- AliFatal("Could not get calibration object");
- }
-
fRawVersion = AliTRDfeeParam::Instance()->GetRAWversion();
// Initialize debug stream
}
//_____________________________________________________________________________
-AliTRDclusterizer::AliTRDclusterizer(const Text_t *name, const Text_t *title, const AliTRDReconstructor *const rec)
+AliTRDclusterizer::AliTRDclusterizer(const Text_t *name
+ , const Text_t *title
+ , const AliTRDReconstructor *const rec)
:TNamed(name,title)
,fReconstructor(rec)
,fRunLoader(NULL)
,fClusterTree(NULL)
,fRecPoints(NULL)
,fTracklets(NULL)
+ ,fTracks(NULL)
,fTrackletTree(NULL)
,fDigitsManager(new AliTRDdigitsManager())
,fTrackletContainer(NULL)
,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
SetBit(kLabels, kTRUE);
SetBit(knewDM, kFALSE);
- AliTRDcalibDB *trd = 0x0;
- if (!(trd = AliTRDcalibDB::Instance())) {
- AliFatal("Could not get calibration object");
- }
-
fDigitsManager->CreateArrays();
fRawVersion = AliTRDfeeParam::Instance()->GetRAWversion();
,fClusterTree(NULL)
,fRecPoints(NULL)
,fTracklets(NULL)
+ ,fTracks(NULL)
,fTrackletTree(NULL)
,fDigitsManager(NULL)
,fTrackletContainer(NULL)
,fDigits(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
+ ,fMaxThreshTest(0)
,fSigThresh(0)
,fMinMaxCutSigma(0)
,fMinLeftRightCutSigma(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
delete fTracklets;
}
+ if (fTracks){
+ fTracks->Delete();
+ delete fTracks;
+ }
+
if (fDigitsManager) {
delete fDigitsManager;
fDigitsManager = NULL;
}
- if (fTrackletContainer){
- delete [] fTrackletContainer[0];
- delete [] fTrackletContainer[1];
- delete [] fTrackletContainer;
- fTrackletContainer = NULL;
- }
-
if (fTransform){
delete fTransform;
fTransform = NULL;
((AliTRDclusterizer &) c).fRecPoints = NULL;
((AliTRDclusterizer &) c).fTrackletTree = NULL;
((AliTRDclusterizer &) c).fDigitsManager = NULL;
- ((AliTRDclusterizer &) c).fTrackletContainer = NULL;
((AliTRDclusterizer &) c).fRawVersion = fRawVersion;
((AliTRDclusterizer &) c).fTransform = NULL;
((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)
{
TObjArray *ioArray = new TObjArray(400);
TBranch *branch = fClusterTree->GetBranch("TRDcluster");
if (!branch) {
- branch = fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
+ fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
} else branch->SetAddress(&ioArray);
Int_t nRecPoints = RecPoints()->GetEntriesFast();
return kTRUE;
}
-//_____________________________________________________________________________
-Bool_t AliTRDclusterizer::WriteTracklets(Int_t det)
-{
- //
- // Write the raw data tracklets into seperate file
- //
-
- UInt_t **leaves = new UInt_t *[2];
- for (Int_t i=0; i<2 ;i++){
- leaves[i] = new UInt_t[258];
- leaves[i][0] = det; // det
- leaves[i][1] = i; // side
- memcpy(leaves[i]+2, fTrackletContainer[i], sizeof(UInt_t) * 256);
- }
-
- if (!fTrackletTree){
- AliDataLoader *dl = fRunLoader->GetLoader("TRDLoader")->GetDataLoader("tracklets");
- dl->MakeTree();
- fTrackletTree = dl->Tree();
- }
-
- TBranch *trkbranch = fTrackletTree->GetBranch("trkbranch");
- if (!trkbranch) {
- trkbranch = fTrackletTree->Branch("trkbranch",leaves[0],"det/i:side/i:tracklets[256]/i");
- }
-
- for (Int_t i=0; i<2; i++){
- if (leaves[i][2]>0) {
- trkbranch->SetAddress(leaves[i]);
- fTrackletTree->Fill();
- }
- }
-
- AliDataLoader *dl = fRunLoader->GetLoader("TRDLoader")->GetDataLoader("tracklets");
- dl->WriteData("OVERWRITE");
- //dl->Unload();
- delete [] leaves;
-
- return kTRUE;
-
-}
-
//_____________________________________________________________________________
Bool_t AliTRDclusterizer::ReadDigits()
{
}
+Bool_t AliTRDclusterizer::ReadTracklets()
+{
+ //
+ // Reads simulated tracklets from the input aliroot file
+ //
+
+ AliRunLoader *runLoader = AliRunLoader::Instance();
+ if (!runLoader) {
+ AliError("No run loader available");
+ return kFALSE;
+ }
+
+ AliLoader* loader = runLoader->GetLoader("TRDLoader");
+
+ AliDataLoader *trackletLoader = loader->GetDataLoader("tracklets");
+ if (!trackletLoader) {
+ return kFALSE;
+ }
+
+ // simulated tracklets
+ trackletLoader->Load();
+ TTree *trackletTree = trackletLoader->Tree();
+
+ if (trackletTree) {
+ TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
+ TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
+ if (trklbranch && trklArray) {
+ AliTRDtrackletMCM *trkl = 0x0;
+ trklbranch->SetAddress(&trkl);
+ for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
+ trklbranch->GetEntry(iTracklet);
+ new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
+ }
+ return kTRUE;
+ }
+ }
+ return kFALSE;
+}
+
+Bool_t AliTRDclusterizer::ReadTracks()
+{
+ //
+ // Reads simulated GTU tracks from the input aliroot file
+ //
+
+ AliRunLoader *runLoader = AliRunLoader::Instance();
+
+ if (!runLoader) {
+ AliError("No run loader available");
+ return kFALSE;
+ }
+
+ AliLoader* loader = runLoader->GetLoader("TRDLoader");
+ if (!loader) {
+ return kFALSE;
+ }
+
+ AliDataLoader *trackLoader = loader->GetDataLoader("gtutracks");
+ if (!trackLoader) {
+ return kFALSE;
+ }
+
+ trackLoader->Load();
+
+ TTree *trackTree = trackLoader->Tree();
+ if (!trackTree) {
+ return kFALSE;
+ }
+
+ TClonesArray *trackArray = TracksArray();
+ AliTRDtrackGTU *trk = 0x0;
+ trackTree->SetBranchAddress("TRDtrackGTU", &trk);
+ for (Int_t iTrack = 0; iTrack < trackTree->GetEntries(); iTrack++) {
+ trackTree->GetEntry(iTrack);
+ new ((*trackArray)[trackArray->GetEntries()]) AliESDTrdTrack(*(trk->CreateTrdTrack()));
+ }
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
Bool_t AliTRDclusterizer::MakeClusters()
{
// 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);
}
- fReconstructor->SetDigitsParam(fDigitsManager->GetDigitsParam());
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
fDigitsManager->SetUseDictionaries(TestBit(kLabels));
- // tracklet container for raw tracklet writing
- if (!fTrackletContainer && ( fReconstructor->IsWritingTracklets() || fReconstructor->IsProcessingTracklets() )) {
- // maximum tracklets for one HC
- const Int_t kTrackletChmb=256;
- fTrackletContainer = new UInt_t *[2];
- fTrackletContainer[0] = new UInt_t[kTrackletChmb];
- fTrackletContainer[1] = new UInt_t[kTrackletChmb];
+ // ----- preparing tracklet output -----
+ if (fReconstructor->IsWritingTracklets()) {
+ AliDataLoader *trklLoader = AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets");
+ if (!trklLoader) {
+ //AliInfo("Could not get the tracklets data loader, adding it now!");
+ trklLoader = new AliDataLoader("TRD.Tracklets.root","tracklets", "tracklets");
+ AliRunLoader::Instance()->GetLoader("TRDLoader")->AddDataLoader(trklLoader);
+ }
+ AliTreeLoader *trklTreeLoader = dynamic_cast<AliTreeLoader*> (trklLoader->GetBaseLoader("tracklets-raw"));
+ if (!trklTreeLoader) {
+ trklTreeLoader = new AliTreeLoader("tracklets-raw", trklLoader);
+ trklLoader->AddBaseLoader(trklTreeLoader);
+ }
+ if (!trklTreeLoader->Tree())
+ trklTreeLoader->MakeTree();
}
if(!fRawStream)
- fRawStream = AliTRDrawStreamBase::GetRawStream(rawReader);
+ fRawStream = new AliTRDrawStream(rawReader);
else
fRawStream->SetReader(rawReader);
- if(fReconstructor->IsHLT()){
- fRawStream->SetSharedPadReadout(kFALSE);
- fRawStream->SetNoErrorWarning();
- }
+ //if(fReconstructor->IsHLT()){
+ fRawStream->DisableErrorStorage();
+ //}
- AliDebug(1,Form("Stream version: %s", fRawStream->IsA()->GetName()));
-
- Int_t det = 0;
- while ((det = fRawStream->NextChamber(fDigitsManager,fTrackletContainer)) >= 0){
- Bool_t iclusterBranch = kFALSE;
+ // register tracklet array for output
+ fRawStream->SetTrackletArray(TrackletsArray("AliTRDtrackletMCM"));
+ fRawStream->SetTrackArray(TracksArray());
+
+ UInt_t det = 0;
+ while ((det = fRawStream->NextChamber(fDigitsManager)) < AliTRDgeometry::kNdet){
if (fDigitsManager->GetIndexes(det)->HasEntry()){
- iclusterBranch = MakeClusters(det);
+ MakeClusters(det);
+ fDigitsManager->ClearArrays(det);
}
-
- fDigitsManager->ClearArrays(det);
-
- if (!fReconstructor->IsWritingTracklets()) continue;
- if (*(fTrackletContainer[0]) > 0 || *(fTrackletContainer[1]) > 0) WriteTracklets(det);
}
- fReconstructor->SetDigitsParam(fDigitsManager->GetDigitsParam());
-
- if (fTrackletContainer){
- delete [] fTrackletContainer[0];
- delete [] fTrackletContainer[1];
- delete [] fTrackletContainer;
- fTrackletContainer = NULL;
+
+ if (fReconstructor->IsWritingTracklets()) {
+ if (AliDataLoader *trklLoader = AliRunLoader::Instance()->GetLoader("TRDLoader")->GetDataLoader("tracklets")) {
+ if (trklLoader) {
+ if (AliTreeLoader *trklTreeLoader = (AliTreeLoader*) trklLoader->GetBaseLoader("tracklets-raw"))
+ trklTreeLoader->WriteData("OVERWRITE");
+ trklLoader->UnloadAll();
+ }
+ }
}
if(fReconstructor->IsWritingClusters()) WriteClusters(-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;
}
+ const AliTRDrecoParam *const recoParam = fReconstructor->GetRecoParam();
- fMaxThresh = fReconstructor->GetRecoParam()->GetClusMaxThresh();
- fSigThresh = fReconstructor->GetRecoParam()->GetClusSigThresh();
- fMinMaxCutSigma = fReconstructor->GetRecoParam()->GetMinMaxCutSigma();
- fMinLeftRightCutSigma = fReconstructor->GetRecoParam()->GetMinLeftRightCutSigma();
+ fMaxThresh = (Short_t)recoParam->GetClusMaxThresh();
+ fMaxThreshTest = (Short_t)(recoParam->GetClusMaxThresh()/2+fBaseline);
+ fSigThresh = (Short_t)recoParam->GetClusSigThresh();
+ fMinMaxCutSigma = recoParam->GetMinMaxCutSigma();
+ fMinLeftRightCutSigma = recoParam->GetMinLeftRightCutSigma();
+ const Int_t iEveryNTB = recoParam->GetRecEveryNTB();
Int_t istack = fIndexes->GetStack();
fLayer = fIndexes->GetLayer();
fDet = AliTRDgeometry::GetDetector(fLayer,istack,isector);
if (fDet != det) {
- AliError("Strange Detector number Missmatch!");
+ AliError(Form("Detector number missmatch! Request[%03d] RAW[%03d]", det, fDet));
return kFALSE;
}
Int_t iGeoModule = istack + AliTRDgeometry::Nstack() * isector;
fVolid = AliGeomManager::LayerToVolUID(iGeoLayer,iGeoModule);
- if(fReconstructor->IsProcessingTracklets() && fTrackletContainer)
- AddTrackletsToArray();
-
fColMax = fDigits->GetNcol();
- //Int_t nRowMax = fDigits->GetNrow();
- fTimeTotal = fDigits->GetNtime();
+ fTimeTotal = fDigitsManager->GetDigitsParam()->GetNTimeBins(det);
+
+ // Check consistency between Geometry and raw data
+ AliTRDpadPlane *pp(fTransform->GetPadPlane());
+ Int_t ncols(pp->GetNcols()), nrows(pp->GetNrows());
+ if(ncols != fColMax) AliDebug(1, Form("N cols missmatch in Digits for Det[%3d] :: Geom[%3d] RAW[%3d]", fDet, ncols, fColMax));
+ if(nrows != fDigits->GetNrow()) AliDebug(1, Form("N rows missmatch in Digits for Det[%3d] :: Geom[%3d] RAW[%3d]", fDet, nrows, fDigits->GetNrow()));
+ if(ncols != fIndexes->GetNcol()) AliDebug(1, Form("N cols missmatch in Digits for Det[%3d] :: Geom[%3d] RAW[%3d]", fDet, ncols, fIndexes->GetNcol()));
+ if(nrows != fIndexes->GetNrow()) AliDebug(1, Form("N rows missmatch in Digits for Det[%3d] :: Geom[%3d] RAW[%3d]", fDet, nrows, fIndexes->GetNrow()));
// Check consistency between OCDB and raw data
Int_t nTimeOCDB = calibration->GetNumberOfTimeBinsDCS();
- if ((nTimeOCDB > -1) &&
- (fTimeTotal != nTimeOCDB)) {
- AliError(Form("Number of timebins does not match OCDB value (RAW[%d] OCDB[%d])"
- ,fTimeTotal,calibration->GetNumberOfTimeBinsDCS()));
+ if(fReconstructor->IsHLT()){
+ 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(Form("Number of timebins in raw data is negative, skipping chamber[%3d]!", fDet));
+ 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[%3d]!"
+ ,fTimeTotal,nTimeOCDB, fDet));
+ return kFALSE;
+ }
}
// Detector wise calibration object for the gain factors
// Calibration object with the pad status
fCalPadStatusROC = calibration->GetPadStatusROC(fDet);
+ // Calibration object of the online gain
+ fCalOnGainROC = calibration->GetOnlineGainTableROC(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();
+ // Use the configuration from the DCS to find out whether online
+ // tail cancellation was applied
+ if(!calibration->HasOnlineTailCancellation()) TailCancelation(recoParam);
MaxStruct curr, last;
Int_t nMaximas = 0, nCorrupted = 0;
// Here the clusterfining is happening
- for(curr.time = 0; curr.time < fTimeTotal; curr.time++){
+ for(curr.time = 0; curr.time < fTimeTotal; curr.time+=iEveryNTB){
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);
+ if(curr.col==last.col+2 && curr.row==last.row && curr.time==last.time) FivePadCluster(last, curr);
CreateCluster(last);
}
last=curr; curr.fivePad=kFALSE;
}
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
<< "NCorrupted=" << nCorrupted
<< "\n";
}
- if (TestBit(kLabels)) AddLabels();
+ // if (TestBit(kLabels)) AddLabels();
return kTRUE;
//
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;
+ Float_t ongain = fCalOnGainROC ? fCalOnGainROC->GetGainCorrectionFactor(Max.row,Max.col) : 1;
+ Signals[1] = (Short_t)((fDigits->GetData(Max.row, Max.col, Max.time) - fBaseline) * ongain / gain + 0.5f);
+ if(Signals[1] <= fMaxThresh) return kFALSE;
- Float_t noiseMiddleThresh = fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row);
- if (Signals[1] < noiseMiddleThresh) return kFALSE;
+ if(Max.col < 1 || Max.col + 1 >= fColMax) return kFALSE;
- if (Max.col + 1 >= fColMax || Max.col < 1) return kFALSE;
+ Short_t noiseMiddleThresh = (Short_t)(fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row));
+ if (Signals[1] <= noiseMiddleThresh) return kFALSE;
UChar_t status[3]={
fCalPadStatusROC->GetStatus(Max.col-1, Max.row)
,fCalPadStatusROC->GetStatus(Max.col+1, Max.row)
};
- gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col-1,Max.row);
- Signals[0] = (Short_t)((fDigits->GetData(Max.row, Max.col-1, Max.time) - fBaseline) / gain + 0.5f);
- gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col+1,Max.row);
- Signals[2] = (Short_t)((fDigits->GetData(Max.row, Max.col+1, Max.time) - fBaseline) / gain + 0.5f);
+ Short_t signal(0);
+ if((signal = fDigits->GetData(Max.row, Max.col-1, Max.time))){
+ gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col-1,Max.row);
+ ongain = fCalOnGainROC ? fCalOnGainROC->GetGainCorrectionFactor(Max.row,Max.col-1) : 1;
+ Signals[0] = (Short_t)((signal - fBaseline) * ongain / gain + 0.5f);
+ } else Signals[0] = 0;
+ if((signal = fDigits->GetData(Max.row, Max.col+1, Max.time))){
+ gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col+1,Max.row);
+ ongain = fCalOnGainROC ? fCalOnGainROC->GetGainCorrectionFactor(Max.row,Max.col+1) : 1;
+ Signals[2] = (Short_t)((signal - fBaseline) * ongain / gain + 0.5f);
+ } else Signals[2] = 0;
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;
}
Int_t nPadCount = 1;
Short_t signals[7] = { 0, 0, Max.signals[0], Max.signals[1], Max.signals[2], 0, 0 };
- if(!TestBit(kHLT)) CalcAdditionalInfo(Max, signals, nPadCount);
+ if(!fReconstructor->IsHLT()) CalcAdditionalInfo(Max, signals, nPadCount);
AliTRDcluster cluster(fDet, ((UChar_t) Max.col), ((UChar_t) Max.row), ((UChar_t) Max.time), signals, fVolid);
cluster.SetNPads(nPadCount);
cluster.SetPadMaskedPosition(maskPosition);
cluster.SetPadMaskedStatus(GetPadStatus(Max.padStatus));
}
+ cluster.SetXcorr(fReconstructor->UseClusterRadialCorrection());
// Transform the local cluster coordinates into calibrated
// space point positions defined in the local tracking system.
// Here the calibration for T0, Vdrift and ExB is applied as well.
- if(!fTransform->Transform(&cluster)) return;
+ if(!TestBit(kSkipTrafo)) if(!fTransform->Transform(&cluster)) return;
+
// Temporarily store the Max.Row, column and time bin of the center pad
// Used to later on assign the track indices
cluster.SetLabel(Max.row, 0);
cluster.SetLabel(Max.time,2);
//needed for HLT reconstruction
- AddClusterToArray(&cluster);
+ AddClusterToArray(&cluster);
// Store the index of the first cluster in the current ROC
if (firstClusterROC < 0) firstClusterROC = fNoOfClusters;
//_____________________________________________________________________________
void AliTRDclusterizer::CalcAdditionalInfo(const MaxStruct &Max, Short_t *const signals, Int_t &nPadCount)
{
+// Calculate number of pads/cluster and
+// ADC signals at position 0, 1, 5 and 6
+
+ Float_t tmp(0.), kMaxShortVal(32767.); // protect against data overflow due to wrong gain calibration
+ Float_t gain(1.); Short_t signal(0);
+ // Store the amplitudes of the pads in the cluster for later analysis
+ // and check whether one of these pads is masked in the database
+ signals[3]=Max.signals[1];
+ Int_t ipad(1), jpad(0);
// Look to the right
- Int_t ii = 1;
- while (fDigits->GetData(Max.row, Max.col-ii, Max.time) >= fSigThresh) {
+ while((jpad = Max.col-ipad)){
+ if(!(signal = fDigits->GetData(Max.row, jpad, Max.time))) break; // empty digit !
+ gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(jpad, Max.row);
+ tmp = (signal - fBaseline) / gain + 0.5f;
+ signal = (Short_t)TMath::Min(tmp, kMaxShortVal);
+ if(signal<fSigThresh) break; // signal under threshold
nPadCount++;
- ii++;
- if (Max.col < ii) break;
+ if(ipad<=3) signals[3 - ipad] = signal;
+ ipad++;
}
+ ipad=1;
// Look to the left
- ii = 1;
- while (fDigits->GetData(Max.row, Max.col+ii, Max.time) >= fSigThresh) {
+ while((jpad = Max.col+ipad)<fColMax){
+ if(!(signal = fDigits->GetData(Max.row, jpad, Max.time))) break; // empty digit !
+ gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(jpad, Max.row);
+ tmp = (signal - fBaseline) / gain + 0.5f;
+ signal = (Short_t)TMath::Min(tmp, kMaxShortVal);
+ if(signal<fSigThresh) break; // signal under threshold
nPadCount++;
- ii++;
- if (Max.col+ii >= fColMax) break;
+ if(ipad<=3) signals[3 + ipad] = signal;
+ ipad++;
}
- // Store the amplitudes of the pads in the cluster for later analysis
- // and check whether one of these pads is masked in the database
- signals[2]=Max.signals[0];
- signals[3]=Max.signals[1];
- signals[4]=Max.signals[2];
- Float_t gain;
- for(Int_t i = 0; i<2; i++)
- {
- if(Max.col+i >= 3){
- gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col-3+i,Max.row);
- signals[i] = (Short_t)((fDigits->GetData(Max.row, Max.col-3+i, Max.time) - fBaseline) / gain + 0.5f);
- }
- if(Max.col+3-i < fColMax){
- gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col+3-i,Max.row);
- signals[6-i] = (Short_t)((fDigits->GetData(Max.row, Max.col+3-i, Max.time) - fBaseline) / gain + 0.5f);
- }
- }
- /*for (Int_t jPad = Max.Col-3; jPad <= Max.Col+3; jPad++) {
- if ((jPad >= 0) && (jPad < fColMax))
- signals[jPad-Max.Col+3] = TMath::Nint(fDigits->GetData(Max.Row,jPad,Max.Time));
- }*/
+ AliDebug(4, Form("Signals[%3d %3d %3d %3d %3d %3d %3d] Npads[%d]."
+ , signals[0], signals[1], signals[2], signals[3], signals[4], signals[5], signals[6], nPadCount));
}
//_____________________________________________________________________________
new((*RecPoints())[n]) AliTRDcluster(*cluster);
}
-//_____________________________________________________________________________
-void AliTRDclusterizer::AddTrackletsToArray()
-{
- //
- // Add the online tracklets of this chamber to the array
- //
-
- UInt_t* trackletword;
- for(Int_t side=0; side<2; side++)
- {
- Int_t trkl=0;
- trackletword=fTrackletContainer[side];
- while(trackletword[trkl]>0){
- Int_t n = TrackletsArray()->GetEntriesFast();
- AliTRDtrackletWord tmp(trackletword[trkl]);
- new((*TrackletsArray())[n]) AliTRDcluster(&tmp,fDet,fVolid);
- trkl++;
- }
- }
-}
-
//_____________________________________________________________________________
Bool_t AliTRDclusterizer::AddLabels()
{
}
//_____________________________________________________________________________
-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 nexp = recoParam->GetTCnexp();
+ if(!nexp) return;
+
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
-
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();
while(fIndexes->NextRCIndex(iRow, iCol))
{
- Bool_t corrupted = kFALSE;
- if (fCalPadStatusROC->GetStatus(iCol, iRow)) corrupted = kTRUE;
-
- // 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;
-
+ // 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
- << "time=" << iTime
- << "inADC=" << inADC[iTime]
- << "outADC=" << outADC[iTime]
- << "corrupted=" << corrupted
- << "\n";
+ 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]));
-
- // 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));
-
+ // Apply the tail cancelation via the digital filter
+ //DeConvExp(fDigits->GetDataAddress(iRow,iCol),fTimeTotal,nexp);
+ ApplyTCTM(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::ApplyTCTM(Short_t *const arr, const Int_t nTime, const Int_t nexp)
+{
+ //
+ // Steer tail cancellation
+ //
+
+
+ switch(nexp) {
+ case 1:
+ case 2:
+ DeConvExp(arr,nTime,nexp);
+ break;
+ case -1:
+ ConvExp(arr,nTime);
+ break;
+ case -2:
+ DeConvExp(arr,nTime,1);
+ ConvExp(arr,nTime);
+ break;
+ default:
+ break;
+ }
+}
+
+
+//_____________________________________________________________________________
+void AliTRDclusterizer::ConvExp(Short_t *const arr, const Int_t nTime)
+{
+ //
+ // Tail maker
+ //
+
+ // Initialization (coefficient = alpha, rates = lambda)
+ Float_t slope = 1.0;
+ Float_t coeff = 0.5;
+ Float_t rate;
+
+ Double_t par[4];
+ fReconstructor->GetRecoParam()->GetTCParams(par);
+ slope = par[1];
+ coeff = par[3];
+
+ Double_t dt = 0.1;
+
+ rate = TMath::Exp(-dt/(slope));
+
+ Float_t reminder = .0;
+ Float_t correction = 0.0;
+ Float_t result = 0.0;
+
+ for (int i = nTime-1; i >= 0; i--) {
+
+ result = arr[i] + correction - fBaseline; // No rescaling
+ arr[i] = (Short_t)(result + fBaseline + 0.5f);
+
+ correction = 0.0;
+
+ correction += reminder = rate * (reminder + coeff * result);
+ }
+}
+
+
+//_____________________________________________________________________________
+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;
Double_t dt = 0.1;
rates[0] = TMath::Exp(-dt/(r1));
- rates[1] = TMath::Exp(-dt/(r2));
+ rates[1] = (nexp == 1) ? .0 : TMath::Exp(-dt/(r2));
- Int_t i = 0;
- Int_t k = 0;
+ Float_t reminder[2] = { .0, .0 };
+ Float_t correction = 0.0;
+ Float_t result = 0.0;
- Double_t reminder[2];
- Double_t correction = 0.0;
- Double_t result = 0.0;
+ for (int i = 0; i < nTime; i++) {
- // Attention: computation order is important
- for (k = 0; k < nexp; k++) {
- reminder[k] = 0.0;
- }
-
- for (i = 0; i < n; i++) {
-
- result = (source[i] - correction); // No rescaling
- target[i] = result;
-
- for (k = 0; k < nexp; k++) {
- reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
- }
+ result = arr[i] - correction - fBaseline; // No rescaling
+ arr[i] = (Short_t)(result + fBaseline + 0.5f);
correction = 0.0;
- for (k = 0; k < nexp; k++) {
- correction += reminder[k];
+ for (int k = 0; k < 2; k++) {
+ correction += reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
}
}
//
if (fRecPoints) {
- fRecPoints->Delete();
- delete fRecPoints;
+ fRecPoints->Clear();
+ fNoOfClusters = 0;
+ // delete fRecPoints;
}
}
}
//_____________________________________________________________________________
-TClonesArray *AliTRDclusterizer::TrackletsArray()
+TClonesArray *AliTRDclusterizer::TrackletsArray(const TString &trkltype)
{
//
- // Returns the list of rec points
+ // Returns the array of on-line tracklets
//
- if (!fTracklets && fReconstructor->IsProcessingTracklets()) {
- fTracklets = new TClonesArray("AliTRDcluster", 2*MAXTRACKLETSPERHC);
- //SetClustersOwner(kTRUE);
- //AliTRDReconstructor::SetTracklets(0x0);
+ if (trkltype.Length() != 0) {
+ if (!fTracklets) {
+ fTracklets = new TClonesArray(trkltype, 200);
+ }
+ else if (TClass::GetClass(trkltype.Data()) != fTracklets->GetClass()){
+ fTracklets->Delete();
+ delete fTracklets;
+ fTracklets = new TClonesArray(trkltype, 200);
+ }
}
return fTracklets;
-
}
+//_____________________________________________________________________________
+TClonesArray* AliTRDclusterizer::TracksArray()
+{
+ // return array of GTU tracks (create TClonesArray if necessary)
+
+ if (!fTracks) {
+ fTracks = new TClonesArray("AliESDTrdTrack",100);
+ }
+ return fTracks;
+}