#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)
- ,fTrackletTree(NULL)
+ ,fTracks(NULL)
,fDigitsManager(new AliTRDdigitsManager())
- ,fTrackletContainer(NULL)
,fRawVersion(2)
,fTransform(new AliTRDtransform(0))
,fDigits(NULL)
+ ,fDigitsRaw(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
,fMaxThreshTest(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnlGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
,fBaseline(0)
,fRawStream(NULL)
+ ,fTrgFlags()
{
//
// AliTRDclusterizer default constructor
,fClusterTree(NULL)
,fRecPoints(NULL)
,fTracklets(NULL)
- ,fTrackletTree(NULL)
+ ,fTracks(NULL)
,fDigitsManager(new AliTRDdigitsManager())
- ,fTrackletContainer(NULL)
,fRawVersion(2)
,fTransform(new AliTRDtransform(0))
,fDigits(NULL)
+ ,fDigitsRaw(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
,fMaxThreshTest(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnlGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
,fBaseline(0)
,fRawStream(NULL)
+ ,fTrgFlags()
{
//
// AliTRDclusterizer constructor
,fClusterTree(NULL)
,fRecPoints(NULL)
,fTracklets(NULL)
- ,fTrackletTree(NULL)
+ ,fTracks(NULL)
,fDigitsManager(NULL)
- ,fTrackletContainer(NULL)
,fRawVersion(2)
,fTransform(NULL)
,fDigits(NULL)
+ ,fDigitsRaw(NULL)
,fIndexes(NULL)
,fMaxThresh(0)
,fMaxThreshTest(0)
,fCalNoiseROC(NULL)
,fCalNoiseDetValue(0)
,fCalPadStatusROC(NULL)
+ ,fCalOnlGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
,fBaseline(0)
,fRawStream(NULL)
+ ,fTrgFlags()
{
//
// AliTRDclusterizer copy constructor
// AliTRDclusterizer destructor
//
- if (fRecPoints/* && IsClustersOwner()*/){
- fRecPoints->Delete();
- delete fRecPoints;
- }
-
- if (fTracklets){
- fTracklets->Delete();
- delete fTracklets;
- }
-
if (fDigitsManager) {
delete fDigitsManager;
fDigitsManager = NULL;
}
- if (fTrackletContainer){
- delete [] fTrackletContainer[0];
- delete [] fTrackletContainer[1];
- delete [] fTrackletContainer;
- fTrackletContainer = NULL;
+ if (fDigitsRaw) {
+ delete fDigitsRaw;
+ fDigitsRaw = NULL;
}
if (fTransform){
delete fRawStream;
fRawStream = NULL;
}
-
}
//_____________________________________________________________________________
((AliTRDclusterizer &) c).fClusterTree = 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).fDigits = NULL;
+ ((AliTRDclusterizer &) c).fDigitsRaw = NULL;
((AliTRDclusterizer &) c).fIndexes = NULL;
((AliTRDclusterizer &) c).fMaxThresh = 0;
((AliTRDclusterizer &) c).fMaxThreshTest = 0;
AliError(Form("Unexpected detector index %d.\n",det));
return kFALSE;
}
+ Int_t nRecPoints = RecPoints()->GetEntriesFast();
+ if(!nRecPoints) return kTRUE;
TObjArray *ioArray = new TObjArray(400);
TBranch *branch = fClusterTree->GetBranch("TRDcluster");
fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
} else branch->SetAddress(&ioArray);
- Int_t nRecPoints = RecPoints()->GetEntriesFast();
+ AliTRDcluster *c(NULL);
if(det >= 0){
for (Int_t i = 0; i < nRecPoints; i++) {
- AliTRDcluster *c = (AliTRDcluster *) RecPoints()->UncheckedAt(i);
+ if(!(c = (AliTRDcluster *) RecPoints()->UncheckedAt(i))) continue;
if(det != c->GetDetector()) continue;
ioArray->AddLast(c);
}
fClusterTree->Fill();
ioArray->Clear();
} else {
- Int_t detOld = -1, nw(0);
- for (Int_t i = 0; i < nRecPoints; i++) {
- AliTRDcluster *c = (AliTRDcluster *) RecPoints()->UncheckedAt(i);
+ if(!(c = (AliTRDcluster*)RecPoints()->UncheckedAt(0))){
+ AliError("Missing first cluster.");
+ delete ioArray;
+ return kFALSE;
+ }
+ Int_t detOld(c->GetDetector()), nw(0);
+ ioArray->AddLast(c);
+ for (Int_t i(1); i<nRecPoints; i++) {
+ if(!(c = (AliTRDcluster *) RecPoints()->UncheckedAt(i))) continue;
if(c->GetDetector() != detOld){
nw += ioArray->GetEntriesFast();
+ // fill & clear previously detector set of clusters
fClusterTree->Fill();
ioArray->Clear();
detOld = c->GetDetector();
}
if(ioArray->GetEntriesFast()){
nw += ioArray->GetEntriesFast();
+ // fill & clear last detector set of clusters (if any)
fClusterTree->Fill();
ioArray->Clear();
}
AliDebug(2, Form("Clusters FOUND[%d] WRITTEN[%d] STATUS[%s]", nRecPoints, nw, nw==nRecPoints?"OK":"FAILED"));
+ if(nw!=nRecPoints) AliWarning(Form("Clusters FOUND[%d] WRITTEN[%d]", nRecPoints, nw));
}
delete ioArray;
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"); //jkl: wrong here
-// dl->WriteData("OVERWRITE"); //jkl: wrong here
- //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;
+ }
+ trackletLoader->Load();
+
+ Bool_t loaded = kFALSE;
+ // look for simulated tracklets
+ TTree *trackletTree = trackletLoader->Tree();
+
+ if (trackletTree) {
+ TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
+ TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
+ if (trklbranch && trklArray) {
+ AliTRDtrackletMCM *trkl = 0x0;
+ trklbranch->SetAddress(&trkl);
+ Int_t nTracklets = trklbranch->GetEntries();
+ for (Int_t iTracklet = 0; iTracklet < nTracklets; iTracklet++) {
+ trklbranch->GetEntry(iTracklet);
+ new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
+ }
+ loaded = kTRUE;
+ }
+ }
+ else {
+ // if no simulated tracklets found, look for raw tracklets
+ AliTreeLoader *treeLoader = (AliTreeLoader*) trackletLoader->GetBaseLoader("tracklets-raw");
+ trackletTree = treeLoader ? treeLoader->Load(), treeLoader->Tree() : 0x0;
+
+ if (trackletTree) {
+ TClonesArray *trklArray = TrackletsArray("AliTRDtrackletWord");
+
+ Int_t hc;
+ TClonesArray *ar = 0x0;
+ trackletTree->SetBranchAddress("hc", &hc);
+ trackletTree->SetBranchAddress("trkl", &ar);
+
+ Int_t nEntries = trackletTree->GetEntries();
+ for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
+ trackletTree->GetEntry(iEntry);
+ Int_t nTracklets = ar->GetEntriesFast();
+ AliDebug(2, Form("%i tracklets in HC %i", nTracklets, hc));
+ for (Int_t iTracklet = 0; iTracklet < nTracklets; iTracklet++) {
+ AliTRDtrackletWord *trklWord = (AliTRDtrackletWord*) (*ar)[iTracklet];
+ new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletWord(trklWord->GetTrackletWord(), hc);
+ }
+ }
+ loaded = kTRUE;
+ }
+ }
+
+ trackletLoader->UnloadAll();
+ trackletLoader->CloseFile();
+
+ return loaded;
+}
+
+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;
+ }
+
+ Bool_t loaded = kFALSE;
+
+ trackLoader->Load();
+
+ TTree *trackTree = trackLoader->Tree();
+ if (trackTree) {
+ 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()));
+ }
+ loaded = kTRUE;
+ }
+
+ trackLoader->UnloadAll();
+ trackLoader->CloseFile();
+
+ return loaded;
+}
+
//_____________________________________________________________________________
Bool_t AliTRDclusterizer::MakeClusters()
{
fDigitsManager->BuildIndexes(i);
}
- Bool_t fR = kFALSE;
+ Bool_t fR(kFALSE);
if (indexes->HasEntry()){
if (TestBit(kLabels)){
+ Int_t nDict(0);
for (Int_t iDict = 0; iDict < AliTRDdigitsManager::kNDict; iDict++){
- AliTRDarrayDictionary *tracksIn = 0; //mod
+ AliTRDarrayDictionary *tracksIn(NULL); //mod
tracksIn = (AliTRDarrayDictionary *) fDigitsManager->GetDictionary(i,iDict); //mod
- tracksIn->Expand();
+ // This is to take care of data reconstruction
+ if (!tracksIn->GetDim()) continue;
+ tracksIn->Expand(); nDict++;
+ }
+ if(!nDict){
+ AliDebug(1, "MC labels not available. Switch them off.");
+ SetUseLabels(kFALSE);
}
}
fR = MakeClusters(i);
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
- AliInfo(Form("Number of found clusters : %d", RecPoints()->GetEntriesFast()));
+ AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+ RecPoints()?RecPoints()->GetEntriesFast():0,
+ TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+ TracksArray()?TracksArray()->GetEntriesFast():0));
return fReturn;
fDigitsManager->SetUseDictionaries(TestBit(kLabels));
- // ----- 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();
- }
-
- // 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];
- memset(fTrackletContainer[0], 0, kTrackletChmb*sizeof(UInt_t)); //jkl
- memset(fTrackletContainer[1], 0, kTrackletChmb*sizeof(UInt_t)); //jkl
- }
-
if(!fRawStream)
fRawStream = new AliTRDrawStream(rawReader);
else
fRawStream->SetReader(rawReader);
- if(fReconstructor->IsHLT()){
- ((AliTRDrawStream*)fRawStream)->DisableErrorStorage();
- }
+ //if(fReconstructor->IsHLT()){
+ fRawStream->DisableErrorStorage();
+ //}
+
+ // register tracklet array for output
+ fRawStream->SetTrackletArray(TrackletsArray("AliTRDtrackletWord"));
+ fRawStream->SetTrackArray(TracksArray());
- AliDebug(1,Form("Stream version: %s", fRawStream->IsA()->GetName()));
-
UInt_t det = 0;
- while ((det = fRawStream->NextChamber(fDigitsManager,fTrackletContainer)) < AliTRDgeometry::kNdet){
+ while ((det = fRawStream->NextChamber(fDigitsManager)) < AliTRDgeometry::kNdet){
if (fDigitsManager->GetIndexes(det)->HasEntry()){
MakeClusters(det);
fDigitsManager->ClearArrays(det);
}
-
- if (!fReconstructor->IsWritingTracklets()) continue;
- if (*(fTrackletContainer[0]) > 0 || *(fTrackletContainer[1]) > 0) WriteTracklets(det);
- }
-
- 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 (fTrackletContainer){
- delete [] fTrackletContainer[0];
- delete [] fTrackletContainer[1];
- delete [] fTrackletContainer;
- fTrackletContainer = NULL;
+ for (Int_t iSector = 0; iSector < AliTRDgeometry::kNsector; iSector++) {
+ fTrgFlags[iSector] = fRawStream->GetTriggerFlags(iSector);
}
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
fRawStream = NULL;
}
- AliInfo(Form("Number of found clusters : %d", fNoOfClusters));
+ AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+ RecPoints()?RecPoints()->GetEntriesFast():0,
+ TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+ TracksArray()?TracksArray()->GetEntriesFast():0));
return kTRUE;
}
const AliTRDrecoParam *const recoParam = fReconstructor->GetRecoParam();
- fMaxThresh = (Short_t)recoParam->GetClusMaxThresh();
- fMaxThreshTest = (Short_t)(recoParam->GetClusMaxThresh()/2+fBaseline);
- fSigThresh = (Short_t)recoParam->GetClusSigThresh();
+ fMaxThresh = recoParam->GetClusMaxThresh();
+ fMaxThreshTest = (recoParam->GetClusMaxThresh()/2+fBaseline);
+ fSigThresh = recoParam->GetClusSigThresh();
fMinMaxCutSigma = recoParam->GetMinMaxCutSigma();
fMinLeftRightCutSigma = recoParam->GetMinLeftRightCutSigma();
const Int_t iEveryNTB = recoParam->GetRecEveryNTB();
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();
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(fReconstructor->IsHLT()){
}
}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;
+ AliDebug(1, "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!"
- ,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;
}
}
+ AliDebug(1, Form("Using %2d number of timebins for Det[%03d].", fTimeTotal, fDet));
// Detector wise calibration object for the gain factors
const AliTRDCalDet *calGainFactorDet = calibration->GetGainFactorDet();
// Calibration object with the pad status
fCalPadStatusROC = calibration->GetPadStatusROC(fDet);
+ // Calibration object of the online gain
+ fCalOnlGainROC = 0x0;
+ if (calibration->HasOnlineFilterGain()) {
+ fCalOnlGainROC = calibration->GetOnlineGainTableROC(fDet);
+ }
firstClusterROC = -1;
fClusterROC = 0;
// Apply the gain and the tail cancelation via digital filter
// Use the configuration from the DCS to find out whether online
// tail cancellation was applied
- if(!calibration->HasOnlineTailCancellation()) TailCancelation(recoParam);
+ if(!calibration->HasOnlineTailCancellation()){
+ // save a copy of raw data
+ if(TestBit(kRawSignal)){
+ if(fDigitsRaw){
+ fDigitsRaw->~AliTRDarrayADC();
+ new(fDigitsRaw) AliTRDarrayADC(*fDigits);
+ } else fDigitsRaw = new AliTRDarrayADC(*fDigits);
+ }
+ TailCancelation(recoParam);
+ }
MaxStruct curr, last;
Int_t nMaximas = 0, nCorrupted = 0;
}
//_____________________________________________________________________________
-Bool_t AliTRDclusterizer::IsMaximum(const MaxStruct &Max, UChar_t &padStatus, Short_t *const Signals)
+Bool_t AliTRDclusterizer::IsMaximum(const MaxStruct &Max, UChar_t &padStatus, Float_t *const Signals)
{
//
// Returns true if this row,col,time combination is a maximum.
//
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);
+ Float_t onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(Max.row,Max.col) : 1;
+ Signals[1] = (fDigits->GetData(Max.row, Max.col, Max.time) - fBaseline) /(onlcf * gain) + 0.5f;
if(Signals[1] <= fMaxThresh) return kFALSE;
if(Max.col < 1 || Max.col + 1 >= fColMax) return kFALSE;
- Short_t noiseMiddleThresh = (Short_t)(fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row));
+ Float_t noiseMiddleThresh = fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row);
if (Signals[1] <= noiseMiddleThresh) return kFALSE;
- UChar_t status[3]={
+ Char_t status[3]={
fCalPadStatusROC->GetStatus(Max.col-1, Max.row)
,fCalPadStatusROC->GetStatus(Max.col, Max.row)
,fCalPadStatusROC->GetStatus(Max.col+1, Max.row)
Short_t signal(0);
if((signal = fDigits->GetData(Max.row, Max.col-1, Max.time))){
gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(Max.col-1,Max.row);
- Signals[0] = (Short_t)((signal - fBaseline) / gain + 0.5f);
- } else Signals[0] = 0;
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(Max.row,Max.col-1) : 1;
+ Signals[0] = (signal - fBaseline) /( onlcf * 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);
- Signals[2] = (Short_t)((signal - fBaseline) / gain + 0.5f);
- } else Signals[2] = 0;
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(Max.row,Max.col+1) : 1;
+ Signals[2] = (signal - fBaseline) /( onlcf * 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[0]<0)Signals[0]=0;
- if(Signals[2]<0)Signals[2]=0;
- Short_t noiseSumThresh = (Short_t)(fMinLeftRightCutSigma * fCalNoiseDetValue
- * fCalNoiseROC->GetValue(Max.col, Max.row));
+ 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;
padStatus = 0;
return kTRUE;
if (ThisMax.col >= fColMax - 3) return kFALSE;
Float_t gain;
+ Float_t onlcf;
if (ThisMax.col < fColMax - 5){
gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(ThisMax.col+4,ThisMax.row);
- if (fDigits->GetData(ThisMax.row, ThisMax.col+4, ThisMax.time) - fBaseline >= fSigThresh * gain)
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(ThisMax.row,ThisMax.col+4) : 1;
+ if (fDigits->GetData(ThisMax.row, ThisMax.col+4, ThisMax.time) - fBaseline >= fSigThresh * gain * onlcf)
return kFALSE;
}
if (ThisMax.col > 1) {
gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(ThisMax.col-2,ThisMax.row);
- if (fDigits->GetData(ThisMax.row, ThisMax.col-2, ThisMax.time) - fBaseline >= fSigThresh * gain)
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(ThisMax.row,ThisMax.col-2) : 1;
+ if (fDigits->GetData(ThisMax.row, ThisMax.col-2, ThisMax.time) - fBaseline >= fSigThresh * gain * onlcf)
return kFALSE;
}
// Unfold the two maxima and set the signal on
// the overlapping pad to the ratio
Float_t ratio = Unfold(kEpsilon,fLayer,padSignal);
- ThisMax.signals[2] = (Short_t)(ThisMax.signals[2]*ratio + 0.5f);
- NeighbourMax.signals[0] = (Short_t)(NeighbourMax.signals[0]*(1-ratio) + 0.5f);
+ ThisMax.signals[2] = ThisMax.signals[2]*ratio + 0.5f;
+ NeighbourMax.signals[0] = NeighbourMax.signals[0]*(1-ratio) + 0.5f;
ThisMax.fivePad=kTRUE;
NeighbourMax.fivePad=kTRUE;
return kTRUE;
void AliTRDclusterizer::CreateCluster(const MaxStruct &Max)
{
//
- // Creates a cluster at the given position and saves it in fRecPoints
+ // Creates a cluster at the given position and saves it in RecPoints
//
Int_t nPadCount = 1;
- Short_t signals[7] = { 0, 0, Max.signals[0], Max.signals[1], Max.signals[2], 0, 0 };
+ Short_t signals[7] = { 0, 0, (Short_t)Max.signals[0], (Short_t)Max.signals[1], (Short_t)Max.signals[2], 0, 0 };
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.SetQ(Max.signals[0]+Max.signals[1]+Max.signals[2]);
if(TestBit(kLUT)) cluster.SetRPhiMethod(AliTRDcluster::kLUT);
else if(TestBit(kGAUS)) cluster.SetRPhiMethod(AliTRDcluster::kGAUS);
else cluster.SetRPhiMethod(AliTRDcluster::kCOG);
// space point positions defined in the local tracking system.
// Here the calibration for T0, Vdrift and ExB is applied as well.
if(!TestBit(kSkipTrafo)) if(!fTransform->Transform(&cluster)) return;
-
+ // Store raw signals in cluster. This MUST be called after position reconstruction !
+ // Xianguo Lu and Alex Bercuci 19.03.2012
+ if(TestBit(kRawSignal) && fDigitsRaw){
+ Float_t tmp(0.), kMaxShortVal(32767.); // protect against data overflow due to wrong gain calibration
+ Short_t rawSignal[7] = {0};
+ for(Int_t ipad(Max.col-3), iRawId(0); ipad<=Max.col+3; ipad++, iRawId++){
+ if(ipad<0 || ipad>=fColMax) continue;
+ if(!fCalOnlGainROC){
+ rawSignal[iRawId] = fDigitsRaw->GetData(Max.row, ipad, Max.time);
+ continue;
+ }
+ // Deconvolute online gain calibration when available
+ // Alex Bercuci 27.04.2012
+ tmp = (fDigitsRaw->GetData(Max.row, ipad, Max.time) - fBaseline)/fCalOnlGainROC->GetGainCorrectionFactor(Max.row, ipad) + 0.5f;
+ rawSignal[iRawId] = (Short_t)TMath::Min(tmp, kMaxShortVal);
+ }
+ cluster.SetSignals(rawSignal, kTRUE);
+ }
// 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);
// Calculate number of pads/cluster and
// ADC signals at position 0, 1, 5 and 6
- Float_t gain(1.); Short_t signal(0.);
+ Float_t tmp(0.), kMaxShortVal(32767.); // protect against data overflow due to wrong gain calibration
+ Float_t gain(1.); Float_t onlcf(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];
while((jpad = Max.col-ipad)){
if(!(signal = fDigits->GetData(Max.row, jpad, Max.time))) break; // empty digit !
gain = fCalGainFactorDetValue * fCalGainFactorROC->GetValue(jpad, Max.row);
- signal = (Short_t)((signal - fBaseline) / gain + 0.5f);
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(Max.row,jpad) : 1;
+ tmp = (signal - fBaseline) / (onlcf * gain) + 0.5f;
+ signal = (Short_t)TMath::Min(tmp, kMaxShortVal);
if(signal<fSigThresh) break; // signal under threshold
nPadCount++;
if(ipad<=3) signals[3 - ipad] = signal;
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);
- signal = (Short_t)((signal - fBaseline) / gain + 0.5f);
+ onlcf = fCalOnlGainROC ? fCalOnlGainROC->GetGainCorrectionFactor(Max.row,jpad) : 1;
+ tmp = (signal - fBaseline) / (onlcf * gain) + 0.5f;
+ signal = (Short_t)TMath::Min(tmp, kMaxShortVal);
if(signal<fSigThresh) break; // signal under threshold
nPadCount++;
if(ipad<=3) signals[3 + ipad] = signal;
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()
{
// Loop through the dictionary arrays one-by-one
// to keep memory consumption low
- AliTRDarrayDictionary *tracksIn = 0; //mod
+ AliTRDarrayDictionary *tracksIn(NULL); //mod
for (Int_t iDict = 0; iDict < kNdict; iDict++) {
// tracksIn should be expanded beforehand!
irc = calibration->PadResponse(ampRight,maxRight,layer,newRightSignal);
// Calculate new overlapping ratio
- ratio = TMath::Min((Double_t) 1.0
- ,newLeftSignal[2] / (newLeftSignal[2] + newRightSignal[0]));
+ // Coverity
+ if (irc != 0) {
+ ratio = TMath::Min((Double_t) 1.0
+ ,newLeftSignal[2] / (newLeftSignal[2] + newRightSignal[0]));
+ }
}
// Applies the tail cancelation
//
+ Int_t nexp = recoParam->GetTCnexp();
+ if(!nexp) return;
+
Int_t iRow = 0;
Int_t iCol = 0;
Int_t iTime = 0;
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))
{
// if corrupted then don't make the tail cancallation
}
// Apply the tail cancelation via the digital filter
- DeConvExp(fDigits->GetDataAddress(iRow,iCol),fTimeTotal,nexp);
-
+ //DeConvExp(fDigits->GetDataAddress(iRow,iCol),fTimeTotal,nexp);
+ ApplyTCTM(fDigits->GetDataAddress(iRow,iCol),fTimeTotal,nexp);
} // while irow icol
return;
}
+
+//_____________________________________________________________________________
+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)
{
for (int k = 0; k < 2; k++) {
correction += reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
}
-
- }
-
-}
-
-//_____________________________________________________________________________
-void AliTRDclusterizer::ResetRecPoints()
-{
- //
- // Resets the list of rec points
- //
-
- if (fRecPoints) {
- fRecPoints->Clear();
- fNoOfClusters = 0;
- // delete fRecPoints;
}
}
// Returns the list of rec points
//
- if (!fRecPoints) {
- if(!(fRecPoints = AliTRDReconstructor::GetClusters())){
- // determine number of clusters which has to be allocated
- Float_t nclusters = fReconstructor->GetRecoParam()->GetNClusters();
-
- fRecPoints = new TClonesArray("AliTRDcluster", Int_t(nclusters));
- }
- //SetClustersOwner(kTRUE);
- AliTRDReconstructor::SetClusters(0x0);
- }
+ fRecPoints = AliTRDReconstructor::GetClusters();
+ if (!fRecPoints) AliError("Missing cluster array");
return 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);
- }
+ fTracklets = AliTRDReconstructor::GetTracklets(trkltype.Data());
+ if (!fTracklets) AliError("Missing online tracklets array");
return fTracklets;
-
}
+//_____________________________________________________________________________
+TClonesArray* AliTRDclusterizer::TracksArray()
+{
+ // return array of GTU tracks (create TClonesArray if necessary)
+
+ fTracks = AliTRDReconstructor::GetTracks();
+ if (!fTracks) AliError("Missing online tracks array");
+ return fTracks;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff