AliGeant4/AliMoreModulesConstruction.cxx

   1 // $Id$
   2 // Category: geometry
   3 //
   4 // See the class description in the header file.
   5
   6 #include "AliMoreModulesConstruction.h"
   7 #include "AliSingleModuleConstruction.h"
   8 #include "AliSDManager.h"
   9 #include "AliSensitiveDetector.h"
  10 #include "AliModule.h"
  11 #include "AliRun.h"
  12 #include "AliGlobals.h"
  13
  14 #include "TG4GeometryManager.h"
  15
  16 #include <G4SDManager.hh>
  17 #include <G4LogicalVolume.hh>
  18 #include <G4LogicalVolumeStore.hh>
  19
  20 #include <TROOT.h>
  21 #include <TCint.h>
  22
  23 AliMoreModulesConstruction::AliMoreModulesConstruction() {
  24 //
  25   fSDManager = AliSDManager::Instance();
  26 }
  27
  28 AliMoreModulesConstruction::AliMoreModulesConstruction(
  29                                const AliMoreModulesConstruction& right)
  30 {
  31   // delete current module constructions
  32   fModuleConstructionVector.erase(
  33     fModuleConstructionVector.begin(), fModuleConstructionVector.end());
  34
  35   // create new module constructions
  36   G4int nofModules = right.fModuleConstructionVector.size();
  37   for (G4int i=0; i<nofModules; i++) {
  38     G4String name = right.fModuleConstructionVector[i]->GetDetName();
  39     G4int version = right.fModuleConstructionVector[i]->GetVersion();
  40     AliModuleType type = right.fModuleConstructionVector[i]->GetType();
  41     AddModule(name, version, type);
  42   }
  43
  44   fSDManager = right.fSDManager;
  45 }
  46
  47
  48 AliMoreModulesConstruction::~AliMoreModulesConstruction()
  49 {
  50   // delete module constructions
  51   fModuleConstructionVector.erase(
  52     fModuleConstructionVector.begin(), fModuleConstructionVector.end());
  53 }
  54
  55 // operators
  56
  57 AliMoreModulesConstruction&
  58 AliMoreModulesConstruction::operator=(const AliMoreModulesConstruction& right)
  59 {
  60   // check assignement to self
  61   if (this == &right) return *this;
  62
  63   // delete current module constructions
  64   fModuleConstructionVector.erase(
  65     fModuleConstructionVector.begin(), fModuleConstructionVector.end());
  66
  67   // create new module constructions
  68   G4int nofModules = right.fModuleConstructionVector.size();
  69   for (G4int i=0; i<nofModules; i++) {
  70     G4String name = right.fModuleConstructionVector[i]->GetDetName();
  71     G4int version = right.fModuleConstructionVector[i]->GetVersion();
  72     AliModuleType type = right.fModuleConstructionVector[i]->GetType();
  73     AddModule(name, version, type);
  74   }
  75
  76   fSDManager = right.fSDManager;
  77
  78   return *this;
  79 }
  80
  81 // private methods
  82
  83 void AliMoreModulesConstruction::CreateSensitiveDetectors(
  84                                    G4bool allLVSensitive)
  85 {
  86 // Creates sensitive detectors.
  87 // ---
  88
  89   if (allLVSensitive)
  90     CreateSensitiveDetectors1();
  91   else
  92     CreateSensitiveDetectors2();
  93
  94   // set static number of logical volumes already processed
  95   G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance();
  96   fSDManager->SetNofLVWithSD(pLVStore->entries());
  97 }
  98
  99 void AliMoreModulesConstruction::CreateSensitiveDetectors1()
 100 {
 101 // Creates sensitive detectors.
 102 // Sensitive detectors are set to all logical volumes
 103 // ---
 104
 105   G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance();
 106   G4int nofLV = pLVStore->entries();
 107
 108   G4int nofLVWithSD = fSDManager->GetNofLVWithSD();
 109   for (G4int i=nofLVWithSD; i<nofLV; i++) {
 110     G4LogicalVolume* lv = (*pLVStore)[i];
 111     AliModule* module = fSDManager->FindAliModule(lv);
 112     fSDManager->CreateSD(lv, module);
 113   }
 114 }
 115
 116 void AliMoreModulesConstruction::CreateSensitiveDetectors2()
 117 {
 118 // Creates sensitive detectors.
 119 // Sensitive detectors are set only to logical volumes
 120 // in G3SensVolVector.
 121 // ---
 122
 123   TG4GeometryManager* pGeometryManager = TG4GeometryManager::Instance();
 124
 125   G3SensVolVector pSVVector
 126     = pGeometryManager->GetG3SensVolVector();
 127
 128   G4int nofSV = pSVVector.entries();
 129   if (nofSV>0)
 130     for (G4int isv=0; isv<nofSV; isv++) {
 131       G4LogicalVolume* lv = pSVVector[isv];
 132       AliModule* module = fSDManager->FindAliModule(lv);
 133       fSDManager->CreateSD(lv, module);
 134     }
 135 }
 136
 137 // public methods
 138
 139 void AliMoreModulesConstruction::AddModule(G4String moduleName, G4int version,
 140                                            AliModuleType moduleType)
 141 {
 142 // Adds module specified by name, version and type.
 143 // ---
 144
 145   // create module construction
 146   AliSingleModuleConstruction* moduleConstruction
 147     = new AliSingleModuleConstruction(moduleName, version, moduleType);
 148
 149   // add module, module construction to vectors
 150   fModuleConstructionVector.push_back(moduleConstruction);
 151 }
 152
 153 void AliMoreModulesConstruction::Configure()
 154 {
 155 // Executes the detectors setup Root macros
 156 // (extracted from AliRoot Config.C) and
 157 // G4 macros.
 158 // ---
 159
 160   // number of modules
 161   G4int nofModules = fModuleConstructionVector.size();
 162
 163   if (nofModules == 0) {
 164     AliGlobals::Warning(
 165       "AliMoreModulesConstruction::Construct(): No modules are defined.");
 166   }
 167   else
 168     for (G4int i=0; i<nofModules; i++)
 169       fModuleConstructionVector[i]->Configure();
 170 }
 171
 172 void AliMoreModulesConstruction::Construct()
 173 {
 174 // Constructs geometry.
 175 // G3 tables are process for all modules alltogether.
 176 // --
 177
 178   // number of modules
 179   G4int nofModules = fModuleConstructionVector.size();
 180
 181   if (nofModules == 0) {
 182     AliGlobals::Warning(
 183       "AliMoreModulesConstruction::Construct(): No modules are defined.");
 184   }
 185   else {
 186     // get geometry manager
 187     TG4GeometryManager* pGeometryManager = TG4GeometryManager::Instance();
 188
 189     G4bool allLVSensitive = false;
 190     G4int i;
 191     for (i=0; i<nofModules; i++) {
 192
 193       // fModuleConstructionVector[i]->Configure();
 194
 195       // register module name in the name map
 196       AliModule* module = fModuleConstructionVector[i]->GetAliModule();
 197       pGeometryManager->SetMapSecond(module->GetName());
 198
 199       G4bool readGeometry = fModuleConstructionVector[i]->GetReadGeometry();
 200       G4bool writeGeometry = fModuleConstructionVector[i]->GetWriteGeometry();
 201       G4String dataFilePath = fModuleConstructionVector[i]->GetDataFilePath();
 202
 203       if (readGeometry) {
 204         // TG4GeometryManager uses g3tog4 methods for reading
 205         // g3calls.dat files - as these methods do not fill name map
 206         // they cannot be used for constructing more modules
 207         // together
 208         //
 209         // pGeometryManager->SetWriteGeometry(false);
 210         // pGeometryManager->ReadG3Geometry(dataFilePath);
 211
 212         G4String text = "AliMoreModulesConstruction::Construct - Limitation:\n";
 213         text = text + "    Reading g3calls.dat is not implemented.";
 214         AliGlobals::Exception(text);
 215       }
 216       else {
 217         // set geometry output stream for this module
 218         pGeometryManager->SetWriteGeometry(writeGeometry);
 219         if (writeGeometry)
 220           pGeometryManager->OpenOutFile(dataFilePath);
 221
 222         // create geometry from AliRoot
 223
 224         // construct materials
 225         module->CreateMaterials();
 226
 227         // construct G3 geometry
 228         module->CreateGeometry();
 229
 230         if (writeGeometry)
 231           pGeometryManager->CloseOutFile();
 232       }
 233
 234       // all logical volumes will be made sensitive if any
 235       // module requires this
 236       if (fModuleConstructionVector[i]->GetAllLVSensitive())
 237          allLVSensitive = true;
 238     }
 239
 240     // construct G4 geometry
 241     pGeometryManager->CreateG4Geometry();
 242
 243     // print name map
 244     // pGeometryManager->PrintNameMap();
 245
 246     // create sensitive detectors
 247     CreateSensitiveDetectors(allLVSensitive);
 248
 249     for (i=0; i<nofModules; i++) {
 250       // set the detector frame (envelope)
 251       // (without warning output if enevelope is not defined)
 252       fModuleConstructionVector[i]->SetDetFrame(false);
 253
 254       // build sensitive detectors table
 255       fModuleConstructionVector[i]->GetAliModule()->Init();
 256
 257       // construct geometry for display
 258       fModuleConstructionVector[i]->GetAliModule()->BuildGeometry();
 259     }
 260
 261     // reset TG4GeometryManager
 262     pGeometryManager->ClearG3Tables();
 263
 264     // print current total number of logical volumes
 265     G4cout << "Current total number of sensitive volumes: "
 266            << pGeometryManager->NofVolumes() << G4endl;
 267
 268 #ifdef ALICE_VISUALIZE
 269     // set visualization attributes
 270     for (i=0; i<nofModules; i++) {
 271       if (fModuleConstructionVector[i]->GetDetFrame()) {
 272         fModuleConstructionVector[i]->SetDetVisibility(true);
 273         fModuleConstructionVector[i]->SetDetColour("Yellow");
 274       }
 275     }
 276 #endif
 277   }
 278 }