G4VUserDetectorConstruction Class Reference

#include <G4VUserDetectorConstruction.hh>

Public Member Functions
	G4VUserDetectorConstruction ()=default
virtual	~G4VUserDetectorConstruction ()=default
virtual G4VPhysicalVolume *	Construct ()=0
virtual void	ConstructSDandField ()
virtual void	CloneSD ()
virtual void	CloneF ()
void	RegisterParallelWorld (G4VUserParallelWorld *)
G4int	ConstructParallelGeometries ()
void	ConstructParallelSD ()
G4int	GetNumberOfParallelWorld () const
G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Protected Member Functions
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)

Detailed Description

Definition at line 50 of file G4VUserDetectorConstruction.hh.

Constructor & Destructor Documentation

G4VUserDetectorConstruction()

G4VUserDetectorConstruction::G4VUserDetectorConstruction ( )

default

~G4VUserDetectorConstruction()

virtual G4VUserDetectorConstruction::~G4VUserDetectorConstruction ( )

virtualdefault

Member Function Documentation

CloneF()

void G4VUserDetectorConstruction::CloneF ( )

virtual

Definition at line 97 of file G4VUserDetectorConstruction.cc.

{
  using FMtoFMmap = std::map<G4FieldManager*, G4FieldManager*>;
  using FMpair = std::pair<G4FieldManager*, G4FieldManager*>;
 
  FMtoFMmap masterToWorker;
  G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
  for (const auto& g4LogicalVolume : *logVolStore) {
    // Use shadow of master to get instance of FM
    G4FieldManager* masterFM = nullptr;  // g4LogicalVolume->fFieldManager;
    G4FieldManager* clonedFM = nullptr;
    if (masterFM != nullptr) {
      auto fmFound = masterToWorker.find(masterFM);
      if (fmFound == masterToWorker.cend()) {
        // First time we see this SD, let's clone and remember...
        try {
          auto insertedEl = masterToWorker.insert(FMpair(masterFM, masterFM->Clone()));
          clonedFM = (insertedEl.first)->second;
        }
        catch (...) {
          G4ExceptionDescription msg;
          msg << "Cloning of G4FieldManager failed."
              << " But derived class does not implement cloning. Cannot "
                 "continue.";
          G4Exception("G4VUserDetectorConstruction::CloneSD()", "Run0053", FatalException, msg);
        }
      }
      else {
        // We have already seen this SD attached to a different LogicalVolume,
        // let's re-use previous clone
        clonedFM = (*fmFound).second;
      }
    }  // masterFM != 0
    // Note that we do not push FM to daughters (false argument), however, since
    // we area looping on all logical volumes and we implemented the "trick" of
    // the map master<->cloned the final effect is the same as using here the
    // correct Boolean flag: log-volumes that originally were sharing the same
    // FM they will have cloned ones
    g4LogicalVolume->SetFieldManager(clonedFM, false);
  }
}

CloneSD()

void G4VUserDetectorConstruction::CloneSD ( )

virtual

Definition at line 140 of file G4VUserDetectorConstruction.cc.

{
  // Loop on ALL logial volumes to search for attached SD
  G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
 
  using SDtoSDmap = std::map<G4VSensitiveDetector*, G4VSensitiveDetector*>;
  using SDpair = std::pair<G4VSensitiveDetector*, G4VSensitiveDetector*>;
  SDtoSDmap masterToWorker;
 
  for (const auto& g4LogicalVolume : *logVolStore) {
    // Use shadow of master to get the instance of SD
    G4VSensitiveDetector* masterSD = nullptr;
    G4VSensitiveDetector* clonedSD = nullptr;
    if (masterSD != nullptr) {
      auto sdFound = masterToWorker.find(masterSD);
      if (sdFound == masterToWorker.cend()) {
        // First time we see this SD, let's clone and remember...
        try {
          auto insertedEl = masterToWorker.insert(SDpair(masterSD, masterSD->Clone()));
          clonedSD = (insertedEl.first)->second;
        }
        catch (...) {
          G4ExceptionDescription msg;
          msg << "Cloning of G4VSensitiveDetector requested for:" << masterSD->GetName() << "\n"
#ifndef WIN32
              << " (full path name: " << masterSD->GetFullPathName() << ").\n"
#endif
              << " But derived class does not implement cloning. Cannot "
                 "continue.";
          G4Exception("G4VUserDetectorConstruction::CloneSD()", "Run0053", FatalException, msg);
        }
      }
      else {
        // We have already seen this SD attached to a different LogicalVolume,
        // let's re-use previous clone
        clonedSD = (*sdFound).second;
      }
    }  // masterSD!=0
    g4LogicalVolume->SetSensitiveDetector(clonedSD);
  }
}

Construct()

virtual G4VPhysicalVolume * G4VUserDetectorConstruction::Construct ( )

pure virtual

Referenced by G4RunManager::InitializeGeometry(), and G4ErrorRunManagerHelper::SetUserInitialization().

ConstructParallelGeometries()

G4int G4VUserDetectorConstruction::ConstructParallelGeometries

(

)

Definition at line 62 of file G4VUserDetectorConstruction.cc.

{
  G4int nP = 0;
  for (const auto& pwItr : parallelWorld) {
    pwItr->Construct();
    ++nP;
  }
  return nP;
}

Referenced by G4RunManager::InitializeGeometry().

ConstructParallelSD()

void G4VUserDetectorConstruction::ConstructParallelSD

(

)

Definition at line 73 of file G4VUserDetectorConstruction.cc.

{
  for (const auto& pwItr : parallelWorld) {
    pwItr->ConstructSD();
  }
}

Referenced by G4RunManager::InitializeGeometry(), and G4WorkerRunManager::InitializeGeometry().

ConstructSDandField()

void G4VUserDetectorConstruction::ConstructSDandField ( )

virtual

Definition at line 94 of file G4VUserDetectorConstruction.cc.

{}

Referenced by G4RunManager::InitializeGeometry(), and G4WorkerRunManager::InitializeGeometry().

GetNumberOfParallelWorld()

G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld

(

)

const

Definition at line 81 of file G4VUserDetectorConstruction.cc.

{
  return (G4int)parallelWorld.size();
}

Referenced by GetParallelWorld().

GetParallelWorld()

G4VUserParallelWorld * G4VUserDetectorConstruction::GetParallelWorld

(

G4int

i

)

const

Definition at line 87 of file G4VUserDetectorConstruction.cc.

{
  if (i < 0 || i >= GetNumberOfParallelWorld()) return nullptr;
  return parallelWorld[i];
}

RegisterParallelWorld()

void G4VUserDetectorConstruction::RegisterParallelWorld

(

G4VUserParallelWorld *

aPW

)

Definition at line 48 of file G4VUserDetectorConstruction.cc.

{
  auto pwItr = std::find(parallelWorld.cbegin(), parallelWorld.cend(), aPW);
  if (pwItr != parallelWorld.cend()) {
    G4String eM = "A parallel world <";
    eM += aPW->GetName();
    eM += "> is already registered to the user detector construction.";
    G4Exception("G4VUserDetectorConstruction::RegisterParallelWorld", "Run0051",
                FatalErrorInArgument, eM);
  }
  parallelWorld.push_back(aPW);
}

SetSensitiveDetector() [1/2]

void G4VUserDetectorConstruction::SetSensitiveDetector ( const G4String & logVolName, G4VSensitiveDetector * aSD, G4bool multi = false )

protected

Definition at line 183 of file G4VUserDetectorConstruction.cc.

{
  G4bool found = false;
  G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
  auto volmap = store->GetMap();
  auto pos = volmap.find(logVolName);
  if (pos != volmap.cend()) {
    if ((pos->second.size() > 1) && !multi) {
      G4String eM = "More than one logical volumes of name <";
      eM += pos->first;
      eM += "> are found and thus the sensitive detector <";
      eM += aSD->GetName();
      eM += "> cannot be uniquely assigned.";
      G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector()", "Run0052",
                  FatalErrorInArgument, eM);
    }
    found = true;
    for (auto& i : pos->second) {
      SetSensitiveDetector(i, aSD);
    }
  }
  if (!found) {
    G4String eM2 = "No logical volume of name <";
    eM2 += logVolName;
    eM2 += "> is found. The specified sensitive detector <";
    eM2 += aSD->GetName();
    eM2 += "> couldn't be assigned to any volume.";
    G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector()", "Run0053",
                FatalErrorInArgument, eM2);
  }
}

Referenced by SetSensitiveDetector().

SetSensitiveDetector() [2/2]

void G4VUserDetectorConstruction::SetSensitiveDetector ( G4LogicalVolume * logVol, G4VSensitiveDetector * aSD )

protected

Definition at line 217 of file G4VUserDetectorConstruction.cc.

{
  assert(logVol != nullptr && aSD != nullptr);
 
  // The aSD has already been added by user to the manager if needed
  // G4SDManager::GetSDMpointer()->AddNewDetector(aSD);
 
  // New Logic: allow for "multiple" SDs being attached to a single LV.
  // To do that we use a special proxy SD called G4MultiSensitiveDetector
 
  // Get existing SD if already set and check if it is of the special type
  G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
  if (originalSD == aSD) {
    G4ExceptionDescription msg;
    msg << "Attempting to add multiple times the same sensitive detector (\"";
    msg << originalSD->GetName() << "\") is not allowed, skipping.";
    G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector", "Run0054", JustWarning, msg);
    return;
  }
  if (originalSD == nullptr) {
    logVol->SetSensitiveDetector(aSD);
  }
  else {
    auto msd = dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
    if (msd != nullptr) {
      msd->AddSD(aSD);
    }
    else {
      std::ostringstream mn;
      mn << "/MultiSD_" << logVol->GetName() << "_" << logVol;
      const G4String msdname = mn.str();
      msd = new G4MultiSensitiveDetector(msdname);
      // We need to register the proxy to have correct handling of IDs
      G4SDManager::GetSDMpointer()->AddNewDetector(msd);
      msd->AddSD(originalSD);
      msd->AddSD(aSD);
      logVol->SetSensitiveDetector(msd);
    }
  }
}

---

The documentation for this class was generated from the following files:

• G4VUserDetectorConstruction.hh
• G4VUserDetectorConstruction.cc