// $Id$
// Category: visualization
//
+// Author: I. Hrivnacova
+//
+// Class AliColourStore
+// --------------------
// See the class description in the header file.
#include "AliColourStore.h"
//_____________________________________________________________________________
AliColourStore::AliColourStore() {
//
- fColours.insert(AliColour("White", 1.0, 1.0, 1.0));
- fColours.insert(AliColour("Black", 0.0, 0.0, 0.0));
- fColours.insert(AliColour("Red", 1.0, 0.0, 0.0));
- fColours.insert(AliColour("RoseDark", 1.0, 0.0, 0.5));
- fColours.insert(AliColour("Green", 0.0, 1.0, 0.0));
- fColours.insert(AliColour("Green2", 0.0, 1.0, 0.5));
- fColours.insert(AliColour("GreenClair",0.5, 1.0, 0.0));
- fColours.insert(AliColour("Yellow", 1.0, 1.0, 0.0));
- fColours.insert(AliColour("BlueDark", 0.0, 0.0, 1.0));
- fColours.insert(AliColour("BlueClair", 0.0, 1.0, 1.0));
- fColours.insert(AliColour("BlueClair2",0.0, 0.5, 1.0));
- fColours.insert(AliColour("Magenta", 1.0, 0.0, 1.0));
- fColours.insert(AliColour("Magenta2", 0.5, 0.0, 1.0));
- fColours.insert(AliColour("BrownClair",1.0, 0.5, 0.0));
- fColours.insert(AliColour("Gray", 0.3, 0.3, 0.3));
- fColours.insert(AliColour("GrayClair", 0.6, 0.6, 0.6));
+ fColours.push_back(AliColour("White", 1.0, 1.0, 1.0));
+ fColours.push_back(AliColour("Black", 0.0, 0.0, 0.0));
+ fColours.push_back(AliColour("Red", 1.0, 0.0, 0.0));
+ fColours.push_back(AliColour("RoseDark", 1.0, 0.0, 0.5));
+ fColours.push_back(AliColour("Green", 0.0, 1.0, 0.0));
+ fColours.push_back(AliColour("Green2", 0.0, 1.0, 0.5));
+ fColours.push_back(AliColour("GreenClair",0.5, 1.0, 0.0));
+ fColours.push_back(AliColour("Yellow", 1.0, 1.0, 0.0));
+ fColours.push_back(AliColour("BlueDark", 0.0, 0.0, 1.0));
+ fColours.push_back(AliColour("BlueClair", 0.0, 1.0, 1.0));
+ fColours.push_back(AliColour("BlueClair2",0.0, 0.5, 1.0));
+ fColours.push_back(AliColour("Magenta", 1.0, 0.0, 1.0));
+ fColours.push_back(AliColour("Magenta2", 0.5, 0.0, 1.0));
+ fColours.push_back(AliColour("BrownClair",1.0, 0.5, 0.0));
+ fColours.push_back(AliColour("Gray", 0.3, 0.3, 0.3));
+ fColours.push_back(AliColour("GrayClair", 0.6, 0.6, 0.6));
}
//_____________________________________________________________________________
// Creates the instance if it does not exist.
// ---
- if (fgInstance == 0 ) {
+ if (fgInstance == 0 )
fgInstance = new AliColourStore();
- }
return fgInstance;
}
// Retrieves the colour by name.
// ---
- G4int nofCol = fColours.entries();
- for (G4int i=0; i<nofCol; i++)
- {
- AliColour alColour = fColours[i];
- if (name == alColour.GetName())
- { return alColour.GetColour(); }
- }
+ ColourConstIterator it;
+ for (it = fColours.begin(); it != fColours.end(); it++)
+ if (name == (*it).GetName()) return (*it).GetColour();
G4String text = "Colour " + name + " is not defined.";
AliGlobals::Exception(text);
// ---
G4String list = "";
- G4int nofCol = fColours.entries();
- for (G4int i=0; i<nofCol; i++)
- {
- list += fColours[i].GetName();
+ ColourConstIterator it;
+
+ for (it = fColours.begin(); it != fColours.end(); it++) {
+ list += (*it).GetName();
list += " ";
- };
+ }
+
return list;
}
// ---
G4String list = "";
- G4int nofCol = fColours.entries();
- for (G4int i=0; i<nofCol; i++)
- {
- list += fColours[i].GetName();
- if (i < nofCol-1) list += ", ";
- };
+ G4int i = 0;
+ ColourConstIterator it;
+
+ for (it = fColours.begin(); it != fColours.end(); it++) {
+ list += (*it).GetName();
+ if (i++ < fColours.size()-1) list += ", ";
+ }
+
return list;
}
// $Id$
// Category: geometry
//
+// Author: I. Hrivnacova
+//
+// Class AliModulesComposition
+// ---------------------------
// See the class description in the header file.
#include "AliModulesComposition.h"
-#include "AliModulesCompositionMessenger.h"
#include "AliSingleModuleConstruction.h"
#include "AliMoreModulesConstruction.h"
#include "AliDetSwitch.h"
AliModulesComposition::AliModulesComposition()
: fReadGeometry(false),
fWriteGeometry(false),
- fMagneticField(0)
+ fMagneticField(0),
+ fMessenger(this)
{
//
fMoreModulesConstruction = new AliMoreModulesConstruction();
- fMessenger = new AliModulesCompositionMessenger(this);
}
//_____________________________________________________________________________
AliModulesComposition::AliModulesComposition(const AliModulesComposition& right)
+ : fMessenger(this)
{
//
AliGlobals::Exception("AliModulesComposition is protected from copying.");
//
delete fMoreModulesConstruction;
delete fMagneticField;
- delete fMessenger;
// destroy det switch vector
- fDetSwitchVector.clearAndDestroy();
+ DetSwitchIterator it;
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ delete *it;
// destroy det construction vector
- fModuleConstructionVector.clearAndDestroy();
+ SingleModuleIterator itm;
+ for (itm = fModuleConstructionVector.begin();
+ itm != fModuleConstructionVector.end(); it++)
+ delete *itm;
}
// operators
// Adds detSwitch to the detSwitch vector.
// ---
- fDetSwitchVector.insert(detSwitch);
- fMessenger->SetCandidates();
+ fDetSwitchVector.push_back(detSwitch);
+ fMessenger.SetCandidates();
}
//_____________________________________________________________________________
-void AliModulesComposition::AddSingleModuleConstruction(G4String moduleName,
- G4int version, AliModuleType moduleType)
+void AliModulesComposition::AddSingleModuleConstruction(
+ const G4String& name, G4int version,
+ AliModuleType moduleType)
{
// Adds SingleModuleConstruction.
// ---
- AliSingleModuleConstruction* moduleConstruction
- = new AliSingleModuleConstruction(moduleName, version, moduleType);
- fModuleConstructionVector.insert(moduleConstruction);
+ fModuleConstructionVector
+ .push_back(new AliSingleModuleConstruction(name, version, moduleType));
}
//_____________________________________________________________________________
-void AliModulesComposition::AddMoreModuleConstruction(G4String moduleName,
- G4int version, AliModuleType moduleType)
+void AliModulesComposition::AddMoreModuleConstruction(
+ const G4String& name, G4int version,
+ AliModuleType moduleType)
{
// Adds module to MoreModulesConstruction (construction of dependent
// modules.)
// ---
- fMoreModulesConstruction->AddModule(moduleName, version, moduleType);
+ fMoreModulesConstruction->AddModule(name, version, moduleType);
}
//_____________________________________________________________________________
SetWriteGeometryToModules(fWriteGeometry);
// 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;
+ SingleModuleIterator it;
+ for (it = fModuleConstructionVector.begin();
+ it != fModuleConstructionVector.end(); it++) {
+
+ (*it)->Configure(*AliFiles::Instance());
+ cout << "Module " << (*it)->GetDetName() << " configured." << endl;
}
// configure dependent modules
- G4int nofModules = fMoreModulesConstruction->GetNofModules();
- if (nofModules>0) {
+ if (fMoreModulesConstruction->GetNofModules() > 0)
fMoreModulesConstruction->Configure(*AliFiles::Instance());
- }
// construct single modules
- for (i=0; i<nofDets; i++) {
- G4cout << "Module " << fModuleConstructionVector[i]->GetDetName()
+ for (it = fModuleConstructionVector.begin();
+ it != fModuleConstructionVector.end(); it++) {
+
+ G4cout << "Module " << (*it)->GetDetName()
<< " will be constructed now." << G4endl;
- fModuleConstructionVector[i]->Construct();
+ (*it)->Construct();
}
// construct dependent modules
- if (nofModules>0) {
+ if (fMoreModulesConstruction->GetNofModules() > 0) {
G4cout << "Dependent modules will be constructed now." << G4endl;
fMoreModulesConstruction->Construct();
}
}
//_____________________________________________________________________________
-AliDetSwitch* AliModulesComposition::GetDetSwitch(const G4String& detName)
+AliDetSwitch* AliModulesComposition::GetDetSwitch(const G4String& moduleName)
{
// 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;
+ DetSwitchIterator it;
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ if ((*it)->GetDetName() == moduleName) return *it;
+
+ G4String text = "AliModulesComposition::GetDetSwitch:\n";
+ text = text + "Wrong detector name for " + moduleName;
+ AliGlobals::Exception(text);
+ return 0;
}
//_____________________________________________________________________________
// ---
// single module constructions
- G4int nofDets = fModuleConstructionVector.entries();
- G4int i;
- for (i=0; i<nofDets; i++)
- fModuleConstructionVector[i]->SetReadGeometry(readGeometry);
+ SingleModuleIterator it;
+ for (it = fModuleConstructionVector.begin();
+ it != fModuleConstructionVector.end(); it++)
+ (*it)->SetReadGeometry(readGeometry);
// more modules construction
- nofDets = fMoreModulesConstruction->GetNofModules();
- for (i=0; i<nofDets; i++) {
- AliSingleModuleConstruction* moduleConstruction
- = fMoreModulesConstruction->GetModuleConstruction(i);
- moduleConstruction->SetReadGeometry(readGeometry);
- }
+ for (G4int i=0; i<fMoreModulesConstruction->GetNofModules(); i++)
+ fMoreModulesConstruction
+ ->GetModuleConstruction(i)->SetReadGeometry(readGeometry);
}
//_____________________________________________________________________________
// ---
// single module constructions
- G4int nofDets = fModuleConstructionVector.entries();
- G4int i;
- for (i=0; i<nofDets; i++)
- fModuleConstructionVector[i]->SetWriteGeometry(writeGeometry);
+ SingleModuleIterator it;
+ for (it = fModuleConstructionVector.begin();
+ it != fModuleConstructionVector.end(); it++)
+ (*it)->SetWriteGeometry(writeGeometry);
// more modules construction
- nofDets = fMoreModulesConstruction->GetNofModules();
- for (i=0; i<nofDets; i++) {
- AliSingleModuleConstruction* moduleConstruction
- = fMoreModulesConstruction->GetModuleConstruction(i);
- moduleConstruction->SetWriteGeometry(writeGeometry);
- }
+ for (G4int i=0; i<fMoreModulesConstruction->GetNofModules(); i++)
+ fMoreModulesConstruction
+ ->GetModuleConstruction(i)->SetWriteGeometry(writeGeometry);
}
//_____________________________________________________________________________
// ---
// single module constructions
- G4int nofDets = fModuleConstructionVector.entries();
- G4int i;
- for (i=0; i<nofDets; i++)
- fModuleConstructionVector[i]->SetProcessConfig(processConfig);
+ SingleModuleIterator it;
+ for (it = fModuleConstructionVector.begin();
+ it != fModuleConstructionVector.end(); it++)
+ (*it)->SetProcessConfig(processConfig);
// more modules construction
- nofDets = fMoreModulesConstruction->GetNofModules();
- for (i=0; i<nofDets; i++) {
- AliSingleModuleConstruction* moduleConstruction
- = fMoreModulesConstruction->GetModuleConstruction(i);
- moduleConstruction->SetProcessConfig(processConfig);
- }
+ for (G4int i=0; i<fMoreModulesConstruction->GetNofModules(); i++)
+ fMoreModulesConstruction
+ ->GetModuleConstruction(i)->SetProcessConfig(processConfig);
}
// public methods
//_____________________________________________________________________________
-void AliModulesComposition::SwitchDetOn(G4String moduleNameVer)
+void AliModulesComposition::SwitchDetOn(const G4String& moduleNameVer)
{
// Switchs on module specified by name and version.
// ---
- G4int nofDets = fDetSwitchVector.entries();
+ DetSwitchIterator it;
+
if (moduleNameVer == "ALL") {
- for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnDefault();
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ (*it)->SwitchOnDefault();
}
else if (moduleNameVer == "PPR") {
- for (G4int id=0; id<nofDets; id++) fDetSwitchVector[id]->SwitchOnPPR();
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ (*it)->SwitchOnPPR();
AliFiles::Instance()->SetMacroName("ConfigPPR");
}
else if (moduleNameVer == "NONE") {
- for (G4int id=0; id<nofDets; id++)
- fDetSwitchVector[id]->SwitchOff();
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ (*it)->SwitchOff();
}
else {
// get version number
G4int len = moduleNameVer.length();
- G4String moduleName = moduleNameVer(0, len-1);
- G4String version = moduleNameVer(len-1, 1);
+ G4String moduleName = moduleNameVer.substr(0, len-1);
+ G4String version = moduleNameVer.substr(len-1, 1);
G4int iVersion = AliGlobals::StringToInt(version);
if (iVersion < 0) {
}
//_____________________________________________________________________________
-void AliModulesComposition::SwitchDetOn(G4String moduleName, G4int version)
+void AliModulesComposition::SwitchDetOn(const 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 + ".");
+ GetDetSwitch(moduleName)->SwitchOn(version);
}
//_____________________________________________________________________________
-void AliModulesComposition::SwitchDetOnDefault(G4String moduleName)
+void AliModulesComposition::SwitchDetOnDefault(const 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 + ".");
+ GetDetSwitch(moduleName)->SwitchOnDefault();
}
//_____________________________________________________________________________
-void AliModulesComposition::SwitchDetOnPPR(G4String moduleName)
+void AliModulesComposition::SwitchDetOnPPR(const 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 + ".");
+ GetDetSwitch(moduleName)->SwitchOnPPR();
}
//_____________________________________________________________________________
-void AliModulesComposition::SwitchDetOff(G4String moduleName)
+void AliModulesComposition::SwitchDetOff(const 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;
- }
- }
+ DetSwitchIterator it;
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ (*it)->SwitchOff();
}
- AliGlobals::Exception(
- "AliModulesComposition: Wrong detector name for " + moduleName + ".");
+ else
+ GetDetSwitch(moduleName)->SwitchOff();
}
//_____________________________________________________________________________
G4String detName;
G4String detVersion = "";
G4int version = -1;
- for (G4int i=fDetSwitchVector.entries()-1; i>=0; i--) {
+ for (G4int i=fDetSwitchVector.size()-1; i>=0; i--) {
version = fDetSwitchVector[i]->GetSwitchedVersion();
if (version > -1) {
detName = fDetSwitchVector[i]->GetDetName();
// Returns list of switched detectors.
// ---
- G4String svList = "";
-
- G4int nofDets = fDetSwitchVector.entries();
+ G4String svList = "";
G4int nofSwitchedDets = 0;
- for (G4int id=0; id<nofDets; id++) {
- G4int iVersion = fDetSwitchVector[id]->GetSwitchedVersion();
+ DetSwitchConstIterator it;
+
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++) {
+ G4int iVersion = (*it)->GetSwitchedVersion();
if (iVersion > -1) {
nofSwitchedDets++;
- G4String moduleNameVer = fDetSwitchVector[id]->GetDetName();
+ G4String moduleNameVer = (*it)->GetDetName();
AliGlobals::AppendNumberToString(moduleNameVer, iVersion);
svList += moduleNameVer;
svList += " ";
}
}
- if (nofSwitchedDets == nofDets) svList = "ALL: " + svList;
- if (nofSwitchedDets == 0) svList = "NONE";
+ if (nofSwitchedDets == fDetSwitchVector.size()) svList = "ALL: " + svList;
+ if (nofSwitchedDets == 0) svList = "NONE";
return svList;
}
// ---
G4String svList = "";
+ DetSwitchConstIterator it;
- 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();
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ for (G4int iv=0; iv<(*it)->GetNofVersions(); iv++) {
+ G4String moduleNameVer = (*it)->GetDetName();
AliGlobals::AppendNumberToString(moduleNameVer, iv);
svList += moduleNameVer;
svList += " ";
- }
- }
+ }
return svList;
}
// ---
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();
+ G4int id =0;
+ DetSwitchConstIterator it;
+
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++)
+ for (G4int iv=0; iv<(*it)->GetNofVersions(); iv++) {
+ G4String moduleNameVer = (*it)->GetDetName();
AliGlobals::AppendNumberToString(moduleNameVer, iv);
svList += moduleNameVer;
- if (iv<nofVersions-1) svList += "/";
- else if (id < nofDets-1) svList += ", ";
+ if (iv < (*it)->GetNofVersions()-1) svList += "/";
+ else if (id++ < fDetSwitchVector.size()-1) svList += ", ";
}
- }
return svList;
}
// ---
G4String svList = "";
+ DetSwitchConstIterator it;
- G4int nofDets = fDetSwitchVector.entries();
- for (G4int id=0; id<nofDets; id++) {
- svList += fDetSwitchVector[id]->GetDetName();
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++) {
+ svList += (*it)->GetDetName();
svList += " ";
}
// ---
G4String svList = "";
-
- G4int nofDets = fDetSwitchVector.entries();
- for (G4int id=0; id<nofDets; id++) {
- svList += fDetSwitchVector[id]->GetDetName();
- if (id < nofDets-1) svList += ", ";
+ G4int id =0;
+ DetSwitchConstIterator it;
+
+ for (it = fDetSwitchVector.begin(); it != fDetSwitchVector.end(); it++) {
+ svList += (*it)->GetDetName();
+ if (id++ < fDetSwitchVector.size()-1) svList += ", ";
}
return svList;
// $Id$
// Category: geometry
//
+// Author: I. Hrivnacova
+//
+// Class AliModulesComposition
+// ---------------------------
// Detector construction base class for building geometry
// composed from independent modules with availability of interactive modules
// setup.
#ifndef ALI_MODULES_COMPOSITION_H
#define ALI_MODULES_COMPOSITION_H
+#include "AliModulesCompositionMessenger.h"
#include "AliModuleType.h"
#include <G4VUserDetectorConstruction.hh>
#include <globals.hh>
-
-#include <g4rw/tpordvec.h>
+#include <g4std/vector>
class AliSingleModuleConstruction;
class AliDetSwitch;
-class AliModulesCompositionMessenger;
class AliMoreModulesConstruction;
class AliMagneticField;
class AliModulesComposition : public G4VUserDetectorConstruction
{
- typedef G4RWTPtrOrderedVector<AliDetSwitch> AliDetSwitchRWVector;
- typedef G4RWTPtrOrderedVector<AliSingleModuleConstruction>
- AliSingleModuleConstructionRWVector;
+ typedef G4std::vector<AliDetSwitch*> DetSwitchVector;
+ typedef DetSwitchVector::iterator DetSwitchIterator;
+ typedef DetSwitchVector::const_iterator DetSwitchConstIterator;
+
+ typedef G4std::vector<AliSingleModuleConstruction*> SingleModuleVector;
+ typedef SingleModuleVector::iterator SingleModuleIterator;
public:
AliModulesComposition();
// methods
virtual G4VPhysicalVolume* Construct() = 0;
- void SwitchDetOn(G4String moduleNameVer);
- void SwitchDetOn(G4String moduleName, G4int version);
- void SwitchDetOnDefault(G4String moduleName);
- void SwitchDetOnPPR(G4String moduleName);
- void SwitchDetOff(G4String moduleName);
+ void SwitchDetOn(const G4String& moduleNameVer);
+ void SwitchDetOn(const G4String& moduleName, G4int version);
+ void SwitchDetOnDefault(const G4String& moduleName);
+ void SwitchDetOnPPR(const G4String& moduleName);
+ void SwitchDetOff(const G4String& moduleName);
void PrintSwitchedDets() const;
void PrintAvailableDets() const;
void PrintMaterials() const;
// methods
void AddDetSwitch(AliDetSwitch* detSwitch);
- void AddSingleModuleConstruction(G4String moduleName, G4int version,
+ void AddSingleModuleConstruction(const G4String& name, G4int version,
AliModuleType moduleType = kDetector);
- void AddMoreModuleConstruction(G4String moduleName, G4int version,
+ void AddMoreModuleConstruction(const G4String& name, G4int version,
AliModuleType moduleType = kDetector);
void ConstructModules();
// get methods
- AliDetSwitch* GetDetSwitch(const G4String& detName);
+ AliDetSwitch* GetDetSwitch(const G4String& moduleName);
// data members
- AliDetSwitchRWVector fDetSwitchVector; //vector of AliDetSwitch
+ DetSwitchVector fDetSwitchVector; //vector of AliDetSwitch
private:
// methods
void SetWriteGeometryToModules(G4bool writeGeometry);
// data members
- AliSingleModuleConstructionRWVector fModuleConstructionVector; //..
- //vector of
- //AliSingleModuleConstruction
- AliMoreModulesConstruction* fMoreModulesConstruction; //..
- //AliMoreModulesConstruction
-
- AliMagneticField* fMagneticField; //magnetic field
- AliModulesCompositionMessenger* fMessenger; //messenger
+ SingleModuleVector fModuleConstructionVector; //vector of
+ //single module constructions
+ AliMoreModulesConstruction* fMoreModulesConstruction; //..
+ //dependent modules construction
+
+ AliMagneticField* fMagneticField; //magnetic field
+ AliModulesCompositionMessenger fMessenger; //messenger
G4bool fReadGeometry; //option applied to all modules
G4bool fWriteGeometry; //option applied to all modules
};
// $Id$
// Category: event
//
+// Author: I. Hrivnacova
+//
+// Class AliParticleGun
+// --------------------
// See the class description in the header file.
#include "AliParticleGun.h"
#include <G4Event.hh>
//_____________________________________________________________________________
-AliParticleGun::AliParticleGun() {
+AliParticleGun::AliParticleGun()
+ :fMessenger(this) {
//
- fMessenger = new AliParticleGunMessenger(this);
+ //fMessenger = new AliParticleGunMessenger(this);
}
//_____________________________________________________________________________
AliParticleGun::AliParticleGun(const AliParticleGun& right)
- : G4VPrimaryGenerator(right)
+ : G4VPrimaryGenerator(right),
+ fMessenger(this)
{
- // allocation
- fMessenger = new AliParticleGunMessenger(this);
-
// copy stuff
*this = right;
}
//_____________________________________________________________________________
AliParticleGun::~AliParticleGun() {
//
- fGunParticlesVector.clearAndDestroy();
- delete fMessenger;
+ // delete gun particles
+ Reset();
}
// operators
// base class assignment
this->G4VPrimaryGenerator::operator=(right);
- // particles vector
- fGunParticlesVector.clearAndDestroy();
- for (G4int i=0; i<right.fGunParticlesVector.entries(); i++) {
- AliGunParticle* rhsParticle = right.fGunParticlesVector[i];
- AliGunParticle* newParticle = new AliGunParticle(*rhsParticle);
- fGunParticlesVector.insert(newParticle);
- }
+ // delete gun particles
+ Reset();
+
+ // copy gun particles
+ GunParticleConstIterator it;
+ for (it = (right.fGunParticleVector).begin();
+ it != (right.fGunParticleVector).end(); it++)
+ fGunParticleVector.push_back(new AliGunParticle(**it));
return *this;
}
// Adds particle.
// ---
- fGunParticlesVector.insert(particle);
+ fGunParticleVector.push_back(particle);
}
//_____________________________________________________________________________
// Removes particle.
// ---
- AliGunParticle* particle = fGunParticlesVector[iParticle];
- fGunParticlesVector.remove(particle);
- delete particle;
+ GunParticleIterator it = fGunParticleVector.begin();
+ it += iParticle;
+ //advance(it,iParticle);
+
+ delete *it;
+ fGunParticleVector.erase(it);
}
//_____________________________________________________________________________
G4ThreeVector previousPosition = G4ThreeVector();
G4double previousTime = 0.;
- G4int nofGunParticles = fGunParticlesVector.entries();
- for( G4int i=0; i<nofGunParticles; i++ )
- {
- AliGunParticle* particle = fGunParticlesVector[i];
+ GunParticleIterator it;
+ for (it = fGunParticleVector.begin(); it != fGunParticleVector.end(); it++) {
+
+ AliGunParticle* particle = *it;
G4ParticleDefinition* particleDefinition
= particle->GetParticleDefinition();
G4ThreeVector position = particle->GetPosition();
G4double time = particle->GetTime();
G4PrimaryVertex* vertex;
- if ( i==0 || position != previousPosition || time != previousTime ) {
+ if (it == fGunParticleVector.begin() ||
+ position != previousPosition || time != previousTime ) {
// create a new vertex
// in case position and time of gun particle are different from
// previous values
vertex->SetPrimary(primaryParticle);
}
- // delete gun particles
- fGunParticlesVector.clearAndDestroy();
-
// add verbose
G4cout << "AliParticleGun::GeneratePrimaryVertex:" << G4endl;
G4cout << " "
- << event->GetNumberOfPrimaryVertex() << " of primary vertices,"
- << " " << nofGunParticles << " of primary particles " << G4endl;
+ << event->GetNumberOfPrimaryVertex() << " of primary vertices,"
+ << " " << fGunParticleVector.size() << " of primary particles "
+ << G4endl;
+
+ // delete gun particles
+ Reset();
}
//_____________________________________________________________________________
// Resets the particle gun.
// ---
- fGunParticlesVector.clearAndDestroy();
+ GunParticleIterator it;
+ for (it = fGunParticleVector.begin(); it != fGunParticleVector.end(); it++)
+ delete *it;
+
+ fGunParticleVector.clear();
}
//_____________________________________________________________________________
// Lists the particle gun.
// ---
- G4int nofGunParticles = fGunParticlesVector.entries();
-
G4cout << "Particle Gun: " << G4endl;
- if (nofGunParticles==0)
- { G4cout << " No particles are defined." << G4endl; }
- else
- {
- for (G4int i=0; i<nofGunParticles; i++)
- {
- G4cout << i << " th particle properties: " << G4endl;
+ if (fGunParticleVector.size() == 0)
+ G4cout << " No particles are defined." << G4endl;
+ else {
+ G4int i = 0;
+ GunParticleIterator it;
+ for (it = fGunParticleVector.begin();
+ it != fGunParticleVector.end(); it++) {
+
+ G4cout << i++ << " th particle properties: " << G4endl;
G4cout << "============================" << G4endl;
- fGunParticlesVector[i]->Print();
+ (*it)->Print();
}
}
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff