,fRecPoints(NULL)
,fTracklets(NULL)
,fTracks(NULL)
- ,fTrackletTree(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)
- ,fCalOnGainROC(NULL)
+ ,fCalOnlGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
,fBaseline(0)
,fRawStream(NULL)
+ ,fTrgFlags()
{
//
// AliTRDclusterizer default constructor
,fRecPoints(NULL)
,fTracklets(NULL)
,fTracks(NULL)
- ,fTrackletTree(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)
- ,fCalOnGainROC(NULL)
+ ,fCalOnlGainROC(NULL)
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
,fBaseline(0)
,fRawStream(NULL)
+ ,fTrgFlags()
{
//
// AliTRDclusterizer constructor
,fRecPoints(NULL)
,fTracklets(NULL)
,fTracks(NULL)
- ,fTrackletTree(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)
- ,fCalOnGainROC(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 (fTracks){
- fTracks->Delete();
- delete fTracks;
- }
-
if (fDigitsManager) {
delete fDigitsManager;
fDigitsManager = NULL;
}
+ if (fDigitsRaw) {
+ delete fDigitsRaw;
+ fDigitsRaw = NULL;
+ }
+
if (fTransform){
delete fTransform;
fTransform = NULL;
delete fRawStream;
fRawStream = NULL;
}
-
}
//_____________________________________________________________________________
((AliTRDclusterizer &) c).fClusterTree = NULL;
((AliTRDclusterizer &) c).fRecPoints = NULL;
- ((AliTRDclusterizer &) c).fTrackletTree = NULL;
((AliTRDclusterizer &) c).fDigitsManager = 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;
if (!trackletLoader) {
return kFALSE;
}
-
- // simulated tracklets
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);
- for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
- trklbranch->GetEntry(iTracklet);
- new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
- }
- return kTRUE;
- }
- }
- return kFALSE;
+ 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()
}
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) {
- return kFALSE;
+ 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;
}
- 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()));
- }
+ trackLoader->UnloadAll();
+ trackLoader->CloseFile();
- return kTRUE;
+ return loaded;
}
//_____________________________________________________________________________
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();
- }
-
if(!fRawStream)
fRawStream = new AliTRDrawStream(rawReader);
else
//}
// register tracklet array for output
- fRawStream->SetTrackletArray(TrackletsArray("AliTRDtrackletMCM"));
+ fRawStream->SetTrackletArray(TrackletsArray("AliTRDtrackletWord"));
fRawStream->SetTrackArray(TracksArray());
UInt_t det = 0;
}
}
- 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();
- }
- }
+ 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;
}
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
- fCalOnGainROC = calibration->GetOnlineGainTableROC(fDet);
+ 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;
<< "NCorrupted=" << nCorrupted
<< "\n";
}
- // if (TestBit(kLabels)) AddLabels();
+ if (TestBit(kLabels)) AddLabels();
return kTRUE;
}
//_____________________________________________________________________________
-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);
- 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);
+ 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);
- ongain = fCalOnGainROC ? fCalOnGainROC->GetGainCorrectionFactor(Max.row,Max.col-1) : 1;
- Signals[0] = (Short_t)((signal - fBaseline) * ongain / 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);
- ongain = fCalOnGainROC ? fCalOnGainROC->GetGainCorrectionFactor(Max.row,Max.col+1) : 1;
- Signals[2] = (Short_t)((signal - fBaseline) * ongain / 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);
// 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);
+ 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);
- tmp = (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++;
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;
+ 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++;
// 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]));
+ }
}
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;
-
}
//_____________________________________________________________________________
//
// Returns the array of on-line tracklets
//
-
- 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);
- }
- }
+ fTracklets = AliTRDReconstructor::GetTracklets(trkltype.Data());
+ if (!fTracklets) AliError("Missing online tracklets array");
return fTracklets;
}
{
// return array of GTU tracks (create TClonesArray if necessary)
- if (!fTracks) {
- fTracks = new TClonesArray("AliESDTrdTrack",100);
- }
+ fTracks = AliTRDReconstructor::GetTracks();
+ if (!fTracks) AliError("Missing online tracks array");
return fTracks;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff