static const Int_t fgkDeltaAlpha = 31; // accepted deviation in alpha, default: 11
static const Int_t fgkNRefLayers = 3; // no. of reference layers
- static const Float_t fgkBinWidthY;
- static const Float_t fgkBinWidthdY;
-
- static const Int_t fgkBitWidthY;
- static const Int_t fgkBitWidthdY;
- static const Int_t fgkBitWidthYProj;
- static const Int_t fgkBitExcessY;
- static const Int_t fgkBitExcessAlpha;
- static const Int_t fgkBitExcessYProj;
+ static const Float_t fgkBinWidthY; // bin width for y-position
+ static const Float_t fgkBinWidthdY; // bin width for deflection length
+
+ static const Int_t fgkBitWidthY; // bit width for y-position
+ static const Int_t fgkBitWidthdY; // bit width for deflection length
+ static const Int_t fgkBitWidthYProj; // bit width for projected y-position
+ static const Int_t fgkBitExcessY; // excess bits for y-position
+ static const Int_t fgkBitExcessAlpha; // excess bits for alpha
+ static const Int_t fgkBitExcessYProj; // excess bits for projected y-position
Float_t fVertexSize; // assumed vertex size (z-dir.) for the z-channel map
Int_t fZChannelMap[5][16][6][16]; // must be changed
Int_t fZSubChannel[5][fgkNZChannels][6][16]; // must be changed
- Int_t fCurrTrackletMask;
- Float_t fAki[6];
- Float_t fBki[6];
- Float_t fCki[6];
+ Int_t fCurrTrackletMask; // current tracklet mask for which the coefficients have been calculated
+ Float_t fAki[6]; // coefficients used for the fit, calculated for the current tracklet mask
+ Float_t fBki[6]; // coefficients used for the fit, calculated for the current tracklet mask
+ Float_t fCki[6]; // coefficients used for the fit, calculated for the current tracklet mask
Int_t *fRefLayers; //[fgkNRefLayers] reference layers for track finding
TIter next(fTrackletArray);
AliTRDtrackletBase *trkl;
- while (trkl = (AliTRDtrackletBase*) next()) {
+ while ((trkl = (AliTRDtrackletBase*) next())) {
iSec = trkl->GetDetector() / 30;
iStack = (trkl->GetDetector() % 30) / 6;
iLink = 2 * (trkl->GetDetector() % 6) + (trkl->GetYbin() < 0 ? 0 : 1);
}
TIter next(ListOfTracks);
- while (trk = (AliTRDtrackGTU*) next()) {
+ while ((trk = (AliTRDtrackGTU*) next())) {
+ trk->CookLabel();
branch->SetAddress(&trk);
fTrackTree->Fill();
}
TIter nexttrkl(&fZChannelTracklets[layer][zch], kIterBackward);
AliTRDtrackletGTU *t = 0x0;
- while (t = (AliTRDtrackletGTU*) nexttrkl.Next()) {
+ while ((t = (AliTRDtrackletGTU*) nexttrkl.Next())) {
if (t->GetSubChannel(zch) < trk->GetSubChannel(zch) ||
(t->GetSubChannel(zch) == trk->GetSubChannel(zch) && t->GetYProj() < trk->GetYProj()) )
break;
return kTRUE;
}
-Bool_t AliTRDgtuTMU::RunTrackFinder(Int_t zch, TList *ListOfTracks)
+Bool_t AliTRDgtuTMU::RunTrackFinder(Int_t zch, TList* /* ListOfTracks */)
{
// run the track finding
TList *tracksZMergedStage1 = new TList;
- AliTRDtrackGTU **trk = new AliTRDtrackGTU*[fGtuParam->GetNRefLayers()];
+ AliTRDtrackGTU **trkInRefLayer = new AliTRDtrackGTU*[fGtuParam->GetNRefLayers()];
Bool_t done = kFALSE;
Int_t minIdx = 0;
done = kTRUE;
trkStage0 = 0x0;
for (Int_t refLayerIdx = 0; refLayerIdx < fGtuParam->GetNRefLayers(); refLayerIdx++) {
- trk[refLayerIdx] = (AliTRDtrackGTU*) fTracks[zch][refLayerIdx].First();
- if (trk[refLayerIdx] == 0) {
+ trkInRefLayer[refLayerIdx] = (AliTRDtrackGTU*) fTracks[zch][refLayerIdx].First();
+ if (trkInRefLayer[refLayerIdx] == 0) {
continue;
}
else if (trkStage0 == 0x0 ) {
- trkStage0 = trk[refLayerIdx];
+ trkStage0 = trkInRefLayer[refLayerIdx];
minIdx = refLayerIdx;
done = kFALSE;
}
- else if (trk[refLayerIdx]->GetZSubChannel() < trkStage0->GetZSubChannel() ||
- (trk[refLayerIdx]->GetZSubChannel() == trkStage0->GetZSubChannel() && trk[refLayerIdx]->GetYapprox() < trkStage0->GetYapprox()) ) {
+ else if (trkInRefLayer[refLayerIdx]->GetZSubChannel() < trkStage0->GetZSubChannel() ||
+ (trkInRefLayer[refLayerIdx]->GetZSubChannel() == trkStage0->GetZSubChannel() && trkInRefLayer[refLayerIdx]->GetYapprox() < trkStage0->GetYapprox()) ) {
minIdx = refLayerIdx;
- trkStage0 = trk[refLayerIdx];
+ trkStage0 = trkInRefLayer[refLayerIdx];
done = kFALSE;
}
}
protected:
TObjArray **fTracklets; // holding all tracklets from one detector (i. e. one chamber)
TList **fZChannelTracklets; // holding all tracklets for layer and z-channel
- TList **fTracks;
+ TList **fTracks; // lists of tracks
AliTRDgtuParam *fGtuParam; // pointer to the instance of the GtuParam class
Int_t fStack; // Stack of this TMU
#include "AliTRDSimParam.h"
#include "AliTRDgeometry.h"
#include "AliTRDcalibDB.h"
+#include "AliTRDdigitsManager.h"
// additional for new tail filter and/or tracklet
#include "AliTRDtrapAlu.h"
//if you want to activate the MC tracklet output, set fgkMCTrackletOutput=kTRUE in AliTRDfeeParam
- if (!fFeeParam->GetMCTrackletOutput()) return;
+ if (!fFeeParam->GetMCTrackletOutput())
+ return;
-
AliLog::SetClassDebugLevel("AliTRDmcmSim", 10);
AliLog::SetFileOutput("../log/tracklet.log");
- UInt_t* trackletWord;
- Int_t* adcChannel;
-
- Int_t u = 0;
-
// testing for wordnr in order to speed up the simulation
if (wordnr == 0)
return;
- //Int_t mcmNr = fRobPos * (fGeo->MCMmax()) + fMcmPos;
-
- trackletWord = new UInt_t[fMaxTracklets];
- adcChannel = new Int_t[fMaxTracklets];
+ UInt_t *trackletWord = new UInt_t[fMaxTracklets];
+ Int_t *adcChannel = new Int_t[fMaxTracklets];
+ Int_t *trackRef = new Int_t[fMaxTracklets];
+
+ Int_t u = 0;
+
+ AliTRDdigitsManager *digman = new AliTRDdigitsManager();
+ digman->ReadDigits(gAlice->GetRunLoader()->GetLoader("TRDLoader")->TreeD());
+ digman->SetUseDictionaries(kTRUE);
+ AliTRDfeeParam *feeParam = AliTRDfeeParam::Instance();
for (Int_t j = 0; j < fMaxTracklets; j++) {
Int_t i = order[j];
if (bitWord[j]!=0) {
trackletWord[u] = bitWord[j];
adcChannel[u] = mADC[i]; // mapping onto the original adc-array to be in line with the digits-adc-ordering (21 channels in total on 1 mcm, 18 belonging to pads); mADC[i] should be >-1 in case bitWord[i]>0
-
- //fMCMT[u] = bitWord[j];
+
+// Finding label of MC track
+ TH1F *hTrkRef = new TH1F("trackref", "trackref", 100000, 0, 100000);
+ Int_t track[3];
+ Int_t padcol = feeParam->GetPadColFromADC(fRobPos, fMcmPos, adcChannel[u]);
+ Int_t padcol_ngb = feeParam->GetPadColFromADC(fRobPos, fMcmPos, adcChannel[u] - 1);
+ Int_t padrow = 4 * (fRobPos / 2) + fMcmPos / 4;
+ Int_t det = 30 * fSector + 6 * fStack + fLayer;
+ for(Int_t iTimebin = feeParam->GetLinearFitStart(); iTimebin < feeParam->GetLinearFitEnd(); iTimebin++) {
+ track[0] = digman->GetTrack(0, padrow, padcol, iTimebin, det);
+ track[1] = digman->GetTrack(1, padrow, padcol, iTimebin, det);
+ track[2] = digman->GetTrack(2, padrow, padcol, iTimebin, det);
+ hTrkRef->Fill(track[0]);
+ if (track[1] != track[0] && track[1] != -1)
+ hTrkRef->Fill(track[1]);
+ if (track[2] != track[0] && track[2] != track[1] && track[2] != -1)
+ hTrkRef->Fill(track[2]);
+ if (padcol_ngb >= 0) {
+ track[0] = digman->GetTrack(0, padrow, padcol, iTimebin, det);
+ track[1] = digman->GetTrack(1, padrow, padcol, iTimebin, det);
+ track[2] = digman->GetTrack(2, padrow, padcol, iTimebin, det);
+ hTrkRef->Fill(track[0]);
+ if (track[1] != track[0] && track[1] != -1)
+ hTrkRef->Fill(track[1]);
+ if (track[2] != track[0] && track[2] != track[1] && track[2] != -1)
+ hTrkRef->Fill(track[2]);
+ }
+ }
+ trackRef[u] = hTrkRef->GetMaximumBin() - 1;
+ delete hTrkRef;
u = u + 1;
}
}
trkl->SetDetector(30*fSector + 6*fStack + fLayer);
trkl->SetROB(fRobPos);
trkl->SetMCM(fMcmPos);
+ trkl->SetLabel(trackRef[iTracklet]);
trackletTree->Fill();
-// AliInfo(Form("Filling tracklet tree with trkl: %i", iTracklet));
}
delete trkl;
dl->WriteData("OVERWRITE");
}
+ delete [] trackletWord;
+ delete [] adcChannel;
+ delete [] trackRef;
+ delete digman;
// to be done:
// error measure for quality of fit (not necessarily needed for the trigger)
// electron probability
}
-
-
-
-
-
#include "TObject.h"
#include "TObjArray.h"
+#include "TClass.h"
+#include "TH1F.h"
#include "AliLog.h"
#include "AliTRDgtuParam.h"
#include "AliTRDtrackGTU.h"
#include "AliTRDtrackletGTU.h"
+#include "AliTRDtrackletMCM.h"
#include "AliESDTrdTrack.h"
ClassImp(AliTRDtrackGTU)
fZSubChannel(-1),
fA(0),
fB(0),
- fC(0)
+ fC(0),
+ fLabel(-1)
{
+// default ctor
+
fTracklets = new TClonesArray("AliTRDtrackletGTU", 6);
for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++)
new ((*fTracklets)[iTracklet]) AliTRDtrackletGTU();
AliTRDtrackGTU::~AliTRDtrackGTU()
{
+// dtor
+
fTracklets->Delete();
delete fTracklets;
}
void AliTRDtrackGTU::AddTracklet(AliTRDtrackletGTU *tracklet, Int_t layer)
{
+// add a tracklet to this track
+
if ( (fTrackletMask & (1 << layer)) != 0 ) {
AliError(Form("Only one tracklet per layer (%i) possible! Mask: 0x%02x", layer, fTrackletMask));
return;
AliTRDtrackletGTU* AliTRDtrackGTU::GetTracklet(Int_t layer)
{
+// get a pointer to the tracklet in the layer specified
+
return ((AliTRDtrackletGTU*) (*fTracklets)[layer]);
}
Int_t AliTRDtrackGTU::GetNTracklets() const
{
+// returns the number of tracklets in this track
+
return fNTracklets;
}
Bool_t AliTRDtrackGTU::IsTrackletInLayer(Int_t layer) const
{
+// checks for a tracklet in the given layer
+
if ( (GetTrackletMask() & (1 << layer)) != 0)
return kTRUE;
else
void AliTRDtrackGTU::SetFitParams(Float_t a, Float_t b, Float_t c)
{
+// set the fit parameters
+
fA = a;
fB = b;
fC = c;
Int_t AliTRDtrackGTU::GetZSubChannel()
{
+// returns the z-subchannel
+
if (fZSubChannel < 0) {
for (Int_t layer = 0; layer < AliTRDgtuParam::GetNLayers(); layer++)
{
Int_t AliTRDtrackGTU::GetYapprox()
{
+// returns an approximated y-position for the track
+
for (Int_t layer = 0; layer < AliTRDgtuParam::GetNLayers(); layer++)
{
if (IsTrackletInLayer(layer))
AliESDTrdTrack* AliTRDtrackGTU::CreateTrdTrack() const
{
+// creates an AliESDTrdTrack to be added to the ESD
+
AliESDTrdTrack *trk = new AliESDTrdTrack();
trk->SetPt(1./128. * fPt);
trk->SetPID(fPID);
- trk->SetDetector(fSector * 30 + fStack * 6);
+ trk->SetDetector((Char_t) (fSector * 5 + fStack));
+ if (fLabel >= 0)
+ trk->SetLabel(fLabel);
+ AliInfo(Form("setting detector to: %i (sector: %i, stack: %i), readback: %i", fSector * 30 + fStack * 6, fSector, fStack, trk->GetDetector()));
return trk;
}
+
+Bool_t AliTRDtrackGTU::CookLabel()
+{
+ TH1F *h = new TH1F("trkref", "trkref", 100000, 0, 100000);
+ for (Int_t iTracklet = 0; iTracklet < 6; iTracklet++) {
+ h->Fill( ((AliTRDtrackletGTU*) (*fTracklets)[iTracklet])->GetLabel());
+ }
+ if (h->GetEntries() > 0)
+ fLabel = h->GetMaximumBin();
+ else
+ fLabel = -1;
+ delete h;
+ return (fLabel >= 0);
+}
// void SetOuterIntPoint(Float_t *x);
void SetFitParams(Float_t a, Float_t b, Float_t c);
+ Bool_t CookLabel();
+
protected:
- Int_t fStack;
- Int_t fSector;
+ Int_t fStack; // TRD stack to which this track belongs
+ Int_t fSector; // sector in which the track was found
Int_t fPt; // pt in integer representation
- Int_t fPID;
+ Int_t fPID; // PID calculated from tracklet PID
+
+ TClonesArray *fTracklets; // array holding the tracklets composing this track
+ Int_t fTrackletMask; // mask in which layers tracklets have been assigned
+ Int_t fNTracklets; // number of tracklets in this track
- TClonesArray *fTracklets;
- Int_t fTrackletMask;
- Int_t fNTracklets;
+ Int_t fRefLayerIdx; // index of the reference layer in which this track was found
+ Int_t fZChannel; // z-channel unit in which this track was found
+ Int_t fZSubChannel; // z-subchannel of the assigned tracklets
- Int_t fRefLayerIdx;
- Int_t fZChannel;
- Int_t fZSubChannel;
+ Float_t fA; // fit parameter of y' = a + b*x + c*z
+ Float_t fB; // fit parameter of y' = a + b*x + c*z
+ Float_t fC; // fit parameter of y' = a + b*x + c*z
- Float_t fA;
- Float_t fB;
- Float_t fC;
+ Int_t fLabel; // MC label
private:
AliTRDtrackGTU(const AliTRDtrackGTU &rhs); // not implemented
////////////////////////////////////////////////////////////////////////////
#include "TMath.h"
+#include "TClass.h"
#include "AliTRDtrackletGTU.h"
#include "AliTRDtrackletWord.h"
#include "AliTRDmcmTracklet.h"
+#include "AliTRDtrackletMCM.h"
#include "AliLog.h"
#include "AliTRDgtuParam.h"
#include "AliTRDgeometry.h"
for (Int_t zch = 0; zch < fGtuParam->GetNZChannels(); zch++)
fSubChannel[zch] = 0;
fTracklet = tracklet;
+ if ( fTracklet->IsA() == TClass::GetClass("AliTRDtrackletMCM")) {
+ AliInfo(Form("label from mcm tracklet: %i", ((AliTRDtrackletMCM*) fTracklet)->GetLabel()));
+ }
}
AliTRDtrackletGTU::AliTRDtrackletGTU(const AliTRDtrackletGTU& tracklet) :
return fSubChannel[zch];
}
+Int_t AliTRDtrackletGTU::GetLabel() const
+{
+ if ( fTracklet->IsA() == TClass::GetClass("AliTRDtrackletMCM"))
+ return ((AliTRDtrackletMCM*) fTracklet)->GetLabel();
+ else
+ return -1;
+}
+
/*
Float_t AliTRDtrackletGTU::GetPhysX(Int_t layer)
{
#include "AliTRDtrackletBase.h"
#include "AliLog.h"
-class AliTRDmcmTracklet;
class AliTRDgtuParam;
class AliTRDtrackletGTU : public AliTRDtrackletBase {
public:
AliTRDtrackletGTU();
-// AliTRDtrackletGTU(UInt_t tracklet_word = 0);
AliTRDtrackletGTU(AliTRDtrackletBase *tracklet);
AliTRDtrackletGTU(const AliTRDtrackletGTU& trk);
Int_t GetSide() const { return GetYbin() < 0 ? 0 : 1; }
+ Int_t GetLabel() const; // { return fLabel; }
+
// ----- Setters -----
void SetAlpha(Int_t alpha) { fAlpha = alpha; }
void SetYProj(Int_t yproj) { fYProj = yproj; }
Int_t fAlpha; // calculated value for alpha
Int_t fYProj; // calculated value for y_proj
Int_t fYPrime; // calculated value for y'
- Int_t fIndex;
+ Int_t fIndex; // index of tracklet in the sequence after the input units
- static AliTRDtrackletBase* fgkDummyTracklet;
+ static AliTRDtrackletBase* fgkDummyTracklet; // dummy tracklet, used in case no tracklet is given
private:
AliTRDtrackletMCM::AliTRDtrackletMCM(UInt_t trackletWord) :
AliTRDtrackletBase(),
+ fGeo(0x0),
fHCId(-1),
fTrackletWord(trackletWord),
fMCM(-1),
- fROB(-1)
+ fROB(-1),
+ fLabel(-1)
{
-
+ fGeo = new AliTRDgeometry();
}
AliTRDtrackletMCM::AliTRDtrackletMCM(UInt_t trackletWord, Int_t hcid) :
AliTRDtrackletBase(),
+ fGeo(0x0),
fHCId(hcid),
fTrackletWord(trackletWord),
fMCM(-1),
- fROB(-1)
+ fROB(-1),
+ fLabel(-1)
{
-
+ fGeo = new AliTRDgeometry();
}
AliTRDtrackletMCM::AliTRDtrackletMCM(const AliTRDtrackletMCM &rhs) :
AliTRDtrackletBase(rhs),
+ fGeo(0x0),
fHCId(rhs.fHCId),
fTrackletWord(rhs.fTrackletWord),
fMCM(rhs.fMCM),
- fROB(rhs.fROB)
+ fROB(rhs.fROB),
+ fLabel(rhs.fLabel)
{
-
+ fGeo = new AliTRDgeometry();
}
AliTRDtrackletMCM::~AliTRDtrackletMCM()
{
-
+ delete fGeo;
}
Int_t AliTRDtrackletMCM::GetYbin() const {
//----------------------------------
#include "AliTRDtrackletBase.h"
+#include "AliTRDgeometry.h"
+#include "AliTRDpadPlane.h"
class AliTRDtrackletMCM : public AliTRDtrackletBase {
public:
- AliTRDtrackletMCM(UInt_t tracklet_word = 0);
- AliTRDtrackletMCM(UInt_t tracklet_word, Int_t hcid);
+ AliTRDtrackletMCM(UInt_t trackletWord = 0);
+ AliTRDtrackletMCM(UInt_t trackletWword, Int_t hcid);
AliTRDtrackletMCM(const AliTRDtrackletMCM &rhs);
~AliTRDtrackletMCM();
// ----- Getters for MCM-tracklet information -----
Int_t GetMCM() const { return fMCM; }
Int_t GetROB() const { return fROB; }
+ Int_t GetLabel() const { return fLabel; }
// ----- Getters for offline corresponding values -----
Bool_t CookPID() { return kFALSE; }
Int_t GetDetector() const { return fHCId / 2; }
Int_t GetHCId() const { return fHCId; }
Float_t GetdYdX() const { return (GetdY() * 140e-4 / 3.); }
- Float_t GetX() const { return 0; }
+ Float_t GetX() const { return fGeo->GetTime0((fHCId % 12) / 2); }
Float_t GetY() const { return (GetYbin() * 160e-4); }
- Float_t GetZ() const { return 0; }
+ Float_t GetZ() const { return fGeo->GetPadPlane((fHCId % 12) / 2, (fHCId / 12) % 5)->GetRowPos( 4 * (fROB / 2) + fMCM / 4); }
UInt_t GetTrackletWord() const { return fTrackletWord; }
void SetTrackletWord(UInt_t trackletWord) { fTrackletWord = trackletWord; }
void SetHCId(Int_t id) { fHCId = id; }
void SetMCM(Int_t mcm) { fMCM = mcm; }
void SetROB(Int_t rob) { fROB = rob; }
+ void SetLabel(Int_t label) { fLabel = label; }
protected:
+ AliTRDgeometry *fGeo; //! TRD geometry
+
Int_t fHCId; // half-chamber ID (only transient)
UInt_t fTrackletWord; // tracklet word: PID | Z | deflection length | Y
// bits: 12 4 7 13
- Int_t fMCM;
- Int_t fROB;
+ Int_t fMCM; // MCM no. in which the tracklet was found
+ Int_t fROB; // ROB no. on which the tracklet was found
+
+ Int_t fLabel; // label for MC track
+
+ private:
+ AliTRDtrackletMCM& operator=(const AliTRDtrackletMCM &rhs); // not implemented
ClassDef(AliTRDtrackletMCM, 1);
};
class AliTRDtrackletWord : public AliTRDtrackletBase {
public:
- AliTRDtrackletWord(UInt_t tracklet_word = 0);
- AliTRDtrackletWord(UInt_t tracklet_word, Int_t hcid);
+ AliTRDtrackletWord(UInt_t trackletWord = 0);
+ AliTRDtrackletWord(UInt_t trackletWord, Int_t hcid);
AliTRDtrackletWord(const AliTRDtrackletWord &rhs);
~AliTRDtrackletWord();
UInt_t fTrackletWord; // tracklet word: PID | Z | deflection length | Y
// bits: 12 4 7 13
+ private:
+ AliTRDtrackletWord& operator=(const AliTRDtrackletWord &rhs); // not implemented
+
ClassDef(AliTRDtrackletWord, 1);
};