,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
+ ,fBaseline(0)
+ ,fRawStream(NULL)
{
//
// AliTRDclusterizer default constructor
//
SetBit(kLabels, kTRUE);
+ SetBit(knewDM, kFALSE);
AliTRDcalibDB *trd = 0x0;
if (!(trd = AliTRDcalibDB::Instance())) {
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
+ ,fBaseline(0)
+ ,fRawStream(NULL)
{
//
// AliTRDclusterizer constructor
//
SetBit(kLabels, kTRUE);
+ SetBit(knewDM, kFALSE);
AliTRDcalibDB *trd = 0x0;
if (!(trd = AliTRDcalibDB::Instance())) {
,fClusterROC(0)
,firstClusterROC(0)
,fNoOfClusters(0)
+ ,fBaseline(0)
+ ,fRawStream(NULL)
{
//
// AliTRDclusterizer copy constructor
//
SetBit(kLabels, kTRUE);
+ SetBit(knewDM, kFALSE);
//FillLUT();
}
if (fTrackletContainer){
- delete fTrackletContainer;
+ delete [] fTrackletContainer[0];
+ delete [] fTrackletContainer[1];
+ delete [] fTrackletContainer;
fTrackletContainer = NULL;
}
if (fTransform){
delete fTransform;
- fTransform = NULL;
+ fTransform = NULL;
+ }
+
+ if (fRawStream){
+ delete fRawStream;
+ fRawStream = NULL;
}
}
((AliTRDclusterizer &) c).fClusterROC = 0;
((AliTRDclusterizer &) c).firstClusterROC= 0;
((AliTRDclusterizer &) c).fNoOfClusters = 0;
+ ((AliTRDclusterizer &) c).fBaseline = 0;
+ ((AliTRDclusterizer &) c).fRawStream = NULL;
+
}
//_____________________________________________________________________________
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;
-
}
//_____________________________________________________________________________
fDigitsManager->RemoveDictionaries(i);
fDigitsManager->ClearIndexes(i);
}
+ fReconstructor->SetDigitsParam(fDigitsManager->GetDigitsParam());
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
// Create the digits manager
if (!fDigitsManager){
+ SetBit(knewDM, kTRUE);
fDigitsManager = new AliTRDdigitsManager(kTRUE);
fDigitsManager->CreateArrays();
}
fTrackletContainer[1] = new UInt_t[kTrackletChmb];
}
- AliTRDrawStreamBase *input = AliTRDrawStreamBase::GetRawStream(rawReader);
- if(fReconstructor->IsHLT())
- input->SetSharedPadReadout(kFALSE);
+ if(!fRawStream)
+ fRawStream = AliTRDrawStreamBase::GetRawStream(rawReader);
+ else
+ fRawStream->SetReader(rawReader);
+
+ if(fReconstructor->IsHLT()){
+ fRawStream->SetSharedPadReadout(kFALSE);
+ fRawStream->SetNoErrorWarning();
+ }
- AliInfo(Form("Stream version: %s", input->IsA()->GetName()));
+ AliDebug(1,Form("Stream version: %s", fRawStream->IsA()->GetName()));
Int_t det = 0;
- while ((det = input->NextChamber(fDigitsManager,fTrackletContainer)) >= 0){
+ while ((det = fRawStream->NextChamber(fDigitsManager,fTrackletContainer)) >= 0){
Bool_t iclusterBranch = kFALSE;
if (fDigitsManager->GetIndexes(det)->HasEntry()){
iclusterBranch = MakeClusters(det);
if (!fReconstructor->IsWritingTracklets()) continue;
if (*(fTrackletContainer[0]) > 0 || *(fTrackletContainer[1]) > 0) WriteTracklets(det);
}
+ fReconstructor->SetDigitsParam(fDigitsManager->GetDigitsParam());
if (fTrackletContainer){
delete [] fTrackletContainer[0];
if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
- delete fDigitsManager;
- fDigitsManager = NULL;
-
- delete input;
- input = NULL;
+ if(!TestBit(knewDM)){
+ delete fDigitsManager;
+ fDigitsManager = NULL;
+ delete fRawStream;
+ fRawStream = NULL;
+ }
AliInfo(Form("Number of found clusters : %d", fNoOfClusters));
return kTRUE;
//
// Get the digits
- fDigits = (AliTRDarrayADC *) fDigitsManager->GetDigits(det); //mod
+ fDigits = (AliTRDarrayADC *) fDigitsManager->GetDigits(det); //mod
+ fBaseline = fDigitsManager->GetDigitsParam()->GetADCbaseline();
// This is to take care of switched off super modules
if (!fDigits->HasData()) return kFALSE;
return kFALSE;
}
+ AliDebug(2, Form("Det[%d] @ Sec[%d] Stk[%d] Ly[%d]", fDet, isector, istack, fLayer));
+
// TRD space point transformation
fTransform->SetDetector(det);
//Int_t nRowMax = fDigits->GetNrow();
fTimeTotal = fDigits->GetNtime();
+ // 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()));
+ }
+
// Detector wise calibration object for the gain factors
const AliTRDCalDet *calGainFactorDet = calibration->GetGainFactorDet();
// Calibration object with pad wise values for the gain factors
// Here the clusterfining is happening
- for(curr.Time = 0; curr.Time < fTimeTotal; curr.Time++){
- while(fIndexes->NextRCIndex(curr.Row, curr.Col)){
- //printf("\nCHECK r[%2d] c[%3d] t[%d]\n", curr.Row, curr.Col, curr.Time);
- if(IsMaximum(curr, curr.padStatus, &curr.Signals[0])){
- //printf("\tMAX s[%d %d %d]\n", curr.Signals[0], curr.Signals[1], curr.Signals[2]);
- if(last.Row>-1){
- if(curr.Time==last.Time && curr.Row==last.Row && curr.Col==last.Col+2) FivePadCluster(last, curr);
+ 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(last.row>-1){
+ if(curr.time==last.time && curr.row==last.row && curr.col==last.col+2) FivePadCluster(last, curr);
CreateCluster(last);
}
- last=curr; curr.FivePad=kFALSE;
+ last=curr; curr.fivePad=kFALSE;
}
- //printf("\t--- s[%d %d %d]\n", curr.Signals[0], curr.Signals[1], curr.Signals[2]);
}
}
- if(last.Row>-1) CreateCluster(last);
+ if(last.row>-1) CreateCluster(last);
if(fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 2 && fReconstructor->IsDebugStreaming()){
TTreeSRedirector* fDebugStream = fReconstructor->GetDebugStream(AliTRDrecoParam::kClusterizer);
// Gives back the padStatus and the signals of the center pad and the two neighbouring pads.
//
- Signals[1] = fDigits->GetData(Max.Row, Max.Col, Max.Time);
+ 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 noiseMiddleThresh = 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;
- if (Max.Col + 1 >= fColMax || Max.Col < 1) return kFALSE;
+ if (Max.col + 1 >= fColMax || Max.col < 1) return kFALSE;
UChar_t status[3]={
- fCalPadStatusROC->GetStatus(Max.Col-1, Max.Row)
- ,fCalPadStatusROC->GetStatus(Max.Col, Max.Row)
- ,fCalPadStatusROC->GetStatus(Max.Col+1, Max.Row)
+ fCalPadStatusROC->GetStatus(Max.col-1, Max.row)
+ ,fCalPadStatusROC->GetStatus(Max.col, Max.row)
+ ,fCalPadStatusROC->GetStatus(Max.col+1, Max.row)
};
- Signals[0] = fDigits->GetData(Max.Row, Max.Col-1, Max.Time);
- Signals[2] = fDigits->GetData(Max.Row, Max.Col+1, Max.Time);
+ 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);
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;
Float_t noiseSumThresh = fMinLeftRightCutSigma
* fCalNoiseDetValue
- * fCalNoiseROC->GetValue(Max.Col, Max.Row);
+ * 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) {
Signals[2]=0;
SetPadStatus(status[2], padStatus);
return kTRUE;
}
else if (status[1] && (!(status[0] || status[2])) && ((Signals[2] >= fSigThresh) || (Signals[0] >= fSigThresh))) {
- Signals[1]=TMath::Nint(fMaxThresh);
+ Signals[1] = (Short_t)(fMaxThresh + 0.5f);
SetPadStatus(status[1], padStatus);
return kTRUE;
}
// Look for 5 pad cluster with minimum in the middle
// Gives back the ratio
//
- if (ThisMax.Col >= fColMax - 3) return kFALSE;
- if (ThisMax.Col < fColMax - 5){
- if (fDigits->GetData(ThisMax.Row, ThisMax.Col+4, ThisMax.Time) >= fSigThresh)
+
+ if (ThisMax.col >= fColMax - 3) return kFALSE;
+ Float_t gain;
+ 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)
return kFALSE;
}
- if (ThisMax.Col > 1) {
- if (fDigits->GetData(ThisMax.Row, ThisMax.Col-2, ThisMax.Time) >= fSigThresh)
+ 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)
return kFALSE;
}
const Float_t kEpsilon = 0.01;
- Double_t padSignal[5] = {ThisMax.Signals[0], ThisMax.Signals[1], ThisMax.Signals[2],
- NeighbourMax.Signals[1], NeighbourMax.Signals[2]};
+ Double_t padSignal[5] = {ThisMax.signals[0], ThisMax.signals[1], ThisMax.signals[2],
+ NeighbourMax.signals[1], NeighbourMax.signals[2]};
// 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] = TMath::Nint(ThisMax.Signals[2]*ratio);
- NeighbourMax.Signals[0] = TMath::Nint(NeighbourMax.Signals[0]*(1-ratio));
- ThisMax.FivePad=kTRUE;
- NeighbourMax.FivePad=kTRUE;
+ ThisMax.signals[2] = (Short_t)(ThisMax.signals[2]*ratio + 0.5f);
+ NeighbourMax.signals[0] = (Short_t)(NeighbourMax.signals[0]*(1-ratio) + 0.5f);
+ ThisMax.fivePad=kTRUE;
+ NeighbourMax.fivePad=kTRUE;
return kTRUE;
}
//
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, Max.signals[0], Max.signals[1], Max.signals[2], 0, 0 };
if(!TestBit(kHLT)) CalcAdditionalInfo(Max, signals, nPadCount);
- AliTRDcluster cluster(fDet, ((UChar_t) Max.Col), ((UChar_t) Max.Row), ((UChar_t) Max.Time), signals, fVolid);
+ AliTRDcluster cluster(fDet, ((UChar_t) Max.col), ((UChar_t) Max.row), ((UChar_t) Max.time), signals, fVolid);
cluster.SetNPads(nPadCount);
if(TestBit(kLUT)) cluster.SetRPhiMethod(AliTRDcluster::kLUT);
else if(TestBit(kGAUS)) cluster.SetRPhiMethod(AliTRDcluster::kGAUS);
else cluster.SetRPhiMethod(AliTRDcluster::kCOG);
- cluster.SetFivePad(Max.FivePad);
+ cluster.SetFivePad(Max.fivePad);
// set pads status for the cluster
UChar_t maskPosition = GetCorruption(Max.padStatus);
if (maskPosition) {
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.Col, 1);
- cluster.SetLabel(Max.Time,2);
+ cluster.SetLabel(Max.row, 0);
+ cluster.SetLabel(Max.col, 1);
+ cluster.SetLabel(Max.time,2);
//needed for HLT reconstruction
AddClusterToArray(&cluster);
{
// Look to the right
Int_t ii = 1;
- while (fDigits->GetData(Max.Row, Max.Col-ii, Max.Time) >= fSigThresh) {
+ while (fDigits->GetData(Max.row, Max.col-ii, Max.time) >= fSigThresh) {
nPadCount++;
ii++;
- if (Max.Col < ii) break;
+ if (Max.col < ii) break;
}
// Look to the left
ii = 1;
- while (fDigits->GetData(Max.Row, Max.Col+ii, Max.Time) >= fSigThresh) {
+ while (fDigits->GetData(Max.row, Max.col+ii, Max.time) >= fSigThresh) {
nPadCount++;
ii++;
- if (Max.Col+ii >= fColMax) break;
+ if (Max.col+ii >= fColMax) break;
}
// 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];
+ 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)
- signals[i] = fDigits->GetData(Max.Row, Max.Col-3+i, Max.Time);
- if(Max.Col+3-i < fColMax)
- signals[6-i] = fDigits->GetData(Max.Row, Max.Col+3-i, Max.Time);
+ 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))
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 = fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 7 && fReconstructor->IsDebugStreaming();
while(fIndexes->NextRCIndex(iRow, iCol))
{
- Float_t fCalGainFactorROCValue = fCalGainFactorROC->GetValue(iCol,iRow);
- Double_t gain = fCalGainFactorDetValue
- * fCalGainFactorROCValue;
-
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++)
- {
- // Apply gain gain factor
- inADC[iTime] = fDigits->GetData(iRow,iCol,iTime);
- if (fCalPadStatusROC->GetStatus(iCol, iRow)) corrupted = kTRUE;
- inADC[iTime] /= gain;
- outADC[iTime] = inADC[iTime];
- if(fReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kClusterizer) > 7 && fReconstructor->IsDebugStreaming()){
- (*fDebugStream) << "TailCancellation"
- << "col=" << iCol
- << "row=" << iRow
- << "time=" << iTime
- << "inADC=" << inADC[iTime]
- << "gain=" << gain
- << "outADC=" << outADC[iTime]
- << "corrupted=" << corrupted
- << "\n";
- }
- }
+ inADC[iTime] = fDigits->GetData(iRow,iCol,iTime)-fBaseline;
+
+ 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";
+ }
+
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++)//while (fIndexes->NextTbinIndex(iTime))
- {
- // Store the amplitude of the digit if above threshold
- if (outADC[iTime] > 0)
- fDigits->SetData(iRow,iCol,iTime,TMath::Nint(outADC[iTime]));
- else
- fDigits->SetData(iRow,iCol,iTime,0);
- } // while itime
-
+ // 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));
+
} // while irow icol
delete [] inADC;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff