X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=FMD%2FAliFMD.cxx;h=11f7f93c3d8d70e3f0f51c213157a66bcdc0928c;hb=0b8eb97cd06b5df502fad89d03f22ce1359719aa;hp=288edb7623bef8100fdd2db2ac879369cc34952c;hpb=56b1929b4687f57bebdd95309d2994db32b6255c;p=u%2Fmrichter%2FAliRoot.git diff --git a/FMD/AliFMD.cxx b/FMD/AliFMD.cxx index 288edb7623b..11f7f93c3d8 100644 --- a/FMD/AliFMD.cxx +++ b/FMD/AliFMD.cxx @@ -12,51 +12,52 @@ * 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 + @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 5 Si volumes covered pseudorapidity interval -// from 1.7 to 5.1. +// 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. // // The actual code is done by various separate classes. Below is // diagram showing the relationship between the various FMD classes -// that handles the geometry +// that handles the simulation // // // +----------+ +----------+ -// | AliFMDv1 | | AliFMDv1 | +// | AliFMDv1 | | AliFMDv0 | // +----------+ +----------+ -// | | -// +----+--------------+ -// | -// | +------------+ 1 +---------------+ -// | +- | AliFMDRing |<>--| AliFMDPolygon | -// V 2 | +------------+ +---------------+ -// +--------+<>--+ | -// | AliFMD | ^ -// +--------+<>--+ V 1..2 -// 3 | +-------------------+ -// +-| AliFMDSubDetector | -// +-------------------+ -// ^ -// | -// +-------------+-------------+ -// | | | -// +---------+ +---------+ +---------+ -// | AliFMD1 | | AliFMD2 | | AliFMD3 | -// +---------+ +---------+ +---------+ -// +// | | +-----------------+ +// +----+--------------+ +--| AliFMDDigitizer | +// | | +-----------------+ +// | +---------------------+ | +// | +--| AliFMDBaseDigitizer |<--+ +// V 1 | +---------------------+ | +// +--------+<>--+ | +------------------+ +// | AliFMD | +--| AliFMDSDigitizer | +// +--------+<>--+ +------------------+ +// 1 | +---------------------+ +// +--| AliFMDReconstructor | +// +---------------------+ // // * AliFMD // This defines the interface for the various parts of AliROOT that -// uses the FMD, like AliFMDDigitizer, AliFMDReconstructor, and so -// on. +// uses the FMD, like AliFMDSimulator, AliFMDDigitizer, +// AliFMDReconstructor, and so on. +// +// * AliFMDv0 +// This is a concrete implementation of the AliFMD interface. +// It is the responsibility of this class to create the FMD +// geometry. // // * AliFMDv1 // This is a concrete implementation of the AliFMD interface. @@ -64,156 +65,100 @@ // geometry, process hits in the FMD, and serve hits and digits to // the various clients. // -// It uses the objects of class AliFMDSubDetector to do the various -// stuff for FMD1, 2, and 3 -// -// * AliFMDRing -// This class contains all stuff needed to do with a ring. It's -// used by the AliFMDSubDetector objects to instantise inner and -// outer rings. The AliFMDRing objects are shared by the -// AliFMDSubDetector objects, and owned by the AliFMDv1 object. -// -// * AliFMDPolygon -// The code I lifted from TGeoPolygon to help with the geometry of -// the modules, as well as to decide wether a hit is actually with -// in the real module shape. The point is, that the shape of the -// various ring modules are really polygons (much like the lid of a -// coffin), but it's segmented at constant radius. That is very -// hard to implement using GEANT 3.21 shapes, so instead the -// modules are implemented as TUBS (tube sections), and in the step -// procedure we do the test whether the track was inside the real -// shape of the module. -// -// * AliFMD1, AliFMD2, and AliFMD3 -// These are specialisation of AliFMDSubDetector, that contains the -// particularities of each of the sub-detector system. It is -// envisioned that the classes should also define the support -// volumes and material for each of the detectors. +// * AliFMDSimulator +// This is the base class for the FMD simulation tasks. The +// simulator tasks are responsible to implment the geoemtry, and +// process hits. // -// The responsible person for this module is Alla Maevskaia -// . +// * AliFMDReconstructor +// This is a concrete implementation of the AliReconstructor that +// reconstructs pseudo-inclusive-multiplicities from digits (raw or +// from simulation) // -// Many modifications by Christian Holm Christensen +// 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 // __CMATH__ #include // ROOT_TClonesArray #include // ROOT_TGeomtry #include // ROOT_TNode +#include // ROOT_TXTRU +#include // ROOT_TRotMatrix #include // ROOT_TTUBE #include // ROOT_TTree -#include // ROOT_TVirtualMC #include // ROOT_TBrowser -#include // ROOT_TMath +#include // ROOT_TVirtualMC +#include // ROOT_TVector2 +#include // ROOT_TGeoManager #include // ALIRUNDIGITIZER_H #include // ALILOADER_H #include // ALIRUN_H #include // ALIMC_H -#include // ALILOG_H #include // ALIMAGF_H +// #include // ALILOG_H +#include "AliFMDDebug.h" // Better debug macros #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 "AliFMD1.h" // ALIFMD1_H -#include "AliFMD2.h" // ALIFMD2_H -#include "AliFMD3.h" // ALIFMD3_H +#include "AliFMDSDigitizer.h" // ALIFMDSDIGITIZER_H +// #include "AliFMDGeometryBuilder.h" #include "AliFMDRawWriter.h" // ALIFMDRAWWRITER_H +#include "AliFMDPoints.h" // ALIFMDPOINTS_H //____________________________________________________________________ -ClassImp(AliFMD); +ClassImp(AliFMD) +#if 0 + ; // This is to keep Emacs from indenting the next line +#endif //____________________________________________________________________ AliFMD::AliFMD() - : fInner(0), - fOuter(0), - fFMD1(0), - fFMD2(0), - fFMD3(0), + : AliDetector(), fSDigits(0), fNsdigits(0), - fPrintboardRotationId(0), - fIdentityRotationId(0), - fShortLegId(0), - fLongLegId(0), - fLegLength(0), - fLegRadius(0), - fModuleSpacing(0), - fSiDensity(0), - fSiThickness(0), - fSiDeDxMip(1.664), - fVA1MipRange(0), - fAltroChannelSize(0), - fSampleRate(0) + fDetailed(kTRUE), + fUseOld(kFALSE), + fUseAssembly(kTRUE), + fBad(0) { // // Default constructor for class AliFMD // - AliDebug(0, "Default CTOR"); - fHits = 0; - fDigits = 0; - fIshunt = 0; -} - -//____________________________________________________________________ -AliFMD::AliFMD(const AliFMD& other) - : AliDetector(other), - fInner(other.fInner), - fOuter(other.fOuter), - fFMD1(other.fFMD1), - fFMD2(other.fFMD2), - fFMD3(other.fFMD3), - fSDigits(other.fSDigits), - fNsdigits(other.fNsdigits), - fPrintboardRotationId(other.fPrintboardRotationId), - fIdentityRotationId(other.fIdentityRotationId), - fShortLegId(other.fShortLegId), - fLongLegId(other.fLongLegId), - fLegLength(other.fLegLength), - fLegRadius(other.fLegRadius), - fModuleSpacing(other.fModuleSpacing), - fSiDensity(other.fSiDensity), - fSiThickness(other.fSiThickness), - fSiDeDxMip(other.fSiDeDxMip), - fVA1MipRange(other.fVA1MipRange), - fAltroChannelSize(other.fAltroChannelSize), - fSampleRate(other.fSampleRate) -{ - // Copy constructor + AliFMDDebug(10, ("\tDefault CTOR")); + fHits = 0; + fDigits = 0; + fIshunt = 0; + fBad = new TClonesArray("AliFMDHit"); } //____________________________________________________________________ -AliFMD::AliFMD(const char *name, const char *title, bool detailed) +AliFMD::AliFMD(const char *name, const char *title) : AliDetector (name, title), - fInner(0), - fOuter(0), - fFMD1(0), - fFMD2(0), - fFMD3(0), fSDigits(0), fNsdigits(0), - fPrintboardRotationId(0), - fIdentityRotationId(0), - fShortLegId(0), - fLongLegId(0), - fLegLength(0), - fLegRadius(0), - fModuleSpacing(0), - fSiDensity(0), - fSiThickness(0), - fSiDeDxMip(1.664), - fVA1MipRange(0), - fAltroChannelSize(0), - fSampleRate(0) + fDetailed(kTRUE), + fUseOld(kFALSE), + fUseAssembly(kFALSE), + fBad(0) { // // Standard constructor for Forward Multiplicity Detector // - AliDebug(0, "Standard CTOR"); - + AliFMDDebug(10, ("\tStandard CTOR")); + fBad = new TClonesArray("AliFMDHit"); + // Initialise Hit array HitsArray(); gAlice->GetMCApp()->AddHitList(fHits); @@ -224,66 +169,8 @@ AliFMD::AliFMD(const char *name, const char *title, bool detailed) // CHC: What is this? fIshunt = 0; - SetMarkerColor(kRed); - SetLineColor(kYellow); - SetSiDensity(); - - // Create sub-volume managers - fInner = new AliFMDRing('I', detailed); - fOuter = new AliFMDRing('O', detailed); - fFMD1 = new AliFMD1(); - fFMD2 = new AliFMD2(); - fFMD3 = new AliFMD3(); - - // Specify parameters of sub-volume managers - fFMD1->SetInner(fInner); - fFMD1->SetOuter(0); - - fFMD2->SetInner(fInner); - fFMD2->SetOuter(fOuter); - - fFMD3->SetInner(fInner); - fFMD3->SetOuter(fOuter); - - SetLegLength(); - SetLegRadius(); - SetLegOffset(); - SetModuleSpacing(); - SetSiThickness(); - SetSiDensity(); - SetVA1MipRange(); - SetAltroChannelSize(); - SetSampleRate(); - - fInner->SetLowR(4.3); - fInner->SetHighR(17.2); - fInner->SetWaferRadius(13.4/2); - fInner->SetTheta(36/2); - fInner->SetNStrips(512); - fInner->SetSiThickness(fSiThickness); - fInner->SetPrintboardThickness(.11); - fInner->SetBondingWidth(.5); - - fOuter->SetLowR(15.6); - fOuter->SetHighR(28.0); - fOuter->SetWaferRadius(13.4/2); - fOuter->SetTheta(18/2); - fOuter->SetNStrips(256); - fOuter->SetSiThickness(fSiThickness); - fOuter->SetPrintboardThickness(.1); - fOuter->SetBondingWidth(.5); - - - fFMD1->SetHoneycombThickness(1); - fFMD1->SetInnerZ(340.0); - - fFMD2->SetHoneycombThickness(1); - fFMD2->SetInnerZ(83.4); - fFMD2->SetOuterZ(75.2); - - fFMD3->SetHoneycombThickness(1); - fFMD3->SetInnerZ(-62.8); - fFMD3->SetOuterZ(-75.2); + //PH SetMarkerColor(kRed); + //PH SetLineColor(kYellow); } //____________________________________________________________________ @@ -305,36 +192,13 @@ AliFMD::~AliFMD () delete fSDigits; fSDigits = 0; } + if (fBad) { + fBad->Delete(); + delete fBad; + fBad = 0; + } } -//____________________________________________________________________ -AliFMD& -AliFMD::operator=(const AliFMD& other) -{ - AliDetector::operator=(other); - fInner = other.fInner; - fOuter = other.fOuter; - fFMD1 = other.fFMD1; - fFMD2 = other.fFMD2; - fFMD3 = other.fFMD3; - fSDigits = other.fSDigits; - fNsdigits = other.fNsdigits; - fSiDensity = other.fSiDensity; - fPrintboardRotationId = other.fPrintboardRotationId; - fIdentityRotationId = other.fIdentityRotationId; - fShortLegId = other.fShortLegId; - fLongLegId = other.fLongLegId; - fLegLength = other.fLegLength; - fLegRadius = other.fLegRadius; - fModuleSpacing = other.fModuleSpacing; - fSiDensity = other.fSiDensity; - fSiThickness = other.fSiThickness; - fVA1MipRange = other.fVA1MipRange; - fAltroChannelSize = other.fAltroChannelSize; - fSampleRate = other.fSampleRate; - - return *this; -} //==================================================================== // @@ -346,88 +210,50 @@ AliFMD::CreateGeometry() { // // 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: + // construction of the geometry is delegated to the class + // AliFMDGeometryBuilder, invoked by the singleton manager + // AliFMDGeometry. // - // 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 - // - - // DebugGuard guard("AliFMD::CreateGeometry"); - AliDebug(10, "Creating geometry"); - - fInner->Init(); - fOuter->Init(); - - TString name; - Double_t par[3]; - - par[0] = fLegRadius - .1; - par[1] = fLegRadius; - par[2] = fLegLength / 2; - name = "FSL"; - fShortLegId = gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3); - - par[2] += fModuleSpacing / 2; - name = "FLL"; - fLongLegId = gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3); - - fInner->SetupGeometry((*fIdtmed)[kAirId], - (*fIdtmed)[kSiId], - (*fIdtmed)[kPcbId], - fPrintboardRotationId, - fIdentityRotationId); - fOuter->SetupGeometry((*fIdtmed)[kAirId], - (*fIdtmed)[kSiId], - (*fIdtmed)[kPcbId], - fPrintboardRotationId, - fIdentityRotationId); - - fFMD1->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kAlId]); - fFMD2->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kAlId]); - fFMD3->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kAlId]); - - fFMD1->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId); - fFMD2->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId); - fFMD3->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId); + AliFMDGeometry* fmd = AliFMDGeometry::Instance(); + fmd->SetDetailed(fDetailed); + fmd->UseAssembly(fUseAssembly); + fmd->Build(); } //____________________________________________________________________ void AliFMD::CreateMaterials() { - // Register various materials and tracking mediums with the - // backend. - // - // Currently defined materials and mediums are - // - // FMD Air Normal air - // FMD Si Active silicon of sensors - // FMD Carbon Normal carbon used in support, etc. - // FMD Kapton Carbon used in Honeycomb - // FMD PCB Printed circuit board material - // FMD Plastic Material for support legs + // 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 // - // Also defined are two rotation matricies. + // 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) // - // DebugGuard guard("AliFMD::CreateMaterials"); - AliDebug(10, "Creating materials"); + // 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. + // + AliFMDDebug(10, ("\tCreating materials")); + // Get pointer to geometry singleton object. + AliFMDGeometry* geometry = AliFMDGeometry::Instance(); + geometry->Init(); +#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; @@ -445,17 +271,17 @@ void AliFMD::CreateMaterials() // Silicon a = 28.0855; z = 14.; - density = fSiDensity; + density = geometry->GetSiDensity(); radiationLength = 9.36; maxBending = 1; maxStepSize = .001; precision = .001; minStepSize = .001; id = kSiId; - AliMaterial(id, "FMD Si$", a, z, density, radiationLength, absorbtionLength); - AliMedium(kSiId, "FMD Si$",id,1,fieldType,maxField,maxBending, + AliMaterial(id, "Si$", a, z, density, radiationLength, absorbtionLength); + AliMedium(kSiId, "Si$", id,1,fieldType,maxField,maxBending, maxStepSize,maxEnergyLoss,precision,minStepSize); - + // Carbon a = 12.011; @@ -467,10 +293,9 @@ void AliFMD::CreateMaterials() precision = .003; minStepSize = .003; id = kCarbonId; - AliMaterial(id, "FMD Carbon$", a, z, density, radiationLength, - absorbtionLength); - AliMedium(kCarbonId, "FMD Carbon$",id,0,fieldType,maxField,maxBending, - maxStepSize,maxEnergyLoss,precision,minStepSize); + AliMaterial(id, "Carbon$", a, z, density, radiationLength, absorbtionLength); + AliMedium(kCarbonId, "Carbon$", id,0,fieldType,maxField,maxBending, + maxStepSize,maxEnergyLoss,precision,minStepSize); // Aluminum a = 26.981539; @@ -478,32 +303,42 @@ void AliFMD::CreateMaterials() density = 2.7; radiationLength = 8.9; id = kAlId; - AliMaterial(id, "FMD Aluminum$", a, z, density, radiationLength, - absorbtionLength); - AliMedium(kAlId, "FMD Aluminum$", id, 0, fieldType, maxField, maxBending, + 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 }; + 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; + density = 2.36436; maxBending = 10; maxStepSize = .01; precision = .003; minStepSize = .003; - id = kSiChipId; - AliMixture(id, "FMD Si Chip$", as, zs, density, 6, ws); - AliMedium(kSiChipId, "FMD Si Chip$", id, 0, fieldType, maxField, - maxBending, maxStepSize, maxEnergyLoss, precision, minStepSize); + id = kSiChipId; + AliMixture(id, "Si Chip$", as, zs, density, 6, ws); + AliMedium(kSiChipId, "Si Chip$", id, 0, fieldType, maxField, maxBending, + maxStepSize, maxEnergyLoss, precision, minStepSize); } -#if 0 // Kaption { Float_t as[] = { 1.00794, 12.0107, 14.010, 15.9994}; @@ -514,12 +349,11 @@ void AliFMD::CreateMaterials() maxStepSize = .001; precision = .001; minStepSize = .001; - id = KaptionId; - AliMixture(id, "FMD Kaption$", as, zs, density, 4, ws); - AliMedium(kAlId, "FMD Kaption$",id,0,fieldType,maxField,maxBending, + id = kKaptonId; + AliMixture(id, "Kaption$", as, zs, density, 4, ws); + AliMedium(kKaptonId, "Kaption$", id,0,fieldType,maxField,maxBending, maxStepSize,maxEnergyLoss,precision,minStepSize); } -#endif // Air { @@ -532,8 +366,8 @@ void AliFMD::CreateMaterials() precision = .001; minStepSize = .001; id = kAirId; - AliMixture(id, "FMD Air$", as, zs, density, 4, ws); - AliMedium(kAirId, "FMD Air$", id,0,fieldType,maxField,maxBending, + AliMixture(id, "Air$", as, zs, density, 4, ws); + AliMedium(kAirId, "Air$", id,0,fieldType,maxField,maxBending, maxStepSize,maxEnergyLoss,precision,minStepSize); } @@ -557,11 +391,22 @@ void AliFMD::CreateMaterials() precision = .001; minStepSize = .001; id = kPcbId; - AliMixture(id, "FMD PCB$", as, zs, density, 14, ws); - AliMedium(kPcbId, "FMD PCB$", id,1,fieldType,maxField,maxBending, + AliMixture(id, "PCB$", as, zs, density, 14, ws); + AliMedium(kPcbId, "PCB$", id,0,fieldType,maxField,maxBending, maxStepSize,maxEnergyLoss,precision,minStepSize); } + // Stainless steel + { + Float_t as[] = { 55.847, 51.9961, 58.6934, 28.0855 }; + Float_t zs[] = { 26., 24., 28., 14. }; + Float_t ws[] = { .715, .18, .1, .005 }; + density = 7.88; + id = kSteelId; + AliMixture(id, "Steel$", as, zs, density, 4, ws); + AliMedium(kSteelId, "Steel$", id, 0, fieldType, maxField, maxBending, + maxStepSize, maxEnergyLoss, precision, minStepSize); + } // Plastic { Float_t as[] = { 1.01, 12.01 }; @@ -573,37 +418,56 @@ void AliFMD::CreateMaterials() precision = .003; minStepSize = .003; id = kPlasticId; - AliMixture(id, "FMD Plastic$", as, zs, density, -2, ws); - AliMedium(kPlasticId, "FMD Plastic$", id,0,fieldType,maxField,maxBending, - maxStepSize,maxEnergyLoss,precision,minStepSize); + AliMixture(id, "Plastic$", as, zs, density, -2, ws); + AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending, + maxStepSize,maxEnergyLoss,precision,minStepSize); } - AliMatrix(fPrintboardRotationId, 90, 90, 0, 90, 90, 0); - AliMatrix(fIdentityRotationId, 90, 0, 90, 90, 0, 0); + } //____________________________________________________________________ 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 + // + AliFMDDebug(1, ("Initialising FMD detector object")); + TVirtualMC* mc = TVirtualMC::GetMC(); + AliFMDGeometry* fmd = AliFMDGeometry::Instance(); + const TArrayI& actGeo = fmd->ActiveIds(); + TArrayI actVmc(actGeo.fN); + for (Int_t i = 0; i < actGeo.fN; i++) { + TGeoVolume *sens = gGeoManager->GetVolume(actGeo[i]); + if (!sens) { + AliError(Form("No TGeo volume for sensitive volume ID=%d",actGeo[i])); + continue; + } + actVmc[i] = mc->VolId(sens->GetName()); + AliFMDDebug(1, ("Active vol id # %d: %d changed to %d", + i, actGeo[i], actVmc[i])); } - // - // + fmd->SetActive(actVmc.fArray, actVmc.fN); + // 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(next()))) hit->Print("D"); + fBad->Clear(); + } +} + + //==================================================================== // // Graphics and event display @@ -613,61 +477,215 @@ void 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. - AliDebug(10, "Creating a simplified geometry"); + // Build simple ROOT TNode geometry for event display. With the new + // geometry modeller, TGeoManager, this seems rather redundant. + AliFMDDebug(10, ("\tCreating a simplified geometry")); + AliFMDGeometry* fmd = AliFMDGeometry::Instance(); + + static TXTRU* innerShape = 0; + static TXTRU* outerShape = 0; + static TObjArray* innerRot = 0; + static TObjArray* outerRot = 0; + + if (!innerShape || !outerShape) { + // Make the shapes for the modules + for (Int_t i = 0; i < 2; i++) { + AliFMDRing* r = 0; + switch (i) { + case 0: r = fmd->GetRing('I'); break; + case 1: r = fmd->GetRing('O'); break; + } + if (!r) { + AliError(Form("no ring found for i=%d", i)); + return; + } + Double_t siThick = r->GetSiThickness(); + 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", 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(kYellow); //PH kYellow is the default line color in FMD + + TObjArray* rots = new TObjArray(nmod); + for (Int_t j = 0; j < nmod; j++) { + Double_t th = (j + .5) * theta * 2; + TString name(Form("FMD_ring_%c_rot_%02d", r->GetId(), j)); + TString title(Form("FMD Ring %c Rotation # %d", r->GetId(), j)); + TRotMatrix* rot = new TRotMatrix(name.Data(), title.Data(), + 90, th, 90, fmod(90+th,360), 0, 0); + rots->AddAt(rot, j); + } + + switch (r->GetId()) { + case 'i': + case 'I': innerShape = shape; innerRot = rots; break; + case 'o': + case 'O': outerShape = shape; outerRot = rots; break; + } + } + } + TNode* top = gAlice->GetGeometry()->GetNode("alice"); - fFMD1->SimpleGeometry(fNodes, top, GetLineColor(), 0); - fFMD2->SimpleGeometry(fNodes, top, GetLineColor(), 0); - fFMD3->SimpleGeometry(fNodes, top, GetLineColor(), 0); + for (Int_t i = 1; i <= 3; i++) { + AliFMDDetector* det = fmd->GetDetector(i); + if (!det) { + Warning("BuildGeometry", "FMD%d seems to be disabled", i); + continue; + } + Double_t w = 0; + Double_t rh = det->GetRing('I')->GetHighR(); + Char_t id = 'I'; + if (det->GetRing('O')) { + w = TMath::Abs(det->GetRingZ('O') - det->GetRingZ('I')); + id = (TMath::Abs(det->GetRingZ('O')) + > TMath::Abs(det->GetRingZ('I')) ? 'O' : 'I'); + rh = det->GetRing('O')->GetHighR(); + } + w += (det->GetRing(id)->GetModuleSpacing() + + det->GetRing(id)->GetSiThickness()); + TShape* shape = new TTUBE(det->GetName(), det->GetTitle(), "void", + det->GetRing('I')->GetLowR(), rh, w / 2); + Double_t z = (det->GetRingZ('I') - w / 2); + if (z > 0) z += det->GetRing(id)->GetModuleSpacing(); + top->cd(); + TNode* node = new TNode(det->GetName(), det->GetTitle(), shape, + 0, 0, z, 0); + fNodes->Add(node); + + for (Int_t j = 0; j < 2; j++) { + AliFMDRing* r = 0; + TShape* rshape = 0; + TObjArray* rots = 0; + switch (j) { + case 0: + r = det->GetRing('I'); rshape = innerShape; rots = innerRot; break; + case 1: + r = det->GetRing('O'); rshape = outerShape; rots = outerRot; break; + } + if (!r) continue; + + Double_t siThick = r->GetSiThickness(); + Int_t nmod = r->GetNModules(); + Double_t modspace = r->GetModuleSpacing(); + Double_t rz = - (z - det->GetRingZ(r->GetId())); + + for (Int_t k = 0; k < nmod; k++) { + node->cd(); + Double_t offz = (k % 2 == 1 ? modspace : 0); + TRotMatrix* rot = static_cast(rots->At(k)); + TString name(Form("%s%c_module_%02d", det->GetName(), r->GetId(),k)); + TString title(Form("%s%c Module %d", det->GetName(), r->GetId(),k)); + TNode* mnod = new TNode(name.Data(), title.Data(), rshape, + 0, 0, rz - siThick / 2 + + TMath::Sign(offz,z), rot); + 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 ; ...) + } // for (Int_t i = 1 ; ...) } //____________________________________________________________________ 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"); - AliDebug(10, "Draw detector"); - - //Set ALIC mother transparent - gMC->Gsatt("ALIC","SEEN",0); - - //Set volumes visible - fFMD1->Gsatt(); - fFMD2->Gsatt(); - fFMD3->Gsatt(); - fInner->Gsatt(); - fOuter->Gsatt(); + 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(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())); + } +} - // - 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"); +//____________________________________________________________________ +void +AliFMD::DrawDetector() +{ + // Draw a shaded view of the Forward multiplicity detector. This + // isn't really useful anymore. + AliFMDDebug(10, ("\tDraw detector")); } //____________________________________________________________________ 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; } @@ -731,8 +749,6 @@ AliFMD::SetTreeAddress() } } - - //____________________________________________________________________ void AliFMD::SetHitsAddressBranch(TBranch *b) @@ -766,40 +782,41 @@ AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits) // hits[9] [Float_t ] Time when the track hit // // - AddHit(track, - UShort_t(vol[0]), // Detector # - Char_t(vol[1]), // Ring ID - UShort_t(vol[2]), // Sector # - UShort_t(vol[3]), // Strip # - hits[0], // X - hits[1], // Y - hits[2], // Z - hits[3], // Px - hits[4], // Py - hits[5], // Pz - hits[6], // Energy loss - Int_t(hits[7]), // PDG - hits[8]); // Time + AddHitByFields(track, + UShort_t(vol[0]), // Detector # + Char_t(vol[1]), // Ring ID + UShort_t(vol[2]), // Sector # + UShort_t(vol[3]), // Strip # + hits[0], // X + hits[1], // Y + hits[2], // Z + hits[3], // Px + hits[4], // Py + hits[5], // Pz + hits[6], // Energy loss + Int_t(hits[7]), // PDG + hits[8]); // Time } //____________________________________________________________________ -void -AliFMD::AddHit(Int_t track, - UShort_t detector, - Char_t ring, - UShort_t sector, - UShort_t strip, - Float_t x, - Float_t y, - Float_t z, - Float_t px, - Float_t py, - Float_t pz, - Float_t edep, - Int_t pdg, - Float_t t) +AliFMDHit* +AliFMD::AddHitByFields(Int_t track, + UShort_t detector, + Char_t ring, + UShort_t sector, + UShort_t strip, + Float_t x, + Float_t y, + Float_t z, + Float_t px, + Float_t py, + Float_t pz, + Float_t edep, + Int_t pdg, + Float_t t, + Float_t l, + Bool_t stop) { - // // Add a hit to the list // // Parameters: @@ -818,6 +835,8 @@ AliFMD::AddHit(Int_t track, // 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 @@ -825,31 +844,34 @@ AliFMD::AddHit(Int_t track, // 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(a.At(i)); + hit = static_cast(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); + AliFMDDebug(1, ("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::AddDigit(Int_t* digits) +AliFMD::AddDigit(Int_t* digits, Int_t*) { // Add a digit to the Digit tree // @@ -863,24 +885,26 @@ AliFMD::AddDigit(Int_t* digits) // digits[5] [Short_t] ADC Count, -1 if not used // digits[6] [Short_t] ADC Count, -1 if not used // - AddDigit(UShort_t(digits[0]), // Detector # - Char_t(digits[1]), // Ring ID - UShort_t(digits[2]), // Sector # - UShort_t(digits[3]), // Strip # - UShort_t(digits[4]), // ADC Count1 - Short_t(digits[5]), // ADC Count2 - Short_t(digits[6])); // ADC Count3 + AddDigitByFields(UShort_t(digits[0]), // Detector # + Char_t(digits[1]), // Ring ID + UShort_t(digits[2]), // Sector # + UShort_t(digits[3]), // Strip # + UShort_t(digits[4]), // ADC Count1 + Short_t(digits[5]), // ADC Count2 + Short_t(digits[6]), // ADC Count3 + Short_t(digits[7])); } //____________________________________________________________________ void -AliFMD::AddDigit(UShort_t detector, - Char_t ring, - UShort_t sector, - UShort_t strip, - UShort_t count1, - Short_t count2, - Short_t count3) +AliFMD::AddDigitByFields(UShort_t detector, + Char_t ring, + UShort_t sector, + UShort_t strip, + UShort_t count1, + Short_t count2, + Short_t count3, + Short_t count4) { // add a real digit - as coming from data // @@ -896,7 +920,12 @@ AliFMD::AddDigit(UShort_t detector, TClonesArray& a = *(DigitsArray()); new (a[fNdigits++]) - AliFMDDigit(detector, ring, sector, strip, count1, count2, count3); + AliFMDDigit(detector, ring, sector, strip, count1, count2, count3, count4); + AliFMDDebug(15, ("Adding digit # %5d/%5d for FMD%d%c[%2d,%3d]=(%d,%d,%d,%d)", + fNdigits-1, a.GetEntriesFast(), + detector, ring, sector, strip, + count1, count2, count3, count4)); + } //____________________________________________________________________ @@ -916,26 +945,28 @@ AliFMD::AddSDigit(Int_t* digits) // digits[6] [Short_t] ADC Count, -1 if not used // digits[7] [Short_t] ADC Count, -1 if not used // - AddSDigit(UShort_t(digits[0]), // Detector # - Char_t(digits[1]), // Ring ID - UShort_t(digits[2]), // Sector # - UShort_t(digits[3]), // Strip # - Float_t(digits[4]), // Edep - UShort_t(digits[5]), // ADC Count1 - Short_t(digits[6]), // ADC Count2 - Short_t(digits[7])); // ADC Count3 + AddSDigitByFields(UShort_t(digits[0]), // Detector # + Char_t(digits[1]), // Ring ID + UShort_t(digits[2]), // Sector # + UShort_t(digits[3]), // Strip # + Float_t(digits[4]), // Edep + UShort_t(digits[5]), // ADC Count1 + Short_t(digits[6]), // ADC Count2 + Short_t(digits[7]), // ADC Count3 + Short_t(digits[8])); } //____________________________________________________________________ void -AliFMD::AddSDigit(UShort_t detector, - Char_t ring, - UShort_t sector, - UShort_t strip, - Float_t edep, - UShort_t count1, - Short_t count2, - Short_t count3) +AliFMD::AddSDigitByFields(UShort_t detector, + Char_t ring, + UShort_t sector, + UShort_t strip, + Float_t edep, + UShort_t count1, + Short_t count2, + Short_t count3, + Short_t count4) { // add a summable digit // @@ -953,15 +984,15 @@ AliFMD::AddSDigit(UShort_t detector, TClonesArray& a = *(SDigitsArray()); new (a[fNsdigits++]) - AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3); + AliFMDSDigit(detector, ring, sector, strip, edep, + count1, count2, count3, count4); } //____________________________________________________________________ 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(); @@ -1015,12 +1046,15 @@ AliFMD::Hits2Digits() // 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; } //____________________________________________________________________ @@ -1031,10 +1065,8 @@ AliFMD::Hits2SDigits() // an AliFMDSDigitizer object, and executing it. // AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root"); - digitizer->SetSampleRate(fSampleRate); - digitizer->SetVA1MipRange(fVA1MipRange); - digitizer->SetAltroChannelSize(fAltroChannelSize); digitizer->Exec(""); + delete digitizer; } @@ -1044,9 +1076,6 @@ AliFMD::CreateDigitizer(AliRunDigitizer* manager) const { // Create a digitizer object AliFMDDigitizer* digitizer = new AliFMDDigitizer(manager); - digitizer->SetSampleRate(fSampleRate); - digitizer->SetVA1MipRange(fVA1MipRange); - digitizer->SetAltroChannelSize(fAltroChannelSize); return digitizer; } @@ -1063,70 +1092,9 @@ AliFMD::Digits2Raw() // This uses the class AliFMDRawWriter to do the job. Please refer // to that class for more information. AliFMDRawWriter writer(this); - writer.SetSampleRate(fSampleRate); writer.Exec(); } -//================================================================== -// -// Various setter functions for the common paramters -// - -//__________________________________________________________________ -void -AliFMD::SetLegLength(Double_t length) -{ - // Set lenght of plastic legs that hold the hybrid (print board and - // silicon sensor) onto the honeycomp support - // - // DebugGuard guard("AliFMD::SetLegLength"); - AliDebug(10, "AliFMD::SetLegLength"); - fLegLength = length; - fInner->SetLegLength(fLegLength); - fOuter->SetLegLength(fLegLength); -} - -//__________________________________________________________________ -void -AliFMD::SetLegOffset(Double_t offset) -{ - // Set offset from edge of hybrid to plastic legs that hold the - // hybrid (print board and silicon sensor) onto the honeycomp - // support - // - // DebugGuard guard("AliFMD::SetLegOffset"); - AliDebug(10, "AliFMD::SetLegOffset"); - fInner->SetLegOffset(offset); - fOuter->SetLegOffset(offset); -} - -//__________________________________________________________________ -void -AliFMD::SetLegRadius(Double_t radius) -{ - // Set the diameter of the plastic legs that hold the hybrid (print - // board and silicon sensor) onto the honeycomp support - // - // DebugGuard guard("AliFMD::SetLegRadius"); - AliDebug(10, "AliFMD::SetLegRadius"); - fLegRadius = radius; - fInner->SetLegRadius(fLegRadius); - fOuter->SetLegRadius(fLegRadius); -} - -//__________________________________________________________________ -void -AliFMD::SetModuleSpacing(Double_t spacing) -{ - // Set the distance between the front and back sensor modules - // (module staggering). - // - // DebugGuard guard("AliFMD::SetModuleSpacing"); - AliDebug(10, "AliFMD::SetModuleSpacing"); - fModuleSpacing = spacing; - fInner->SetModuleSpacing(fModuleSpacing); - fOuter->SetModuleSpacing(fModuleSpacing); -} //==================================================================== // @@ -1138,16 +1106,57 @@ AliFMD::Browse(TBrowser* b) { // Browse this object. // - AliDebug(10, "AliFMD::Browse"); + AliFMDDebug(30, ("\tBrowsing the FMD")); AliDetector::Browse(b); - if (fInner) b->Add(fInner, "Inner Ring"); - if (fOuter) b->Add(fOuter, "Outer Ring"); - if (fFMD1) b->Add(fFMD1, "FMD1 SubDetector"); - if (fFMD2) b->Add(fFMD2, "FMD2 SubDetector"); - if (fFMD3) b->Add(fFMD3, "FMD3 SubDetector"); + 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 . 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. + AliFMDGeometry::Instance()->SetAlignableVolumes(); +#if 0 + 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())); + } + } + } + } +#endif +} //___________________________________________________________________ // // EOF