[u/mrichter/AliRoot.git] / AliGeant4 / AliModulesComposition.cxx

// $Id$
// Category: geometry
//
// See the class description in the header file.

#include "AliModulesComposition.h"
#include "AliModulesCompositionMessenger.h"
#include "AliSingleModuleConstruction.h"
#include "AliMoreModulesConstruction.h"
#include "AliDetSwitch.h"
#include "AliMagneticField.h"
#include "AliGlobals.h"
#include "AliFiles.h"

#include "TG4GeometryManager.h"
#include "TG4XMLGeometryGenerator.h"

#include <G4Material.hh>
#include <G4VPhysicalVolume.hh>

AliModulesComposition::AliModulesComposition()
  : fAllLVSensitive(false),
    fForceAllLVSensitive(true),
    fReadGeometry(false),
    fWriteGeometry(false),
    fMagneticField(0)    
{
//
  fMoreModulesConstruction = new AliMoreModulesConstruction();
  fMessenger = new AliModulesCompositionMessenger(this);
}

AliModulesComposition::AliModulesComposition(const AliModulesComposition& right)
{
//
  AliGlobals::Exception("AliModulesComposition is protected from copying.");  
}

AliModulesComposition::~AliModulesComposition() {
//   
  delete fMoreModulesConstruction;
  delete fMagneticField;
  delete fMessenger; 
  
  // destroy det switch vector
  fDetSwitchVector.clearAndDestroy();  
  
  // destroy det construction vector
  fModuleConstructionVector.clearAndDestroy();
}

// operators

AliModulesComposition& 
AliModulesComposition::operator=(const AliModulesComposition& right)
{
  // check assignement to self
  if (this == &right) return *this;
  
  AliGlobals::Exception("AliModulesComposition is protected from assigning.");  

  return *this;  
}    
          
// protected methods

void AliModulesComposition::AddDetSwitch(AliDetSwitch* detSwitch)
{
// Adds detSwitch to the detSwitch vector.
// ---

  fDetSwitchVector.insert(detSwitch);
  fMessenger->SetCandidates();
}  
  
void AliModulesComposition::AddSingleModuleConstruction(G4String moduleName, 
                               G4int version, AliModuleType moduleType)
{
// Adds SingleModuleConstruction.
// ---

  AliSingleModuleConstruction* moduleConstruction
    = new AliSingleModuleConstruction(moduleName, version, moduleType);
  fModuleConstructionVector.insert(moduleConstruction);
}  
		  
void AliModulesComposition::AddMoreModuleConstruction(G4String moduleName, 
                               G4int version, AliModuleType moduleType)
{
// Adds module to MoreModulesConstruction (construction of dependent
// modules.)
// ---

  fMoreModulesConstruction->AddModule(moduleName, version, moduleType);
}  
		  		  
void AliModulesComposition::ConstructModules()
{
// Construct geometry of all modules (both standalone and dependent.)
// ---

  // set common options
  SetReadGeometryToModules(fReadGeometry);
  SetWriteGeometryToModules(fWriteGeometry);
  SetAllLVSensitiveToModules(fAllLVSensitive);
     // common setAllLVSensitive is overridden by Config.in
     // macro
  
  // configure single modules
  G4int nofDets = fModuleConstructionVector.entries();
  G4int i;
  for (i=0; i<nofDets; i++) {
    fModuleConstructionVector[i]->Configure(*AliFiles::Instance());
    cout << "Module " << fModuleConstructionVector[i]->GetDetName() 
         << " configured." << endl;
  }  
  if (fForceAllLVSensitive)
    SetAllLVSensitiveToModules(fForceAllLVSensitive);
      // override the setAllLVSensitive by Config.in macro
      // if required
     
  // configure dependent modules
  G4int nofModules = fMoreModulesConstruction->GetNofModules();
  if (nofModules>0) {
    fMoreModulesConstruction->Configure(*AliFiles::Instance());
    if (fForceAllLVSensitive)
      SetAllLVSensitiveToModules(fForceAllLVSensitive);
        // override the setAllLVSensitive by Config.in macro
        // if required
  }  

  // construct single modules
  for (i=0; i<nofDets; i++) {
    G4cout << "Module " << fModuleConstructionVector[i]->GetDetName()
           << " will be constructed now." << G4endl;
    fModuleConstructionVector[i]->Construct();
  }  
    
  // construct dependent modules
  if (nofModules>0) {
    G4cout << "Dependent modules will be constructed now." << G4endl;
    fMoreModulesConstruction->Construct();
  }  
    
  // fill medium Id vector
  TG4GeometryManager::Instance()->FillMediumIdVector();
        // this step can be done only after the sensitive
        // detectors have been created
}  

AliDetSwitch* AliModulesComposition::GetDetSwitch(const G4String& detName)
{
// Returns the detector switch with given detector name.
// ---

  AliDetSwitch* detSwitch = 0;
  for (G4int id=0; id<fDetSwitchVector.entries(); id++) {  
    detSwitch = fDetSwitchVector[id];
    if (detSwitch->GetDetName() == detName) return detSwitch; 
  }
  
  return detSwitch;  
} 


void AliModulesComposition::SetReadGeometryToModules(G4bool readGeometry)
{
// Sets readGeometry control to all modules.
// ---

  // single module constructions
  G4int nofDets = fModuleConstructionVector.entries();
  G4int i;
  for (i=0; i<nofDets; i++)
    fModuleConstructionVector[i]->SetReadGeometry(readGeometry);

  // more modules construction
  nofDets = fMoreModulesConstruction->GetNofModules();
  for (i=0; i<nofDets; i++) { 
    AliSingleModuleConstruction* moduleConstruction
      = fMoreModulesConstruction->GetModuleConstruction(i);
    moduleConstruction->SetReadGeometry(readGeometry);
  }  
}    
  
void AliModulesComposition::SetWriteGeometryToModules(G4bool writeGeometry)
{
// Sets writeGeometry control to all modules.
// ---

  // single module constructions
  G4int nofDets = fModuleConstructionVector.entries();
  G4int i;
  for (i=0; i<nofDets; i++)
    fModuleConstructionVector[i]->SetWriteGeometry(writeGeometry);

  // more modules construction
  nofDets = fMoreModulesConstruction->GetNofModules();
  for (i=0; i<nofDets; i++) { 
    AliSingleModuleConstruction* moduleConstruction
      = fMoreModulesConstruction->GetModuleConstruction(i);
    moduleConstruction->SetWriteGeometry(writeGeometry);
  }  
}    

void AliModulesComposition::SetAllLVSensitiveToModules(G4bool allSensitive)
{
// Sets setAllSensitive control to all modules.
// ---

  // single module constructions
  G4int nofDets = fModuleConstructionVector.entries();
  G4int i;
  for (i=0; i<nofDets; i++)
    fModuleConstructionVector[i]->SetAllLVSensitive(allSensitive);

  // more modules construction
  nofDets = fMoreModulesConstruction->GetNofModules();
  for (i=0; i<nofDets; i++) { 
    AliSingleModuleConstruction* moduleConstruction
      = fMoreModulesConstruction->GetModuleConstruction(i);
    moduleConstruction->SetAllLVSensitive(allSensitive);
  }  
}    

void AliModulesComposition::SetProcessConfigToModules(G4bool processConfig)
{
// Sets processConfig control to all modules.
// ---

  // single module constructions
  G4int nofDets = fModuleConstructionVector.entries();
  G4int i;
  for (i=0; i<nofDets; i++)
    fModuleConstructionVector[i]->SetProcessConfig(processConfig);
  
  // more modules construction
  nofDets = fMoreModulesConstruction->GetNofModules();
  for (i=0; i<nofDets; i++) { 
    AliSingleModuleConstruction* moduleConstruction
      = fMoreModulesConstruction->GetModuleConstruction(i);
    moduleConstruction->SetProcessConfig(processConfig);
  }    
}    

// public methods

void AliModulesComposition::SwitchDetOn(G4String moduleNameVer)
{ 
// Switchs on module specified by name and version.
// ---

  G4int nofDets = fDetSwitchVector.entries(); 
  if (moduleNameVer == "ALL") {
    for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnDefault(); 
  }
  else if (moduleNameVer == "PPR") {
    for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnPPR(); 
    AliFiles::Instance()->SetMacroName("ConfigPPR");
  }
  else if (moduleNameVer == "NONE") {
    for (G4int id=0; id<nofDets; id++)
      fDetSwitchVector[id]->SwitchOff(); 
  }
  else {
    // get version number
    G4int len = moduleNameVer.length();
    G4String moduleName = moduleNameVer(0, len-1);
    G4String version = moduleNameVer(len-1, 1);
    G4int iVersion = AliGlobals::StringToInt(version);

    if (iVersion < 0) {
      // in case the version number is not provided
      // the default one is set
      SwitchDetOnDefault(moduleNameVer);
    }  
    else 
      SwitchDetOn(moduleName, iVersion);
  }
}

void AliModulesComposition::SwitchDetOn(G4String moduleName, G4int version)
{ 
// Switchs on module specified by name and version.
// ---

  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) {
    G4String iDetName = fDetSwitchVector[id]->GetDetName();
    if (iDetName == moduleName) {
      fDetSwitchVector[id]->SwitchOn(version);
      return;
    }
  }
  AliGlobals::Exception(
    "AliModulesComposition: Wrong detector name for " + moduleName + ".");
}

void AliModulesComposition::SwitchDetOnDefault(G4String moduleName)
{ 
// Switchs on module specified by name with default version.
// ---

  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) {
    G4String iDetName = fDetSwitchVector[id]->GetDetName();
    if (iDetName == moduleName) {
      fDetSwitchVector[id]->SwitchOnDefault();
      return;
    }
  }
  AliGlobals::Exception(
    "AliModulesComposition: Wrong detector name for " + moduleName + ".");
}

void AliModulesComposition::SwitchDetOnPPR(G4String moduleName)
{ 
// Switchs on module specified by name with PPR version.
// ---

  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) {
    G4String iDetName = fDetSwitchVector[id]->GetDetName();
    if (iDetName == moduleName) {
      fDetSwitchVector[id]->SwitchOnPPR();
      return;
    }
  }
  AliGlobals::Exception(
    "AliModulesComposition: Wrong detector name for " + moduleName + ".");
}

void AliModulesComposition::SwitchDetOff(G4String moduleName)
{ 
// Switchs off module specified by name.
// ---

  G4int nofDets = fDetSwitchVector.entries(); 
  if (moduleName == "ALL") {
    for (G4int id=0; id<nofDets; id++)
      fDetSwitchVector[id]->SwitchOff(); 
  }
  else {
    for (G4int id=0; id<nofDets; id++) {
      G4String iDetName = fDetSwitchVector[id]->GetDetName();
      if (iDetName == moduleName) { 
        fDetSwitchVector[id]->SwitchOff();
        return;
      }
    }
  }
  AliGlobals::Exception(
    "AliModulesComposition: Wrong detector name for " + moduleName + ".");
}

void AliModulesComposition::PrintSwitchedDets() const
{ 
// Lists switched detectors.
// ---

  G4String svList = GetSwitchedDetsList();
    
  G4cout << "Switched Alice detectors: " << G4endl;
  G4cout << "--------------------------" << G4endl;
  G4cout << svList << G4endl;
}

void AliModulesComposition::PrintAvailableDets() const
{ 
// Lists available detectors.
// ---

  G4String avList = GetAvailableDetsList();
    
  G4cout << "Available Alice detectors: " << G4endl;
  G4cout << "---------------------------" << G4endl;
  G4cout << avList << G4endl;
}

void AliModulesComposition::PrintMaterials() const
{
// Prints all materials.
// ---

  const G4MaterialTable* matTable = G4Material::GetMaterialTable();
  G4cout << *matTable;
}

void AliModulesComposition::GenerateXMLGeometry() const 
{
// Generates XML geometry file from the top volume.
// The file name is set according the last switched detector
// registered in the det switch vector.
// ---

  G4VPhysicalVolume* world = AliSingleModuleConstruction::GetWorld();

  // XML filename
  // according to last switched detector
  G4String detName;
  G4String detVersion = "";
  G4int version = -1;
  for (G4int i=fDetSwitchVector.entries()-1; i>=0; i--) {
    version = fDetSwitchVector[i]->GetSwitchedVersion();
    if (version > -1) {
      detName = fDetSwitchVector[i]->GetDetName();
      AliGlobals::AppendNumberToString(detVersion,version); 
      break;
    }  
  }  
  G4String filePath 
    = AliFiles::Instance()->GetXMLFilePath(detName, version);
  
  // set top volume name
  G4String topName = world->GetName() + "_comp";
  
  // generate XML
  
  TG4XMLGeometryGenerator xml;
  xml.OpenFile(filePath);

  // generate materials 
  // not yet implemented
  // xml.GenerateMaterials(version, "today", "Generated from G4",
  //                     "v4", world->GetLogicalVolume());

  // generate volumes tree
  xml.GenerateSection(detName, detVersion, "today", "Generated from Geant4",
                      topName, world->GetLogicalVolume());
  xml.CloseFile();
  
  // set verbose
  G4cout << "File " << detName << "v" << version << ".xml has been generated." 
         << G4endl;
}  


G4String AliModulesComposition::GetSwitchedDetsList() const
{ 
// Returns list of switched detectors.
// ---

  G4String svList = "";
  
  G4int nofDets = fDetSwitchVector.entries(); 
  G4int nofSwitchedDets = 0;
  for (G4int id=0; id<nofDets; id++) {
    G4int iVersion = fDetSwitchVector[id]->GetSwitchedVersion();
    if (iVersion > -1) {
      nofSwitchedDets++;
      G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
      AliGlobals::AppendNumberToString(moduleNameVer, iVersion);
      svList += moduleNameVer;
      svList += " "; 
    }
  }

  if (nofSwitchedDets ==  nofDets) svList = "ALL: " + svList;
  if (nofSwitchedDets ==  0)       svList = "NONE";   

  return svList;
}

G4String AliModulesComposition::GetAvailableDetsList() const
{ 
// Returns list of available detectors.
// ---

  G4String svList = "";
  
  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) {
    G4int nofVersions = fDetSwitchVector[id]->GetNofVersions();
    for (G4int iv=0; iv<nofVersions; iv++) {
      G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
      AliGlobals::AppendNumberToString(moduleNameVer, iv);
      svList += moduleNameVer;
      svList += " ";
    }
  }

  return svList;
}

G4String AliModulesComposition::GetAvailableDetsListWithCommas() const
{ 
// Returns list of available detectors with commas.
// ---

  G4String svList = "";
  
  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) {
    G4int nofVersions = fDetSwitchVector[id]->GetNofVersions();
    for (G4int iv=0; iv<nofVersions; iv++) {
      G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
      AliGlobals::AppendNumberToString(moduleNameVer, iv);
      svList += moduleNameVer;
      if (iv<nofVersions-1)    svList += "/";
      else if (id < nofDets-1) svList += ", ";
    }
  }

  return svList;
}

G4String AliModulesComposition::GetDetNamesList() const
{ 
// Returns list of detector names.
// ---

  G4String svList = "";
  
  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) { 
    svList += fDetSwitchVector[id]->GetDetName();
    svList += " ";
  }

  return svList;
}

G4String AliModulesComposition::GetDetNamesListWithCommas() const
{ 
// Returns list of detector names with commas.
// ---

  G4String svList = "";
  
  G4int nofDets = fDetSwitchVector.entries(); 
  for (G4int id=0; id<nofDets; id++) { 
    svList += fDetSwitchVector[id]->GetDetName();
    if (id < nofDets-1) svList += ", ";
  }

  return svList;
}

void AliModulesComposition::SetMagField(G4double fieldValue)
{
// Sets uniform magnetic field to specified value.
// ---

  // create fields if it does not exist
  if (!fMagneticField) fMagneticField = new AliMagneticField();
  
  // set value
  fMagneticField->SetFieldValue(fieldValue);
}
Commit	Line	Data
676fb573	1	// $Id$
	2	// Category: geometry
	3	//
	4	// See the class description in the header file.
	5
	6	#include "AliModulesComposition.h"
	7	#include "AliModulesCompositionMessenger.h"
	8	#include "AliSingleModuleConstruction.h"
	9	#include "AliMoreModulesConstruction.h"
c97337f9	10	#include "AliDetSwitch.h"
676fb573	11	#include "AliMagneticField.h"
676fb573	12	#include "AliGlobals.h"
55ebdd9f	13	#include "AliFiles.h"
676fb573	14
6f0bd611	15	#include "TG4GeometryManager.h"
7b34522f	16	#include "TG4XMLGeometryGenerator.h"
7b34522f	17
7b34522f	18	#include <G4Material.hh>
c97337f9	19	#include <G4VPhysicalVolume.hh>
676fb573	20
	21	AliModulesComposition::AliModulesComposition()
	22	: fAllLVSensitive(false),
6f0bd611	23	fForceAllLVSensitive(true),
676fb573	24	fReadGeometry(false),
9b0f6db2	25	fWriteGeometry(false),
9b0f6db2	26	fMagneticField(0)
676fb573	27	{
	28	//
	29	fMoreModulesConstruction = new AliMoreModulesConstruction();
676fb573	30	fMessenger = new AliModulesCompositionMessenger(this);
	31	}
	32
	33	AliModulesComposition::AliModulesComposition(const AliModulesComposition& right)
	34	{
	35	//
	36	AliGlobals::Exception("AliModulesComposition is protected from copying.");
	37	}
	38
	39	AliModulesComposition::~AliModulesComposition() {
	40	//
	41	delete fMoreModulesConstruction;
	42	delete fMagneticField;
	43	delete fMessenger;
	44
	45	// destroy det switch vector
	46	fDetSwitchVector.clearAndDestroy();
	47
	48	// destroy det construction vector
	49	fModuleConstructionVector.clearAndDestroy();
	50	}
	51
	52	// operators
	53
	54	AliModulesComposition&
	55	AliModulesComposition::operator=(const AliModulesComposition& right)
	56	{
	57	// check assignement to self
	58	if (this == &right) return *this;
	59
	60	AliGlobals::Exception("AliModulesComposition is protected from assigning.");
	61
	62	return *this;
	63	}
	64
	65	// protected methods
	66
	67	void AliModulesComposition::AddDetSwitch(AliDetSwitch* detSwitch)
	68	{
	69	// Adds detSwitch to the detSwitch vector.
	70	// ---
	71
	72	fDetSwitchVector.insert(detSwitch);
	73	fMessenger->SetCandidates();
	74	}
	75
	76	void AliModulesComposition::AddSingleModuleConstruction(G4String moduleName,
	77	G4int version, AliModuleType moduleType)
	78	{
	79	// Adds SingleModuleConstruction.
	80	// ---
	81
	82	AliSingleModuleConstruction* moduleConstruction
	83	= new AliSingleModuleConstruction(moduleName, version, moduleType);
	84	fModuleConstructionVector.insert(moduleConstruction);
	85	}
	86
	87	void AliModulesComposition::AddMoreModuleConstruction(G4String moduleName,
	88	G4int version, AliModuleType moduleType)
	89	{
	90	// Adds module to MoreModulesConstruction (construction of dependent
	91	// modules.)
	92	// ---
	93
94	fMoreModulesConstruction->AddModule(moduleName, version, moduleType);
95	}
96
97	void AliModulesComposition::ConstructModules()
98	{
99	// Construct geometry of all modules (both standalone and dependent.)
100	// ---
101
102	// set common options
103	SetReadGeometryToModules(fReadGeometry);
104	SetWriteGeometryToModules(fWriteGeometry);
105	SetAllLVSensitiveToModules(fAllLVSensitive);
106	// common setAllLVSensitive is overridden by Config.in
107	// macro
108
7fe075c8	109	// configure single modules
676fb573	110	G4int nofDets = fModuleConstructionVector.entries();
a4749644	111	G4int i;
a4749644	112	for (i=0; i<nofDets; i++) {
55ebdd9f	113	fModuleConstructionVector[i]->Configure(*AliFiles::Instance());
7fe075c8	114	cout << "Module " << fModuleConstructionVector[i]->GetDetName()
7fe075c8	115	<< " configured." << endl;
7b34522f	116	}
45ee196a	117	if (fForceAllLVSensitive)
	118	SetAllLVSensitiveToModules(fForceAllLVSensitive);
	119	// override the setAllLVSensitive by Config.in macro
	120	// if required
	121
7fe075c8	122	// configure dependent modules
676fb573	123	G4int nofModules = fMoreModulesConstruction->GetNofModules();
676fb573	124	if (nofModules>0) {
55ebdd9f	125	fMoreModulesConstruction->Configure(*AliFiles::Instance());
45ee196a	126	if (fForceAllLVSensitive)
	127	SetAllLVSensitiveToModules(fForceAllLVSensitive);
	128	// override the setAllLVSensitive by Config.in macro
	129	// if required
7fe075c8	130	}
45ee196a	131
7fe075c8	132	// construct single modules
	133	for (i=0; i<nofDets; i++) {
	134	G4cout << "Module " << fModuleConstructionVector[i]->GetDetName()
	135	<< " will be constructed now." << G4endl;
	136	fModuleConstructionVector[i]->Construct();
	137	}
	138
	139	// construct dependent modules
	140	if (nofModules>0) {
ba6f5bec	141	G4cout << "Dependent modules will be constructed now." << G4endl;
676fb573	142	fMoreModulesConstruction->Construct();
676fb573	143	}
6f0bd611	144
	145	// fill medium Id vector
	146	TG4GeometryManager::Instance()->FillMediumIdVector();
	147	// this step can be done only after the sensitive
	148	// detectors have been created
676fb573	149	}
676fb573	150
7fe075c8	151	AliDetSwitch* AliModulesComposition::GetDetSwitch(const G4String& detName)
	152	{
	153	// Returns the detector switch with given detector name.
	154	// ---
	155
	156	AliDetSwitch* detSwitch = 0;
	157	for (G4int id=0; id<fDetSwitchVector.entries(); id++) {
	158	detSwitch = fDetSwitchVector[id];
	159	if (detSwitch->GetDetName() == detName) return detSwitch;
	160	}
	161
	162	return detSwitch;
	163	}
	164
	165
676fb573	166	void AliModulesComposition::SetReadGeometryToModules(G4bool readGeometry)
	167	{
	168	// Sets readGeometry control to all modules.
	169	// ---
	170
	171	// single module constructions
	172	G4int nofDets = fModuleConstructionVector.entries();
	173	G4int i;
	174	for (i=0; i<nofDets; i++)
	175	fModuleConstructionVector[i]->SetReadGeometry(readGeometry);
	176
	177	// more modules construction
	178	nofDets = fMoreModulesConstruction->GetNofModules();
	179	for (i=0; i<nofDets; i++) {
	180	AliSingleModuleConstruction* moduleConstruction
	181	= fMoreModulesConstruction->GetModuleConstruction(i);
	182	moduleConstruction->SetReadGeometry(readGeometry);
	183	}
	184	}
	185
	186	void AliModulesComposition::SetWriteGeometryToModules(G4bool writeGeometry)
	187	{
	188	// Sets writeGeometry control to all modules.
	189	// ---
	190
	191	// single module constructions
	192	G4int nofDets = fModuleConstructionVector.entries();
	193	G4int i;
	194	for (i=0; i<nofDets; i++)
	195	fModuleConstructionVector[i]->SetWriteGeometry(writeGeometry);
	196
	197	// more modules construction
	198	nofDets = fMoreModulesConstruction->GetNofModules();
	199	for (i=0; i<nofDets; i++) {
	200	AliSingleModuleConstruction* moduleConstruction
	201	= fMoreModulesConstruction->GetModuleConstruction(i);
	202	moduleConstruction->SetWriteGeometry(writeGeometry);
	203	}
	204	}
	205
	206	void AliModulesComposition::SetAllLVSensitiveToModules(G4bool allSensitive)
	207	{
	208	// Sets setAllSensitive control to all modules.
	209	// ---
	210
	211	// single module constructions
	212	G4int nofDets = fModuleConstructionVector.entries();
	213	G4int i;
ba6f5bec	214	for (i=0; i<nofDets; i++)
ba6f5bec	215	fModuleConstructionVector[i]->SetAllLVSensitive(allSensitive);
676fb573	216
	217	// more modules construction
	218	nofDets = fMoreModulesConstruction->GetNofModules();
	219	for (i=0; i<nofDets; i++) {
	220	AliSingleModuleConstruction* moduleConstruction
	221	= fMoreModulesConstruction->GetModuleConstruction(i);
	222	moduleConstruction->SetAllLVSensitive(allSensitive);
	223	}
	224	}
	225
	226	void AliModulesComposition::SetProcessConfigToModules(G4bool processConfig)
	227	{
	228	// Sets processConfig control to all modules.
	229	// ---
	230
	231	// single module constructions
	232	G4int nofDets = fModuleConstructionVector.entries();
	233	G4int i;
ba6f5bec	234	for (i=0; i<nofDets; i++)
ba6f5bec	235	fModuleConstructionVector[i]->SetProcessConfig(processConfig);
676fb573	236
	237	// more modules construction
	238	nofDets = fMoreModulesConstruction->GetNofModules();
	239	for (i=0; i<nofDets; i++) {
	240	AliSingleModuleConstruction* moduleConstruction
	241	= fMoreModulesConstruction->GetModuleConstruction(i);
	242	moduleConstruction->SetProcessConfig(processConfig);
	243	}
	244	}
	245
	246	// public methods
	247
	248	void AliModulesComposition::SwitchDetOn(G4String moduleNameVer)
	249	{
	250	// Switchs on module specified by name and version.
	251	// ---
	252
	253	G4int nofDets = fDetSwitchVector.entries();
	254	if (moduleNameVer == "ALL") {
55ebdd9f	255	for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnDefault();
	256	}
	257	else if (moduleNameVer == "PPR") {
	258	for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnPPR();
	259	AliFiles::Instance()->SetMacroName("ConfigPPR");
676fb573	260	}
	261	else if (moduleNameVer == "NONE") {
	262	for (G4int id=0; id<nofDets; id++)
	263	fDetSwitchVector[id]->SwitchOff();
	264	}
	265	else {
	266	// get version number
	267	G4int len = moduleNameVer.length();
	268	G4String moduleName = moduleNameVer(0, len-1);
	269	G4String version = moduleNameVer(len-1, 1);
	270	G4int iVersion = AliGlobals::StringToInt(version);
	271
	272	if (iVersion < 0) {
	273	// in case the version number is not provided
	274	// the default one is set
	275	SwitchDetOnDefault(moduleNameVer);
	276	}
	277	else
	278	SwitchDetOn(moduleName, iVersion);
	279	}
	280	}
	281
	282	void AliModulesComposition::SwitchDetOn(G4String moduleName, G4int version)
	283	{
	284	// Switchs on module specified by name and version.
	285	// ---
	286
	287	G4int nofDets = fDetSwitchVector.entries();
	288	for (G4int id=0; id<nofDets; id++) {
	289	G4String iDetName = fDetSwitchVector[id]->GetDetName();
	290	if (iDetName == moduleName) {
	291	fDetSwitchVector[id]->SwitchOn(version);
	292	return;
	293	}
	294	}
	295	AliGlobals::Exception(
	296	"AliModulesComposition: Wrong detector name for " + moduleName + ".");
	297	}
	298
	299	void AliModulesComposition::SwitchDetOnDefault(G4String moduleName)
	300	{
	301	// Switchs on module specified by name with default version.
	302	// ---
	303
	304	G4int nofDets = fDetSwitchVector.entries();
	305	for (G4int id=0; id<nofDets; id++) {
	306	G4String iDetName = fDetSwitchVector[id]->GetDetName();
	307	if (iDetName == moduleName) {
	308	fDetSwitchVector[id]->SwitchOnDefault();
	309	return;
	310	}
	311	}
	312	AliGlobals::Exception(
	313	"AliModulesComposition: Wrong detector name for " + moduleName + ".");
	314	}
	315
55ebdd9f	316	void AliModulesComposition::SwitchDetOnPPR(G4String moduleName)
	317	{
	318	// Switchs on module specified by name with PPR version.
	319	// ---
	320
	321	G4int nofDets = fDetSwitchVector.entries();
	322	for (G4int id=0; id<nofDets; id++) {
	323	G4String iDetName = fDetSwitchVector[id]->GetDetName();
	324	if (iDetName == moduleName) {
	325	fDetSwitchVector[id]->SwitchOnPPR();
	326	return;
	327	}
	328	}
	329	AliGlobals::Exception(
	330	"AliModulesComposition: Wrong detector name for " + moduleName + ".");
	331	}
	332
676fb573	333	void AliModulesComposition::SwitchDetOff(G4String moduleName)
	334	{
	335	// Switchs off module specified by name.
	336	// ---
	337
	338	G4int nofDets = fDetSwitchVector.entries();
	339	if (moduleName == "ALL") {
	340	for (G4int id=0; id<nofDets; id++)
	341	fDetSwitchVector[id]->SwitchOff();
	342	}
	343	else {
	344	for (G4int id=0; id<nofDets; id++) {
	345	G4String iDetName = fDetSwitchVector[id]->GetDetName();
	346	if (iDetName == moduleName) {
	347	fDetSwitchVector[id]->SwitchOff();
	348	return;
	349	}
	350	}
	351	}
	352	AliGlobals::Exception(
	353	"AliModulesComposition: Wrong detector name for " + moduleName + ".");
	354	}
	355
	356	void AliModulesComposition::PrintSwitchedDets() const
	357	{
	358	// Lists switched detectors.
	359	// ---
	360
	361	G4String svList = GetSwitchedDetsList();
	362
ba6f5bec	363	G4cout << "Switched Alice detectors: " << G4endl;
	364	G4cout << "--------------------------" << G4endl;
	365	G4cout << svList << G4endl;
676fb573	366	}
	367
	368	void AliModulesComposition::PrintAvailableDets() const
	369	{
	370	// Lists available detectors.
	371	// ---
	372
	373	G4String avList = GetAvailableDetsList();
	374
ba6f5bec	375	G4cout << "Available Alice detectors: " << G4endl;
	376	G4cout << "---------------------------" << G4endl;
	377	G4cout << avList << G4endl;
676fb573	378	}
676fb573	379
7b34522f	380	void AliModulesComposition::PrintMaterials() const
	381	{
	382	// Prints all materials.
	383	// ---
	384
	385	const G4MaterialTable* matTable = G4Material::GetMaterialTable();
	386	G4cout << *matTable;
	387	}
	388
	389	void AliModulesComposition::GenerateXMLGeometry() const
	390	{
	391	// Generates XML geometry file from the top volume.
	392	// The file name is set according the last switched detector
	393	// registered in the det switch vector.
	394	// ---
	395
	396	G4VPhysicalVolume* world = AliSingleModuleConstruction::GetWorld();
	397
55ebdd9f	398	// XML filename
55ebdd9f	399	// according to last switched detector
7b34522f	400	G4String detName;
7fe075c8	401	G4String detVersion = "";
09744020	402	G4int version = -1;
7b34522f	403	for (G4int i=fDetSwitchVector.entries()-1; i>=0; i--) {
55ebdd9f	404	version = fDetSwitchVector[i]->GetSwitchedVersion();
55ebdd9f	405	if (version > -1) {
7b34522f	406	detName = fDetSwitchVector[i]->GetDetName();
7fe075c8	407	AliGlobals::AppendNumberToString(detVersion,version);
7b34522f	408	break;
	409	}
	410	}
55ebdd9f	411	G4String filePath
55ebdd9f	412	= AliFiles::Instance()->GetXMLFilePath(detName, version);
7b34522f	413
	414	// set top volume name
	415	G4String topName = world->GetName() + "_comp";
	416
	417	// generate XML
	418
	419	TG4XMLGeometryGenerator xml;
	420	xml.OpenFile(filePath);
	421
	422	// generate materials
	423	// not yet implemented
	424	// xml.GenerateMaterials(version, "today", "Generated from G4",
	425	// "v4", world->GetLogicalVolume());
	426
	427	// generate volumes tree
7fe075c8	428	xml.GenerateSection(detName, detVersion, "today", "Generated from Geant4",
7b34522f	429	topName, world->GetLogicalVolume());
	430	xml.CloseFile();
	431
	432	// set verbose
55ebdd9f	433	G4cout << "File " << detName << "v" << version << ".xml has been generated."
7b34522f	434	<< G4endl;
	435	}
	436
	437
676fb573	438	G4String AliModulesComposition::GetSwitchedDetsList() const
	439	{
	440	// Returns list of switched detectors.
	441	// ---
	442
	443	G4String svList = "";
	444
	445	G4int nofDets = fDetSwitchVector.entries();
	446	G4int nofSwitchedDets = 0;
	447	for (G4int id=0; id<nofDets; id++) {
	448	G4int iVersion = fDetSwitchVector[id]->GetSwitchedVersion();
	449	if (iVersion > -1) {
	450	nofSwitchedDets++;
	451	G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
	452	AliGlobals::AppendNumberToString(moduleNameVer, iVersion);
	453	svList += moduleNameVer;
	454	svList += " ";
	455	}
	456	}
	457
	458	if (nofSwitchedDets == nofDets) svList = "ALL: " + svList;
	459	if (nofSwitchedDets == 0) svList = "NONE";
	460
	461	return svList;
	462	}
	463
676fb573	464	G4String AliModulesComposition::GetAvailableDetsList() const
	465	{
	466	// Returns list of available detectors.
	467	// ---
	468
	469	G4String svList = "";
	470
	471	G4int nofDets = fDetSwitchVector.entries();
	472	for (G4int id=0; id<nofDets; id++) {
	473	G4int nofVersions = fDetSwitchVector[id]->GetNofVersions();
	474	for (G4int iv=0; iv<nofVersions; iv++) {
	475	G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
	476	AliGlobals::AppendNumberToString(moduleNameVer, iv);
	477	svList += moduleNameVer;
	478	svList += " ";
	479	}
	480	}
	481
	482	return svList;
	483	}
	484
	485	G4String AliModulesComposition::GetAvailableDetsListWithCommas() const
	486	{
	487	// Returns list of available detectors with commas.
	488	// ---
	489
	490	G4String svList = "";
	491
	492	G4int nofDets = fDetSwitchVector.entries();
	493	for (G4int id=0; id<nofDets; id++) {
	494	G4int nofVersions = fDetSwitchVector[id]->GetNofVersions();
	495	for (G4int iv=0; iv<nofVersions; iv++) {
	496	G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
	497	AliGlobals::AppendNumberToString(moduleNameVer, iv);
	498	svList += moduleNameVer;
	499	if (iv<nofVersions-1) svList += "/";
	500	else if (id < nofDets-1) svList += ", ";
	501	}
	502	}
	503
	504	return svList;
	505	}
	506
	507	G4String AliModulesComposition::GetDetNamesList() const
	508	{
	509	// Returns list of detector names.
	510	// ---
	511
	512	G4String svList = "";
	513
	514	G4int nofDets = fDetSwitchVector.entries();
	515	for (G4int id=0; id<nofDets; id++) {
	516	svList += fDetSwitchVector[id]->GetDetName();
	517	svList += " ";
	518	}
	519
	520	return svList;
	521	}
	522
	523	G4String AliModulesComposition::GetDetNamesListWithCommas() const
	524	{
	525	// Returns list of detector names with commas.
	526	// ---
	527
528	G4String svList = "";
529
530	G4int nofDets = fDetSwitchVector.entries();
531	for (G4int id=0; id<nofDets; id++) {
532	svList += fDetSwitchVector[id]->GetDetName();
533	if (id < nofDets-1) svList += ", ";
534	}
535
536	return svList;
537	}
538
539	void AliModulesComposition::SetMagField(G4double fieldValue)
540	{
541	// Sets uniform magnetic field to specified value.
542	// ---
9b0f6db2	543
	544	// create fields if it does not exist
	545	if (!fMagneticField) fMagneticField = new AliMagneticField();
	546
	547	// set value
	548	fMagneticField->SetFieldValue(fieldValue);
676fb573	549	}
676fb573	550