* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
/* $Id$ */
-
+/** @file AliFMD.cxx
+ @author Christian Holm Christensen <cholm@nbi.dk>
+ @date Sun Mar 26 17:59:18 2006
+ @brief Implementation of AliFMD base class
+*/
//____________________________________________________________________
//
// Forward Multiplicity Detector based on Silicon wafers. This class
-// contains the base procedures for the Forward Multiplicity detector
-// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
-// which has 1 or 2 rings of silicon sensors.
+// is the driver for especially simulation.
+//
+// The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+// FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors.
//
// This is the base class for all FMD manager classes.
//
// +----+--------------+ +--| AliFMDDigitizer |
// | | +-----------------+
// | +---------------------+ |
-// | +- | AliFMDBaseDigitizer |<--+
+// | +--| AliFMDBaseDigitizer |<--+
// V 1 | +---------------------+ |
// +--------+<>--+ | +------------------+
// | AliFMD | +--| AliFMDSDigitizer |
// +--------+<>--+ +------------------+
-// 1 | +-----------------+
-// +-| AliFMDSimulator |
-// +-----------------+
-// ^
-// |
-// +-------------+-------------+
-// | |
-// +--------------------+ +-------------------+
-// | AliFMDGeoSimulator | | AliFMDG3Simulator |
-// +--------------------+ +---------+---------+
-//
+// 1 | +---------------------+
+// +--| AliFMDReconstructor |
+// +---------------------+
//
// * AliFMD
// This defines the interface for the various parts of AliROOT that
// simulator tasks are responsible to implment the geoemtry, and
// process hits.
//
-// * AliFMDGeoSimulator
-// This is a concrete implementation of the AliFMDSimulator that
-// uses the TGeo classes directly only.
+// * AliFMDReconstructor
+// This is a concrete implementation of the AliReconstructor that
+// reconstructs pseudo-inclusive-multiplicities from digits (raw or
+// from simulation)
//
-// * AliFMDG3Simulator
-// This is a concrete implementation of the AliFMDSimulator that
-// uses the TVirtualMC interface with GEANT 3.21-like messages.
+// Calibration and geometry parameters are managed by separate
+// singleton managers. These are AliFMDGeometry and
+// AliFMDParameters. Please refer to these classes for more
+// information on these.
//
// These files are not in the same directory, so there's no reason to
// ask the preprocessor to search in the current directory for these
// files by including them with `#include "..."'
-#include <math.h> // __CMATH__
+// #include <math.h> // __CMATH__
#include <TClonesArray.h> // ROOT_TClonesArray
#include <TGeometry.h> // ROOT_TGeomtry
#include <TNode.h> // ROOT_TNode
#include <TTUBE.h> // ROOT_TTUBE
#include <TTree.h> // ROOT_TTree
#include <TBrowser.h> // ROOT_TBrowser
-#include <TMath.h> // ROOT_TMath
-#include <TVirtualMC.h> // ROOT_TVirtualMC
+// #include <TVirtualMC.h> // ROOT_TVirtualMC
+#include <TVector2.h> // ROOT_TVector2
+#include <TGeoManager.h> // ROOT_TGeoManager
#include <AliRunDigitizer.h> // ALIRUNDIGITIZER_H
#include <AliLoader.h> // ALILOADER_H
#include <AliRun.h> // ALIRUN_H
#include <AliMC.h> // ALIMC_H
+#include <AliMagF.h> // ALIMAGF_H
#include <AliLog.h> // ALILOG_H
#include "AliFMD.h" // ALIFMD_H
-#include "AliFMDDigit.h" // ALIFMDDIGIG_H
+#include "AliFMDDigit.h" // ALIFMDDIGIT_H
+#include "AliFMDSDigit.h" // ALIFMDSDIGIT_H
#include "AliFMDHit.h" // ALIFMDHIT_H
#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
#include "AliFMDDetector.h" // ALIFMDDETECTOR_H
#include "AliFMDRing.h" // ALIFMDRING_H
#include "AliFMDDigitizer.h" // ALIFMDDIGITIZER_H
-#include "AliFMDSimulator.h" // ALIFMDSIMULATOR_H
-#include "AliFMDG3Simulator.h" // ALIFMDG3SIMULATOR_H
-#include "AliFMDGeoSimulator.h" // ALIFMDGEOSIMULATOR_H
+#include "AliFMDSDigitizer.h" // ALIFMDSDIGITIZER_H
+// #include "AliFMDGeometryBuilder.h"
#include "AliFMDRawWriter.h" // ALIFMDRAWWRITER_H
+#include "AliFMDPoints.h" // ALIFMDPOINTS_H
//____________________________________________________________________
ClassImp(AliFMD)
//____________________________________________________________________
AliFMD::AliFMD()
- : fSDigits(0),
+ : AliDetector(),
+ fSDigits(0),
fNsdigits(0),
fDetailed(kTRUE),
- fSimulator(0)
+ fUseOld(kFALSE),
+ fUseAssembly(kTRUE),
+ fBad(0)
{
//
// Default constructor for class AliFMD
//
AliDebug(10, "\tDefault CTOR");
- fHits = 0;
- fDigits = 0;
- fIshunt = 0;
-}
-
-//____________________________________________________________________
-AliFMD::AliFMD(const AliFMD& other)
- : AliDetector(other),
- fSDigits(other.fSDigits),
- fNsdigits(other.fNsdigits),
- fDetailed(other.fDetailed),
- fSimulator(other.fSimulator)
-{
- // Copy constructor
+ fHits = 0;
+ fDigits = 0;
+ fIshunt = 0;
+ fBad = new TClonesArray("AliFMDHit");
}
//____________________________________________________________________
fSDigits(0),
fNsdigits(0),
fDetailed(kTRUE),
- fSimulator(0)
+ fUseOld(kFALSE),
+ fUseAssembly(kFALSE),
+ fBad(0)
{
//
// Standard constructor for Forward Multiplicity Detector
//
AliDebug(10, "\tStandard CTOR");
-
+ fBad = new TClonesArray("AliFMDHit");
+
// Initialise Hit array
HitsArray();
gAlice->GetMCApp()->AddHitList(fHits);
// CHC: What is this?
fIshunt = 0;
- SetMarkerColor(kRed);
- SetLineColor(kYellow);
+ //PH SetMarkerColor(kRed);
+ //PH SetLineColor(kYellow);
}
//____________________________________________________________________
delete fSDigits;
fSDigits = 0;
}
+ if (fBad) {
+ fBad->Delete();
+ delete fBad;
+ fBad = 0;
+ }
}
-//____________________________________________________________________
-AliFMD&
-AliFMD::operator=(const AliFMD& other)
-{
- AliDetector::operator=(other);
- fSDigits = other.fSDigits;
- fNsdigits = other.fNsdigits;
- fDetailed = other.fDetailed;
- fSimulator = other.fSimulator;
-
- return *this;
-}
//====================================================================
//
{
//
// Create the geometry of Forward Multiplicity Detector. The actual
- // construction of the geometry is delegated to the class AliFMDRing
- // and AliFMDSubDetector and the relevant derived classes.
- //
- // The flow of this member function is:
- //
- // FOR rings fInner and fOuter DO
- // AliFMDRing::Init();
- // END FOR
- //
- // Set up hybrud card support (leg) volume shapes
- //
- // FOR rings fInner and fOuter DO
- // AliFMDRing::SetupGeometry();
- // END FOR
- //
- // FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
- // AliFMDSubDetector::SetupGeomtry();
- // END FOR
- //
- // FOR subdetectors fFMD1, fFMD2, and fFMD3 DO
- // AliFMDSubDetector::Geomtry();
- // END FOR
+ // construction of the geometry is delegated to the class
+ // AliFMDGeometryBuilder, invoked by the singleton manager
+ // AliFMDGeometry.
//
- if (!fSimulator) {
- AliFatal("Simulator object not made yet!");
- return;
- }
- fSimulator->DefineGeometry();
+ AliFMDGeometry* fmd = AliFMDGeometry::Instance();
+ fmd->SetDetailed(fDetailed);
+ fmd->UseAssembly(fUseAssembly);
+ fmd->Build();
}
//____________________________________________________________________
void AliFMD::CreateMaterials()
{
- // Register various materials and tracking mediums with the
- // backend.
+ // Define the materials and tracking mediums needed by the FMD
+ // simulation. These mediums are made by sending the messages
+ // AliMaterial, AliMixture, and AliMedium to the passed AliModule
+ // object module. The defined mediums are
//
+ // FMD Si$ Silicon (active medium in sensors)
+ // FMD C$ Carbon fibre (support cone for FMD3 and vacuum pipe)
+ // FMD Al$ Aluminium (honeycomb support plates)
+ // FMD PCB$ Printed Circuit Board (FEE board with VA1_3)
+ // FMD Chip$ Electronics chips (currently not used)
+ // FMD Air$ Air (Air in the FMD)
+ // FMD Plastic$ Plastic (Support legs for the hybrid cards)
+ //
+ // The geometry builder should really be the one that creates the
+ // materials, but the architecture of AliROOT makes that design
+ // akward. What should happen, was that the AliFMDGeometryBuilder
+ // made the mediums, and that this class retrives pointers from the
+ // TGeoManager, and registers the mediums here. Alas, it's not
+ // really that easy.
+ //
AliDebug(10, "\tCreating materials");
-
- if (fSimulator) {
- AliFatal("Simulator object already instantised!");
- return;
- }
+ // Get pointer to geometry singleton object.
AliFMDGeometry* geometry = AliFMDGeometry::Instance();
geometry->Init();
- TVirtualMC* mc = TVirtualMC::GetMC();
- Bool_t geo = mc->IsRootGeometrySupported();
- if (geo)
- fSimulator = new AliFMDGeoSimulator(this, fDetailed);
- else
- fSimulator = new AliFMDG3Simulator(this, fDetailed);
+#if 0
+ if (gGeoManager && gGeoManager->GetMedium("FMD Si$")) {
+ // We need to figure out the some stuff about the geometry
+ fmd->ExtractGeomInfo();
+ return;
+ }
+#endif
+ Int_t id;
+ Double_t a = 0;
+ Double_t z = 0;
+ Double_t density = 0;
+ Double_t radiationLength = 0;
+ Double_t absorbtionLength = 999;
+ Int_t fieldType = gAlice->Field()->Integ(); // Field type
+ Double_t maxField = gAlice->Field()->Max(); // Field max.
+ Double_t maxBending = 0; // Max Angle
+ Double_t maxStepSize = 0.001; // Max step size
+ Double_t maxEnergyLoss = 1; // Max Delta E
+ Double_t precision = 0.001; // Precision
+ Double_t minStepSize = 0.001; // Minimum step size
+
+ // Silicon
+ a = 28.0855;
+ z = 14.;
+ density = geometry->GetSiDensity();
+ radiationLength = 9.36;
+ maxBending = 1;
+ maxStepSize = .001;
+ precision = .001;
+ minStepSize = .001;
+ id = kSiId;
+ AliMaterial(id, "Si$", a, z, density, radiationLength, absorbtionLength);
+ AliMedium(kSiId, "Si$", id,1,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+
+
+ // Carbon
+ a = 12.011;
+ z = 6.;
+ density = 2.265;
+ radiationLength = 18.8;
+ maxBending = 10;
+ maxStepSize = .01;
+ precision = .003;
+ minStepSize = .003;
+ id = kCarbonId;
+ AliMaterial(id, "Carbon$", a, z, density, radiationLength, absorbtionLength);
+ AliMedium(kCarbonId, "Carbon$", id,0,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+
+ // Aluminum
+ a = 26.981539;
+ z = 13.;
+ density = 2.7;
+ radiationLength = 8.9;
+ id = kAlId;
+ AliMaterial(id, "Aluminum$",a,z, density, radiationLength, absorbtionLength);
+ AliMedium(kAlId, "Aluminum$", id, 0, fieldType, maxField, maxBending,
+ maxStepSize, maxEnergyLoss, precision, minStepSize);
+
+
+ // Copper
+ a = 63.546;
+ z = 29;
+ density = 8.96;
+ radiationLength = 1.43;
+ id = kCopperId;
+ AliMaterial(id, "Copper$",
+ a, z, density, radiationLength, absorbtionLength);
+ AliMedium(kCopperId, "Copper$", id, 0, fieldType, maxField, maxBending,
+ maxStepSize, maxEnergyLoss, precision, minStepSize);
+
+
+ // Silicon chip
+ {
+ Float_t as[] = { 12.0107, 14.0067, 15.9994,
+ 1.00794, 28.0855, 107.8682 };
+ Float_t zs[] = { 6., 7., 8.,
+ 1., 14., 47. };
+ Float_t ws[] = { 0.039730642, 0.001396798, 0.01169634,
+ 0.004367771, 0.844665, 0.09814344903 };
+ density = 2.36436;
+ maxBending = 10;
+ maxStepSize = .01;
+ precision = .003;
+ minStepSize = .003;
+ id = kSiChipId;
+ AliMixture(id, "Si Chip$", as, zs, density, 6, ws);
+ AliMedium(kSiChipId, "Si Chip$", id, 0, fieldType, maxField, maxBending,
+ maxStepSize, maxEnergyLoss, precision, minStepSize);
+ }
+
+ // Kaption
+ {
+ Float_t as[] = { 1.00794, 12.0107, 14.010, 15.9994};
+ Float_t zs[] = { 1., 6., 7., 8.};
+ Float_t ws[] = { 0.026362, 0.69113, 0.07327, 0.209235};
+ density = 1.42;
+ maxBending = 1;
+ maxStepSize = .001;
+ precision = .001;
+ minStepSize = .001;
+ id = kKaptonId;
+ AliMixture(id, "Kaption$", as, zs, density, 4, ws);
+ AliMedium(kKaptonId, "Kaption$", id,0,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+ }
+
+ // Air
+ {
+ Float_t as[] = { 12.0107, 14.0067, 15.9994, 39.948 };
+ Float_t zs[] = { 6., 7., 8., 18. };
+ Float_t ws[] = { 0.000124, 0.755267, 0.231781, 0.012827 };
+ density = .00120479;
+ maxBending = 1;
+ maxStepSize = .001;
+ precision = .001;
+ minStepSize = .001;
+ id = kAirId;
+ AliMixture(id, "Air$", as, zs, density, 4, ws);
+ AliMedium(kAirId, "Air$", id,0,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+ }
- fSimulator->DefineMaterials();
+ // PCB
+ {
+ Float_t zs[] = { 14., 20., 13., 12.,
+ 5., 22., 11., 19.,
+ 26., 9., 8., 6.,
+ 7., 1.};
+ Float_t as[] = { 28.0855, 40.078, 26.981538, 24.305,
+ 10.811, 47.867, 22.98977, 39.0983,
+ 55.845, 18.9984, 15.9994, 12.0107,
+ 14.0067, 1.00794};
+ Float_t ws[] = { 0.15144894, 0.08147477, 0.04128158, 0.00904554,
+ 0.01397570, 0.00287685, 0.00445114, 0.00498089,
+ 0.00209828, 0.00420000, 0.36043788, 0.27529426,
+ 0.01415852, 0.03427566};
+ density = 1.8;
+ maxBending = 1;
+ maxStepSize = .001;
+ precision = .001;
+ minStepSize = .001;
+ id = kPcbId;
+ AliMixture(id, "PCB$", as, zs, density, 14, ws);
+ AliMedium(kPcbId, "PCB$", id,0,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+ }
+
+ // Plastic
+ {
+ Float_t as[] = { 1.01, 12.01 };
+ Float_t zs[] = { 1., 6. };
+ Float_t ws[] = { 1., 1. };
+ density = 1.03;
+ maxBending = 10;
+ maxStepSize = .01;
+ precision = .003;
+ minStepSize = .003;
+ id = kPlasticId;
+ AliMixture(id, "Plastic$", as, zs, density, -2, ws);
+ AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
+ maxStepSize,maxEnergyLoss,precision,minStepSize);
+ }
}
//____________________________________________________________________
void
AliFMD::Init()
{
- //
- // Initialis the FMD after it has been built
- Int_t i;
- //
- if (fDebug) {
- cout << "\n" << ClassName() << ": " << flush;
- for (i = 0; i < 35; i++) cout << "*";
- cout << " FMD_INIT ";
- for (i = 0; i < 35; i++) cout << "*";
- cout << "\n" << ClassName() << ": " << flush;
- //
- // Here the FMD initialisation code (if any!)
- for (i = 0; i < 80; i++) cout << "*";
- cout << endl;
+ // Initialize the detector
+ //
+ AliDebug(1, "Initialising FMD detector object");
+ // AliFMDGeometry* fmd = AliFMDGeometry::Instance();
+ // fmd->InitTransformations();
+}
+
+//____________________________________________________________________
+void
+AliFMD::FinishEvent()
+{
+ // Called at the end of the an event in simulations. If the debug
+ // level is high enough, then the `bad' hits are printed.
+ //
+ if (AliLog::GetDebugLevel("FMD", "AliFMD") < 10) return;
+ if (fBad && fBad->GetEntries() > 0) {
+ AliWarning((Form("EndEvent", "got %d 'bad' hits", fBad->GetEntries())));
+ TIter next(fBad);
+ AliFMDHit* hit;
+ while ((hit = static_cast<AliFMDHit*>(next()))) hit->Print("D");
+ fBad->Clear();
}
- //
- //
}
+
//====================================================================
//
// Graphics and event display
AliFMD::BuildGeometry()
{
//
- // Build simple ROOT TNode geometry for event display
- //
- // Build a simplified geometry of the FMD used for event display
- //
- // The actual building of the TNodes is done by
- // AliFMDSubDetector::SimpleGeometry.
+ // Build simple ROOT TNode geometry for event display. With the new
+ // geometry modeller, TGeoManager, this seems rather redundant.
AliDebug(10, "\tCreating a simplified geometry");
AliFMDGeometry* fmd = AliFMDGeometry::Instance();
return;
}
Double_t siThick = r->GetSiThickness();
- const Int_t nv = r->GetNVerticies();
+ const Int_t knv = r->GetNVerticies();
Double_t theta = r->GetTheta();
Int_t nmod = r->GetNModules();
- TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", nv, 2);
- for (Int_t j = 0; j < nv; j++) {
- TVector2* vv = r->GetVertex(nv - 1 - j);
+ TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", knv, 2);
+ for (Int_t j = 0; j < knv; j++) {
+ TVector2* vv = r->GetVertex(knv - 1 - j);
shape->DefineVertex(j, vv->X(), vv->Y());
}
shape->DefineSection(0, -siThick / 2, 1, 0, 0);
shape->DefineSection(1, +siThick / 2, 1, 0, 0);
- shape->SetLineColor(GetLineColor());
+ shape->SetLineColor(kYellow); //PH kYellow is the default line color in FMD
TObjArray* rots = new TObjArray(nmod);
for (Int_t j = 0; j < nmod; j++) {
TNode* mnod = new TNode(name.Data(), title.Data(), rshape,
0, 0, rz - siThick / 2
+ TMath::Sign(offz,z), rot);
- mnod->SetLineColor(GetLineColor());
+ mnod->SetLineColor(kYellow); //PH kYellow is the default line color in FMD
fNodes->Add(mnod);
} // for (Int_t k = 0 ; ...)
} // for (Int_t j = 0 ; ...)
//____________________________________________________________________
void
-AliFMD::DrawDetector()
+AliFMD::LoadPoints(Int_t /* track */)
{
+ // Store x, y, z of all hits in memory for display.
+ //
+ // Normally, the hits are drawn using TPolyMarker3D - however, that
+ // is not very useful for the FMD. Therefor, this member function
+ // is overloaded to make TMarker3D, via the class AliFMDPoints.
+ // AliFMDPoints is a local class.
//
- // Draw a shaded view of the Forward multiplicity detector
- //
- // DebugGuard guard("AliFMD::DrawDetector");
+ if (!fHits) {
+ AliError(Form("fHits == 0. Name is %s",GetName()));
+ return;
+ }
+ Int_t nHits = fHits->GetEntriesFast();
+ if (nHits == 0) {
+ return;
+ }
+ Int_t tracks = gAlice->GetMCApp()->GetNtrack();
+ if (fPoints == 0) fPoints = new TObjArray(2 * tracks);
+
+ // Get geometry
+ AliFMDGeometry* geom = AliFMDGeometry::Instance();
+ geom->Init();
+ geom->InitTransformations();
+
+ // Now make markers for each hit
+ // AliInfo(Form("Drawing %d hits (have %d points) for track %d",
+ // nHits, fPoints->GetEntriesFast(), track));
+ for (Int_t ihit = 0; ihit < nHits; ihit++) {
+ AliFMDHit* hit = static_cast<AliFMDHit*>(fHits->At(ihit));
+ if (!hit) continue;
+ Double_t edep = hit->Edep();
+ Double_t m = hit->M();
+ Double_t poverm = (m == 0 ? 0 : hit->P());
+ Double_t absQ = TMath::Abs(hit->Q());
+ Bool_t bad = kFALSE;
+ // This `if' is to debug abnormal energy depositions. We trigger on
+ // p/m approx larger than or equal to a MIP, and a large edep - more
+ // than 1 keV - a MIP is 100 eV.
+ if (edep > absQ * absQ && poverm > 1) bad = kTRUE;
+
+ AliFMDPoints* p1 = new AliFMDPoints(hit, kRed); //PH kRed is the default marker color in FMD
+ // AliPoints* p1 = new AliPoints();
+ // p1->SetMarkerColor(GetMarkerColor());
+ // p1->SetMarkerSize(GetMarkerSize());
+ // p1->SetPoint(0, hit->X(), hit->Y(), hit->Z());
+ p1->SetDetector(this);
+ p1->SetParticle(hit->GetTrack());
+ fPoints->AddAt(p1, hit->GetTrack());
+ if (bad) {
+ p1->SetMarkerColor(4);
+ // p1->SetMarkerSize(2 * GetMarkerSize());
+ }
+
+ Double_t x, y, z;
+ geom->Detector2XYZ(hit->Detector(), hit->Ring(), hit->Sector(),
+ hit->Strip(), x, y, z);
+ AliFMDPoints* p = new AliFMDPoints(hit, 3);
+ // AliPoints* p = new AliPoints();
+ // p->SetMarkerColor(3);
+ // p->SetMarkerSize(GetMarkerSize());
+ // p->SetPoint(0, x, y, z);
+ p->SetDetector(this);
+ p->SetParticle(hit->GetTrack());
+ p->SetXYZ(x, y, z);
+ p->SetMarkerColor(3);
+ fPoints->AddAt(p, tracks+hit->GetTrack());
+ if (bad) {
+ p->SetMarkerColor(5);
+ // p->SetMarkerSize(2 * GetMarkerSize());
+ }
+ // AliInfo(Form("Adding point at %d", tracks+hit->GetTrack()));
+ }
+}
+
+//____________________________________________________________________
+void
+AliFMD::DrawDetector()
+{
+ // Draw a shaded view of the Forward multiplicity detector. This
+ // isn't really useful anymore.
AliDebug(10, "\tDraw detector");
-
-#if 0
- //Set ALIC mother transparent
- gMC->Gsatt("ALIC","SEEN",0);
- //
- gMC->Gdopt("hide", "on");
- gMC->Gdopt("shad", "on");
- gMC->Gsatt("*", "fill", 7);
- gMC->SetClipBox(".");
- gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
- gMC->DefaultRange();
- gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
- gMC->Gdhead(1111, "Forward Multiplicity Detector");
- gMC->Gdman(16, 10, "MAN");
- gMC->Gdopt("hide", "off");
-#endif
}
//____________________________________________________________________
Int_t
-AliFMD::DistanceToPrimitive(Int_t, Int_t)
+AliFMD::DistancetoPrimitive(Int_t, Int_t)
{
- //
// Calculate the distance from the mouse to the FMD on the screen
- // Dummy routine
+ // Dummy routine.
//
return 9999;
}
}
}
-
-
//____________________________________________________________________
void
AliFMD::SetHitsAddressBranch(TBranch *b)
}
//____________________________________________________________________
-void
+AliFMDHit*
AliFMD::AddHitByFields(Int_t track,
UShort_t detector,
Char_t ring,
Float_t pz,
Float_t edep,
Int_t pdg,
- Float_t t)
+ Float_t t,
+ Float_t l,
+ Bool_t stop)
{
- //
// Add a hit to the list
//
// Parameters:
// edep Energy deposited by track
// pdg Track's particle Id #
// t Time when the track hit
+ // l Track length through the material.
+ // stop Whether track was stopped or disappeared
//
TClonesArray& a = *(HitsArray());
// Search through the list of already registered hits, and see if we
// a new hit, but rather update the energy deposited in the hit.
// This is done, so that a FLUKA based simulation will get the
// number of hits right, not just the enerrgy deposition.
+ AliFMDHit* hit = 0;
for (Int_t i = 0; i < fNhits; i++) {
if (!a.At(i)) continue;
-
AliFMDHit* hit = static_cast<AliFMDHit*>(a.At(i));
+ hit = static_cast<AliFMDHit*>(a.At(i));
if (hit->Detector() == detector
&& hit->Ring() == ring
&& hit->Sector() == sector
&& hit->Strip() == strip
&& hit->Track() == track) {
- Warning("AddHit", "already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
- " adding energy (%f) to that hit (%f) -> %f",
- detector, ring, sector, strip, track, edep, hit->Edep(),
- hit->Edep() + edep);
+ AliDebug(1, Form("already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
+ " adding energy (%f) to that hit (%f) -> %f",
+ detector, ring, sector, strip, track, edep, hit->Edep(),
+ hit->Edep() + edep));
hit->SetEdep(hit->Edep() + edep);
- return;
+ return hit;
}
}
// If hit wasn't already registered, do so know.
- new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, strip,
- x, y, z, px, py, pz, edep, pdg, t);
+ hit = new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector,
+ strip, x, y, z, px, py, pz, edep, pdg, t,
+ l, stop);
fNhits++;
+ return hit;
}
//____________________________________________________________________
void
AliFMD::ResetSDigits()
{
- //
- // Reset number of digits and the digits array for this detector
+ // Reset number of digits and the digits array for this detector.
//
fNsdigits = 0;
if (fSDigits) fSDigits->Clear();
// Create AliFMDDigit's from AliFMDHit's. This is done by making a
// AliFMDDigitizer, and executing that code.
//
+ Warning("Hits2Digits", "Try not to use this method.\n"
+ "Instead, use AliSimulator");
AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
manager->SetInputStream(0, "galice.root");
manager->SetOutputFile("H2Dfile");
/* AliDigitizer* dig =*/ CreateDigitizer(manager);
manager->Exec("");
+ delete manager;
}
//____________________________________________________________________
//
AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root");
digitizer->Exec("");
+ delete digitizer;
}
//
AliDebug(30, "\tBrowsing the FMD");
AliDetector::Browse(b);
- if (fSimulator) b->Add(fSimulator);
b->Add(AliFMDGeometry::Instance());
}
+//____________________________________________________________________
+void
+AliFMD::AddAlignableVolumes() const
+{
+ //
+ // Create entries for alignable volumes associating the symbolic volume
+ // name with the corresponding volume path. Needs to be syncronized with
+ // eventual changes in the geometry.
+ //
+ // This code was made by Raffaele Grosso <rgrosso@mail.cern.ch>. I
+ // (cholm) will probably want to change it. For one, I think it
+ // should be the job of the geometry manager to deal with this.
+ for(size_t f = 1; f <= 3; f++){ // Detector 1,2,3
+ for(size_t tb = 0; tb <2 ; tb++){ // Top/Bottom
+ char stb = tb == 0 ? 'T' : 'B';
+ unsigned min = tb == 0 ? 0 : 5;
+
+ TString halfVol(Form("/ALIC_1/F%dM%c_%d", f, stb, f));
+ TString halfSym(halfVol);
+ if(!gGeoManager->SetAlignableEntry(halfSym.Data(),halfVol.Data()))
+ AliFatal(Form("Alignable entry %s not created. "
+ "Volume path %s not valid",
+ halfSym.Data(),halfVol.Data()));
+ for(size_t io = 0; io < 2; io++){ // inner, outer
+ if (f==1 && io==1) continue; // Only one ring in FMD1
+ if(tb == 1 && io==1) min=10;
+ char sio = (io == 0 ? 'I' : 'O');
+ unsigned nio = (io == 0 ? 3 : 9);
+ unsigned max = (io == 0 ? 5 : 10) + min;
+
+ for(size_t i = min; i < max; i++) { // Modules
+ TString modVol(Form("%s/F%c%cV_7%d/F%cSE_%d", halfVol.Data(),
+ sio, stb, nio, sio, i));
+ TString modSym(modVol);
+ if(!gGeoManager->SetAlignableEntry(modSym.Data(),modVol.Data()))
+ AliFatal(Form("Alignable entry %s not created. "
+ "Volume path %s not valid",
+ modSym.Data(), modVol.Data()));
+ }
+ }
+ }
+ }
+
+}
//___________________________________________________________________
//
// EOF
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff