/*
$Log$
+
+Revision 1.17.2.6 2000/10/15 23:29:08 cblume
+Introduced more detailed geometry for the display
+
+Revision 1.17.2.5 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.17.2.4 2000/10/04 16:34:57 cblume
+Replace include files by forward declarations
+
+Revision 1.17.2.3 2000/09/22 14:45:17 cblume
+Included changes for the tracking
+
+Revision 1.17.2.2 2000/09/18 13:25:13 cblume
+Included LoadPoints() method to display the TR photons
+
+Revision 1.22 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.21 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
+Revision 1.20 2000/06/08 18:32:57 cblume
+Make code compliant to coding conventions
+
+Revision 1.19 2000/06/07 16:25:37 cblume
+Try to remove compiler warnings on Sun and HP
+
+Revision 1.18 2000/05/08 16:17:27 cblume
+Merge TRD-develop
+
Revision 1.21 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
#include <TMath.h>
#include <TNode.h>
-#include <TPGON.h>
#include <TGeometry.h>
-#include <TTree.h>
+#include <TTree.h>
+#include <TPGON.h>
-#include "AliTRD.h"
#include "AliRun.h"
#include "AliConst.h"
+#include "AliDigit.h"
+#include "AliMagF.h"
+#include "AliMC.h"
+
+#include "AliTRD.h"
+#include "AliTRDhit.h"
+#include "AliTRDpoints.h"
+#include "AliTRDdigit.h"
#include "AliTRDdigitizer.h"
#include "AliTRDclusterizer.h"
#include "AliTRDgeometryHole.h"
#include "AliTRDgeometryFull.h"
#include "AliTRDrecPoint.h"
-#include "AliMagF.h"
-#include "AliMC.h"
-
+
ClassImp(AliTRD)
//_____________________________________________________________________________
fGeometry = 0;
+ fGasDensity = 0;
+ fFoilDensity = 0;
+
+ fDrawTR = 0;
+ fDisplayType = 0;
+
}
//_____________________________________________________________________________
}
// Allocate the hit array
- fHits = new TClonesArray("AliTRDhit" ,405);
+ fHits = new TClonesArray("AliTRDhit" ,405);
gAlice->AddHitList(fHits);
// Allocate the digits array
- fDigits = 0;
+ fDigits = 0;
// Allocate the rec point array
- fRecPoints = new TObjArray(400);
- fNRecPoints = 0;
+ fRecPoints = new TObjArray(400);
+ fNRecPoints = 0;
- fIshunt = 0;
- fGasMix = 0;
+ fIshunt = 0;
+ fGasMix = 0;
+
+ fGasDensity = 0;
+ fFoilDensity = 0;
+
+ fDrawTR = 0;
+ fDisplayType = 0;
SetMarkerColor(kWhite);
}
//_____________________________________________________________________________
-void AliTRD::AddRecPoint(Float_t *pos, Int_t *digits, Int_t det, Float_t amp)
+void AliTRD::AddRecPoint(Float_t *pos, Int_t *digits, Int_t det, Float_t amp
+ , Int_t *tracks)
{
//
// Add a reconstructed point for the TRD
//
-
+
AliTRDrecPoint *recPoint = new AliTRDrecPoint();
TVector3 posVec(pos[0],pos[1],pos[2]);
recPoint->SetLocalPosition(posVec);
recPoint->AddDigit(digits[iDigit]);
}
+ recPoint->AddTrackIndex(tracks);
+
+ recPoint->SetTrackingYZ(0.,0.); // variance values set inside
fRecPoints->Add(recPoint);
}
}
//_____________________________________________________________________________
-void AliTRD::AddHit(Int_t track, Int_t *det, Float_t *hits)
+void AliTRD::AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q)
{
//
// Add a hit for the TRD
//
TClonesArray &lhits = *fHits;
- new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits);
+ new(lhits[fNhits++]) AliTRDhit(fIshunt,track,det,hits,q);
}
TNode *node, *top;
TPGON *pgon;
+
+ Float_t rmin, rmax;
+ Float_t zmax1, zmax2;
+
const Int_t kColorTRD = 46;
// Find the top node alice
top = gAlice->GetGeometry()->GetNode("alice");
- pgon = new TPGON("S_TRD","TRD","void",0,360,kNsect,4);
- Float_t ff = TMath::Cos(kDegrad * 180 / kNsect);
- Float_t rrmin = kRmin / ff;
- Float_t rrmax = kRmax / ff;
- pgon->DefineSection(0,-kZmax1,rrmax,rrmax);
- pgon->DefineSection(1,-kZmax2,rrmin,rrmax);
- pgon->DefineSection(2, kZmax2,rrmin,rrmax);
- pgon->DefineSection(3, kZmax1,rrmax,rrmax);
- top->cd();
- node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
- node->SetLineColor(kColorTRD);
- fNodes->Add(node);
+ switch (fDisplayType) {
+
+ case 0:
+
+ pgon = new TPGON("S_TRD","TRD","void",0,360,AliTRDgeometry::Nsect(),4);
+ rmin = AliTRDgeometry::Rmin();
+ rmax = AliTRDgeometry::Rmax();
+ pgon->DefineSection(0,-AliTRDgeometry::Zmax1(),rmax,rmax);
+ pgon->DefineSection(1,-AliTRDgeometry::Zmax2(),rmin,rmax);
+ pgon->DefineSection(2, AliTRDgeometry::Zmax2(),rmin,rmax);
+ pgon->DefineSection(3, AliTRDgeometry::Zmax1(),rmax,rmax);
+ top->cd();
+ node = new TNode("TRD","TRD","S_TRD",0,0,0,"");
+ node->SetLineColor(kColorTRD);
+ fNodes->Add(node);
+
+ break;
+
+ case 1:
+
+ Float_t slope = (AliTRDgeometry::Zmax1() - AliTRDgeometry::Zmax2())
+ / (AliTRDgeometry::Rmax() - AliTRDgeometry::Rmin());
+
+ rmin = AliTRDgeometry::Rmin() + AliTRDgeometry::RaThick();
+ rmax = rmin + AliTRDgeometry::DrThick();
+ zmax2 = AliTRDgeometry::Zmax2() + slope * AliTRDgeometry::RaThick();
+ zmax1 = zmax2 + slope * AliTRDgeometry::DrThick();
+ Char_t name[7];
+
+ for (Int_t iPlan = 0; iPlan < AliTRDgeometry::Nplan(); iPlan++) {
+
+ sprintf(name,"S_TRD%d",iPlan);
+ pgon = new TPGON(name,"TRD","void",0,360,AliTRDgeometry::Nsect(),4);
+ pgon->DefineSection(0,-zmax1,rmax,rmax);
+ pgon->DefineSection(1,-zmax2,rmin,rmax);
+ pgon->DefineSection(2, zmax2,rmin,rmax);
+ pgon->DefineSection(3, zmax1,rmax,rmax);
+ top->cd();
+ node = new TNode("TRD","TRD",name,0,0,0,"");
+ node->SetLineColor(kColorTRD);
+ fNodes->Add(node);
+
+ Float_t height = AliTRDgeometry::Cheight() + AliTRDgeometry::Cspace();
+ rmin = rmin + height;
+ rmax = rmax + height;
+ zmax1 = zmax1 + slope * height;
+ zmax2 = zmax2 + slope * height;
+
+ }
+
+ break;
+
+ };
}
// Copy function
//
- ((AliTRD &) trd).fGasMix = fGasMix;
- ((AliTRD &) trd).fGeometry = fGeometry;
- ((AliTRD &) trd).fRecPoints = fRecPoints;
- ((AliTRD &) trd).fNRecPoints = fNRecPoints;
+ ((AliTRD &) trd).fGasMix = fGasMix;
+ ((AliTRD &) trd).fGeometry = fGeometry;
+ ((AliTRD &) trd).fRecPoints = fRecPoints;
+ ((AliTRD &) trd).fNRecPoints = fNRecPoints;
+ ((AliTRD &) trd).fGasDensity = fGasDensity;
+ ((AliTRD &) trd).fFoilDensity = fFoilDensity;
+ ((AliTRD &) trd).fDrawTR = fDrawTR;
+ ((AliTRD &) trd).fDisplayType = fDisplayType;
//AliDetector::Copy(trd);
Float_t stmin = -0.001;
Float_t absl, radl, d, buf[1];
- Float_t agm[2], dgm, zgm[2], wgm[2];
+ Float_t agm[2], zgm[2], wgm[2];
+ Float_t dgm1, dgm2;
Int_t nbuf;
//////////////////////////////////////////////////////////////////////////
// Create gas mixture
wgm[0] = fxc;
wgm[1] = 1. - fxc;
- dgm = wgm[0] * dxe + wgm[1] * dco;
- AliMixture(10, "Gas mixture 1$", agm, zgm, dgm, 2, wgm);
+ dgm1 = wgm[0] * dxe + wgm[1] * dco;
+ AliMixture(10, "Gas mixture 1$", agm, zgm, dgm1, 2, wgm);
// Xe/Isobutane-mixture
// Get properties of Xe
gMC->Gfmate((*fIdmate)[4], namate, agm[0], zgm[0], d, radl, absl, buf, nbuf);
// Create gas mixture
wgm[0] = fxi;
wgm[1] = 1. - fxi;
- dgm = wgm[0] * dxe + wgm[1] * dis;
- AliMixture(11, "Gas mixture 2$", agm, zgm, dgm, 2, wgm);
+ dgm2 = wgm[0] * dxe + wgm[1] * dis;
+ AliMixture(11, "Gas mixture 2$", agm, zgm, dgm2, 2, wgm);
//////////////////////////////////////////////////////////////////////////
// Tracking Media Parameters
AliMedium(14, "Water$", 13, 0, isxfld, sxmgmx
, tmaxfd, stemax, deemax, epsil, stmin);
+ // Save the density values for the TRD absorbtion
+ fFoilDensity = dmy;
+ if (fGasMix == 1)
+ fGasDensity = dgm1;
+ else
+ fGasDensity = dgm2;
+
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
+void AliTRD::LoadPoints(Int_t track)
+{
+ //
+ // Store x, y, z of all hits in memory.
+ // Hit originating from TR photons are given a different color
+ //
+
+ if (!fDrawTR) {
+ AliDetector::LoadPoints(track);
+ return;
+ }
+
+ if (fHits == 0) return;
+
+ Int_t nhits = fHits->GetEntriesFast();
+ if (nhits == 0) return;
+
+ Int_t tracks = gAlice->GetNtrack();
+ if (fPoints == 0) fPoints = new TObjArray(tracks);
+
+ AliTRDhit *ahit;
+
+ Int_t *ntrkE = new Int_t[tracks];
+ Int_t *ntrkT = new Int_t[tracks];
+ Int_t *limiE = new Int_t[tracks];
+ Int_t *limiT = new Int_t[tracks];
+ Float_t **coorE = new Float_t*[tracks];
+ Float_t **coorT = new Float_t*[tracks];
+ for(Int_t i = 0; i < tracks; i++) {
+ ntrkE[i] = 0;
+ ntrkT[i] = 0;
+ coorE[i] = 0;
+ coorT[i] = 0;
+ limiE[i] = 0;
+ limiT[i] = 0;
+ }
+
+ AliTRDpoints *points = 0;
+ Float_t *fp = 0;
+ Int_t trk;
+ Int_t chunk = nhits / 4 + 1;
+
+ // Loop over all the hits and store their position
+ for (Int_t hit = 0; hit < nhits; hit++) {
+
+ ahit = (AliTRDhit *) fHits->UncheckedAt(hit);
+
+ // dEdx hits
+ if (ahit->GetCharge() >= 0) {
+
+ trk = ahit->GetTrack();
+ if (ntrkE[trk] == limiE[trk]) {
+ // Initialise a new track
+ fp = new Float_t[3*(limiE[trk]+chunk)];
+ if (coorE[trk]) {
+ memcpy(fp,coorE[trk],sizeof(Float_t)*3*limiE[trk]);
+ delete [] coorE[trk];
+ }
+ limiE[trk] += chunk;
+ coorE[trk] = fp;
+ }
+ else {
+ fp = coorE[trk];
+ }
+ fp[3*ntrkE[trk] ] = ahit->X();
+ fp[3*ntrkE[trk]+1] = ahit->Y();
+ fp[3*ntrkE[trk]+2] = ahit->Z();
+ ntrkE[trk]++;
+
+ }
+ // TR photon hits
+ else {
+
+ trk = ahit->GetTrack();
+ if (ntrkT[trk] == limiT[trk]) {
+ // Initialise a new track
+ fp = new Float_t[3*(limiT[trk]+chunk)];
+ if (coorT[trk]) {
+ memcpy(fp,coorT[trk],sizeof(Float_t)*3*limiT[trk]);
+ delete [] coorT[trk];
+ }
+ limiT[trk] += chunk;
+ coorT[trk] = fp;
+ }
+ else {
+ fp = coorT[trk];
+ }
+ fp[3*ntrkT[trk] ] = ahit->X();
+ fp[3*ntrkT[trk]+1] = ahit->Y();
+ fp[3*ntrkT[trk]+2] = ahit->Z();
+ ntrkT[trk]++;
+
+ }
+
+ }
+
+ for (trk = 0; trk < tracks; ++trk) {
+
+ if (ntrkE[trk] || ntrkT[trk]) {
+
+ points = new AliTRDpoints();
+ points->SetDetector(this);
+ points->SetParticle(trk);
+
+ // Set the dEdx points
+ if (ntrkE[trk]) {
+ points->SetMarkerColor(GetMarkerColor());
+ points->SetMarkerSize(GetMarkerSize());
+ points->SetPolyMarker(ntrkE[trk],coorE[trk],GetMarkerStyle());
+ delete [] coorE[trk];
+ coorE[trk] = 0;
+ }
+
+ // Set the TR photon points
+ if (ntrkT[trk]) {
+ points->SetTRpoints(ntrkT[trk],coorT[trk]);
+ delete [] coorT[trk];
+ coorT[trk] = 0;
+ }
+
+ fPoints->AddAt(points,trk);
+
+ }
+
+ }
+
+ delete [] coorE;
+ delete [] coorT;
+ delete [] ntrkE;
+ delete [] ntrkT;
+ delete [] limiE;
+ delete [] limiT;
+
+}
+
+//_____________________________________________________________________________
void AliTRD::MakeBranch(Option_t* option)
{
//
// Create Tree branches for the TRD digits and cluster.
//
- Int_t buffersize = 4000;
- Char_t branchname[15];
+ //Int_t buffersize = 4000;
+ //Char_t branchname[15];
AliDetector::MakeBranch(option);
- Char_t *r = strstr(option,"R");
- sprintf(branchname,"%srecPoints",GetName());
- if (fRecPoints && gAlice->TreeR() && r) {
- gAlice->TreeR()->Branch(branchname,fRecPoints->IsA()->GetName()
- ,&fRecPoints,buffersize,0);
- printf("* AliTRD::MakeBranch * Making Branch %s for points in TreeR\n",branchname);
- }
+ //Char_t *r = strstr(option,"R");
+ //sprintf(branchname,"%srecPoints",GetName());
+ //if (fRecPoints && gAlice->TreeR() && r) {
+ // gAlice->TreeR()->Branch(branchname,fRecPoints->IsA()->GetName()
+ // ,&fRecPoints,buffersize,0);
+ // printf("* AliTRD::MakeBranch * Making Branch %s for points in TreeR\n",branchname);
+ //}
}
// Reset number of reconstructed points and the point array
//
- fNRecPoints = 0;
- if (fRecPoints) fRecPoints->Delete();
+ if(fRecPoints) {
+ fNRecPoints = 0;
+ Int_t nentr = fRecPoints->GetEntriesFast();
+ for(Int_t i = 0; i < nentr; i++) delete fRecPoints->RemoveAt(i);
+ }
}
}
//_____________________________________________________________________________
+void AliTRD::SetPHOShole()
+{
+ //
+ // Selects a geometry with a hole in front of the PHOS
+ //
+
+ fGeometry->SetPHOShole();
+
+}
+
+//_____________________________________________________________________________
+void AliTRD::SetRICHhole()
+{
+ //
+ // Selects a geometry with a hole in front of the RICH
+ //
+
+ fGeometry->SetRICHhole();
+
+}
+
+//_____________________________________________________________________________
AliTRD &AliTRD::operator=(const AliTRD &trd)
{
//
////////////////////////////////////////////////
// Manager and hits classes for set: TRD //
////////////////////////////////////////////////
-
-#include "AliRun.h"
+
#include "AliDetector.h"
-#include "AliTRDhit.h"
-#include "AliDigit.h"
-#include "AliTRDconst.h"
-#include "AliTRDgeometry.h"
+class AliRun;
+class AliDigit;
+
+class AliTRDhit;
+class AliTRDsim;
+class AliTRDgeometry;
//_____________________________________________________________________________
class AliTRD : public AliDetector {
AliTRD &operator=(const AliTRD &trd);
- virtual void AddHit(Int_t track, Int_t *det, Float_t *hits);
+ virtual void AddHit(Int_t track, Int_t det, Float_t *hits, Int_t q);
virtual void AddDigit(Int_t *digits, Int_t *amp);
virtual void AddRecPoint(Float_t *pos, Int_t *digits
- , Int_t det, Float_t amp);
+ , Int_t det, Float_t amp, Int_t *tracks);
virtual void BuildGeometry();
virtual void Copy(TObject &trd);
virtual void CreateGeometry();
virtual void CreateMaterials();
virtual void DrawModule();
Int_t DistancetoPrimitive(Int_t px, Int_t py);
- TObjArray *RecPoints() { return fRecPoints; };
+ virtual void LoadPoints(Int_t track);
+ TObjArray *RecPoints() const { return fRecPoints; };
virtual void Init();
virtual Int_t IsVersion() const = 0;
virtual void MakeBranch(Option_t* option);
virtual void SetGasMix(Int_t imix = 0);
virtual void SetHits() {};
- virtual void SetPHOShole() { fGeometry->SetPHOShole(); };
- virtual void SetRICHhole() { fGeometry->SetRICHhole(); };
+ virtual void SetPHOShole();
+ virtual void SetRICHhole();
+ virtual void SetDrawTR(Int_t idraw = 1) { fDrawTR = idraw; };
+ virtual void SetDisplayType(Int_t type = 0) { fDisplayType = type; };
- AliTRDgeometry *GetGeometry() { return fGeometry; };
+ AliTRDgeometry *GetGeometry() const { return fGeometry; };
virtual void SetSensChamber(Int_t ichamber) = 0;
virtual void SetSensPlane(Int_t iplane) = 0;
virtual void SetSensSector(Int_t isector) = 0;
virtual void SetSensSector(Int_t isector, Int_t nsector) = 0;
- virtual Int_t GetSensChamber() = 0;
- virtual Int_t GetSensPlane() = 0;
- virtual Int_t GetSensSector() = 0;
- virtual Int_t GetSensSectorRange() = 0;
+ virtual Int_t GetSensChamber() const = 0;
+ virtual Int_t GetSensPlane() const = 0;
+ virtual Int_t GetSensSector() const = 0;
+ virtual Int_t GetSensSectorRange() const = 0;
+
+ virtual AliTRDsim *CreateTR() = 0;
+ virtual AliTRDsim *GetTR() const = 0;
protected:
TObjArray *fRecPoints; // Array of reconstructed points
Int_t fNRecPoints; //! Number of reconstructed points
+ Float_t fGasDensity; // The density of the drift gas
+ Float_t fFoilDensity; // The density of the entrance window foil
+
+ Int_t fDrawTR; // Switches marking the TR photons in the display
+ Int_t fDisplayType; // Display type (0: normal, 1: detailed)
+
ClassDef(AliTRD,1) // Transition Radiation Detector base class
};
--- /dev/null
+Int_t AliTRDanalyzeDigits()
+{
+ //
+ // Analyzes the digits
+ //
+
+ Int_t rc = 0;
+
+ return rc;
+
+}
--- /dev/null
+Int_t AliTRDanalyzeHits()
+{
+ //
+ // Analyzes the hits and fills QA-histograms
+ //
+
+ Int_t rc = 0;
+
+ if (!gAlice) {
+ cout << "<AliTRDanalyzeHits> No AliRun object found" << endl;
+ rc = 1;
+ return rc;
+ }
+ gAlice->GetEvent(0);
+
+ // Get the pointer to the TRD detector
+ AliDetector *TRD = gAlice->GetDetector("TRD");
+ if (!TRD) {
+ cout << "<AliTRDanalyzeHits> No TRD detector found" << endl;
+ rc = 2;
+ return rc;
+ }
+
+ // Define the histograms
+ TH1F *hQdedx = new TH1F("hQdedx","Charge dedx-hits",100,0.0,1000.0);
+ TH1F *hQtr = new TH1F("hQtr" ,"Charge TR-hits" ,100,0.0,1000.0);
+ TH2F *hZY = new TH2F("hZY" ,"Y vs Z",50,-100.0,100.0,40,290.0,370.0);
+ TH2F *hXZ = new TH2F("hXZ" ,"Z vs X",50,-100.0,100.0,50,-100.0,100.0);
+
+ // Get the pointer hit tree
+ TTree *HitTree = gAlice->TreeH();
+ if (!HitTree) {
+ cout << "<AliTRDanalyzeHits> No hit tree found" << endl;
+ rc = 3;
+ return rc;
+ }
+
+ Int_t countHits = 0;
+ Int_t nBytes = 0;
+
+ // Get the number of entries in the hit tree
+ // (Number of primary particles creating a hit somewhere)
+ Int_t nTrack = (Int_t) HitTree->GetEntries();
+ cout << "<AliTRDanalyzeHits> Found " << nTrack
+ << " primary particles with hits" << endl;
+
+ // Loop through all entries in the tree
+ for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
+
+ gAlice->ResetHits();
+ nBytes += HitTree->GetEvent(iTrack);
+
+ // Get the number of hits in the TRD created by this particle
+ Int_t nHit = TRD->Hits()->GetEntriesFast();
+ //cout << "<AliTRDanalyzeHits> Found " << nHit
+ // << " hits for primary particle " << iTrack << endl;
+
+ // Loop through the TRD hits
+ for (Int_t iHit = 0; iHit < nHit; iHit++) {
+
+ countHits++;
+
+ AliTRDhit *hit = (AliTRDhit *) TRD->Hits()->UncheckedAt(iHit);
+
+ Float_t x = hit->X();
+ Float_t y = hit->Y();
+ Float_t z = hit->Z();
+ Float_t q = hit->GetCharge();
+
+ if (q > 0)
+ hQdedx->Fill(q);
+ else
+ hQtr->Fill(TMath::Abs(q));
+
+ hZY->Fill(z,y);
+ hXZ->Fill(x,z);
+
+ }
+
+ }
+
+ cout << "<AliTRDanalyzeHits> Found " << countHits << " hits in total" << endl;
+
+ TCanvas *cHits = new TCanvas("cHits","AliTRDanalyzeHits",50,50,600,600);
+ cHits->Divide(2,2);
+ cHits->cd(1);
+ hXZ->Draw("COL");
+ cHits->cd(2);
+ hZY->Draw("COL");
+ cHits->cd(3);
+ gPad->SetLogy();
+ hQdedx->Draw();
+ cHits->cd(4);
+ gPad->SetLogy();
+ hQtr->Draw();
+
+ return rc;
+
+}
/*
$Log$
+
+Revision 1.1.4.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.4 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
+Revision 1.3 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
+Revision 1.2 2000/05/08 16:17:27 cblume
+Merge TRD-develop
+
+Revision 1.1.4.1 2000/05/08 14:35:54 cblume
+Update
+
+Revision 1.4 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.3 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
}
-
//_____________________________________________________________________________
void AliTRDarrayI::Expand(Int_t n)
{
/* $Id: AliTRDarrayI.h,v */
-#include "TObject.h"
-#include "TArrayI.h"
+#include <TObject.h>
+#include <TArrayI.h>
class AliTRDarrayI: public TObject ,public TArrayI {
public:
- ~AliTRDarrayI();
+ virtual ~AliTRDarrayI();
void Copy(TObject &a);
void Expand(Int_t n);
- ClassDef(AliTRDarrayI,1)
+ ClassDef(AliTRDarrayI,1) // An array of integers
};
/*
$Log$
+
+Revision 1.1.4.5 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.4.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.2 2000/09/22 14:49:49 cblume
+Adapted to tracking code
+
+Revision 1.5 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.4 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
+Revision 1.3 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
+Revision 1.2 2000/05/08 16:17:27 cblume
+Merge TRD-develop
+
+Revision 1.1.4.1 2000/05/08 15:08:03 cblume
+Remove the class AliTRDcluster
+
Revision 1.4 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
#include <TROOT.h>
#include <TTree.h>
+#include <TFile.h>
#include "AliRun.h"
#include "AliTRD.h"
#include "AliTRDclusterizer.h"
+#include "AliTRDrecPoint.h"
+#include "AliTRDgeometry.h"
ClassImp(AliTRDclusterizer)
}
//_____________________________________________________________________________
-Bool_t AliTRDclusterizer::WriteCluster()
+Bool_t AliTRDclusterizer::WriteClusters(Int_t det)
{
//
- // Writes out the TRD-cluster
- //
+ // Fills TRDrecPoints branch in TRDrecPoints## tree with rec. points
+ // found in detector = det. For det=-1 writes the tree.
+ // For det=-2 recreates the tree.
+
+ Char_t treeName[14];
+ sprintf(treeName,"TRDrecPoints%d", fEvent);
+
+ if (det == -2) {
+ fInputFile->Delete(treeName);
+ TTree *tree = new TTree(treeName,"Tree with TRD rec. points");
+ tree->Write();
+ return kTRUE;
+ }
- // Write the new tree into the input file (use overwrite option)
- Char_t treeName[7];
- sprintf(treeName,"TreeR%d",fEvent);
- printf("AliTRDclusterizer::WriteCluster -- ");
- printf("Write the cluster tree %s for event %d.\n"
- ,treeName,fEvent);
- gAlice->TreeR()->Write(treeName,2);
+ TTree *tree=(TTree*)fInputFile->Get(treeName);
+ TBranch *branch=tree->GetBranch("TRDrecPoints");
- return kTRUE;
+ if(!branch) {
+ TObjArray *ioArray = 0;
+ branch = tree->Branch("TRDrecPoints","TObjArray",&ioArray,32000,0);
+ }
+
+ if ((det >= 0) && (det < AliTRDgeometry::Ndet())) {
+
+ AliTRD *TRD = (AliTRD*) gAlice->GetDetector("TRD");
+ Int_t nRecPoints = TRD->RecPoints()->GetEntriesFast();
+ TObjArray *fDetRecPoints = new TObjArray(400);
+
+ for (Int_t i=0; i<nRecPoints; i++) {
+ AliTRDrecPoint *p=(AliTRDrecPoint*)TRD->RecPoints()->UncheckedAt(i);
+ if(det == p->GetDetector()) fDetRecPoints->AddLast(p);
+ else printf("attempt to write a RecPoint with unexpected detector index");
+ }
+
+ branch->SetAddress(&fDetRecPoints);
+ tree->Fill();
+ return kTRUE;
+ }
+
+ if (det == -1) {
+
+ printf("\rAliTRDclusterizer::WriteClusters -- ");
+ printf("Writing the cluster tree %-18s for event %d.\n"
+ ,tree->GetName(),fEvent);
+
+ tree->Write();
+ return kTRUE;
+ }
+
+ printf("\rAliTRDclusterizer::WriteClusters -- ");
+ printf("Unexpected detector index %d.\n", det);
+ return kFALSE;
}
+
+
+
/* $Id$ */
#include <TNamed.h>
-#include <TFile.h>
+
+class TFile;
///////////////////////////////////////////////////////
// Finds and handles cluster //
virtual void Copy(TObject &c);
virtual void Init();
virtual Bool_t Open(const Char_t *name, Int_t nEvent = 0);
- virtual Bool_t MakeCluster() = 0;
- virtual Bool_t WriteCluster();
+ virtual Bool_t MakeClusters() = 0;
+ virtual Bool_t WriteClusters(Int_t det);
protected:
/*
$Log$
+Revision 1.1.4.6 2000/10/16 01:16:53 cblume
+Changed timebin 0 to be the one closest to the readout
+
+Revision 1.1.4.5 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.4.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.2 2000/09/22 14:49:49 cblume
+Adapted to tracking code
+
+Revision 1.5 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.4 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
+Revision 1.3 2000/06/07 16:27:01 cblume
+Try to remove compiler warnings on Sun and HP
+
+Revision 1.2 2000/05/08 16:17:27 cblume
+Merge TRD-develop
+
+Revision 1.1.4.1 2000/05/08 15:08:41 cblume
+Replace AliTRDcluster by AliTRDrecPoint
+
Revision 1.4 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
#include <TRandom.h>
#include <TTree.h>
+
+#include "AliRun.h"
+#include "AliTRD.h"
#include "AliTRDclusterizerV0.h"
-#include "AliTRDconst.h"
+#include "AliTRDhit.h"
#include "AliTRDgeometry.h"
#include "AliTRDrecPoint.h"
}
//_____________________________________________________________________________
-Bool_t AliTRDclusterizerV0::MakeCluster()
+Bool_t AliTRDclusterizerV0::MakeClusters()
{
//
// Generates the cluster
Int_t nTrack = (Int_t) hitTree->GetEntries();
// Loop through all the chambers
- for (Int_t icham = 0; icham < kNcham; icham++) {
- for (Int_t iplan = 0; iplan < kNplan; iplan++) {
- for (Int_t isect = 0; isect < kNsect; isect++) {
+ for (Int_t icham = 0; icham < AliTRDgeometry::Ncham(); icham++) {
+ for (Int_t iplan = 0; iplan < AliTRDgeometry::Nplan(); iplan++) {
+ for (Int_t isect = 0; isect < AliTRDgeometry::Nsect(); isect++) {
Int_t nColMax = geo->GetColMax(iplan);
Float_t row0 = geo->GetRow0(iplan,icham,isect);
// Transform into local coordinates
smear[0] = (Int_t) ((smear[0] - row0) / rowPadSize);
smear[1] = (Int_t) ((smear[1] - col0) / colPadSize);
- smear[2] = (Int_t) ((smear[2] - time0) / timeBinSize);
+ smear[2] = (Int_t) ((time0 - smear[2]) / timeBinSize);
// Add the smeared cluster to the output array
Int_t detector = recPoint1->GetDetector();
Int_t digits[3] = {0};
- trd->AddRecPoint(smear,digits,detector,0.0);
+ Int_t tr[9] = {-1};
+ trd->AddRecPoint(smear,digits,detector,0.0,tr);
}
/* $Id$ */
-#include "AliTRD.h"
#include "AliTRDclusterizer.h"
///////////////////////////////////////////////////////
virtual ~AliTRDclusterizerV0();
virtual void Init();
- virtual Bool_t MakeCluster();
+ virtual Bool_t MakeClusters();
virtual void SetRphiSigma(Float_t sigma) { fRphiSigma = sigma; };
virtual void SetRphiDist(Float_t dist) { fRphiDist = dist; };
- virtual Float_t GetRphiSigma() { return fRphiSigma; };
- virtual Float_t GetRphiDist() { return fRphiDist; };
+ virtual Float_t GetRphiSigma() const { return fRphiSigma; };
+ virtual Float_t GetRphiDist() const { return fRphiDist; };
protected:
/*
$Log$
+Revision 1.1.4.5 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.4.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.2 2000/09/22 14:49:49 cblume
+Adapted to tracking code
+
+Revision 1.8 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
Revision 1.7 2000/06/27 13:08:50 cblume
Changed to Copy(TObject &A) to appease the HP-compiler
#include <TF1.h>
#include <TTree.h>
+#include <TH1.h>
+#include "AliRun.h"
+
+#include "AliTRD.h"
#include "AliTRDclusterizerV1.h"
#include "AliTRDmatrix.h"
#include "AliTRDgeometry.h"
#include "AliTRDdigitizer.h"
#include "AliTRDrecPoint.h"
#include "AliTRDdataArrayF.h"
+#include "AliTRDdataArrayI.h"
+#include "AliTRDdigitsManager.h"
ClassImp(AliTRDclusterizerV1)
}
//_____________________________________________________________________________
-Bool_t AliTRDclusterizerV1::MakeCluster()
+Bool_t AliTRDclusterizerV1::MakeClusters()
{
//
// Generates the cluster.
printf("Start creating clusters.\n");
AliTRDdataArrayI *digits;
+ AliTRDdataArrayI *track0;
+ AliTRDdataArrayI *track1;
+ AliTRDdataArrayI *track2;
// Parameters
Float_t maxThresh = fClusMaxThresh; // threshold value for maximum
const Int_t kNsig = 5;
Int_t chamBeg = 0;
- Int_t chamEnd = kNcham;
+ Int_t chamEnd = AliTRDgeometry::Ncham();
if (trd->GetSensChamber() >= 0) {
chamBeg = trd->GetSensChamber();
chamEnd = chamBeg + 1;
}
Int_t planBeg = 0;
- Int_t planEnd = kNplan;
+ Int_t planEnd = AliTRDgeometry::Nplan();
if (trd->GetSensPlane() >= 0) {
planBeg = trd->GetSensPlane();
planEnd = planBeg + 1;
}
Int_t sectBeg = 0;
- Int_t sectEnd = kNsect;
+ Int_t sectEnd = AliTRDgeometry::Nsect();
// *** Start clustering *** in every chamber
for (Int_t icham = chamBeg; icham < chamEnd; icham++) {
if (trd->GetSensSector() >= 0) {
Int_t sens1 = trd->GetSensSector();
Int_t sens2 = sens1 + trd->GetSensSectorRange();
- sens2 -= ((Int_t) (sens2 / kNsect)) * kNsect;
+ sens2 -= ((Int_t) (sens2 / AliTRDgeometry::Nsect()))
+ * AliTRDgeometry::Nsect();
if (sens1 < sens2) {
if ((isect < sens1) || (isect >= sens2)) continue;
}
AliTRDmatrix *maximaMatrix = new AliTRDmatrix(nRowMax,nColMax,nTimeMax
,isect,icham,iplan);
+ // Create a matrix for track indexes
+ AliTRDmatrix *trackMatrix = new AliTRDmatrix(nRowMax,nColMax,nTimeMax
+ ,isect,icham,iplan);
+
// Read in the digits
digits = fDigitsManager->GetDigits(idet);
+ track0 = fDigitsManager->GetDictionary(idet,0);
+ track1 = fDigitsManager->GetDictionary(idet,1);
+ track2 = fDigitsManager->GetDictionary(idet,2);
// Loop through the detector pixel
for (time = 0; time < nTimeMax; time++) {
Int_t signal = digits->GetData(row,col,time);
Int_t index = digits->GetIndex(row,col,time);
+ Int_t t[3] = {-1};
+ t[0] = track0->GetData(row,col,time) - 1;
+ t[1] = track1->GetData(row,col,time) - 1;
+ t[2] = track2->GetData(row,col,time) - 1;
// Fill the detector matrix
if (signal > signalThresh) {
digitMatrix->SetSignal(row,col,time,signal);
// Store the digits number
digitMatrix->AddTrack(row,col,time,index);
+ for(Int_t i = 0; i < 3; i++) {
+ trackMatrix->AddTrack(row,col,time,t[i]);
+ }
}
-
}
}
}
Float_t clusterPads[kNclus] = {0};
// Cluster digit info
Int_t clusterDigit[kNclus] = {0};
+ // Cluster MC tracks info
+ const Int_t nt = kNclus*3;
+ Int_t clusterTracks[nt] = {-1};
Int_t iPad;
for (iPad = 0; iPad < kNclus; iPad++) {
clusterSignal[iPad] = digitMatrix->GetSignal(row,col-1+iPad,time);
clusterDigit[iPad] = digitMatrix->GetTrack(row,col-1+iPad,time,0);
+ for (Int_t j = 0; j < 3; j++) {
+ clusterTracks[iPad*3+j] = trackMatrix->GetTrack(row,col-1+iPad,time,j);
+ }
}
// neighbouring maximum on right side?
case 1:
// method 1: simply center of mass
clusterPads[0] = row + 0.5;
- clusterPads[1] = col - 0.5 + (clusterSignal[2] - clusterSignal[0]) /
+ clusterPads[1] = col + 0.5 + (clusterSignal[2] - clusterSignal[0]) /
(clusterSignal[0] + clusterSignal[1] + clusterSignal[2]);
clusterPads[2] = time + 0.5;
+
+/* printf("col = %d, left = %f, center = %f, right = %f,
+ final =%f \n", col,
+ digitMatrix->GetSignal(row,col-1,time),
+ digitMatrix->GetSignal(row,col,time),
+ digitMatrix->GetSignal(row,col+1,time),
+ clusterPads[1]);
+
+ printf("col = %d, sig(0) = %f, sig(1) = %f, sig(2) = %f,
+ final =%f \n", col,
+ clusterSignal[0],
+ clusterSignal[1],
+ clusterSignal[2],
+ clusterPads[1]);
+
+*/
+
nClusters++;
break;
case 2:
+ clusterSignal[2];
// Add the cluster to the output array
- trd->AddRecPoint(clusterPads,clusterDigit,idet,clusterCharge);
+ trd->AddRecPoint(clusterPads,clusterDigit,idet,clusterCharge,clusterTracks);
}
} // time
printf("AliTRDclusterizerV1::MakeCluster -- ");
printf("Number of clusters found: %d\n",nClusters);
+ WriteClusters(idet);
+ trd->ResetRecPoints();
+
delete digitMatrix;
delete maximaMatrix;
+ delete trackMatrix;
} // isect
} // iplan
} // icham
- printf("AliTRDclusterizerV1::MakeCluster -- ");
- printf("Total number of points found: %d\n"
- ,trd->RecPoints()->GetEntries());
+// printf("AliTRDclusterizerV1::MakeCluster -- ");
+// printf("Total number of points found: %d\n"
+// ,trd->RecPoints()->GetEntries());
- // Get the pointer to the cluster branch
- TTree *clusterTree = gAlice->TreeR();
+// // Get the pointer to the cluster branch
+// TTree *clusterTree = gAlice->TreeR();
- // Fill the cluster-branch
- printf("AliTRDclusterizerV1::MakeCluster -- ");
- printf("Fill the cluster tree.\n");
- clusterTree->Fill();
+// // Fill the cluster-branch
+// printf("AliTRDclusterizerV1::MakeCluster -- ");
+// printf("Fill the cluster tree.\n");
+// clusterTree->Fill();
printf("AliTRDclusterizerV1::MakeCluster -- ");
printf("Done.\n");
/* $Id$ */
-#include "AliTRD.h"
-#include "AliTRDdigitsManager.h"
#include "AliTRDclusterizer.h"
///////////////////////////////////////////////////////
// Finds and handles cluster (slow simulation) //
///////////////////////////////////////////////////////
+class AliTRDdigitsManager;
+
class AliTRDclusterizerV1 : public AliTRDclusterizer {
public:
virtual void Copy(TObject &c);
virtual void Init();
- virtual Bool_t MakeCluster();
+ virtual Bool_t MakeClusters();
virtual Bool_t ReadDigits();
virtual void SetClusMaxThresh(Float_t thresh) { fClusMaxThresh = thresh; };
virtual void SetClusSigThresh(Float_t thresh) { fClusSigThresh = thresh; };
virtual void SetClusMethod(Int_t meth) { fClusMethod = meth; };
- virtual Float_t GetClusMaxThresh() { return fClusMaxThresh; };
- virtual Float_t GetClusSigThresh() { return fClusSigThresh; };
- virtual Int_t GetClusMethod() { return fClusMethod; };
+ virtual Float_t GetClusMaxThresh() const { return fClusMaxThresh; };
+ virtual Float_t GetClusSigThresh() const { return fClusSigThresh; };
+ virtual Int_t GetClusMethod() const { return fClusMethod; };
protected:
--- /dev/null
+void Config()
+{
+
+ new AliGeant3("C++ Interface to Geant3");
+
+ // Create the output file
+ TFile *rootfile = new TFile("TRD_test.root","recreate");
+ rootfile->SetCompressionLevel(2);
+
+ // Define the monte carlo
+ TGeant3 *geant3 = (TGeant3*) gMC;
+
+ // Set external decayer
+ AliDecayer* decayer = new AliDecayerPythia();
+ decayer->SetForceDecay(all);
+ decayer->Init();
+ gMC->SetExternalDecayer(decayer);
+
+ // ******* GEANT STEERING parameters FOR ALICE SIMULATION *******
+ geant3->SetTRIG(1); // Number of events to be processed
+ geant3->SetSWIT(4,10);
+ geant3->SetDEBU(0,0,1);
+ //geant3->SetSWIT(2,2);
+ geant3->SetDCAY(1);
+ geant3->SetPAIR(1);
+ geant3->SetCOMP(1);
+ geant3->SetPHOT(1);
+ geant3->SetPFIS(0);
+ geant3->SetDRAY(0);
+ geant3->SetANNI(1);
+ geant3->SetBREM(1);
+ geant3->SetMUNU(1);
+ geant3->SetCKOV(1);
+ geant3->SetHADR(1); // Select pure GEANH (HADR 1) or GEANH/NUCRIN (HADR 3)
+ geant3->SetLOSS(2);
+ geant3->SetMULS(1);
+ geant3->SetRAYL(1);
+ geant3->SetAUTO(1); // Select automatic STMIN etc... calc. (AUTO 1) or manual (AUTO 0)
+ geant3->SetABAN(0); // Restore 3.16 behaviour for abandoned tracks
+ geant3->SetOPTI(2); // Select optimisation level for GEANT geometry searches (0,1,2)
+ geant3->SetERAN(5.e-7);
+
+ Float_t cut = 1.e-3; // 1MeV cut by default
+ Float_t tofmax = 1.e10;
+ // GAM ELEC NHAD CHAD MUON EBREM MUHAB EDEL MUDEL MUPA TOFMAX
+ geant3->SetCUTS(cut,cut, cut, cut, cut, cut, cut, cut, cut, cut, tofmax);
+
+ // ************* STEERING parameters FOR ALICE SIMULATION **************
+ // --- Specify event type to be tracked through the ALICE setup
+ // --- All positions are in cm, angles in degrees, and P and E in GeV
+ //AliGenHIJINGpara *gener = new AliGenHIJINGpara(250);
+ AliGenBox *gener = new AliGenBox(100);
+ gener->SetMomentumRange(1.0,3.0);
+ gener->SetPhiRange(80.0,100.0);
+ gener->SetThetaRange(70.0,110.0);
+ gener->SetPart(11); // Only electrons
+ gener->SetOrigin(0,0,0); // Vertex position
+ gener->SetSigma(0,0,0); // Sigma in (X,Y,Z) (cm) on IP position
+ gener->Init();
+
+ //Specify maximum magnetic field in Tesla (neg. ==> default field)
+ gAlice->SetField(-999,2);
+
+ Int_t iMAG = 1;
+ Int_t iITS = 1;
+ Int_t iTPC = 1;
+ Int_t iTRD = 1;
+ Int_t iABSO = 1;
+ Int_t iDIPO = 1;
+ Int_t iHALL = 1;
+ Int_t iFRAME = 1;
+ Int_t iSHIL = 1;
+ Int_t iPIPE = 1;
+
+ //=================== Alice BODY parameters =============================
+ AliBODY *BODY = new AliBODY("BODY","Alice envelop");
+
+ if (iMAG) {
+ //=================== MAG parameters ============================
+ // --- Start with Magnet since detector layouts may be depending ---
+ // --- on the selected Magnet dimensions ---
+ AliMAG *MAG = new AliMAG("MAG","Magnet");
+ }
+
+ if (iABSO) {
+ //=================== ABSO parameters ============================
+ AliABSO *ABSO = new AliABSOv0("ABSO","Muon Absorber");
+ }
+
+ if (iDIPO) {
+ //=================== DIPO parameters ============================
+ AliDIPO *DIPO = new AliDIPOv2("DIPO","Dipole version 2");
+ }
+
+ if (iHALL) {
+ //=================== HALL parameters ============================
+ AliHALL *HALL = new AliHALL("HALL","Alice Hall");
+ }
+
+ if (iFRAME) {
+ //=================== FRAME parameters ============================
+ AliFRAME *FRAME = new AliFRAMEv1("FRAME","Space Frame");
+ }
+
+ if (iSHIL) {
+ //=================== SHIL parameters ============================
+ AliSHIL *SHIL = new AliSHILv0("SHIL","Shielding");
+ }
+
+ if (iPIPE) {
+ //=================== PIPE parameters ============================
+ AliPIPE *PIPE = new AliPIPEv0("PIPE","Beam Pipe");
+ }
+
+ if (iITS) {
+ //=================== ITS parameters ============================
+ //
+ // EUCLID is a flag to output (=1) both geometry and media to two ASCII files
+ // (called by default ITSgeometry.euc and ITSgeometry.tme) in a format
+ // understandable to the CAD system EUCLID. The default (=0) means that you
+ // dont want to use this facility.
+ //
+ AliITS *ITS = new AliITSv5("ITS","normal ITS");
+ ITS->SetEUCLID(0);
+ }
+
+ if (iTPC) {
+ //============================ TPC parameters ================================
+ // --- This allows the user to specify sectors for the SLOW (TPC geometry 2)
+ // --- Simulator. SecAL (SecAU) <0 means that ALL lower (upper)
+ // --- sectors are specified, any value other than that requires at least one
+ // --- sector (lower or upper)to be specified!
+ // --- Reminder: sectors 1-24 are lower sectors (1-12 -> z>0, 13-24 -> z<0)
+ // --- sectors 25-72 are the upper ones (25-48 -> z>0, 49-72 -> z<0)
+ // --- SecLows - number of lower sectors specified (up to 6)
+ // --- SecUps - number of upper sectors specified (up to 12)
+ // --- Sens - sensitive strips for the Slow Simulator !!!
+ // --- This does NOT work if all S or L-sectors are specified, i.e.
+ // --- if SecAL or SecAU < 0
+ //
+ //
+ //-----------------------------------------------------------------------------
+
+ gROOT->LoadMacro("SetTPCParam.C");
+ AliTPCParam *param = SetTPCParam();
+ AliTPC *TPC = new AliTPCv1("TPC","Default"); //v1 is default
+ TPC->SetParam(param); // pass the parameter object to the TPC
+
+ // set gas mixture
+ TPC->SetGasMixt(2,20,10,-1,0.9,0.1,0.);
+ TPC->SetSecAL(4);
+ TPC->SetSecAU(4);
+ TPC->SetSecLows(1, 2, 3, 19, 20, 21);
+ TPC->SetSecUps(37, 38, 39, 37+18, 38+18, 39+18, -1, -1, -1, -1, -1, -1);
+ TPC->SetSens(1);
+
+ if (TPC->IsVersion()==1) param->Write(param->GetTitle());
+
+ }
+
+ if (iTRD) {
+ //=================== TRD parameters ============================
+
+ AliTRD *TRD = new AliTRDv1("TRD","TRD slow simulator");
+ TRD->SetSensChamber(2);
+ TRD->SetSensSector(13);
+
+ // Select the gas mixture (0: 97% Xe + 3% isobutane, 1: 90% Xe + 10% CO2)
+ TRD->SetGasMix(1);
+
+ // Set to detailed display
+ TRD->SetDisplayType(1);
+
+ // Switch on TR
+ AliTRDsim *TRDsim = TRD->CreateTR();
+
+ }
+
+}
--- /dev/null
+Int_t AliTRDcreateDigits()
+{
+ //
+ // Creates the digits from the hits of the slow simulator
+ //
+
+ Int_t rc = 0;
+
+ return rc;
+
+ if (!gAlice) {
+ cout << "<AliTRDcreateDigits> No AliRun object found" << endl;
+ rc = 1;
+ return rc;
+ }
+ gAlice->GetEvent(0);
+
+ // Create the TRD digitzer
+ AliTRDdigitizer *Digitizer = new AliTRDdigitizer("digitizer","Digitizer class");
+
+ // Initialize the TRD and the geometry
+ if (!Digitizer->InitDetector()) {
+ cout << "<AliTRDcreateDigits> No TRD geometry found" << endl;
+ rc = 2;
+ return rc;
+ }
+
+ // Set the parameter
+ Digitizer->SetDiffusion();
+ Digitizer->SetVerbose(1);
+
+ // Create the digits
+ if (!Digitizer->MakeDigits()) {
+ rc = 3;
+ return rc;
+ }
+
+ return rc;
+
+}
/*
$Log$
+Revision 1.1.4.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.6 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.5 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
}
//_____________________________________________________________________________
-Int_t AliTRDdataArray::GetIdx1(Int_t row, Int_t col)
+Int_t AliTRDdataArray::GetIdx1(Int_t row, Int_t col) const
{
//
// Maps the two-dimensional row/column plane into an one-dimensional array.
}
//_____________________________________________________________________________
-Int_t AliTRDdataArray::GetIndex(Int_t row, Int_t col, Int_t time)
+Int_t AliTRDdataArray::GetIndex(Int_t row, Int_t col, Int_t time) const
{
//
// Maps the row/column/time into one number
/* $Id$ */
-#include "AliTRDarrayI.h"
-#include "AliTRDarrayF.h"
#include "AliTRDsegmentID.h"
/////////////////////////////////////////////////////////////
// Adapted from AliDigits, origin M.Ivanov //
/////////////////////////////////////////////////////////////
+class AliTRDarrayI;
+
class AliTRDdataArray : public AliTRDsegmentID {
public:
virtual void Allocate(Int_t nrow, Int_t ncol,Int_t ntime);
virtual void Reset();
- virtual Int_t GetNRow() { return fNrow; };
- virtual Int_t GetNCol() { return fNcol; };
- virtual Int_t GetNtime() { return fNtime; };
-
- Int_t GetIndex(Int_t row, Int_t col, Int_t time);
+ virtual Int_t GetNRow() const { return fNrow; };
+ virtual Int_t GetNCol() const { return fNcol; };
+ virtual Int_t GetNtime() const { return fNtime; };
+ Int_t GetIndex(Int_t row, Int_t col, Int_t time) const;
protected:
- Int_t GetIdx1(Int_t row, Int_t col);
+ Int_t GetIdx1(Int_t row, Int_t col) const;
inline Bool_t CheckBounds(const char *where, Int_t idx1, Int_t idx2);
inline Bool_t OutOfBoundsError(const char *where, Int_t idx1, Int_t idx2);
/*
$Log$
+Revision 1.1.2.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.2.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.5 2000/06/27 13:08:50 cblume
+Changed to Copy(TObject &A) to appease the HP-compiler
+
Revision 1.4 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
///////////////////////////////////////////////////////////////////////////////
#include "AliTRDdataArrayF.h"
+#include "AliTRDarrayI.h"
+#include "AliTRDarrayF.h"
ClassImp(AliTRDdataArrayF)
//
if (fElements) fElements->Delete();
+ delete fElements;
}
}
//_____________________________________________________________________________
-Int_t AliTRDdataArrayF::GetDataSize()
+Int_t AliTRDdataArrayF::GetDataSize()
{
//
// Returns the size of only the data part
}
//_____________________________________________________________________________
-Int_t AliTRDdataArrayF::GetOverThreshold(Float_t threshold)
+Int_t AliTRDdataArrayF::GetOverThreshold(Float_t threshold)
{
//
// Returns the number of entries over threshold
}
//_____________________________________________________________________________
-Float_t AliTRDdataArrayF::GetData(Int_t row, Int_t col, Int_t time)
+Float_t AliTRDdataArrayF::GetData(Int_t row, Int_t col, Int_t time) const
{
//
// Returns the data value at a given position of the array
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayF::First()
+Bool_t AliTRDdataArrayF::First()
{
//
// Returns the position of the first valid data value
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayF::First0()
+Bool_t AliTRDdataArrayF::First0()
{
//
// Returns the first entry for a buffer of type 0
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayF::First1()
+Bool_t AliTRDdataArrayF::First1()
{
//
// Returns the first entry for a buffer of type 1
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayF::Next1()
+Bool_t AliTRDdataArrayF::Next1()
{
//
// Returns the next entry for a buffer of type 1
}
//_____________________________________________________________________________
-Float_t AliTRDdataArrayF::GetData1(Int_t idx1, Int_t idx2)
+Float_t AliTRDdataArrayF::GetData1(Int_t idx1, Int_t idx2) const
{
//
// Returns the value at a given position of the array
}
//____________________________________________________________________________
-Float_t AliTRDdataArrayF::GetDataFast(Int_t idx1, Int_t idx2)
+Float_t AliTRDdataArrayF::GetDataFast(Int_t idx1, Int_t idx2) const
{
//
// Returns the value at a given position in the array
return *this;
}
+
// //
/////////////////////////////////////////////////////////////
+class AliTRDarrayF;
+
class AliTRDdataArrayF : public AliTRDdataArray {
public:
void SetData(Int_t row, Int_t col, Int_t time, Float_t value);
virtual void SetThreshold(Float_t threshold) { fThreshold = threshold; };
- virtual Float_t GetData(Int_t row, Int_t col, Int_t time);
- virtual Float_t GetThreshold() { return fThreshold; };
+ virtual Float_t GetData(Int_t row, Int_t col, Int_t time) const;
+ virtual Float_t GetThreshold() const { return fThreshold; };
virtual Int_t GetSize();
virtual Int_t GetDataSize();
protected:
inline void SetDataFast(Int_t idx1, Int_t idx2, Float_t value);
- inline Float_t GetDataFast(Int_t idx1, Int_t idx2);
+ inline Float_t GetDataFast(Int_t idx1, Int_t idx2) const;
- Float_t GetData1(Int_t idx1, Int_t idx2);
+ Float_t GetData1(Int_t idx1, Int_t idx2) const;
void Expand1();
void Compress1();
void Expand2();
/*
$Log$
+Revision 1.1.2.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.2.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.5 2000/06/27 13:08:50 cblume
+Changed to Copy(TObject &A) to appease the HP-compiler
+
Revision 1.4 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
///////////////////////////////////////////////////////////////////////////////
#include "AliTRDdataArrayI.h"
+#include "AliTRDarrayI.h"
ClassImp(AliTRDdataArrayI)
//
if (fElements) fElements->Delete();
+ delete fElements;
}
}
//_____________________________________________________________________________
-Int_t AliTRDdataArrayI::GetData(Int_t row, Int_t col, Int_t time)
+Int_t AliTRDdataArrayI::GetData(Int_t row, Int_t col, Int_t time) const
{
//
// Returns the data value at a given position of the array
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayI::Next0()
+Bool_t AliTRDdataArrayI::Next0()
{
//
// Returns the next entry for a buffer of type 0
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayI::First1()
+Bool_t AliTRDdataArrayI::First1()
{
//
// Returns the first entry for a buffer of type 1
}
//_____________________________________________________________________________
-Bool_t AliTRDdataArrayI::Next1()
+Bool_t AliTRDdataArrayI::Next1()
{
//
// Returns the next entry for a buffer of type 1
}
//_____________________________________________________________________________
-Int_t AliTRDdataArrayI::GetData1(Int_t idx1, Int_t idx2)
+Int_t AliTRDdataArrayI::GetData1(Int_t idx1, Int_t idx2) const
{
//
// Returns the value at a given position of the array
}
//_____________________________________________________________________________
-Int_t AliTRDdataArrayI::GetDataFast(Int_t idx1, Int_t idx2)
+Int_t AliTRDdataArrayI::GetDataFast(Int_t idx1, Int_t idx2) const
{
//
// Returns the value at a given position in the array
void SetData(Int_t row, Int_t col, Int_t time, Int_t value);
virtual void SetThreshold(Int_t threshold) { fThreshold = threshold; };
- virtual Int_t GetData(Int_t row, Int_t col, Int_t time);
- virtual Int_t GetThreshold() { return fThreshold; };
+ virtual Int_t GetData(Int_t row, Int_t col, Int_t time) const;
+ virtual Int_t GetThreshold() const { return fThreshold; };
virtual Int_t GetSize();
virtual Int_t GetDataSize();
protected:
inline void SetDataFast(Int_t idx1, Int_t idx2, Int_t value);
- inline Int_t GetDataFast(Int_t idx1, Int_t idx2);
+ inline Int_t GetDataFast(Int_t idx1, Int_t idx2) const;
- Int_t GetData1(Int_t idx1, Int_t idx2);
+ Int_t GetData1(Int_t idx1, Int_t idx2) const;
void Expand1();
void Compress1();
void Expand2();
#endif
+
+
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
/*
$Log$
+Revision 1.1.2.4 2000/10/17 02:27:34 cblume
+Get rid of global constants
+
+Revision 1.1.2.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.2.2 2000/09/22 14:42:05 cblume
+Changed data members to UShort_t
+
+Revision 1.4 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
Revision 1.3 2000/06/07 16:25:37 cblume
Try to remove compiler warnings on Sun and HP
ClassImp(AliTRDdigit)
//_____________________________________________________________________________
+
+ // Marks a raw digit
+ const UInt_t AliTRDdigit::fgkRawDigit = 0x00000001;
+
+//_____________________________________________________________________________
AliTRDdigit::AliTRDdigit():AliDigitNew()
{
//
// Default constructor
//
- fRow = 0;
- fCol = 0;
- fTime = 0;
+ fRow = 0;
+ fCol = 0;
+ fTime = 0;
}
// Store the signal amplitude
fAmp = amp[0];
- if (isRaw) SetBit(kRawDigit);
+ if (isRaw) SetBit(fgkRawDigit);
}
//
}
+
+//_____________________________________________________________________________
+Int_t AliTRDdigit::DecodeAmp() const
+{
+ //
+ // Decodes the digit amplitude
+ //
+
+ return 0;
+
+}
+
+//______________________________________________________________________________
+void AliTRDdigit::Streamer(TBuffer &R__b)
+{
+ //
+ // Stream an object of class AliTRDdigit.
+ //
+
+ if (R__b.IsReading()) {
+ Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+ AliDigitNew::Streamer(R__b);
+ R__b >> fRow;
+ R__b >> fCol;
+ R__b >> fTime;
+ }
+ else {
+ R__b.WriteVersion(AliTRDdigit::IsA());
+ AliDigitNew::Streamer(R__b);
+ R__b << fRow;
+ R__b << fCol;
+ R__b << fTime;
+ }
+
+}
#include "AliDigitNew.h"
-const UInt_t kRawDigit = 0x00000001;
-
//_____________________________________________________________________________
class AliTRDdigit : public AliDigitNew {
AliTRDdigit(Bool_t isRaw, Int_t *digits, Int_t *amp);
virtual ~AliTRDdigit();
- Int_t GetAmp() const { if (TestBit(kRawDigit))
- return DecodeAmp();
- else
- return fAmp; };
- Int_t GetDetector() { return fId; };
- Int_t GetRow() { return fRow; };
- Int_t GetCol() { return fCol; };
- Int_t GetTime() { return fTime; };
+ static UInt_t RawDigit() { return fgkRawDigit; };
+
+ Int_t GetAmp() const { if (TestBit(fgkRawDigit))
+ return DecodeAmp();
+ else
+ return fAmp; };
+ Int_t GetDetector() const { return fId; };
+ Int_t GetRow() const { return fRow; };
+ Int_t GetCol() const { return fCol; };
+ Int_t GetTime() const { return fTime; };
- Int_t DecodeAmp() const { return 0; };
+ virtual Int_t DecodeAmp() const;
protected:
- Int_t fRow; // Pad row number
- Int_t fCol; // Pad col number
- Int_t fTime; // Time bucket
+ static const UInt_t fgkRawDigit; // Marks a raw digit
+
+ UShort_t fRow; // Pad row number
+ UShort_t fCol; // Pad col number
+ UShort_t fTime; // Time bucket
- ClassDef(AliTRDdigit,1) // Digit for the TRD
+ ClassDef(AliTRDdigit,2) // Digit for the TRD
};
/*
$Log$
+Revision 1.1.4.9 2000/10/26 17:00:22 cblume
+Fixed bug in CheckDetector()
+
+Revision 1.1.4.8 2000/10/23 13:41:35 cblume
+Added protection against Log(0) in the gas gain calulation
+
+Revision 1.1.4.7 2000/10/17 02:27:34 cblume
+Get rid of global constants
+
+Revision 1.1.4.6 2000/10/16 01:16:53 cblume
+Changed timebin 0 to be the one closest to the readout
+
+Revision 1.1.4.5 2000/10/15 23:34:29 cblume
+Faster version of the digitizer
+
+Revision 1.1.4.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.2 2000/09/22 14:41:10 cblume
+Bug fix in PRF. Included time response. New structure
+
Revision 1.10 2000/10/05 07:27:53 cblume
Changes in the header-files by FCA
#include <TRandom.h>
#include <TROOT.h>
#include <TTree.h>
+#include <TFile.h>
+#include <TF1.h>
+
+#include "AliRun.h"
#include "AliTRD.h"
+#include "AliTRDhit.h"
#include "AliTRDdigitizer.h"
#include "AliTRDdataArrayI.h"
#include "AliTRDdataArrayF.h"
+#include "AliTRDsegmentArray.h"
#include "AliTRDdigitsManager.h"
+#include "AliTRDgeometry.h"
ClassImp(AliTRDdigitizer)
fTRD = NULL;
fGeo = NULL;
fPRF = NULL;
+ fTRF = NULL;
+ fTRFint = NULL;
fEvent = 0;
fGasGain = 0.0;
fElAttachOn = 0;
fElAttachProp = 0.0;
fExBOn = 0;
- fLorentzAngle = 0.0;
+ fOmegaTau = 0.0;
+ fPRFOn = 0;
+ fTRFOn = 0;
+ fDriftVelocity = 0.0;
+
+ fTRFbin = 0;
+ fTRFlo = 0.0;
+ fTRFhi = 0.0;
+ fTRFwid = 0.0;
+ fCompress = kFALSE;
+ fVerbose = 1;
}
fEvent = 0;
+ fCompress = kTRUE;
+ fVerbose = 1;
+
Init();
}
}
if (fPRF) delete fPRF;
+ if (fTRF) delete fTRF;
}
((AliTRDdigitizer &) d).fElAttachOn = fElAttachOn;
((AliTRDdigitizer &) d).fElAttachProp = fElAttachProp;
((AliTRDdigitizer &) d).fExBOn = fExBOn;
- ((AliTRDdigitizer &) d).fLorentzAngle = fLorentzAngle;
+ ((AliTRDdigitizer &) d).fOmegaTau = fOmegaTau;
((AliTRDdigitizer &) d).fLorentzFactor = fLorentzFactor;
+ ((AliTRDdigitizer &) d).fPRFOn = fPRFOn;
+ ((AliTRDdigitizer &) d).fTRFOn = fTRFOn;
+
+ ((AliTRDdigitizer &) d).fCompress = fCompress;
+ ((AliTRDdigitizer &) d).fVerbose = fVerbose;
fPRF->Copy(*((AliTRDdigitizer &) d).fPRF);
+ fTRF->Copy(*((AliTRDdigitizer &) d).fTRF);
+
+ ((AliTRDdigitizer &) d).fTRFbin = fTRFbin;
+ ((AliTRDdigitizer &) d).fTRFlo = fTRFlo;
+ ((AliTRDdigitizer &) d).fTRFhi = fTRFhi;
+ ((AliTRDdigitizer &) d).fTRFwid = fTRFwid;
+ if (((AliTRDdigitizer &) d).fTRFint) delete ((AliTRDdigitizer &) d).fTRFint;
+ ((AliTRDdigitizer &) d).fTRFint = new Float_t[fTRFbin];
+ for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
+ ((AliTRDdigitizer &) d).fTRFint[iBin] = fTRFint[iBin];
+ }
}
xyz[0] = gRandom->Gaus(xyz[0], sigmaL * fLorentzFactor);
xyz[1] = gRandom->Gaus(xyz[1], sigmaT * fLorentzFactor);
xyz[2] = gRandom->Gaus(xyz[2], sigmaT);
+
return 1;
}
//
xyz[0] = xyz[0];
- xyz[1] = xyz[1] + fLorentzAngle * driftlength;
+ xyz[1] = xyz[1] + fOmegaTau * driftlength;
xyz[2] = xyz[2];
return 1;
}
//_____________________________________________________________________________
+Int_t AliTRDdigitizer::PadResponse(Float_t signal, Float_t dist, Float_t *pad)
+{
+ //
+ // Applies the pad response
+ //
+
+ if (fPRF) {
+ pad[0] = TMath::Max(fPRF->Eval(-1.0 - dist,0,0) * signal,0.0);
+ pad[1] = TMath::Max(fPRF->Eval( - dist,0,0) * signal,0.0);
+ pad[2] = TMath::Max(fPRF->Eval( 1.0 - dist,0,0) * signal,0.0);
+ return 1;
+ }
+ else {
+ return 0;
+ }
+
+}
+
+//_____________________________________________________________________________
+Float_t AliTRDdigitizer::TimeResponse(Float_t time)
+{
+ //
+ // Applies the preamp shaper time response
+ //
+
+ Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid));
+ if ((iBin >= 0) && (iBin < fTRFbin)) {
+ return fTRFint[iBin];
+ }
+ else {
+ return 0.0;
+ }
+
+}
+
+//_____________________________________________________________________________
void AliTRDdigitizer::Init()
{
//
//
// The default parameter for the digitization
- fGasGain = 2.0E3;
+ fGasGain = 8.0E3;
fNoise = 3000.;
fChipGain = 10.;
fADCoutRange = 255.;
// E x B effects
fExBOn = 0;
// omega * tau. (tau ~ 12 * 10^-12, B = 0.2T)
- fLorentzAngle = 17.6 * 12.0 * 0.2 * 0.01;
+ fOmegaTau = 17.6 * 12.0 * 0.2 * 0.01;
// The pad response function
- fPRF = new TF1("PRF","[0]*([1]+exp(-x*x/(2.0*[2])))",-2,2);
+ fPRFOn = 1;
+ fPRF = new TF1("PRF","[0]*([1]+exp(-x*x/(2.0*[2])))",-3,3);
fPRF->SetParameter(0, 0.8872);
fPRF->SetParameter(1,-0.00573);
fPRF->SetParameter(2, 0.454 * 0.454);
+ // The drift velocity (cm / mus)
+ fDriftVelocity = 1.0;
+
+ // The time response function
+ fTRFOn = 1;
+ Float_t loTRF = -200.0;
+ Float_t hiTRF = 1000.0;
+ fTRF = new TF1("TRF",TRFlandau,loTRF,hiTRF,3);
+ fTRF->SetParameter(0, 1.0 / 24.24249);
+ fTRF->SetParameter(1, 0.0);
+ fTRF->SetParameter(2, 25.0);
+ fTRFbin = 1200;
+ fTRFlo = loTRF * fDriftVelocity / 1000.0;
+ fTRFhi = hiTRF * fDriftVelocity / 1000.0;
+ fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitizer::IntegrateTRF()
+{
+ //
+ // Integrates the time response function over the time bin size
+ //
+
+ if (fTRFint) delete fTRFint;
+ fTRFint = new Float_t[fTRFbin];
+ Float_t hiTRF = fTRFhi / fDriftVelocity * 1000.0;
+ Float_t loTRF = fTRFlo / fDriftVelocity * 1000.0;
+ Float_t timeBin = fGeo->GetTimeBinSize() / fDriftVelocity * 1000.0;
+ Float_t binWidth = (hiTRF - loTRF) / ((Float_t) fTRFbin);
+ for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
+ Float_t bin = iBin * binWidth + loTRF - 0.5 * timeBin;
+ fTRFint[iBin] = fTRF->Integral(bin,bin + timeBin);
+ }
+
}
//_____________________________________________________________________________
return kFALSE;
}
+ return InitDetector();
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitizer::InitDetector()
+{
+ //
+ // Sets the pointer to the TRD detector and the geometry
+ //
+
// Get the pointer to the detector class and check for version 1
fTRD = (AliTRD*) gAlice->GetDetector("TRD");
if (fTRD->IsVersion() != 1) {
///////////////////////////////////////////////////////////////
+ // Number of pads included in the pad response
+ const Int_t kNpad = 3;
+
+ // Number of track dictionary arrays
+ const Int_t kNDict = AliTRDdigitsManager::NDict();
+
Int_t iRow, iCol, iTime;
- Int_t nBytes = 0;
Int_t iDict;
+ Int_t nBytes = 0;
Int_t totalSizeDigits = 0;
Int_t totalSizeDict0 = 0;
Int_t totalSizeDict1 = 0;
Int_t totalSizeDict2 = 0;
- AliTRDdataArrayI *digits;
+ AliTRDdataArrayF *signals = 0;
+ AliTRDdataArrayI *digits = 0;
AliTRDdataArrayI *dictionary[kNDict];
+ // Create a digits manager
+ fDigits = new AliTRDdigitsManager();
+
+ // Create a container for the amplitudes
+ AliTRDsegmentArray *signalsArray
+ = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
+
if (!fGeo) {
printf("AliTRDdigitizer::MakeDigits -- ");
printf("No geometry defined\n");
return kFALSE;
}
- // Create a digits manager
- fDigits = new AliTRDdigitsManager();
-
- // Create detector arrays to keep the signal and track numbers
- AliTRDdataArrayF *signal = new AliTRDdataArrayF();
- AliTRDdataArrayI *tracks[kNDict];
- for (iDict = 0; iDict < kNDict; iDict++) {
- tracks[iDict] = new AliTRDdataArrayI();
- }
-
- // Get the pointer to the hit tree
- TTree *hitTree = gAlice->TreeH();
-
- // Get the number of entries in the hit tree
- // (Number of primary particles creating a hit somewhere)
- Int_t nTrack = (Int_t) hitTree->GetEntries();
-
printf("AliTRDdigitizer::MakeDigits -- ");
printf("Start creating digits.\n");
+ if (fVerbose > 0) this->Dump();
// The Lorentz factor
if (fExBOn) {
- fLorentzFactor = 1.0 / (1.0 + fLorentzAngle*fLorentzAngle);
+ fLorentzFactor = 1.0 / (1.0 + fOmegaTau*fOmegaTau);
}
else {
fLorentzFactor = 1.0;
}
- Int_t chamBeg = 0;
- Int_t chamEnd = kNcham;
- if (fTRD->GetSensChamber() >= 0) {
- chamBeg = fTRD->GetSensChamber();
- chamEnd = chamBeg + 1;
- }
- Int_t planBeg = 0;
- Int_t planEnd = kNplan;
- if (fTRD->GetSensPlane() >= 0) {
- planBeg = fTRD->GetSensPlane();
- planEnd = planBeg + 1;
- }
- Int_t sectBeg = 0;
- Int_t sectEnd = kNsect;
-
- Int_t countHits = 0;
-
- // Loop through all the chambers
- for (Int_t iCham = chamBeg; iCham < chamEnd; iCham++) {
- for (Int_t iPlan = planBeg; iPlan < planEnd; iPlan++) {
- for (Int_t iSect = sectBeg; iSect < sectEnd; iSect++) {
-
- if (fTRD->GetSensSector() >= 0) {
- Int_t sens1 = fTRD->GetSensSector();
- Int_t sens2 = sens1 + fTRD->GetSensSectorRange();
- sens2 -= ((Int_t) (sens2 / kNsect)) * kNsect;
- if (sens1 < sens2) {
- if ((iSect < sens1) || (iSect >= sens2)) continue;
+ // Create the integrated TRF
+ IntegrateTRF();
+
+ // Get the pointer to the hit tree
+ TTree *HitTree = gAlice->TreeH();
+
+ // Get the number of entries in the hit tree
+ // (Number of primary particles creating a hit somewhere)
+ Int_t nTrack = (Int_t) HitTree->GetEntries();
+ if (fVerbose > 0) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Found %d primary particles\n",nTrack);
+ }
+
+ Int_t detectorOld = -1;
+ Int_t countHits = 0;
+
+ // Loop through all entries in the tree
+ for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
+
+ gAlice->ResetHits();
+ nBytes += HitTree->GetEvent(iTrack);
+
+ // Get the number of hits in the TRD created by this particle
+ Int_t nHit = fTRD->Hits()->GetEntriesFast();
+ if (fVerbose > 0) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Found %d hits for primary particle %d\n",nHit,iTrack);
+ }
+
+ // Loop through the TRD hits
+ for (Int_t iHit = 0; iHit < nHit; iHit++) {
+
+ countHits++;
+
+ AliTRDhit *hit = (AliTRDhit *) fTRD->Hits()->UncheckedAt(iHit);
+ Float_t pos[3];
+ pos[0] = hit->X();
+ pos[1] = hit->Y();
+ pos[2] = hit->Z();
+ Float_t q = hit->GetCharge();
+ Int_t track = hit->Track();
+ Int_t detector = hit->GetDetector();
+ Int_t plane = fGeo->GetPlane(detector);
+ Int_t sector = fGeo->GetSector(detector);
+ Int_t chamber = fGeo->GetChamber(detector);
+
+ if (!(CheckDetector(plane,chamber,sector))) continue;
+
+ Int_t nRowMax = fGeo->GetRowMax(plane,chamber,sector);
+ Int_t nColMax = fGeo->GetColMax(plane);
+ Int_t nTimeMax = fGeo->GetTimeMax();
+ Float_t row0 = fGeo->GetRow0(plane,chamber,sector);
+ Float_t col0 = fGeo->GetCol0(plane);
+ Float_t time0 = fGeo->GetTime0(plane);
+ Float_t rowPadSize = fGeo->GetRowPadSize();
+ Float_t colPadSize = fGeo->GetColPadSize();
+ Float_t timeBinSize = fGeo->GetTimeBinSize();
+
+ if (fVerbose > 1) {
+ printf("Analyze hit no. %d ",iHit);
+ printf("-----------------------------------------------------------\n");
+ hit->Dump();
+ printf("plane = %d, sector = %d, chamber = %d\n"
+ ,plane,sector,chamber);
+ printf("nRowMax = %d, nColMax = %d, nTimeMax = %d\n"
+ ,nRowMax,nColMax,nTimeMax);
+ printf("row0 = %f, col0 = %f, time0 = %f\n"
+ ,row0,col0,time0);
+ }
+
+ // Get different container if the detector has changed
+ if (detector != detectorOld) {
+ if (fVerbose > 1) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Get new container. New det = %d, Old det = %d\n"
+ ,detector,detectorOld);
+ }
+ // Compress the old one if enabled
+ if ((fCompress) && (detectorOld > -1)) {
+ if (fVerbose > 1) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Compress the old container ... ");
}
- else {
- if ((iSect < sens1) && (iSect >= sens2)) continue;
+ signals->Compress(1,0);
+ for (iDict = 0; iDict < kNDict; iDict++) {
+ dictionary[iDict]->Compress(1,0);
}
+ if (fVerbose > 1) printf("done\n");
}
+ // Get the new container
+ signals = (AliTRDdataArrayF *) signalsArray->At(detector);
+ if (signals->GetNtime() == 0) {
+ // Allocate a new one if not yet existing
+ if (fVerbose > 1) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Allocate a new container ... ");
+ }
+ signals->Allocate(nRowMax,nColMax,nTimeMax);
+ }
+ else {
+ // Expand an existing one
+ if (fVerbose > 1) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Expand an existing container ... ");
+ }
+ if (fCompress) signals->Expand();
+ }
+ // The same for the dictionary
+ for (iDict = 0; iDict < kNDict; iDict++) {
+ dictionary[iDict] = fDigits->GetDictionary(detector,iDict);
+ if (dictionary[iDict]->GetNtime() == 0) {
+ dictionary[iDict]->Allocate(nRowMax,nColMax,nTimeMax);
+ }
+ else {
+ if (fCompress) dictionary[iDict]->Expand();
+ }
+ }
+ if (fVerbose > 1) printf("done\n");
+ detectorOld = detector;
+ }
- Int_t nDigits = 0;
-
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("Digitizing chamber %d, plane %d, sector %d.\n"
- ,iCham,iPlan,iSect);
-
- Int_t iDet = fGeo->GetDetector(iPlan,iCham,iSect);
- Int_t nRowMax = fGeo->GetRowMax(iPlan,iCham,iSect);
- Int_t nColMax = fGeo->GetColMax(iPlan);
- Int_t nTimeMax = fGeo->GetTimeMax();
- Float_t row0 = fGeo->GetRow0(iPlan,iCham,iSect);
- Float_t col0 = fGeo->GetCol0(iPlan);
- Float_t time0 = fGeo->GetTime0(iPlan);
- Float_t rowPadSize = fGeo->GetRowPadSize();
- Float_t colPadSize = fGeo->GetColPadSize();
- Float_t timeBinSize = fGeo->GetTimeBinSize();
-
- // Adjust the size of the detector arrays
- signal->Allocate(nRowMax,nColMax,nTimeMax);
- for (iDict = 0; iDict < kNDict; iDict++) {
- tracks[iDict]->Allocate(nRowMax,nColMax,nTimeMax);
+ // Rotate the sectors on top of each other
+ Float_t rot[3];
+ fGeo->Rotate(detector,pos,rot);
+
+ // The driftlength
+ Float_t driftlength = time0 - rot[0];
+ if ((driftlength < 0) ||
+ (driftlength > AliTRDgeometry::DrThick())) break;
+ Float_t driftlengthL = driftlength;
+ if (fExBOn) driftlengthL /= TMath::Sqrt(fLorentzFactor);
+
+ // The hit position in pad coordinates (center pad)
+ // The pad row (z-direction)
+ Int_t rowH = (Int_t) ((rot[2] - row0) / rowPadSize);
+ // The pad column (rphi-direction)
+ Int_t colH = (Int_t) ((rot[1] - col0) / colPadSize);
+ // The time bucket
+ Int_t timeH = (Int_t) (driftlength / timeBinSize);
+ if (fVerbose > 1) {
+ printf("rowH = %d, colH = %d, timeH = %d\n"
+ ,rowH,colH,timeH);
+ }
+
+ // Loop over all electrons of this hit
+ // TR photons produce hits with negative charge
+ Int_t nEl = ((Int_t) TMath::Abs(q));
+ for (Int_t iEl = 0; iEl < nEl; iEl++) {
+
+ Float_t xyz[3];
+ xyz[0] = rot[0];
+ xyz[1] = rot[1];
+ xyz[2] = rot[2];
+
+ // Electron attachment
+ if (fElAttachOn) {
+ if (gRandom->Rndm() < (driftlengthL * fElAttachProp / 100.))
+ continue;
+ }
+
+ // Apply the diffusion smearing
+ if (fDiffusionOn) {
+ if (!(Diffusion(driftlengthL,xyz))) continue;
}
- // Loop through all entries in the tree
- for (Int_t iTrack = 0; iTrack < nTrack; iTrack++) {
-
- gAlice->ResetHits();
- nBytes += hitTree->GetEvent(iTrack);
-
- // Get the number of hits in the TRD created by this particle
- Int_t nHit = fTRD->Hits()->GetEntriesFast();
-
- // Loop through the TRD hits
- for (Int_t iHit = 0; iHit < nHit; iHit++) {
-
- countHits++;
-
- AliTRDhit *hit = (AliTRDhit *) fTRD->Hits()->UncheckedAt(iHit);
- Float_t pos[3];
- pos[0] = hit->X();
- pos[1] = hit->Y();
- pos[2] = hit->Z();
- Float_t q = hit->GetCharge();
- Int_t track = hit->Track();
- Int_t detector = hit->GetDetector();
- Int_t plane = fGeo->GetPlane(detector);
- Int_t sector = fGeo->GetSector(detector);
- Int_t chamber = fGeo->GetChamber(detector);
-
- if ((sector != iSect) ||
- (plane != iPlan) ||
- (chamber != iCham))
- continue;
-
- // Rotate the sectors on top of each other
- Float_t rot[3];
- fGeo->Rotate(detector,pos,rot);
-
- // The hit position in pad coordinates (center pad)
- // The pad row (z-direction)
- Int_t rowH = (Int_t) ((rot[2] - row0) / rowPadSize);
- // The pad column (rphi-direction)
- Int_t colH = (Int_t) ((rot[1] - col0) / colPadSize);
- // The time bucket
- Int_t timeH = (Int_t) ((rot[0] - time0) / timeBinSize);
-
- // Array to sum up the signal in a box surrounding the
- // hit postition
- const Int_t kTimeBox = 7;
- const Int_t kColBox = 9;
- const Int_t kRowBox = 7;
- Float_t signalSum[kRowBox][kColBox][kTimeBox];
- for (iRow = 0; iRow < kRowBox; iRow++ ) {
- for (iCol = 0; iCol < kColBox; iCol++ ) {
- for (iTime = 0; iTime < kTimeBox; iTime++) {
- signalSum[iRow][iCol][iTime] = 0;
- }
- }
- }
-
- // Loop over all electrons of this hit
- Int_t nEl = (Int_t) q;
- for (Int_t iEl = 0; iEl < nEl; iEl++) {
-
- // The driftlength
- Float_t driftlength = rot[0] - time0;
- if ((driftlength < 0) ||
- (driftlength > kDrThick)) break;
- Float_t driftlengthL = driftlength;
- if (fExBOn) driftlengthL /= TMath::Sqrt(fLorentzFactor);
- Float_t xyz[3];
- xyz[0] = rot[0];
- xyz[1] = rot[1];
- xyz[2] = rot[2];
-
- // Electron attachment
- if (fElAttachOn) {
- if (gRandom->Rndm() < (driftlengthL * fElAttachProp / 100.)) continue;
- }
+ // Apply E x B effects
+ if (fExBOn) {
+ if (!(ExB(driftlength,xyz))) continue;
+ }
- // Apply the diffusion smearing
- if (fDiffusionOn) {
- if (!(Diffusion(driftlengthL,xyz))) continue;
- }
+ // The electron position
+ // The pad row (z-direction)
+ Int_t rowE = (Int_t) ((xyz[2] - row0) / rowPadSize);
+ // The pad column (rphi-direction)
+ Int_t colE = (Int_t) ((xyz[1] - col0) / colPadSize);
+ // The time bucket
+ Int_t timeE = (Int_t) ((time0 - xyz[0]) / timeBinSize);
+
+ if (( rowE < 0) || ( rowE >= nRowMax)) continue;
+ if (( colE < 0) || ( colE >= nColMax)) continue;
+ if ((timeE < 0) || (timeE >= nTimeMax)) continue;
+
+ // Apply the gas gain including fluctuations
+ Float_t ggRndm = 0.0;
+ do {
+ ggRndm = gRandom->Rndm();
+ } while (ggRndm <= 0);
+ Int_t signal = (Int_t) (-fGasGain * TMath::Log(ggRndm));
+
+ if (fVerbose > 2) {
+ printf(" electron no. %d, signal = %d\n",iEl,signal);
+ printf(" rowE = %d, colE = %d, timeE = %d\n"
+ ,rowE,colE,timeE);
+ }
- // Apply E x B effects
- if (fExBOn) {
- if (!(ExB(driftlength,xyz))) continue;
- }
+ // Apply the pad response
+ Float_t padSignal[kNpad];
+ if (fPRFOn) {
+ // The distance of the electron to the center of the pad
+ // in units of pad width
+ Float_t dist = (xyz[1] - col0 - (colE + 0.5) * colPadSize)
+ / colPadSize;
+ if (!(PadResponse(signal,dist,padSignal))) continue;
+ }
+ else {
+ padSignal[0] = 0.0;
+ padSignal[1] = signal;
+ padSignal[2] = 0.0;
+ }
- // The electron position and the distance to the hit position
- // in pad units
- // The pad row (z-direction)
- Int_t rowE = (Int_t) ((xyz[2] - row0) / rowPadSize);
- Int_t rowD = rowH - rowE;
- // The pad column (rphi-direction)
- Int_t colE = (Int_t) ((xyz[1] - col0) / colPadSize);
- Int_t colD = colH - colE;
- // The time bucket
- Int_t timeE = (Int_t) ((xyz[0] - time0) / timeBinSize);
- Int_t timeD = timeH - timeE;
-
- // Apply the gas gain including fluctuations
- Float_t ggRndm = 0.0;
- do {
- ggRndm = gRandom->Rndm();
- } while (ggRndm <= 0);
- Int_t signal = (Int_t) (-fGasGain * TMath::Log(ggRndm));
-
- // The distance of the electron to the center of the pad
- // in units of pad width
- Float_t dist = (xyz[1] - col0 - (colE + 0.5) * colPadSize)
- / colPadSize;
-
- // Sum up the signal in the different pixels
- // and apply the pad response
- Int_t rowIdx = rowD + (Int_t) ( kRowBox / 2);
- Int_t colIdx = colD + (Int_t) ( kColBox / 2);
- Int_t timeIdx = timeD + (Int_t) (kTimeBox / 2);
-
- if (( rowIdx < 0) || ( rowIdx > kRowBox)) {
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("Boundary error. rowIdx = %d (%d)\n", rowIdx, kRowBox);
- continue;
- }
- if (( colIdx < 0) || ( colIdx > kColBox)) {
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("Boundary error. colIdx = %d (%d)\n", colIdx, kColBox);
- continue;
- }
- if ((timeIdx < 0) || (timeIdx > kTimeBox)) {
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("Boundary error. timeIdx = %d (%d)\n",timeIdx,kTimeBox);
- continue;
- }
- signalSum[rowIdx][colIdx-1][timeIdx] += fPRF->Eval(dist-1.0,0,0) * signal;
- signalSum[rowIdx][colIdx ][timeIdx] += fPRF->Eval(dist ,0,0) * signal;
- signalSum[rowIdx][colIdx+1][timeIdx] += fPRF->Eval(dist+1.0,0,0) * signal;
+ // The distance of the position to the beginning of the timebin
+ Float_t timeOffset = (time0 - timeE * timeBinSize) - xyz[0];
+ Int_t timeTRDbeg = 0;
+ Int_t timeTRDend = 1;
+ if (fTRFOn) {
+ timeTRDbeg = 2;
+ timeTRDend = 11;
+ }
+ for (Int_t iTimeBin = TMath::Max(timeE - timeTRDbeg, 0)
+ ; iTimeBin < TMath::Min(timeE + timeTRDend,nTimeMax)
+ ; iTimeBin++) {
+
+ // Apply the time response
+ Float_t timeResponse = 1.0;
+ if (fTRFOn) {
+ Float_t time = (iTimeBin - timeE) * timeBinSize + timeOffset;
+ timeResponse = TimeResponse(time);
+ }
- }
+ // Add the signals
+ Float_t signalOld[kNpad] = { 0.0, 0.0, 0.0 };
+ for (Int_t iPad = 0; iPad < kNpad; iPad++) {
+ Int_t colPos = colE + iPad - 1;
+ if (colPos < 0) continue;
+ if (colPos >= nColMax) break;
+ signalOld[iPad] = signals->GetData(rowE,colPos,iTimeBin);
+ signalOld[iPad] += padSignal[iPad] * timeResponse;
+ signals->SetData(rowE,colPos,iTimeBin,signalOld[iPad]);
+ }
+ if (fVerbose > 3) {
+ printf(" iTimeBin = %d, timeResponse = %f\n"
+ ,iTimeBin,timeResponse);
+ printf(" pad-signal = %f, %f, %f\n"
+ ,signalOld[0],signalOld[1],signalOld[2]);
+ }
- // Add the padcluster to the detector matrix
- for (iRow = 0; iRow < kRowBox; iRow++ ) {
- for (iCol = 0; iCol < kColBox; iCol++ ) {
- for (iTime = 0; iTime < kTimeBox; iTime++) {
-
- Int_t rowB = rowH + iRow - (Int_t) ( kRowBox / 2);
- Int_t colB = colH + iCol - (Int_t) ( kColBox / 2);
- Int_t timeB = timeH + iTime - (Int_t) (kTimeBox / 2);
- Float_t signalB = signalSum[iRow][iCol][iTime];
- if (( rowB < 0) || ( rowB >= nRowMax)) continue;
- if (( colB < 0) || ( colB >= nColMax)) continue;
- if ((timeB < 0) || (timeB >= nTimeMax)) continue;
- if (signalB > 0.0) {
-
- // Add the signal sum
- signalB += signal->GetData(rowB,colB,timeB);
- signal->SetData(rowB,colB,timeB,signalB);
- // Store the track index in the dictionary
- // Note: We store index+1 in order to allow the array to be compressed
- for (iDict = 0; iDict < kNDict; iDict++) {
- Int_t oldTrack = tracks[iDict]->GetData(rowB,colB,timeB);
- if (oldTrack == track+1) break;
- if (oldTrack == -1) break;
- if (oldTrack == 0) {
- tracks[iDict]->SetData(rowB,colB,timeB,track+1);
- break;
- }
- }
- if (iDict == kNDict) {
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("More than three tracks for one digit!\n");
- }
- }
-
- }
+ // Store the track index in the dictionary
+ // Note: We store index+1 in order to allow the array to be compressed
+ for (iDict = 0; iDict < kNDict; iDict++) {
+ Int_t oldTrack = dictionary[iDict]->GetData(rowE,colE,timeE);
+ if (oldTrack == track+1) break;
+ //if (oldTrack == -1) break;
+ if (oldTrack == 0) {
+ dictionary[iDict]->SetData(rowE,colE,timeE,track+1);
+ if (fVerbose > 3) {
+ printf(" track index = %d\n",track);
}
- }
-
+ break;
+ }
+ }
+ if ((fVerbose > 1) && (iDict == kNDict)) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("More than three tracks for one digit!\n");
}
- }
-
- // Add a container for the digits of this detector
- digits = fDigits->GetDigits(iDet);
- // Allocate memory space for the digits buffer
- digits->Allocate(nRowMax,nColMax,nTimeMax);
-
- // Do the same for the dictionary arrays
- for (iDict = 0; iDict < kNDict; iDict++) {
- dictionary[iDict] = fDigits->GetDictionary(iDet,iDict);
- dictionary[iDict]->Allocate(nRowMax,nColMax,nTimeMax);
}
- // Create the digits for this chamber
- for (iRow = 0; iRow < nRowMax; iRow++ ) {
- for (iCol = 0; iCol < nColMax; iCol++ ) {
- for (iTime = 0; iTime < nTimeMax; iTime++) {
-
- Float_t signalAmp = signal->GetData(iRow,iCol,iTime);
+ }
- // Add the noise
- signalAmp = TMath::Max((Float_t) gRandom->Gaus(signalAmp,fNoise)
- ,(Float_t) 0.0);
- // Convert to fC
- signalAmp *= kEl2fC;
- // Convert to mV
- signalAmp *= fChipGain;
- // Convert to ADC counts
- Int_t adc = (Int_t) (signalAmp * (fADCoutRange / fADCinRange));
+ }
- if (adc > fADCthreshold) {
+ } // All hits finished
- nDigits++;
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Finished analyzing %d hits\n",countHits);
+
+ // Loop through all chambers to finalize the digits
+ for (Int_t iDet = 0; iDet < AliTRDgeometry::Ndet(); iDet++) {
+
+ Int_t plane = fGeo->GetPlane(iDet);
+ Int_t sector = fGeo->GetSector(iDet);
+ Int_t chamber = fGeo->GetChamber(iDet);
+ Int_t nRowMax = fGeo->GetRowMax(plane,chamber,sector);
+ Int_t nColMax = fGeo->GetColMax(plane);
+ Int_t nTimeMax = fGeo->GetTimeMax();
+
+ if (!(CheckDetector(plane,chamber,sector))) continue;
+ if (fVerbose > 0) {
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Digitization for chamber %d\n",iDet);
+ }
- // Store the amplitude of the digit
- digits->SetData(iRow,iCol,iTime,adc);
+ // Add a container for the digits of this detector
+ digits = fDigits->GetDigits(iDet);
+ // Allocate memory space for the digits buffer
+ digits->Allocate(nRowMax,nColMax,nTimeMax);
- // Store the track index in the dictionary
- // Note: We store index+1 in order to allow the array to be compressed
- for (iDict = 0; iDict < kNDict; iDict++) {
- dictionary[iDict]->SetData(iRow,iCol,iTime
- ,tracks[iDict]->GetData(iRow,iCol,iTime));
- }
+ // Get the signal container
+ signals = (AliTRDdataArrayF *) signalsArray->At(iDet);
+ if (signals->GetNtime() == 0) {
+ // Create missing containers
+ signals->Allocate(nRowMax,nColMax,nTimeMax);
+ }
+ else {
+ // Expand the container if neccessary
+ if (fCompress) signals->Expand();
+ }
+ // Create the missing dictionary containers
+ for (iDict = 0; iDict < kNDict; iDict++) {
+ dictionary[iDict] = fDigits->GetDictionary(iDet,iDict);
+ if (dictionary[iDict]->GetNtime() == 0) {
+ dictionary[iDict]->Allocate(nRowMax,nColMax,nTimeMax);
+ }
+ }
- }
+ Int_t nDigits = 0;
+
+ // Create the digits for this chamber
+ for (iRow = 0; iRow < nRowMax; iRow++ ) {
+ for (iCol = 0; iCol < nColMax; iCol++ ) {
+ for (iTime = 0; iTime < nTimeMax; iTime++) {
+
+ Float_t signalAmp = signals->GetData(iRow,iCol,iTime);
+
+ // Add the noise
+ signalAmp = TMath::Max((Float_t) gRandom->Gaus(signalAmp,fNoise),0.0);
+ // Convert to fC
+ signalAmp *= kEl2fC;
+ // Convert to mV
+ signalAmp *= fChipGain;
+ // Convert to ADC counts. Set the overflow-bit fADCoutRange if the
+ // signal is larger than fADCinRange
+ Int_t adc = 0;
+ if (signalAmp >= fADCinRange) {
+ adc = ((Int_t) fADCoutRange);
+ }
+ else {
+ adc = ((Int_t) (signalAmp * (fADCoutRange / fADCinRange)));
+ }
+ if (fVerbose > 2) {
+ printf(" iRow = %d, iCol = %d, iTime = %d\n"
+ ,iRow,iCol,iTime);
+ printf(" signal = %f, adc = %d\n",signalAmp,adc);
+ }
- }
+ // Store the amplitude of the digit if above threshold
+ if (adc > fADCthreshold) {
+ nDigits++;
+ digits->SetData(iRow,iCol,iTime,adc);
}
- }
- // Compress the arrays
- digits->Compress(1,0);
- for (iDict = 0; iDict < kNDict; iDict++) {
- dictionary[iDict]->Compress(1,0);
}
+ }
+ }
+
+ // Compress the arrays
+ digits->Compress(1,0);
+ for (iDict = 0; iDict < kNDict; iDict++) {
+ dictionary[iDict]->Compress(1,0);
+ }
- totalSizeDigits += digits->GetSize();
- totalSizeDict0 += dictionary[0]->GetSize();
- totalSizeDict1 += dictionary[1]->GetSize();
- totalSizeDict2 += dictionary[2]->GetSize();
+ totalSizeDigits += digits->GetSize();
+ totalSizeDict0 += dictionary[0]->GetSize();
+ totalSizeDict1 += dictionary[1]->GetSize();
+ totalSizeDict2 += dictionary[2]->GetSize();
- printf("AliTRDdigitizer::MakeDigits -- ");
- printf("Number of digits found: %d.\n",nDigits);
+ printf("AliTRDdigitizer::MakeDigits -- ");
+ printf("Found %d digits in detector %d.\n",nDigits,iDet);
- // Reset the arrays
- signal->Reset();
- for (iDict = 0; iDict < kNDict; iDict++) {
- tracks[iDict]->Reset();
- }
+ if (fCompress) signals->Compress(1,0);
- }
- }
}
printf("AliTRDdigitizer::MakeDigits -- ");
}
//_____________________________________________________________________________
+Bool_t AliTRDdigitizer::CheckDetector(Int_t plane, Int_t chamber, Int_t sector)
+{
+ //
+ // Checks whether a detector is enabled
+ //
+
+ if ((fTRD->GetSensChamber() >= 0) &&
+ (fTRD->GetSensChamber() != chamber)) return kFALSE;
+ if ((fTRD->GetSensPlane() >= 0) &&
+ (fTRD->GetSensPlane() != sector)) return kFALSE;
+ if ( fTRD->GetSensSector() >= 0) {
+ Int_t sens1 = fTRD->GetSensSector();
+ Int_t sens2 = sens1 + fTRD->GetSensSectorRange();
+ sens2 -= ((Int_t) (sens2 / AliTRDgeometry::Nsect()))
+ * AliTRDgeometry::Nsect();
+ if (sens1 < sens2) {
+ if ((sector < sens1) || (sector >= sens2)) return kFALSE;
+ }
+ else {
+ if ((sector < sens1) && (sector >= sens2)) return kFALSE;
+ }
+ }
+
+ return kTRUE;
+
+}
+
+//_____________________________________________________________________________
Bool_t AliTRDdigitizer::WriteDigits()
{
//
return kTRUE;
}
+
+//_____________________________________________________________________________
+void AliTRDdigitizer::SetPRF(TF1 *prf)
+{
+ //
+ // Defines a new pad response function
+ //
+
+ if (fPRF) delete fPRF;
+ fPRF = prf;
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitizer::SetTRF(TF1 *trf)
+{
+ //
+ // Defines a new time response function
+ //
+
+ if (fTRF) delete fTRF;
+ fTRF = trf;
+
+}
+
+//_____________________________________________________________________________
+Double_t TRFlandau(Double_t *x, Double_t *par)
+{
+
+ Double_t xx = x[0];
+ Double_t landau = par[0] * TMath::Landau(xx,par[1],par[2]);
+
+ return landau;
+
+}
/* $Id$ */
#include <TNamed.h>
-#include <TFile.h>
-#include <TF1.h>
-#include "AliHit.h"
-#include "AliTRDdigit.h"
-#include "AliTRDconst.h"
-#include "AliTRDgeometry.h"
+// Time response function of the preamp
+Double_t TRFlandau(Double_t *x, Double_t *par);
+class TFile;
+class TF1;
+
+class AliTRD;
class AliTRDdigitsManager;
+class AliTRDgeometry;
///////////////////////////////////////////////////////
// Produces digits from the hits information //
virtual Bool_t Open(const Char_t *name, Int_t nEvent = 0);
virtual Bool_t MakeDigits();
virtual Bool_t WriteDigits();
-
- virtual void SetGasGain(Float_t gasgain) { fGasGain = gasgain; };
- virtual void SetNoise(Float_t noise) { fNoise = noise; };
- virtual void SetChipGain(Float_t chipgain) { fChipGain = chipgain; };
- virtual void SetADCoutRange(Float_t range) { fADCoutRange = range; };
- virtual void SetADCinRange(Float_t range) { fADCinRange = range; };
- virtual void SetADCthreshold(Int_t thresh) { fADCthreshold = thresh; };
- virtual void SetDiffusion(Int_t diffOn = 1) { fDiffusionOn = diffOn; };
- virtual void SetDiffusionT(Float_t diff) { fDiffusionT = diff; };
- virtual void SetDiffusionL(Float_t diff) { fDiffusionL = diff; };
- virtual void SetElAttach(Int_t elOn = 1) { fElAttachOn = elOn; };
- virtual void SetElAttachProp(Float_t prop) { fElAttachProp = prop; };
- virtual void SetExB(Int_t exbOn = 1) { fExBOn = exbOn; };
- virtual void SetLorentzAngle(Float_t angle) { fLorentzAngle = angle; };
- virtual void SetPadResponse(TF1 *PRF) { if (fPRF) delete fPRF;
- fPRF = PRF; };
-
- AliTRDdigitsManager *Digits() { return fDigits; };
-
- virtual Float_t GetGasGain() { return fGasGain; };
- virtual Float_t GetNoise() { return fNoise; };
- virtual Float_t GetChipGain() { return fChipGain; };
- virtual Float_t GetADCoutRange() { return fADCoutRange; };
- virtual Float_t GetADCinRange() { return fADCinRange; };
- virtual Int_t GetADCthreshold() { return fADCthreshold; };
- virtual Float_t GetDiffusionT() { return fDiffusionT; };
- virtual Float_t GetDiffusionL() { return fDiffusionL; };
- virtual Float_t GetElAttachProp() { return fElAttachProp; };
- virtual Float_t GetLorentzAngle() { return fLorentzAngle; };
- virtual TF1 *GetPadResponse() { return fPRF; };
+ virtual Bool_t InitDetector();
+
+ virtual void SetGasGain(Float_t gasgain) { fGasGain = gasgain; };
+ virtual void SetNoise(Float_t noise) { fNoise = noise; };
+ virtual void SetChipGain(Float_t chipgain) { fChipGain = chipgain; };
+ virtual void SetADCoutRange(Float_t range) { fADCoutRange = range; };
+ virtual void SetADCinRange(Float_t range) { fADCinRange = range; };
+ virtual void SetADCthreshold(Int_t thresh) { fADCthreshold = thresh; };
+ virtual void SetDiffusion(Int_t diffOn = 1) { fDiffusionOn = diffOn; };
+ virtual void SetDiffusionT(Float_t diff) { fDiffusionT = diff; };
+ virtual void SetDiffusionL(Float_t diff) { fDiffusionL = diff; };
+ virtual void SetElAttach(Int_t elOn = 1) { fElAttachOn = elOn; };
+ virtual void SetElAttachProp(Float_t prop) { fElAttachProp = prop; };
+ virtual void SetExB(Int_t exbOn = 1) { fExBOn = exbOn; };
+ virtual void SetOmegaTau(Float_t ot) { fOmegaTau = ot; };
+ virtual void SetPadResponse(Int_t prfOn = 1) { fPRFOn = prfOn; };
+ virtual void SetPRF(TF1 *prf);
+ virtual void SetTimeResponse(Int_t trfOn = 1) { fTRFOn = trfOn; };
+ virtual void SetTRF(TF1 *trf);
+ virtual void SetDriftVelocity(Float_t v) { fDriftVelocity = v; };
+ virtual void SetCompress(Int_t c = 1) { fCompress = c; };
+ virtual void SetVerbose(Int_t v = 1) { fVerbose = v; };
+
+ AliTRDdigitsManager *Digits() const { return fDigits; };
+
+ virtual Float_t GetGasGain() const { return fGasGain; };
+ virtual Float_t GetNoise() const { return fNoise; };
+ virtual Float_t GetChipGain() const { return fChipGain; };
+ virtual Float_t GetADCoutRange() const { return fADCoutRange; };
+ virtual Float_t GetADCinRange() const { return fADCinRange; };
+ virtual Int_t GetADCthreshold() const { return fADCthreshold; };
+ virtual Float_t GetDiffusionT() const { return fDiffusionT; };
+ virtual Float_t GetDiffusionL() const { return fDiffusionL; };
+ virtual Float_t GetElAttachProp() const { return fElAttachProp; };
+ virtual Float_t GetOmegaTau() const { return fOmegaTau; };
+ virtual TF1 *GetPadResponse() const { return fPRF; };
+ virtual TF1 *GetTimeResponse() const { return fTRF; };
+ virtual Float_t GetDriftVelocity() const { return fDriftVelocity; };
+ virtual Bool_t GetCompress() const { return fCompress; };
protected:
Int_t fElAttachOn; // Switch for the electron attachment
Float_t fElAttachProp; // Propability for electron attachment (for 1m)
Int_t fExBOn; // Switch for the ExB effects
- Float_t fLorentzAngle; // Lorentz angle
+ Float_t fOmegaTau; // Tangens of the Lorentz angle
Float_t fLorentzFactor; // Factor due to Lorentz force
+ Int_t fPRFOn; // Switch for the pad response
TF1 *fPRF; // Pad response function
+ Int_t fTRFOn; // Switch for the time response
+ TF1 *fTRF; // Time response function of the shaper
+ Float_t *fTRFint; //!Integrated time response
+ Int_t fTRFbin; // Number of bins for the TRF
+ Float_t fTRFlo; // Lower boundary of the TRF
+ Float_t fTRFhi; // Higher boundary of the TRF
+ Float_t fTRFwid; // Bin width of the integrated TRF
+ Float_t fDriftVelocity; // Drift velocity (cm / mus)
+ Bool_t fCompress; // Switch to keep only compressed data in memory
+ Int_t fVerbose; // Sets the verbose level
private:
- virtual Int_t Diffusion(Float_t driftlength, Float_t *xyz);
- virtual Int_t ExB(Float_t driftlength, Float_t *xyz);
-
- ClassDef(AliTRDdigitizer,1) // Produces TRD-Digits
+ virtual Int_t Diffusion(Float_t driftlength, Float_t *xyz);
+ virtual Int_t ExB(Float_t driftlength, Float_t *xyz);
+ virtual Int_t PadResponse(Float_t signal, Float_t dist, Float_t *pad);
+ virtual Float_t TimeResponse(Float_t time);
+ virtual Bool_t CheckDetector(Int_t plane, Int_t chamber, Int_t sector);
+ virtual void IntegrateTRF();
+
+ ClassDef(AliTRDdigitizer,2) // Produces TRD-Digits
};
/*
$Log$
+Revision 1.1.2.5 2000/10/17 02:27:34 cblume
+Get rid of global constants
+
+Revision 1.1.2.4 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.2.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.2.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
Revision 1.5 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
// AliTRDdataArray objects. //
// //
///////////////////////////////////////////////////////////////////////////////
-
-#include <TTree.h>
+
+#include <TTree.h>
#include "AliRun.h"
#include "AliTRDdigitsManager.h"
-#include "AliTRDconst.h"
+#include "AliTRDsegmentArray.h"
+#include "AliTRDdataArrayI.h"
+#include "AliTRDdigit.h"
+#include "AliTRDgeometry.h"
ClassImp(AliTRDdigitsManager)
//_____________________________________________________________________________
+
+ // Number of track dictionary arrays
+ const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
+
+//_____________________________________________________________________________
AliTRDdigitsManager::AliTRDdigitsManager():TObject()
{
//
fIsRaw = kFALSE;
- fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",kNdet);
+ fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",AliTRDgeometry::Ndet());
for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI",kNdet);
+ fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
+ ,AliTRDgeometry::Ndet());
}
}
fIsRaw = kTRUE;
- fDigits->SetBit(kRawDigit);
+ fDigits->SetBit(AliTRDdigit::RawDigit());
}
status = fDictionary[iDict]->LoadArray(branchname);
}
- if (fDigits->TestBit(kRawDigit)) {
+ if (fDigits->TestBit(AliTRDdigit::RawDigit())) {
fIsRaw = kTRUE;
}
else {
//_____________________________________________________________________________
AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
- , Int_t time, Int_t det)
+ , Int_t time, Int_t det) const
{
//
// Creates a single digit object
//_____________________________________________________________________________
Int_t AliTRDdigitsManager::GetTrack(Int_t track
, Int_t row, Int_t col, Int_t time
- , Int_t det)
+ , Int_t det) const
{
//
// Returns the MC-track numbers from the dictionary.
}
//_____________________________________________________________________________
-AliTRDdataArrayI *AliTRDdigitsManager::GetDigits(Int_t det)
+AliTRDdataArrayI *AliTRDdigitsManager::GetDigits(Int_t det) const
{
//
// Returns the digits array for one detector
}
//_____________________________________________________________________________
-AliTRDdataArrayI *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i)
+AliTRDdataArrayI *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
{
//
// Returns the dictionary for one detector
}
//_____________________________________________________________________________
-Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit)
+Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
{
//
// Returns the MC-track numbers from the dictionary for a given digit
// Manages the TRD digits //
/////////////////////////////////////////////////////////////
-#include "TObject.h"
+#include <TObject.h>
-#include "AliTRDsegmentArray.h"
-#include "AliTRDdataArrayI.h"
-#include "AliTRDdigit.h"
-
-const Int_t kNDict = 3;
+class AliTRDsegmentArray;
+class AliTRDdataArrayI;
+class AliTRDdigit;
class AliTRDdigitsManager : public TObject {
virtual void SetRaw();
- virtual Bool_t IsRaw() { return fIsRaw; };
- virtual AliTRDsegmentArray *GetDigits() { return fDigits; };
- virtual AliTRDsegmentArray *GetDictionary(Int_t i) { return fDictionary[i]; };
+ virtual Bool_t IsRaw() const { return fIsRaw; };
+ static Int_t NDict() { return fgkNDict; };
+
+ virtual AliTRDsegmentArray *GetDigits() const { return fDigits; };
+ virtual AliTRDsegmentArray *GetDictionary(Int_t i) const { return fDictionary[i]; };
- AliTRDdigit *GetDigit(Int_t row, Int_t col, Int_t time, Int_t det);
- Int_t GetTrack(Int_t track, Int_t row, Int_t col, Int_t time, Int_t det);
+ AliTRDdigit *GetDigit(Int_t row, Int_t col, Int_t time, Int_t det) const;
+ Int_t GetTrack(Int_t track, Int_t row, Int_t col
+ , Int_t time, Int_t det) const;
- AliTRDdataArrayI *GetDigits(Int_t det);
- AliTRDdataArrayI *GetDictionary(Int_t det, Int_t i);
- Int_t GetTrack(Int_t track, AliTRDdigit *Digit);
+ AliTRDdataArrayI *GetDigits(Int_t det) const;
+ AliTRDdataArrayI *GetDictionary(Int_t det, Int_t i) const;
+ Int_t GetTrack(Int_t track, AliTRDdigit *Digit) const;
protected:
+ enum { kNDict = 3 };
+ static const Int_t fgkNDict; // Number of track dictionary arrays
+
AliTRDsegmentArray *fDigits; //! Digits data Array
AliTRDsegmentArray *fDictionary[kNDict]; //! Track dictionary data array
/*
$Log$
+Revision 1.1.4.7 2000/10/16 01:16:53 cblume
+Changed timebin 0 to be the one closest to the readout
+
+Revision 1.1.4.6 2000/10/15 23:35:57 cblume
+Include geometry constants as static member
+
+Revision 1.1.4.5 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.4 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.3 2000/09/22 14:43:40 cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.1.4.2 2000/09/18 13:37:01 cblume
+Minor coding corrections
+
+Revision 1.5 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
+Revision 1.4 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
+Revision 1.3 2000/06/07 16:25:37 cblume
+Try to remove compiler warnings on Sun and HP
+
+Revision 1.2 2000/05/08 16:17:27 cblume
+Merge TRD-develop
+
+Revision 1.1.4.1 2000/05/08 14:45:55 cblume
+Bug fix in RotateBack(). Geometry update
+
Revision 1.4 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
+#include "AliMC.h"
+
#include "AliTRDgeometry.h"
#include "AliTRDrecPoint.h"
#include "AliMC.h"
ClassImp(AliTRDgeometry)
//_____________________________________________________________________________
+
+ //
+ // The geometry constants
+ //
+ const Int_t AliTRDgeometry::fgkNsect = kNsect;
+ const Int_t AliTRDgeometry::fgkNplan = kNplan;
+ const Int_t AliTRDgeometry::fgkNcham = kNcham;
+ const Int_t AliTRDgeometry::fgkNdet = kNdet;
+
+ //
+ // Dimensions of the detector
+ //
+ const Float_t AliTRDgeometry::fgkRmin = 294.0;
+ const Float_t AliTRDgeometry::fgkRmax = 368.0;
+
+ const Float_t AliTRDgeometry::fgkZmax1 = 378.35;
+ const Float_t AliTRDgeometry::fgkZmax2 = 302.0;
+
+ const Float_t AliTRDgeometry::fgkSheight = 74.0;
+ const Float_t AliTRDgeometry::fgkSwidth1 = 99.613;
+ const Float_t AliTRDgeometry::fgkSwidth2 = 125.707;
+ const Float_t AliTRDgeometry::fgkSlenTR1 = 751.0;
+ const Float_t AliTRDgeometry::fgkSlenTR2 = 313.5;
+ const Float_t AliTRDgeometry::fgkSlenTR3 = 159.5;
+
+ const Float_t AliTRDgeometry::fgkCheight = 11.0;
+ const Float_t AliTRDgeometry::fgkCspace = 1.6;
+ const Float_t AliTRDgeometry::fgkCathick = 1.0;
+ const Float_t AliTRDgeometry::fgkCcthick = 1.0;
+ const Float_t AliTRDgeometry::fgkCaframe = 2.675;
+ const Float_t AliTRDgeometry::fgkCcframe = AliTRDgeometry::fgkCheight
+ - AliTRDgeometry::fgkCaframe;
+
+ //
+ // Thickness of the the material layers
+ //
+ const Float_t AliTRDgeometry::fgkSeThick = 0.02;
+ const Float_t AliTRDgeometry::fgkRaThick = 4.8;
+ const Float_t AliTRDgeometry::fgkPeThick = 0.20;
+ const Float_t AliTRDgeometry::fgkMyThick = 0.005;
+ const Float_t AliTRDgeometry::fgkXeThick = 3.5;
+ const Float_t AliTRDgeometry::fgkDrThick = 3.0;
+ const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkXeThick
+ - AliTRDgeometry::fgkDrThick;
+ const Float_t AliTRDgeometry::fgkCuThick = 0.001;
+ const Float_t AliTRDgeometry::fgkSuThick = 0.06;
+ const Float_t AliTRDgeometry::fgkFeThick = 0.0044;
+ const Float_t AliTRDgeometry::fgkCoThick = 0.02;
+ const Float_t AliTRDgeometry::fgkWaThick = 0.01;
+
+ //
+ // Position of the material layers
+ //
+ const Float_t AliTRDgeometry::fgkSeZpos = -4.1525;
+ const Float_t AliTRDgeometry::fgkRaZpos = -1.7425;
+ const Float_t AliTRDgeometry::fgkPeZpos = 0.0000;
+ const Float_t AliTRDgeometry::fgkMyZpos = 0.6600;
+ const Float_t AliTRDgeometry::fgkDrZpos = 2.1625;
+ const Float_t AliTRDgeometry::fgkAmZpos = 4.1125;
+ const Float_t AliTRDgeometry::fgkCuZpos = -1.3370;
+ const Float_t AliTRDgeometry::fgkSuZpos = 0.0000;
+ const Float_t AliTRDgeometry::fgkFeZpos = 1.3053;
+ const Float_t AliTRDgeometry::fgkCoZpos = 1.3175;
+ const Float_t AliTRDgeometry::fgkWaZpos = 1.3325;
+
+//_____________________________________________________________________________
AliTRDgeometry::AliTRDgeometry():AliGeometry()
{
//
// Initializes the geometry parameter
//
- Int_t iplan;
+ Int_t isect;
// The width of the chambers
- fCwidth[0] = 99.6;
- fCwidth[1] = 104.1;
- fCwidth[2] = 108.5;
- fCwidth[3] = 112.9;
- fCwidth[4] = 117.4;
- fCwidth[5] = 121.8;
-
- // The default pad dimensions
- fRowPadSize = 4.5;
- fColPadSize = 1.0;
- fTimeBinSize = 0.1;
+ fCwidth[0] = 99.6;
+ fCwidth[1] = 104.1;
+ fCwidth[2] = 108.5;
+ fCwidth[3] = 112.9;
+ fCwidth[4] = 117.4;
+ fCwidth[5] = 121.8;
// The maximum number of pads
// and the position of pad 0,0,0
// chambers seen from the top:
// +----------------------------+
// | |
- // | | ^
- // | | rphi|
- // | | |
- // |0 | |
- // +----------------------------+ +------>
+ // | | ^
+ // | | rphi|
+ // | | |
+ // |0 | |
+ // +----------------------------+ +------>
// z
- // chambers seen from the side: ^
- // +----------------------------+ time|
- // | | |
- // |0 | |
- // +----------------------------+ +------>
+ // chambers seen from the side: ^
+ // +----------------------------+ drift|
+ // |0 | |
+ // | | |
+ // +----------------------------+ +------>
// z
//
+ // IMPORTANT: time bin 0 is now the one closest to the readout !!!
+ //
// The pad column (rphi-direction)
- for (iplan = 0; iplan < kNplan; iplan++) {
- fColMax[iplan] = 1 + TMath::Nint((fCwidth[iplan] - 2. * kCcthick)
+ SetColPadSize(1.0);
+
+ // The time bucket
+ SetTimeBinSize(0.1);
+
+ // The rotation matrix elements
+ Float_t phi = 0;
+ for (isect = 0; isect < fgkNsect; isect++) {
+ phi = -2.0 * kPI / (Float_t) fgkNsect * ((Float_t) isect + 0.5);
+ fRotA11[isect] = TMath::Cos(phi);
+ fRotA12[isect] = TMath::Sin(phi);
+ fRotA21[isect] = TMath::Sin(phi);
+ fRotA22[isect] = TMath::Cos(phi);
+ phi = -1.0 * phi;
+ fRotB11[isect] = TMath::Cos(phi);
+ fRotB12[isect] = TMath::Sin(phi);
+ fRotB21[isect] = TMath::Sin(phi);
+ fRotB22[isect] = TMath::Cos(phi);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDgeometry::SetColPadSize(Float_t size)
+{
+ //
+ // Redefines the pad size in column direction
+ //
+
+ fColPadSize = size;
+ for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
+ fColMax[iplan] = 1 + TMath::Nint((fCwidth[iplan] - 2. * fgkCcthick)
/ fColPadSize - 0.5);
- fCol0[iplan] = -fCwidth[iplan]/2. + kCcthick;
+ fCol0[iplan] = -fCwidth[iplan]/2. + fgkCcthick;
}
- // The time bucket
- fTimeMax = 1 + TMath::Nint(kDrThick / fTimeBinSize - 0.5);
- for (iplan = 0; iplan < kNplan; iplan++) {
- fTime0[iplan] = kRmin + kCcframe/2. + kDrZpos - 0.5 * kDrThick
- + iplan * (kCheight + kCspace);
- }
+}
+
+//_____________________________________________________________________________
+void AliTRDgeometry::SetTimeBinSize(Float_t size)
+{
+ //
+ // Redefines the time bin size
+ //
+
+ fTimeBinSize = size;
+ fTimeMax = 1 + TMath::Nint(fgkDrThick / fTimeBinSize - 0.5);
+ for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
+ fTime0[iplan] = fgkRmin + fgkCcframe/2. + fgkDrZpos + 0.5 * fgkDrThick
+ + iplan * (fgkCheight + fgkCspace);
+ }
}
parCha[0] = -1.;
parCha[1] = -1.;
// G10 layer (radiator seal)
- parCha[2] = kSeThick/2;
+ parCha[2] = fgkSeThick/2;
gMC->Gsvolu("UL01","BOX ",idtmed[1313-1],parCha,kNparCha);
// CO2 layer (radiator)
- parCha[2] = kRaThick/2;
+ parCha[2] = fgkRaThick/2;
gMC->Gsvolu("UL02","BOX ",idtmed[1312-1],parCha,kNparCha);
// PE layer (radiator)
- parCha[2] = kPeThick/2;
+ parCha[2] = fgkPeThick/2;
gMC->Gsvolu("UL03","BOX ",idtmed[1303-1],parCha,kNparCha);
// Mylar layer (entrance window + HV cathode)
- parCha[2] = kMyThick/2;
+ parCha[2] = fgkMyThick/2;
gMC->Gsvolu("UL04","BOX ",idtmed[1308-1],parCha,kNparCha);
// Xe/Isobutane layer (drift volume, sensitive)
- parCha[2] = kDrThick/2.;
+ parCha[2] = fgkDrThick/2.;
gMC->Gsvolu("UL05","BOX ",idtmed[1309-1],parCha,kNparCha);
// Xe/Isobutane layer (amplification volume, not sensitive)
- parCha[2] = kAmThick/2.;
+ parCha[2] = fgkAmThick/2.;
gMC->Gsvolu("UL06","BOX ",idtmed[1309-1],parCha,kNparCha);
// Cu layer (pad plane)
- parCha[2] = kCuThick/2;
+ parCha[2] = fgkCuThick/2;
gMC->Gsvolu("UL07","BOX ",idtmed[1305-1],parCha,kNparCha);
// G10 layer (support structure)
- parCha[2] = kSuThick/2;
+ parCha[2] = fgkSuThick/2;
gMC->Gsvolu("UL08","BOX ",idtmed[1313-1],parCha,kNparCha);
// Cu layer (FEE + signal lines)
- parCha[2] = kFeThick/2;
+ parCha[2] = fgkFeThick/2;
gMC->Gsvolu("UL09","BOX ",idtmed[1305-1],parCha,kNparCha);
// PE layer (cooling devices)
- parCha[2] = kCoThick/2;
+ parCha[2] = fgkCoThick/2;
gMC->Gsvolu("UL10","BOX ",idtmed[1303-1],parCha,kNparCha);
// Water layer (cooling)
- parCha[2] = kWaThick/2;
+ parCha[2] = fgkWaThick/2;
gMC->Gsvolu("UL11","BOX ",idtmed[1314-1],parCha,kNparCha);
// Position the layers in the chambers
ypos = 0;
// G10 layer (radiator seal)
- zpos = kSeZpos;
+ zpos = fgkSeZpos;
gMC->Gspos("UL01",1,"UCII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL01",2,"UCIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL01",3,"UCIO",xpos,ypos,zpos,0,"ONLY");
// CO2 layer (radiator)
- zpos = kRaZpos;
+ zpos = fgkRaZpos;
gMC->Gspos("UL02",1,"UCII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL02",2,"UCIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL02",3,"UCIO",xpos,ypos,zpos,0,"ONLY");
zpos = 0;
gMC->Gspos("UL03",1,"UL02",xpos,ypos,zpos,0,"ONLY");
// Mylar layer (entrance window + HV cathode)
- zpos = kMyZpos;
+ zpos = fgkMyZpos;
gMC->Gspos("UL04",1,"UCII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL04",2,"UCIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL04",3,"UCIO",xpos,ypos,zpos,0,"ONLY");
// Xe/Isobutane layer (drift volume)
- zpos = kDrZpos;
+ zpos = fgkDrZpos;
gMC->Gspos("UL05",1,"UCII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL05",2,"UCIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL05",3,"UCIO",xpos,ypos,zpos,0,"ONLY");
// Xe/Isobutane layer (amplification volume)
- zpos = kAmZpos;
+ zpos = fgkAmZpos;
gMC->Gspos("UL06",1,"UCII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL06",2,"UCIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL06",3,"UCIO",xpos,ypos,zpos,0,"ONLY");
// Cu layer (pad plane)
- zpos = kCuZpos;
+ zpos = fgkCuZpos;
gMC->Gspos("UL07",1,"UAII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL07",2,"UAIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL07",3,"UAIO",xpos,ypos,zpos,0,"ONLY");
// G10 layer (support structure)
- zpos = kSuZpos;
+ zpos = fgkSuZpos;
gMC->Gspos("UL08",1,"UAII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL08",2,"UAIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL08",3,"UAIO",xpos,ypos,zpos,0,"ONLY");
// Cu layer (FEE + signal lines)
- zpos = kFeZpos;
+ zpos = fgkFeZpos;
gMC->Gspos("UL09",1,"UAII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL09",2,"UAIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL09",3,"UAIO",xpos,ypos,zpos,0,"ONLY");
// PE layer (cooling devices)
- zpos = kCoZpos;
+ zpos = fgkCoZpos;
gMC->Gspos("UL10",1,"UAII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL10",2,"UAIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL10",3,"UAIO",xpos,ypos,zpos,0,"ONLY");
// Water layer (cooling)
- zpos = kWaZpos;
+ zpos = fgkWaZpos;
gMC->Gspos("UL11",1,"UAII",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL11",1,"UAIM",xpos,ypos,zpos,0,"ONLY");
gMC->Gspos("UL11",1,"UAIO",xpos,ypos,zpos,0,"ONLY");
// global ALICE reference frame coordinates (x,y,z)
//
- Int_t icham = GetChamber(idet); // Chamber info (0-4)
- Int_t isect = GetSector(idet); // Sector info (0-17)
- Int_t iplan = GetPlane(idet); // Plane info (0-5)
+ Int_t icham = GetChamber(idet); // Chamber info (0-4)
+ Int_t isect = GetSector(idet); // Sector info (0-17)
+ Int_t iplan = GetPlane(idet); // Plane info (0-5)
return Local2Global(iplan,icham,isect,local,global);
// global ALICE reference frame coordinates (x,y,z)
//
- Int_t idet = GetDetector(iplan,icham,isect); // Detector number
+ Int_t idet = GetDetector(iplan,icham,isect); // Detector number
- Float_t padRow = local[0]; // Pad Row position
- Float_t padCol = local[1]; // Pad Column position
- Float_t timeSlice = local[2]; // Time "position"
+ Float_t padRow = local[0]; // Pad Row position
+ Float_t padCol = local[1]; // Pad Column position
+ Float_t timeSlice = local[2]; // Time "position"
- Float_t row0 = GetRow0(iplan,icham,isect);
- Float_t col0 = GetCol0(iplan);
- Float_t time0 = GetTime0(iplan);
+ Float_t row0 = GetRow0(iplan,icham,isect);
+ Float_t col0 = GetCol0(iplan);
+ Float_t time0 = GetTime0(iplan);
- Float_t rot[3];
+ Float_t rot[3];
// calculate (x,y,z) position in rotated chamber
rot[0] = time0 + timeSlice * fTimeBinSize;
}
//_____________________________________________________________________________
-Bool_t AliTRDgeometry::Rotate(Int_t d, Float_t *pos, Float_t *rot)
+Bool_t AliTRDgeometry::Rotate(Int_t d, Float_t *pos, Float_t *rot) const
{
//
// Rotates all chambers in the position of sector 0 and transforms
// corresponding local frame <rot>.
//
- Int_t sector = GetSector(d);
-
- Float_t phi = -2.0 * kPI / (Float_t) kNsect * ((Float_t) sector + 0.5);
+ Int_t sector = GetSector(d);
- rot[0] = pos[0] * TMath::Cos(phi) + pos[1] * TMath::Sin(phi);
- rot[1] = -pos[0] * TMath::Sin(phi) + pos[1] * TMath::Cos(phi);
+ rot[0] = pos[0] * fRotA11[sector] + pos[1] * fRotA12[sector];
+ rot[1] = -pos[0] * fRotA21[sector] + pos[1] * fRotA22[sector];
rot[2] = pos[2];
return kTRUE;
// coordinates <rot> into the coordinates of the ALICE restframe <pos>.
//
- Int_t sector = GetSector(d);
-
- Float_t phi = 2.0 * kPI / (Float_t) kNsect * ((Float_t) sector + 0.5);
+ Int_t sector = GetSector(d);
- pos[0] = rot[0] * TMath::Cos(phi) + rot[1] * TMath::Sin(phi);
- pos[1] = -rot[0] * TMath::Sin(phi) + rot[1] * TMath::Cos(phi);
+ pos[0] = rot[0] * fRotB11[sector] + rot[1] * fRotB12[sector];
+ pos[1] = -rot[0] * fRotB21[sector] + rot[1] * fRotB22[sector];
pos[2] = rot[2];
return kTRUE;
// Convert plane / chamber / sector into detector number
//
- return (p + c * kNplan + s * kNplan * kNcham);
+ return (p + c * fgkNplan + s * fgkNplan * fgkNcham);
}
// Reconstruct the plane number from the detector number
//
- return ((Int_t) (d % kNplan));
+ return ((Int_t) (d % fgkNplan));
}
// Reconstruct the chamber number from the detector number
//
- return ((Int_t) (d % (kNplan * kNcham)) / kNplan);
+ return ((Int_t) (d % (fgkNplan * fgkNcham)) / fgkNplan);
}
// Reconstruct the sector number from the detector number
//
- return ((Int_t) (d / (kNplan * kNcham)));
+ return ((Int_t) (d / (fgkNplan * fgkNcham)));
}
//_____________________________________________________________________________
-void AliTRDgeometry::GetGlobal(const AliRecPoint *p, TVector3 &pos, TMatrix &mat) const
+void AliTRDgeometry::GetGlobal(const AliRecPoint *p, TVector3 &pos
+ , TMatrix &mat) const
{
//
// Returns the global coordinate and error matrix of a AliTRDrecPoint
/* $Id$ */
-#include <TObject.h>
-#include <TMath.h>
-
-#include "AliRun.h"
-#include "AliRecPoint.h"
#include "AliGeometry.h"
-#include "AliTRDconst.h"
-
class AliTRDgeometry : public AliGeometry {
public:
AliTRDgeometry();
virtual ~AliTRDgeometry();
- virtual void CreateGeometry(Int_t *idtmed);
- virtual Int_t IsVersion() const = 0;
- virtual void Init();
- virtual Bool_t Local2Global(Int_t d, Float_t *local, Float_t *global) const;
- virtual Bool_t Local2Global(Int_t p, Int_t c, Int_t s, Float_t *local, Float_t *global) const;
- virtual Bool_t Rotate(Int_t d, Float_t *pos, Float_t *rot);
- virtual Bool_t RotateBack(Int_t d, Float_t *rot, Float_t *pos) const;
-
- virtual void SetPHOShole() = 0;
- virtual void SetRICHhole() = 0;
-
- virtual void SetRowPadSize(Float_t size) { fRowPadSize = size; };
- virtual void SetColPadSize(Float_t size) { fColPadSize = size; };
- virtual void SetTimeBinSize(Float_t size) { fTimeBinSize = size; };
-
- virtual Bool_t GetPHOShole() = 0;
- virtual Bool_t GetRICHhole() = 0;
-
- virtual Int_t GetDetector(Int_t p, Int_t c, Int_t s) const;
- virtual Int_t GetPlane(Int_t d) const;
- virtual Int_t GetChamber(Int_t d) const;
- virtual Int_t GetSector(Int_t d) const;
-
- virtual Int_t GetRowMax(Int_t p, Int_t c, Int_t s) { return fRowMax[p][c][s]; };
- virtual Int_t GetColMax(Int_t p) { return fColMax[p]; };
- virtual Int_t GetTimeMax() { return fTimeMax; };
+ virtual void CreateGeometry(Int_t *idtmed);
+ virtual Int_t IsVersion() const = 0;
+ virtual void Init();
+ virtual Bool_t Local2Global(Int_t d, Float_t *local, Float_t *global) const;
+ virtual Bool_t Local2Global(Int_t p, Int_t c, Int_t s, Float_t *local, Float_t *global) const;
+ virtual Bool_t Rotate(Int_t d, Float_t *pos, Float_t *rot) const;
+ virtual Bool_t RotateBack(Int_t d, Float_t *rot, Float_t *pos) const;
+
+ static Int_t Nsect() { return fgkNsect; };
+ static Int_t Nplan() { return fgkNplan; };
+ static Int_t Ncham() { return fgkNcham; };
+ static Int_t Ndet() { return fgkNdet; };
+
+ static Float_t Rmin() { return fgkRmin; };
+ static Float_t Rmax() { return fgkRmax; };
+ static Float_t Zmax1() { return fgkZmax1; };
+ static Float_t Zmax2() { return fgkZmax2; };
+
+ static Float_t Cwidcha() { return (fgkSwidth2 - fgkSwidth1)
+ / fgkSheight * (fgkCheight + fgkCspace); };
+ static Float_t Cheight() { return fgkCheight; };
+ static Float_t Cspace() { return fgkCspace; };
+ static Float_t MyThick() { return fgkMyThick; };
+ static Float_t DrThick() { return fgkDrThick; };
+ static Float_t RaThick() { return fgkRaThick; };
+
+ virtual void SetPHOShole() = 0;
+ virtual void SetRICHhole() = 0;
+
+ virtual void SetRowPadSize(Float_t size) {};
+ virtual void SetColPadSize(Float_t size);
+ virtual void SetTimeBinSize(Float_t size);
+
+ virtual Bool_t GetPHOShole() const = 0;
+ virtual Bool_t GetRICHhole() const = 0;
+
+ virtual Int_t GetDetector(Int_t p, Int_t c, Int_t s) const;
+ virtual Int_t GetPlane(Int_t d) const;
+ virtual Int_t GetChamber(Int_t d) const;
+ virtual Int_t GetSector(Int_t d) const;
+
+ virtual Float_t GetChamberWidth(Int_t p) const { return fCwidth[p]; };
+
+ virtual Int_t GetRowMax(Int_t p, Int_t c, Int_t s) const { return fRowMax[p][c][s]; };
+ virtual Int_t GetColMax(Int_t p) const { return fColMax[p]; };
+ virtual Int_t GetTimeMax() const { return fTimeMax; };
- virtual Float_t GetRow0(Int_t p, Int_t c, Int_t s) const { return fRow0[p][c][s]; };
- virtual Float_t GetCol0(Int_t p) const { return fCol0[p]; };
- virtual Float_t GetTime0(Int_t p) const { return fTime0[p]; };
-
- virtual Float_t GetRowPadSize() const { return fRowPadSize; };
- virtual Float_t GetColPadSize() const { return fColPadSize; };
- virtual Float_t GetTimeBinSize() const { return fTimeBinSize; };
-
- virtual void GetGlobal(const AliRecPoint *p, TVector3 &pos, TMatrix &mat) const;
- virtual void GetGlobal(const AliRecPoint *p, TVector3 &pos) const;
+ virtual Float_t GetRow0(Int_t p, Int_t c, Int_t s) const { return fRow0[p][c][s]; };
+ virtual Float_t GetCol0(Int_t p) const { return fCol0[p]; };
+ virtual Float_t GetTime0(Int_t p) const { return fTime0[p]; };
- protected:
-
- Float_t fCwidth[kNplan]; // Width of the chambers
+ virtual Float_t GetRowPadSize() const { return fRowPadSize; };
+ virtual Float_t GetColPadSize() const { return fColPadSize; };
+ virtual Float_t GetTimeBinSize() const { return fTimeBinSize; };
- Int_t fRowMax[kNplan][kNcham][kNsect]; // Number of pad-rows
- Int_t fColMax[kNplan]; // Number of pad-columns
- Int_t fTimeMax; // Number of time buckets
+ virtual void GetGlobal(const AliRecPoint *p, TVector3 &pos, TMatrix &mat) const;
+ virtual void GetGlobal(const AliRecPoint *p, TVector3 &pos) const;
- Float_t fRow0[kNplan][kNcham][kNsect]; // Row-position of pad 0
- Float_t fCol0[kNplan]; // Column-position of pad 0
- Float_t fTime0[kNplan]; // Time-position of pad 0
+ static Double_t GetAlpha() { return 2 * 3.14159265358979323846 / fgkNsect; };
- Float_t fRowPadSize; // Pad size in z-direction
- Float_t fColPadSize; // Pad size in rphi-direction
- Float_t fTimeBinSize; // Size of the time buckets
+ protected:
- ClassDef(AliTRDgeometry,1) // TRD geometry base class
+ enum { kNplan = 6, kNcham = 5, kNsect = 18, kNdet = 540 };
+ static const Int_t fgkNsect; // Number of sectors in the full detector (18)
+ static const Int_t fgkNplan; // Number of planes of the TRD (6)
+ static const Int_t fgkNcham; // Number of chambers in z-direction (5)
+ static const Int_t fgkNdet; // Total number of detectors (18 * 6 * 5 = 540)
+
+ static const Float_t fgkRmin; // Minimal radius of the TRD
+ static const Float_t fgkRmax; // Maximal radius of the TRD
+
+ static const Float_t fgkZmax1; // Half-length of the TRD at outer radius
+ static const Float_t fgkZmax2; // Half-length of the TRD at inner radius
+
+ static const Float_t fgkSheight; // Height of the TRD-volume in spaceframe (BTR1-3)
+ static const Float_t fgkSwidth1; // Lower width of the TRD-volume in spaceframe (BTR1-3)
+ static const Float_t fgkSwidth2; // Upper width of the TRD-volume in spaceframe (BTR1-3)
+ static const Float_t fgkSlenTR1; // Length of the TRD-volume in spaceframe (BTR1)
+ static const Float_t fgkSlenTR2; // Length of the TRD-volume in spaceframe (BTR2)
+ static const Float_t fgkSlenTR3; // Length of the TRD-volume in spaceframe (BTR3)
+
+ static const Float_t fgkCheight; // Height of the chambers
+ static const Float_t fgkCspace; // Vertical spacing of the chambers
+ static const Float_t fgkCaframe; // Height of the aluminum frame
+ static const Float_t fgkCcframe; // Height of the carbon frame
+ static const Float_t fgkCathick; // Thickness of the aluminum frame
+ static const Float_t fgkCcthick; // Thickness of the carbon frame
+
+ static const Float_t fgkSeThick; // Thickness of the radiator seal
+ static const Float_t fgkRaThick; // Thickness of the radiator
+ static const Float_t fgkPeThick; // Thickness of the PE-layer in the radiator
+ static const Float_t fgkMyThick; // Thickness of the mylar-layer
+ static const Float_t fgkXeThick; // Thickness of the gas volume
+ static const Float_t fgkDrThick; // Thickness of the drift region
+ static const Float_t fgkAmThick; // Thickness of the amplification region
+ static const Float_t fgkCuThick; // Thickness of the pad plane
+ static const Float_t fgkSuThick; // Thickness of the HEXCEL+G10 support structure
+ static const Float_t fgkFeThick; // Thickness of the FEE + signal lines
+ static const Float_t fgkCoThick; // Thickness of the PE of the cooling device
+ static const Float_t fgkWaThick; // Thickness of the cooling water
+
+ static const Float_t fgkSeZpos; // Position of the radiator seal
+ static const Float_t fgkRaZpos; // Position of the radiator
+ static const Float_t fgkPeZpos; // Position of the PE-layer in the radiator
+ static const Float_t fgkMyZpos; // Position of the mylar-layer
+ static const Float_t fgkDrZpos; // Position of the drift region
+ static const Float_t fgkAmZpos; // Position of the amplification region
+ static const Float_t fgkCuZpos; // Position of the pad plane
+ static const Float_t fgkSuZpos; // Position of the HEXCEL+G10 support structure
+ static const Float_t fgkFeZpos; // Position of the FEE + signal lines
+ static const Float_t fgkCoZpos; // Position of the PE of the cooling device
+ static const Float_t fgkWaZpos; // Position of the colling water
+
+ Int_t fRowMax[kNplan][kNcham][kNsect]; // Number of pad-rows
+ Int_t fColMax[kNplan]; // Number of pad-columns
+ Int_t fTimeMax; // Number of time buckets
+
+ Float_t fCwidth[kNplan]; // Width of the chambers
+
+ Float_t fRow0[kNplan][kNcham][kNsect]; // Row-position of pad 0
+ Float_t fCol0[kNplan]; // Column-position of pad 0
+ Float_t fTime0[kNplan]; // Time-position of pad 0
+
+ Float_t fRowPadSize; // Pad size in z-direction
+ Float_t fColPadSize; // Pad size in rphi-direction
+ Float_t fTimeBinSize; // Size of the time buckets
+
+ Float_t fRotA11[kNsect]; // Matrix elements for the rotation
+ Float_t fRotA12[kNsect]; // Matrix elements for the rotation
+ Float_t fRotA21[kNsect]; // Matrix elements for the rotation
+ Float_t fRotA22[kNsect]; // Matrix elements for the rotation
+
+ Float_t fRotB11[kNsect]; // Matrix elements for the backward rotation
+ Float_t fRotB12[kNsect]; // Matrix elements for the backward rotation
+ Float_t fRotB21[kNsect]; // Matrix elements for the backward rotation
+ Float_t fRotB22[kNsect]; // Matrix elements for the backward rotation
+
+ ClassDef(AliTRDgeometry,2) // TRD geometry base class
};
/*
$Log$
+Revision 1.1.4.6 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.4.5 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.4 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.3 2000/09/22 14:43:41 cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.4 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
Revision 1.3 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
-#include "AliTRDgeometryFull.h"
#include "AliMC.h"
+#include "AliTRDgeometryFull.h"
+
ClassImp(AliTRDgeometryFull)
//_____________________________________________________________________________
fRICHhole = kFALSE;
// The length of the inner chambers
- for (iplan = 0; iplan < kNplan; iplan++)
+ for (iplan = 0; iplan < fgkNplan; iplan++)
fClengthI[iplan] = 110.0;
// The length of the middle chambers
//
// The pad row (z-direction)
- for (iplan = 0; iplan < kNplan; iplan++) {
+ SetRowPadSize(4.5);
+
+}
- for (Int_t isect = 0; isect < kNsect; isect++) {
+//_____________________________________________________________________________
+void AliTRDgeometryFull::SetRowPadSize(Float_t size)
+{
+ //
+ // Redefines the pad size in row direction
+ //
+
+ fRowPadSize = size;
+
+ for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
+
+ for (Int_t isect = 0; isect < fgkNsect; isect++) {
Float_t clengthI = fClengthI[iplan];
Float_t clengthM = fClengthM1[iplan];
Float_t clengthO = fClengthO1[iplan];
clengthO = fClengthO3[iplan];
break;
};
- fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * kCcthick)
+ fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * kCcthick)
+ fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * kCcthick)
+ fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * kCcthick)
+ fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * kCcthick)
+ fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRow0[iplan][0][isect] = -clengthI/2. - clengthM - clengthO + kCcthick;
- fRow0[iplan][1][isect] = -clengthI/2. - clengthM + kCcthick;
- fRow0[iplan][2][isect] = -clengthI/2. + kCcthick;
- fRow0[iplan][3][isect] = clengthI/2. + kCcthick;
- fRow0[iplan][4][isect] = clengthI/2. + clengthM + kCcthick;
+ fRow0[iplan][0][isect] = -clengthI/2. - clengthM - clengthO + fgkCcthick;
+ fRow0[iplan][1][isect] = -clengthI/2. - clengthM + fgkCcthick;
+ fRow0[iplan][2][isect] = -clengthI/2. + fgkCcthick;
+ fRow0[iplan][3][isect] = clengthI/2. + fgkCcthick;
+ fRow0[iplan][4][isect] = clengthI/2. + clengthM + fgkCcthick;
}
}
const Int_t kNparTrd = 4;
const Int_t kNparCha = 3;
+ const Int_t kNplan = fgkNplan;
Float_t parTrd[kNparTrd];
Float_t parCha[kNparCha];
AliTRDgeometry::CreateGeometry(idtmed);
// The TRD mother volume for one sector (Air), full length in z-direction
- parTrd[0] = kSwidth1/2.;
- parTrd[1] = kSwidth2/2.;
- parTrd[2] = kSlenTR1/2.;
- parTrd[3] = kSheight/2.;
+ parTrd[0] = fgkSwidth1/2.;
+ parTrd[1] = fgkSwidth2/2.;
+ parTrd[2] = fgkSlenTR1/2.;
+ parTrd[3] = fgkSheight/2.;
gMC->Gsvolu("TRD1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
-
+
// The TRD mother volume for one sector (Air), leaving hole for PHOS
if (fPHOShole) {
gMC->Gsvolu("TRD2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthI[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFI",iplan ,"TRD1",xpos,ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthI[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthI[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAII",iplan ,"TRD1",xpos,ypos,zpos,0,"ONLY",parCha,kNparCha);
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthI[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFI",iplan ,"TRD1",xpos,ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthI[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthI[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCII",iplan ,"TRD1",xpos,ypos,zpos,0,"ONLY",parCha,kNparCha);
// The middle chambers --------------------------------------------------------------
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM1[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFM",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
- gMC->Gsposp("UAFM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
+ gMC->Gsposp("UAFM",iplan+ fgkNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
if (fPHOShole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM2[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM2[iplan-1]/2. + y1;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFM",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthM1[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthM1[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIM",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
- gMC->Gsposp("UAIM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
+ gMC->Gsposp("UAIM",iplan+ fgkNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
if (fPHOShole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthM2[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthM2[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM2[iplan-1]/2. + y1;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIM",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM1[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFM",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
if (fPHOShole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM2[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM2[iplan-1]/2. + y1;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFM",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthM1[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthM1[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIM",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
if (fPHOShole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthM2[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthM2[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM2[iplan-1]/2. + y1;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIM",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO1[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
if (fPHOShole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO2[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO2[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFO",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
if (fRICHhole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO3[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO3[iplan-1]/2. + y2;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFO",iplan+5*kNplan,"TRD3",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO1[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO1[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
if (fPHOShole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO2[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO2[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO2[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIO",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
if (fRICHhole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO3[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO3[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO3[iplan-1]/2. + y2;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIO",iplan+5*kNplan,"TRD3",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO1[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan, "TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
if (fPHOShole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO2[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO2[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFO",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
if (fRICHhole) {
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO3[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO3[iplan-1]/2. + y2;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFO",iplan+5*kNplan,"TRD3",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
}
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO1[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO1[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
if (fPHOShole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO2[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO2[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO2[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIO",iplan+3*kNplan,"TRD2",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
if (fRICHhole) {
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO3[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO3[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO3[iplan-1]/2. + y2;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIO",iplan+5*kNplan,"TRD3",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
}
}
- xpos = 0.;
- ypos = 0.;
- zpos = 0.;
+ xpos = 0.;
+ ypos = 0.;
+ zpos = 0.;
gMC->Gspos("TRD1",1,"BTR1",xpos,ypos,zpos,0,"ONLY");
if (fPHOShole)
gMC->Gspos("TRD2",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
public:
AliTRDgeometryFull();
- ~AliTRDgeometryFull();
+ virtual ~AliTRDgeometryFull();
void CreateGeometry(Int_t *idtmed);
- Int_t IsVersion() const { return 1; };
+ Int_t IsVersion() const { return 1; };
void Init();
- void SetPHOShole() { fPHOShole = kTRUE; };
- void SetRICHhole() { fRICHhole = kTRUE; };
+ void SetPHOShole() { fPHOShole = kTRUE; };
+ void SetRICHhole() { fRICHhole = kTRUE; };
- Bool_t GetPHOShole() { return fPHOShole; };
- Bool_t GetRICHhole() { return fRICHhole; };
+ virtual void SetRowPadSize(Float_t size);
+
+ Bool_t GetPHOShole() const { return fPHOShole; };
+ Bool_t GetRICHhole() const { return fRICHhole; };
protected:
/*
$Log$
+Revision 1.1.4.4 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.1.4.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.1 2000/09/22 14:43:41 cblume
+Allow the pad/timebin-dimensions to be changed after initialization
+
+Revision 1.3 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
Revision 1.2 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
-#include "AliTRDgeometryHole.h"
#include "AliMC.h"
+#include "AliTRDgeometryHole.h"
+
ClassImp(AliTRDgeometryHole)
//_____________________________________________________________________________
Int_t iplan;
// The length of the inner chambers
- for (iplan = 0; iplan < kNplan; iplan++)
+ for (iplan = 0; iplan < fgkNplan; iplan++)
fClengthI[iplan] = 110.0;
// The length of the middle chambers
//
// The pad row (z-direction)
- for (iplan = 0; iplan < kNplan; iplan++) {
+ SetRowPadSize(4.5);
+
+}
- for (Int_t isect = 0; isect < kNsect; isect++) {
+//_____________________________________________________________________________
+void AliTRDgeometryHole::SetRowPadSize(Float_t size)
+{
+ //
+ // Redefines the pad size in row direction
+ //
+
+ fRowPadSize = size;
+
+ for (Int_t iplan = 0; iplan < fgkNplan; iplan++) {
+
+ for (Int_t isect = 0; isect < fgkNsect; isect++) {
Float_t clengthI = fClengthI[iplan];
Float_t clengthM = fClengthM1[iplan];
Float_t clengthO = fClengthO1[iplan];
clengthO = fClengthO3[iplan];
break;
};
- fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * kCcthick)
+ fRowMax[iplan][0][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * kCcthick)
+ fRowMax[iplan][1][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * kCcthick)
+ fRowMax[iplan][2][isect] = 1 + TMath::Nint((clengthI - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * kCcthick)
+ fRowMax[iplan][3][isect] = 1 + TMath::Nint((clengthM - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * kCcthick)
+ fRowMax[iplan][4][isect] = 1 + TMath::Nint((clengthO - 2. * fgkCcthick)
/ fRowPadSize - 0.5);
- fRow0[iplan][0][isect] = -clengthI/2. - clengthM - clengthO + kCcthick;
- fRow0[iplan][1][isect] = -clengthI/2. - clengthM + kCcthick;
- fRow0[iplan][2][isect] = -clengthI/2. + kCcthick;
- fRow0[iplan][3][isect] = clengthI/2. + kCcthick;
- fRow0[iplan][4][isect] = clengthI/2. + clengthM + kCcthick;
+ fRow0[iplan][0][isect] = -clengthI/2. - clengthM - clengthO + fgkCcthick;
+ fRow0[iplan][1][isect] = -clengthI/2. - clengthM + fgkCcthick;
+ fRow0[iplan][2][isect] = -clengthI/2. + fgkCcthick;
+ fRow0[iplan][3][isect] = clengthI/2. + fgkCcthick;
+ fRow0[iplan][4][isect] = clengthI/2. + clengthM + fgkCcthick;
}
}
const Int_t kNparTrd = 4;
const Int_t kNparCha = 3;
+ const Int_t kNplan = fgkNplan;
Float_t parTrd[kNparTrd];
Float_t parCha[kNparCha];
AliTRDgeometry::CreateGeometry(idtmed);
// The TRD mother volume for one sector (Air) (dimensions identical to BTR1)
- parTrd[0] = kSwidth1/2.;
- parTrd[1] = kSwidth2/2.;
- parTrd[2] = kSlenTR1/2.;
- parTrd[3] = kSheight/2.;
+ parTrd[0] = fgkSwidth1/2.;
+ parTrd[1] = fgkSwidth2/2.;
+ parTrd[2] = fgkSlenTR1/2.;
+ parTrd[3] = fgkSheight/2.;
gMC->Gsvolu("TRD1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
// The TRD mother volume for one sector (Air) (dimensions identical to BTR2)
- parTrd[0] = kSwidth1/2.;
- parTrd[1] = kSwidth2/2.;
- parTrd[2] = kSlenTR2/2.;
- parTrd[3] = kSheight/2.;
+ parTrd[0] = fgkSwidth1/2.;
+ parTrd[1] = fgkSwidth2/2.;
+ parTrd[2] = fgkSlenTR2/2.;
+ parTrd[3] = fgkSheight/2.;
gMC->Gsvolu("TRD2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
// The TRD mother volume for one sector (Air) (dimensions identical to BTR3)
- parTrd[0] = kSwidth1/2.;
- parTrd[1] = kSwidth2/2.;
- parTrd[2] = kSlenTR3/2.;
- parTrd[3] = kSheight/2.;
+ parTrd[0] = fgkSwidth1/2.;
+ parTrd[1] = fgkSwidth2/2.;
+ parTrd[2] = fgkSlenTR3/2.;
+ parTrd[3] = fgkSheight/2.;
gMC->Gsvolu("TRD3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
// Position the chambers in the TRD mother volume
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthI[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFI",iplan ,"TRD1",xpos,ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthI[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthI[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAII",iplan ,"TRD1",xpos,ypos,zpos,0,"ONLY",parCha,kNparCha);
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthI[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFI",iplan ,"TRD1",xpos,ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthI[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthI[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = 0.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCII",iplan ,"TRD1",xpos,ypos,zpos,0,"ONLY",parCha,kNparCha);
// The middle chambers --------------------------------------------------------------
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM1[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthI[iplan-1]/2.+ fClengthM1[iplan-1]/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFM",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM2[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthM1[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthM1[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIM",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthM2[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthM2[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM1[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFM",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthM2[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthM1[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthM1[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIM",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIM",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthM2[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthM2[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIM",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
// The outer chambers ---------------------------------------------------------------
// the aluminum frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO1[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan ,"TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UAFO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO2[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO3[iplan-1]/2.;
- parCha[2] = kCaframe/2.;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthO3[iplan-1]/2. - kSlenTR3/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthO3[iplan-1]/2. - fgkSlenTR3/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAFO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the aluminum frame
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO1[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO1[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UAIO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO2[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO2[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCathick;
- parCha[1] = fClengthO3[iplan-1]/2. - kCathick;
- parCha[2] = kCaframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCathick;
+ parCha[1] = fClengthO3[iplan-1]/2. - fgkCathick;
+ parCha[2] = fgkCaframe/2.;
xpos = 0.;
- ypos = fClengthO3[iplan-1]/2. - kSlenTR3/2.;
- zpos = kCheight - kCaframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthO3[iplan-1]/2. - fgkSlenTR3/2.;
+ zpos = fgkCheight - fgkCaframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UAIO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
// the carbon frame
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO1[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan, "TRD1",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
gMC->Gsposp("UCFO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO2[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
parCha[0] = fCwidth[iplan-1]/2.;
parCha[1] = fClengthO3[iplan-1]/2.;
- parCha[2] = kCcframe/2.;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthO3[iplan-1]/2. - kSlenTR3/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthO3[iplan-1]/2. - fgkSlenTR3/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCFO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"MANY",parCha,kNparCha);
// the inner part of the carbon frame
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO1[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO1[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
ypos = fClengthI[iplan-1]/2. + fClengthM1[iplan-1] + fClengthO1[iplan-1]/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan ,"TRD1",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
gMC->Gsposp("UCIO",iplan+ kNplan,"TRD1",xpos,-ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO2[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO2[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - kSlenTR2/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthM2[iplan-1] + fClengthO2[iplan-1]/2. - fgkSlenTR2/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan+2*kNplan,"TRD2",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
- parCha[0] = fCwidth[iplan-1]/2. - kCcthick;
- parCha[1] = fClengthO3[iplan-1]/2. - kCcthick;
- parCha[2] = kCcframe/2.;
+ parCha[0] = fCwidth[iplan-1]/2. - fgkCcthick;
+ parCha[1] = fClengthO3[iplan-1]/2. - fgkCcthick;
+ parCha[2] = fgkCcframe/2.;
xpos = 0.;
- ypos = fClengthO3[iplan-1]/2. - kSlenTR3/2.;
- zpos = kCcframe/2. - kSheight/2. + (iplan-1) * (kCheight + kCspace);
+ ypos = fClengthO3[iplan-1]/2. - fgkSlenTR3/2.;
+ zpos = fgkCcframe/2. - fgkSheight/2. + (iplan-1) * (fgkCheight + fgkCspace);
gMC->Gsposp("UCIO",iplan+4*kNplan,"TRD3",xpos, ypos,zpos,0,"ONLY",parCha,kNparCha);
}
virtual ~AliTRDgeometryHole();
void CreateGeometry(Int_t *idtmed);
- Int_t IsVersion() const { return 0; };
+ Int_t IsVersion() const { return 0; };
void Init();
- void SetPHOShole() { };
- void SetRICHhole() { };
+ void SetPHOShole() { };
+ void SetRICHhole() { };
- Bool_t GetPHOShole() { return kTRUE; };
- Bool_t GetRICHhole() { return kTRUE; };
+ virtual void SetRowPadSize(Float_t size);
+
+ Bool_t GetPHOShole() const { return kTRUE; };
+ Bool_t GetRICHhole() const { return kTRUE; };
protected:
/*
$Log$
+Revision 1.1.2.2 2000/09/18 13:41:29 cblume
+Changed fDetector to UShort and fQ to Short_t. Use customized streamer
+
+Revision 1.4 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
Revision 1.3 2000/06/07 16:25:37 cblume
Try to remove compiler warnings on Sun and HP
}
//_____________________________________________________________________________
-AliTRDhit::AliTRDhit(Int_t shunt, Int_t track, Int_t *det, Float_t *hits)
+AliTRDhit::AliTRDhit(Int_t shunt, Int_t track, Int_t det
+ , Float_t *hits, Int_t q)
:AliHit(shunt, track)
{
//
// Create a TRD hit
//
- // Store volume hierarchy
- fDetector = det[0];
+ // Store detector number
+ fDetector = (UShort_t) det;
- // Store position and charge
+ // Store position
fX = hits[0];
fY = hits[1];
fZ = hits[2];
- fQ = hits[3];
+
+ // Store the charge
+ fQ = (Short_t) q;
}
//
}
+
+//_____________________________________________________________________________
+void AliTRDhit::Streamer(TBuffer &R__b)
+{
+ //
+ // Stream an object of class AliTRDhit.
+ //
+
+ if (R__b.IsReading()) {
+ Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+ AliHit::Streamer(R__b);
+ R__b >> fDetector;
+ R__b >> fQ;
+ }
+ else {
+ R__b.WriteVersion(AliTRDhit::IsA());
+ AliHit::Streamer(R__b);
+ R__b << fDetector;
+ R__b << fQ;
+ }
+
+}
//_____________________________________________________________________________
class AliTRDhit : public AliHit {
-
+
public:
AliTRDhit();
- AliTRDhit(Int_t shunt, Int_t track, Int_t *det, Float_t *hits);
+ AliTRDhit(Int_t shunt, Int_t track, Int_t det, Float_t *hits, Int_t q);
virtual ~AliTRDhit();
- Int_t GetDetector() { return fDetector; };
- Float_t GetCharge() { return fQ; };
+ Int_t GetDetector() const { return fDetector; };
+ Int_t GetCharge() const { return fQ; };
protected:
- Int_t fDetector; // TRD detector number
- Float_t fQ; // Charge created by a hit (slow simulator only)
-
- ClassDef(AliTRDhit,2) // Hit for the Transition Radiation Detector
+ UShort_t fDetector; // TRD detector number
+ Short_t fQ; // Charge created by a hit. TR signals are negative.
+
+ ClassDef(AliTRDhit,3) // Hit for the Transition Radiation Detector
};
/*
$Log$
+Revision 1.4.2.5 2000/10/17 02:27:34 cblume
+Get rid of global constants
+
+Revision 1.4.2.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.4.2.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.8 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.7 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
+#include <TObjArray.h>
+#include <TH2.h>
+#include <TH3.h>
+#include <TStyle.h>
+#include <TCanvas.h>
+
#include "AliTRDmatrix.h"
+#include "AliTRDpixel.h"
ClassImp(AliTRDmatrix)
if (!(pixel)) return kTRUE;
Bool_t trackSet = kFALSE;
- for (Int_t i = 0; i < kTrackPixel; i++) {
+ for (Int_t i = 0; i < AliTRDpixel::NTrackPixel(); i++) {
if (pixel->GetTrack(i) == track) {
trackSet = kTRUE;
break;
}
//_____________________________________________________________________________
-Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime)
+Float_t AliTRDmatrix::GetSignal(Int_t iRow, Int_t iCol, Int_t iTime) const
{
//
// Returns the amplitude of the signal for one specific pixel
}
//_____________________________________________________________________________
-Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t iTrack)
+Int_t AliTRDmatrix::GetTrack(Int_t iRow, Int_t iCol, Int_t iTime
+ , Int_t iTrack) const
{
//
// Returns the numbers of the tracks passing through one specific pixel
//
- if ((iTrack < 0) || (iTrack >= kTrackPixel)) {
+ if ((iTrack < 0) || (iTrack >= AliTRDpixel::NTrackPixel())) {
printf("AliTRDmatrix::GetTrack -- ");
printf("Index out of bounds (%d)\n",iTrack);
return -1;
}
//_____________________________________________________________________________
-Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime)
+Int_t AliTRDmatrix::GetIndex(Int_t iRow, Int_t iCol, Int_t iTime) const
{
if ((iRow >= 0) && (iRow < fRow ) &&
}
//_____________________________________________________________________________
-AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime)
+AliTRDpixel *AliTRDmatrix::GetPixel(Int_t iRow, Int_t iCol, Int_t iTime) const
{
Int_t iPixel = GetIndex(iRow,iCol,iTime);
/* $Id$ */
#include <TObject.h>
-#include <TObjArray.h>
-#include <TH2.h>
-#include <TH3.h>
-#include <TStyle.h>
-#include <TCanvas.h>
-#include "AliTRDpixel.h"
+class TObjArray;
+
+class AliTRDpixel;
///////////////////////////////////////////////////////
// Stores the pixel-information of one TRD chamber //
virtual void SetTrack(Int_t iRow, Int_t iCol, Int_t iTime
, Int_t iTrack, Int_t track);
- virtual Float_t GetSignal(Int_t iRow, Int_t iCol, Int_t iTime);
- virtual Int_t GetTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t iTrack);
+ virtual Float_t GetSignal(Int_t iRow, Int_t iCol, Int_t iTime) const;
+ virtual Int_t GetTrack(Int_t iRow, Int_t iCol, Int_t iTime, Int_t iTrack) const;
- virtual Int_t GetSector() { return fSector; };
- virtual Int_t GetChamber() { return fChamber; };
- virtual Int_t GetPlane() { return fPlane; };
+ virtual Int_t GetSector() const { return fSector; };
+ virtual Int_t GetChamber() const { return fChamber; };
+ virtual Int_t GetPlane() const { return fPlane; };
protected:
- virtual Int_t GetIndex(Int_t iRow, Int_t iCol, Int_t iTime);
- virtual AliTRDpixel *GetPixel(Int_t iRow, Int_t iCol, Int_t iTime);
+ virtual Int_t GetIndex(Int_t iRow, Int_t iCol, Int_t iTime) const;
+ virtual AliTRDpixel *GetPixel(Int_t iRow, Int_t iCol, Int_t iTime) const;
Int_t fRow; // Number of pad-rows
Int_t fCol; // Number of pad-columns
/*
$Log$
+Revision 1.3.2.2 2000/10/17 02:27:34 cblume
+Get rid of global constants
+
+Revision 1.3.2.1 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.5 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.4 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
ClassImp(AliTRDpixel)
//_____________________________________________________________________________
+
+ // Maximal number of stored tracks
+ const Int_t AliTRDpixel::fgkNTrackPixel = kNTrackPixel;
+
+//_____________________________________________________________________________
AliTRDpixel::AliTRDpixel():TObject()
{
//
//
((AliTRDpixel &) p).fSignal = fSignal;
- for (Int_t iTrackPixel = 0; iTrackPixel < kTrackPixel; iTrackPixel++) {
+ for (Int_t iTrackPixel = 0; iTrackPixel < kNTrackPixel; iTrackPixel++) {
((AliTRDpixel &) p).fTrack[iTrackPixel] = fTrack[iTrackPixel];
}
// Stores the information for one detector pixel //
//////////////////////////////////////////////////////
-const Int_t kTrackPixel = 3;
-
class AliTRDpixel : public TObject {
public:
virtual void Copy(TObject &p);
+ static Int_t NTrackPixel() { return fgkNTrackPixel; };
+
virtual void SetSignal(Float_t signal) { fSignal = signal; };
virtual void SetTrack(Int_t i, Int_t track) { fTrack[i] = track; };
- virtual Float_t GetSignal() { return fSignal; };
- virtual Int_t GetTrack(Int_t i) { return fTrack[i]; };
+ virtual Float_t GetSignal() const { return fSignal; };
+ virtual Int_t GetTrack(Int_t i) const { return fTrack[i]; };
protected:
+ enum { kNTrackPixel = 3 };
+ static const Int_t fgkNTrackPixel; // Maximal number of stored tracks
+
Float_t fSignal; // Signal sum
- Int_t fTrack[kTrackPixel]; // Tracks contributing to this pixel
+ Int_t fTrack[kNTrackPixel]; // Tracks contributing to this pixel
ClassDef(AliTRDpixel,1) // Information for one detector pixel
/*
$Log$
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.1.4.1 2000/09/22 14:50:39 cblume
+Adapted to tracking code
+
+Revision 1.3 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.2 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
+#include "AliRun.h"
+
#include "AliTRDgeometry.h"
#include "AliTRDrecPoint.h"
#include "AliTRD.h"
fLocPosM->operator()(2,2) = ((AliTRDgeometry *) fGeom)->GetTimeBinSize()
/ kSq12;
+ // printf("rec. point: row = %f, col = %f, time = %f \n",
+ // fLocPos[0],fLocPos[1],fLocPos[2]);
+
}
+
+//_____________________________________________________________________________
+void AliTRDrecPoint::SetTrackingYZ(Float_t sigmaY, Float_t sigmaZ)
+{
+ //
+ // Sets the position of the point in the local coordinate system
+ // of tracking sector
+ //
+
+ Int_t plane = ((AliTRDgeometry *) fGeom)->GetPlane(fDetector);
+ Int_t chamber = ((AliTRDgeometry *) fGeom)->GetChamber(fDetector);
+ Int_t sector = ((AliTRDgeometry *) fGeom)->GetSector(fDetector);
+
+
+ // Set the position
+
+ Float_t padRow = fLocPos[0]; // Pad Row position
+ Float_t padCol = fLocPos[1]; // Pad Column position
+
+ Float_t col0 = ((AliTRDgeometry *) fGeom)->GetCol0(plane);
+ Float_t row0 = ((AliTRDgeometry *) fGeom)->GetRow0(plane,chamber,sector);
+
+ // Float_t offset = 0.5 * ((AliTRDgeometry *) fGeom)->GetChamberWidth(plane);
+
+ fY = - (col0 + padCol * ((AliTRDgeometry *) fGeom)->GetColPadSize());
+
+ fZ = row0 + padRow * ((AliTRDgeometry *) fGeom)->GetRowPadSize();
+
+ // fSigmaY = sigmaY * sigmaY;
+ // fSigmaZ = sigmaZ * sigmaZ;
+
+ fSigmaY2 = 0.05 * 0.05;
+
+ fSigmaZ2 = ((AliTRDgeometry *) fGeom)->GetRowPadSize() *
+ ((AliTRDgeometry *) fGeom)->GetRowPadSize() / 12.;
+}
+
+//_____________________________________________________________________________
+void AliTRDrecPoint::AddTrackIndex(Int_t *track)
+{
+ // Adds track index. Currently assumed that track is an array of
+ // size 9, and up to 3 track indexes are stored in fTracks[3].
+ // Indexes are sorted according to:
+ // 1) index of max number of appearances is stored first
+ // 2) if two or more indexes appear equal number of times, the lowest
+ // ones are stored first;
+
+ const Int_t size = 9;
+
+ Int_t entries[size][2], i, j, index;
+
+ Bool_t index_added;
+
+ for (i=0; i<size; i++) {
+ entries[i][0]=-1;
+ entries[i][1]=0;
+ }
+
+
+ for (Int_t k=0; k<size; k++) {
+ index=track[k];
+ index_added=false; j=0;
+ if (index >= 0) {
+ while ( (!index_added) && ( j < size ) ) {
+ if ((entries[j][0]==index) || (entries[j][1]==0)) {
+ entries[j][0]=index;
+ entries[j][1]=entries[j][1]+1;
+ index_added=true;
+ }
+ j++;
+ }
+ }
+ }
+
+ // sort by number of appearances and index value
+ Int_t swap=1, tmp0, tmp1;
+ while ( swap > 0) {
+ swap=0;
+ for(i=0; i<(size-1); i++) {
+ if ((entries[i][0] >= 0) && (entries[i+1][0] >= 0)) {
+ if ((entries[i][1] < entries[i+1][1]) ||
+ ((entries[i][1] == entries[i+1][1]) &&
+ (entries[i][0] > entries[i+1][0]))) {
+ tmp0=entries[i][0];
+ tmp1=entries[i][1];
+ entries[i][0]=entries[i+1][0];
+ entries[i][1]=entries[i+1][1];
+ entries[i+1][0]=tmp0;
+ entries[i+1][1]=tmp1;
+ swap++;
+ }
+ }
+ }
+ }
+
+ // set track indexes
+
+ for(i=0; i<3; i++) {
+ fTracks[i] = entries[i][0];
+ }
+
+ return;
+
+}
virtual void SetLocalCol(Float_t c) { fLocPos.SetY(c); };
virtual void SetLocalTime(Float_t t) { fLocPos.SetZ(t); };
- virtual Int_t GetDetector() { return fDetector; };
- virtual Int_t GetDigit(Int_t i = 0) { if (i < fMulDigit)
+ virtual void SetLocalTimeBin(Int_t tb) { fTimeBin = tb; }
+ virtual void SetTrackingYZ(Float_t fSigmaY = 0.0, Float_t fSigmaZ = 0.0);
+
+ virtual Int_t GetDetector() const { return fDetector; };
+ virtual Int_t GetDigit(Int_t i = 0) const { if (i < fMulDigit)
return fDigitsList[i];
else
return -1;};
- virtual Float_t GetLocalRow() { return fLocPos(0); };
- virtual Float_t GetLocalCol() { return fLocPos(1); };
- virtual Float_t GetLocalTime() { return fLocPos(2); };
+ virtual Float_t GetLocalRow() const { return fLocPos(0); };
+ virtual Float_t GetLocalCol() const { return fLocPos(1); };
+ virtual Float_t GetLocalTime() const { return fLocPos(2); };
+
+ virtual Int_t GetLocalTimeBin() const { return Int_t(fLocPos(2)); }
+ virtual Float_t GetSigmaY2() const { return fSigmaY2; }
+ virtual Float_t GetSigmaZ2() const { return fSigmaZ2; }
+ virtual Float_t GetY() const { return fY; }
+ virtual Float_t GetZ() const { return fZ; }
+ Int_t IsUsed() const { return fUsed; }
+ void Use() { fUsed++; }
+ Int_t GetTrackIndex(Int_t i) const { return fTracks[i]; }
+ void AddTrackIndex(Int_t *i);
protected:
Int_t fDetector; // TRD detector number
+ Int_t fTimeBin; // Time bin number within the detector
+ Int_t fUsed; // 0 initially and incremented if the point is "used"
+ Int_t fTracks[3]; // labels of overlapped tracks
+ Float_t fY; // local Rphi coordinate (cm) within tracking sector
+ Float_t fZ; // local Z coordinate (cm) within tracking sector
+ Float_t fSigmaY2; // Y variance (cm)
+ Float_t fSigmaZ2; // Z variance (cm)
ClassDef(AliTRDrecPoint,1) // Reconstructed point for the TRD
/*
$Log$
+Revision 1.1.4.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.5 2000/10/02 21:28:19 fca
+Removal of useless dependecies via forward declarations
+
Revision 1.4 2000/06/27 13:08:50 cblume
Changed to Copy(TObject &A) to appease the HP-compiler
#include <TTree.h>
+#include "AliRun.h"
+
#include "AliTRD.h"
#include "AliTRDgeometry.h"
#include "AliTRDsegmentArray.h"
}
//_____________________________________________________________________________
-AliTRDdataArray *AliTRDsegmentArray::GetDataArray(Int_t det)
+AliTRDdataArray *AliTRDsegmentArray::GetDataArray(Int_t det) const
{
//
// Returns the data array for a given detector
}
//_____________________________________________________________________________
-AliTRDdataArray *AliTRDsegmentArray::GetDataArray(Int_t pla, Int_t cha, Int_t sec)
+AliTRDdataArray *AliTRDsegmentArray::GetDataArray(Int_t pla
+ , Int_t cha, Int_t sec) const
{
//
// Returns the data array for a given detector
/* $Id$ */
+#include "AliTRDsegmentArrayBase.h"
+
////////////////////////////////////////////////////////
// Array for TRD detector segments containing digits //
////////////////////////////////////////////////////////
-#include "AliTRDsegmentArrayBase.h"
-#include "AliTRDdataArray.h"
+class AliTRDdataArray;
//_____________________________________________________________________________
class AliTRDsegmentArray : public AliTRDsegmentArrayBase {
virtual Bool_t LoadArray(const Char_t *branchname);
virtual Bool_t StoreArray(const Char_t *branchname);
- virtual AliTRDdataArray *GetDataArray(Int_t det);
- virtual AliTRDdataArray *GetDataArray(Int_t sec, Int_t cha, Int_t pla);
+ virtual AliTRDdataArray *GetDataArray(Int_t det) const;
+ virtual AliTRDdataArray *GetDataArray(Int_t sec, Int_t cha, Int_t pla) const;
protected:
/*
$Log$
+Revision 1.1.4.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.1.4.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.5 2000/06/09 11:10:07 cblume
+Compiler warnings and coding conventions, next round
+
Revision 1.4 2000/06/08 18:32:58 cblume
Make code compliant to coding conventions
// //
///////////////////////////////////////////////////////////////////////////////
-#include <TROOT.h>
+#include <TROOT.h>
#include <TTree.h>
-#include "TClonesArray.h"
-#include "TDirectory.h"
-#include "AliTRDarrayI.h"
-#include "TError.h"
-#include "TClass.h"
+#include <TClonesArray.h>
+#include <TDirectory.h>
+#include <TError.h>
+#include <TClass.h>
+#include "AliTRDarrayI.h"
#include "AliTRDsegmentID.h"
#include "AliTRDsegmentArrayBase.h"
fTreeIndex = 0;
fTree = 0;
fClass = 0;
+ fBranch = 0;
}
fTreeIndex = 0;
fTree = 0;
fClass = 0;
+ fBranch = 0;
SetClass(classname);
}
//_____________________________________________________________________________
-const AliTRDsegmentID *AliTRDsegmentArrayBase::At(Int_t i)
+const AliTRDsegmentID *AliTRDsegmentArrayBase::At(Int_t i) const
{
//
// Returns a segment with the given index <i>
// Manager class for a general Alice segment //
////////////////////////////////////////////////
-#include "TNamed.h"
-#include "TError.h"
-#include "TObjArray.h"
+#include <TNamed.h>
class TTree;
class TBranch;
virtual ~AliTRDsegmentArrayBase();
AliTRDsegmentArrayBase &operator=(const AliTRDsegmentArrayBase &a);
- const AliTRDsegmentID *At(Int_t i);
+ const AliTRDsegmentID *At(Int_t i) const;
const AliTRDsegmentID *operator[](Int_t i);
Bool_t AddSegment(AliTRDsegmentID *segment);
Bool_t SetClass(Text_t *classname);
- TClass *GetClass() { return fClass; };
- TTree *GetTree() { return fTree; };
+ TClass *GetClass() const { return fClass; };
+ TTree *GetTree() const { return fTree; };
protected:
/*
$Log$
+Revision 1.1.4.1 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.2 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
Revision 1.1 2000/02/28 19:03:35 cblume
Add new TRD classes
// Base class for a detector segment //
////////////////////////////////////////////////
-#include "TObject.h"
+#include <TObject.h>
class AliTRDsegmentID : public TObject {
AliTRDsegmentID(Int_t index);
virtual ~AliTRDsegmentID();
- Int_t GetID() { return fSegmentID; }
+ Int_t GetID() const { return fSegmentID; }
virtual Int_t GetSize() { return sizeof(*this); }
void SetID(Int_t index) { fSegmentID = index;}
--- /dev/null
+Int_t AliTRDtest()
+{
+ //
+ // Test macro for the TRD code
+ //
+
+ Int_t rc = 0;
+
+ // Initialize the test setup
+ gAlice->Init("AliTRDconfig.C");
+
+ // Run one event and create the hits
+ gAlice->Run(1);
+
+ // Analyze the TRD hits
+ gROOT->LoadMacro("$(ALICE_ROOT)/TRD/AliTRDanalyzeHits.C");
+ if (rc = AliTRDanalyzeHits()) return rc;
+
+ // Run the digitization
+ gROOT->LoadMacro("$(ALICE_ROOT)/TRD/AliTRDcreateDigits.C");
+ if (rc = AliTRDcreateDigits()) return rc;
+
+ // Analyze the digits
+ gROOT->LoadMacro("$(ALICE_ROOT)/TRD/AliTRDanalyzeDigits.C");
+ if (rc = AliTRDanalyzeDigits()) return rc;
+
+ return rc;
+
+}
/*
$Log$
+Revision 1.14.2.3 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.14.2.2 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.14.2.1 2000/09/18 13:48:18 cblume
+Adapt to new AliTRDhit
+
+Revision 1.16 2000/06/08 18:32:58 cblume
+Make code compliant to coding conventions
+
Revision 1.15 2000/06/07 16:25:37 cblume
Try to remove compiler warnings on Sun and HP
#include "AliConst.h"
#include "AliTRDv0.h"
+#include "AliTRDhit.h"
#include "AliTRDgeometry.h"
ClassImp(AliTRDv0)
Int_t iIdSens, icSens;
Int_t iIdChamber, icChamber;
- Float_t hits[4];
- Int_t det[1];
+ Float_t hits[3];
+ Int_t det;
TLorentzVector p;
TClonesArray &lhits = *fHits;
gMC->TrackPosition(p);
for (Int_t i = 0; i < 3; i++) hits[i] = p[i];
- // No charge created
- hits[3] = 0;
// The sector number (0 - 17)
// The numbering goes clockwise and starts at y = 0
// The plane number (0 - 5)
pla = icChamber - TMath::Nint((Float_t) (icChamber / 7)) * 6 - 1;
+ det = fGeometry->GetDetector(pla,cha,sec);
- det[0] = fGeometry->GetDetector(pla,cha,sec);
new(lhits[fNhits++]) AliTRDhit(fIshunt
,gAlice->CurrentTrack()
,det
- ,hits);
+ ,hits
+ ,0);
}
#include "AliTRD.h"
+class AliTRDsim;
+
//_____________________________________________________________________________
class AliTRDv0 : public AliTRD {
AliTRDv0(const char *name, const char *title);
virtual ~AliTRDv0();
- virtual void CreateGeometry();
- virtual void CreateMaterials();
- virtual Int_t IsVersion() const { return 0; };
- virtual void StepManager();
- virtual void Init();
+ virtual void CreateGeometry();
+ virtual void CreateMaterials();
+ virtual Int_t IsVersion() const { return 0; };
+ virtual void StepManager();
+ virtual void Init();
+
+ virtual void SetHits() { fHitsOn = 1; };
- virtual void SetHits() { fHitsOn = 1; };
+ void SetSensChamber(Int_t ) { };
+ void SetSensPlane(Int_t ) { };
+ void SetSensSector(Int_t ) { };
+ void SetSensSector(Int_t ,Int_t) { };
- void SetSensChamber(Int_t ) { };
- void SetSensPlane(Int_t ) { };
- void SetSensSector(Int_t ) { };
- void SetSensSector(Int_t ,Int_t) { };
+ Int_t GetSensChamber() const { return 0; };
+ Int_t GetSensPlane() const { return 0; };
+ Int_t GetSensSector() const { return 0; };
+ Int_t GetSensSectorRange() const { return 0; };
- Int_t GetSensChamber() { return 0; };
- Int_t GetSensPlane() { return 0; };
- Int_t GetSensSector() { return 0; };
- Int_t GetSensSectorRange() { return 0; };
+ AliTRDsim *CreateTR() { return 0; };
+ AliTRDsim *GetTR() const { return 0; };
protected:
/*
$Log$
+Revision 1.17.2.5 2000/10/15 23:40:01 cblume
+Remove AliTRDconst
+
+Revision 1.17.2.4 2000/10/06 16:49:46 cblume
+Made Getters const
+
+Revision 1.17.2.3 2000/10/04 16:34:58 cblume
+Replace include files by forward declarations
+
+Revision 1.17.2.2 2000/09/18 13:50:17 cblume
+Include TR photon generation and adapt to new AliTRDhit
+
+Revision 1.22 2000/06/27 13:08:50 cblume
+Changed to Copy(TObject &A) to appease the HP-compiler
+
Revision 1.21 2000/06/09 11:10:07 cblume
Compiler warnings and coding conventions, next round
#include <TMath.h>
#include <TVector.h>
#include <TRandom.h>
+#include <TF1.h>
#include "AliRun.h"
#include "AliMC.h"
#include "AliConst.h"
#include "AliTRDv1.h"
+#include "AliTRDhit.h"
#include "AliTRDmatrix.h"
#include "AliTRDgeometry.h"
+#include "AliTRDsim.h"
ClassImp(AliTRDv1)
-
//_____________________________________________________________________________
AliTRDv1::AliTRDv1():AliTRD()
fSensSectorRange = 0;
fDeltaE = NULL;
+ fTR = NULL;
}
fSensSectorRange = 0;
fDeltaE = NULL;
+ fTR = NULL;
SetBufferSize(128000);
//
if (fDeltaE) delete fDeltaE;
+ if (fTR) delete fTR;
}
((AliTRDv1 &) trd).fSensSector = fSensSector;
((AliTRDv1 &) trd).fSensSectorRange = fSensSectorRange;
- ((AliTRDv1 &) trd).fDeltaE = NULL;
+ fDeltaE->Copy(*((AliTRDv1 &) trd).fDeltaE);
+ fTR->Copy(*((AliTRDv1 &) trd).fTR);
}
}
//_____________________________________________________________________________
+void AliTRDv1::CreateTRhit(Int_t det)
+{
+ //
+ // Creates an electron cluster from a TR photon.
+ // The photon is assumed to be created a the end of the radiator. The
+ // distance after which it deposits its energy takes into account the
+ // absorbtion of the entrance window and of the gas mixture in drift
+ // volume.
+ //
+
+ // PDG code electron
+ const Int_t kPdgElectron = 11;
+
+ // Ionization energy
+ const Float_t kWion = 22.04;
+
+ // Maximum number of TR photons per track
+ const Int_t kNTR = 50;
+
+ TLorentzVector mom, pos;
+ TClonesArray &lhits = *fHits;
+
+ // Create TR only for electrons
+ Int_t iPdg = gMC->TrackPid();
+ if (TMath::Abs(iPdg) != kPdgElectron) return;
+
+ // Create TR at the entrance of the chamber
+ if (gMC->IsTrackEntering()) {
+
+ Float_t eTR[kNTR];
+ Int_t nTR;
+
+ // Create TR photons
+ gMC->TrackMomentum(mom);
+ Float_t pTot = mom.Rho();
+ fTR->CreatePhotons(iPdg,pTot,nTR,eTR);
+ if (nTR > kNTR) {
+ printf("AliTRDv1::CreateTRhit -- ");
+ printf("Boundary error: nTR = %d, kNTR = %d\n",nTR,kNTR);
+ exit(1);
+ }
+
+ // Loop through the TR photons
+ for (Int_t iTR = 0; iTR < nTR; iTR++) {
+
+ Float_t energyMeV = eTR[iTR] * 0.001;
+ Float_t energyeV = eTR[iTR] * 1000.0;
+ Float_t absLength = 0;
+ Float_t sigma = 0;
+
+ // Take the absorbtion in the entrance window into account
+ Double_t muMy = fTR->GetMuMy(energyMeV);
+ sigma = muMy * fFoilDensity;
+ absLength = gRandom->Exp(sigma);
+ if (absLength < AliTRDgeometry::MyThick()) continue;
+
+ // The absorbtion cross sections in the drift gas
+ if (fGasMix == 1) {
+ // Gas-mixture (Xe/CO2)
+ Double_t muXe = fTR->GetMuXe(energyMeV);
+ Double_t muCO = fTR->GetMuCO(energyMeV);
+ sigma = (0.90 * muXe + 0.10 * muCO) * fGasDensity;
+ }
+ else {
+ // Gas-mixture (Xe/Isobutane)
+ Double_t muXe = fTR->GetMuXe(energyMeV);
+ Double_t muBu = fTR->GetMuBu(energyMeV);
+ sigma = (0.97 * muXe + 0.03 * muBu) * fGasDensity;
+ }
+
+ // The distance after which the energy of the TR photon
+ // is deposited.
+ absLength = gRandom->Exp(sigma);
+ if (absLength > AliTRDgeometry::DrThick()) continue;
+
+ // The position of the absorbtion
+ Float_t posHit[3];
+ gMC->TrackPosition(pos);
+ posHit[0] = pos[0] + mom[0] / pTot * absLength;
+ posHit[1] = pos[1] + mom[1] / pTot * absLength;
+ posHit[2] = pos[2] + mom[2] / pTot * absLength;
+
+ // Create the charge
+ Int_t q = ((Int_t) (energyeV / kWion));
+
+ // Add the hit to the array. TR photon hits are marked
+ // by negative charge
+ new(lhits[fNhits++]) AliTRDhit(fIshunt,gAlice->CurrentTrack()
+ ,det,posHit,-q);
+
+ }
+
+ }
+
+}
+
+//_____________________________________________________________________________
void AliTRDv1::Init()
{
//
if (fSensSector >= 0) {
Int_t sens1 = fSensSector;
Int_t sens2 = fSensSector + fSensSectorRange;
- sens2 -= ((Int_t) (sens2 / kNsect)) * kNsect;
+ sens2 -= ((Int_t) (sens2 / AliTRDgeometry::Nsect()))
+ * AliTRDgeometry::Nsect();
printf(" Only sectors %d - %d are sensitive\n",sens1,sens2-1);
}
}
+ if (fTR)
+ printf(" TR simulation on\n");
+ else
+ printf(" TR simulation off\n");
printf("\n");
// First ionization potential (eV) for the gas mixture (90% Xe + 10% CO2)
// Ermilova distribution for the delta-ray spectrum
Float_t poti = TMath::Log(kPoti);
Float_t eEnd = TMath::Log(kEend);
- fDeltaE = new TF1("deltae",Ermilova,poti,eEnd,0);
+ fDeltaE = new TF1("deltae",Ermilova,poti,eEnd,0);
// Identifier of the sensitive volume (drift region)
fIdSens = gMC->VolId("UL05");
}
//_____________________________________________________________________________
+AliTRDsim *AliTRDv1::CreateTR()
+{
+ //
+ // Enables the simulation of TR
+ //
+
+ fTR = new AliTRDsim();
+ return fTR;
+
+}
+
+//_____________________________________________________________________________
void AliTRDv1::SetSensPlane(Int_t iplane)
{
//
Int_t pla = 0;
Int_t cha = 0;
Int_t sec = 0;
+ Int_t det = 0;
Int_t iPdg;
+ Int_t qTot;
- Int_t det[1];
-
- Float_t hits[4];
+ Float_t hits[3];
Float_t random[1];
Float_t charge;
Float_t aMass;
Double_t pTot;
- Double_t qTot;
Double_t eDelta;
Double_t betaGamma, pp;
eDelta = TMath::Max(eDelta,0.0);
// The number of secondary electrons created
- qTot = (Double_t) ((Int_t) (eDelta / kWion) + 1);
+ qTot = ((Int_t) (eDelta / kWion) + 1);
// The hit coordinates and charge
gMC->TrackPosition(pos);
hits[0] = pos[0];
hits[1] = pos[1];
hits[2] = pos[2];
- hits[3] = qTot;
// The sector number (0 - 17)
// The numbering goes clockwise and starts at y = 0
if (fSensSector >= 0) {
Int_t sens1 = fSensSector;
Int_t sens2 = fSensSector + fSensSectorRange;
- sens2 -= ((Int_t) (sens2 / kNsect)) * kNsect;
+ sens2 -= ((Int_t) (sens2 / AliTRDgeometry::Nsect()))
+ * AliTRDgeometry::Nsect();
if (sens1 < sens2) {
if ((sec < sens1) || (sec >= sens2)) addthishit = 0;
}
// Add this hit
if (addthishit) {
- det[0] = fGeometry->GetDetector(pla,cha,sec);
+ det = fGeometry->GetDetector(pla,cha,sec);
+
+ // Create the electron cluster from TR photons
+ if (fTR) CreateTRhit(det);
+
new(lhits[fNhits++]) AliTRDhit(fIshunt
,gAlice->CurrentTrack()
,det
- ,hits);
+ ,hits
+ ,qTot);
// The energy loss according to Bethe Bloch
gMC->TrackMomentum(mom);
// Energy spectrum of the delta-rays
Double_t Ermilova(Double_t *x, Double_t *par);
-#include <TF1.h>
-
#include "AliTRD.h"
+class TF1;
+
+class AliTRDsim;
+
//_____________________________________________________________________________
class AliTRDv1 : public AliTRD {
virtual ~AliTRDv1();
AliTRDv1 &operator=(const AliTRDv1 &trd);
- virtual void Copy(TObject &trd);
- virtual void CreateGeometry();
- virtual void CreateMaterials();
- virtual Int_t IsVersion() const { return 1; };
- virtual void StepManager();
- virtual void Init();
+ virtual void Copy(TObject &trd);
+ virtual void CreateGeometry();
+ virtual void CreateMaterials();
+ virtual void CreateTRhit(Int_t det);
+ virtual Int_t IsVersion() const { return 1; };
+ virtual void StepManager();
+ virtual void Init();
- void SetSensPlane(Int_t iplane = 0);
- void SetSensChamber(Int_t ichamber = 0);
- void SetSensSector(Int_t isector);
- void SetSensSector(Int_t isector, Int_t nsector);
+ void SetSensPlane(Int_t iplane = 0);
+ void SetSensChamber(Int_t ichamber = 0);
+ void SetSensSector(Int_t isector);
+ void SetSensSector(Int_t isector, Int_t nsector);
- Int_t GetSensPlane() { return fSensPlane; };
- Int_t GetSensChamber() { return fSensChamber; };
- Int_t GetSensSector() { return fSensSector; };
- Int_t GetSensSectorRange() { return fSensSectorRange; };
+ AliTRDsim *CreateTR();
+
+ Int_t GetSensPlane() const { return fSensPlane; };
+ Int_t GetSensChamber() const { return fSensChamber; };
+ Int_t GetSensSector() const { return fSensSector; };
+ Int_t GetSensSectorRange() const { return fSensSectorRange; };
+
+ AliTRDsim *GetTR() const { return fTR; };
protected:
Int_t fSensSector; // Sensitive detector sector
Int_t fSensSectorRange; // Sensitive detector range
+ AliTRDsim *fTR; // TR simulator
+
private:
virtual Double_t BetheBloch(Double_t bg);
AliTRDclusterizerV1.cxx AliTRDrecPoint.cxx \
AliTRDsegmentArray.cxx AliTRDdataArray.cxx \
AliTRDdataArrayI.cxx AliTRDdataArrayF.cxx \
- AliTRDdigitsManager.cxx \
+ AliTRDdigitsManager.cxx AliTRDsim.cxx \
AliTRDsegmentID.cxx AliTRDsegmentArrayBase.cxx \
- AliTRDarrayI.cxx AliTRDarrayF.cxx
+ AliTRDarrayI.cxx AliTRDarrayF.cxx \
+ AliTRDpoints.cxx AliTRDtimeBin.cxx \
+ AliTRDtrackingSector.cxx \
+ AliTRDtrack.cxx AliTRDtracker.cxx \
+ AliTRDcluster.cxx
# C++ Headers
-HDRS = $(SRCS:.cxx=.h) TRDLinkDef.h
+HDRS = $(SRCS:.cxx=.h) \
+ $(ROOTSYS)/include/TF1.h \
+ $(ROOTSYS)/include/TFile.h \
+ $(ROOTSYS)/include/TObjArray.h \
+ TRDLinkDef.h
# Library dictionary
#pragma link C++ class AliTRD;
#pragma link C++ class AliTRDv0;
#pragma link C++ class AliTRDv1;
-#pragma link C++ class AliTRDhit;
-#pragma link C++ class AliTRDdigit;
+#pragma link C++ class AliTRDhit-;
+#pragma link C++ class AliTRDdigit-;
#pragma link C++ class AliTRDdigitsManager;
#pragma link C++ class AliTRDpixel;
#pragma link C++ class AliTRDmatrix;
#pragma link C++ class AliTRDdataArray;
#pragma link C++ class AliTRDdataArrayI;
#pragma link C++ class AliTRDdataArrayF;
+#pragma link C++ class AliTRDsim-;
+#pragma link C++ class AliTRDpoints;
+#pragma link C++ class AliTRDtimeBin;
+#pragma link C++ class AliTRDtrackingSector;
+#pragma link C++ class AliTRDtrack-;
+#pragma link C++ class AliTRDtracker;
+#pragma link C++ class AliTRDcluster;
#pragma link C++ class AliTRDsegmentID;
#pragma link C++ class AliTRDsegmentArrayBase;
}
// Input (and output) file name
- Char_t *alifile = "galice_r_v1.root";
+ Char_t *alifile = "galice.root";
// Create the clusterizer
AliTRDclusterizerV1 *Clusterizer =
// Load the digits
Clusterizer->ReadDigits();
+ // Clean output branch
+ Clusterizer->WriteClusters(-2);
+
// Find the cluster
- Clusterizer->MakeCluster();
+ Clusterizer->MakeClusters();
// Write the cluster into the input file
- Clusterizer->WriteCluster();
+ Clusterizer->WriteClusters(-1);
// Save the clusterizer class in the AliROOT file
Clusterizer->Write();
}
// Input file name
- Char_t *alifile = "galice_d_v1.root";
+ Char_t *alifile = "galice.root";
// Event number
Int_t nEvent = 0;
DigitsManager->ReadDigits();
// Define the detector matrix for one chamber
- const Int_t iSec = 17;
+ const Int_t iSec = 11;
const Int_t iCha = 2;
const Int_t iPla = 0;
Int_t rowMax = TRDgeometry->GetRowMax(iPla,iCha,iSec);
track = DigitsManager->GetTrack(0,row,col,time,iDet);
TRDmatrix->SetSignal(row,col,time,Digit->GetAmp());
- if (track == 96) {
- cout << "-------------------------------------" << endl;
- cout << " track = " << track << endl;
- cout << " iRow = " << row
- << " iCol = " << col
- << " iTime = " << time << endl;
- cout << " adc = " << Digit->GetAmp() << endl;
- Digit->Dump();
- }
delete Digit;
}
// Input (and output) file name
- Char_t *alifile = "galice_d_v1.root";
+ Char_t *alifile = "galice.root";
// Create the TRD digitzer
AliTRDdigitizer *Digitizer = new AliTRDdigitizer("digitizer","Digitizer class");
// Set the parameter
Digitizer->SetDiffusion();
+ Digitizer->SetVerbose(1);
//Digitizer->SetExB();
//Digitizer->SetElAttach();
//Digitizer->SetAttachProb();
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff