QDetectorConstruction Class Reference

#include <QDetectorConstruction.hh>

Inheritance diagram for QDetectorConstruction:

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

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

Private Attributes
std::vector< G4VUserParallelWorld * >	parallelWorld

Detailed Description

Definition at line 42 of file QDetectorConstruction.hh.

Constructor & Destructor Documentation

QDetectorConstruction() [1/2]

QDetectorConstruction::QDetectorConstruction

(

)

Definition at line 51 of file QDetectorConstruction.cc.

{
}

~QDetectorConstruction() [1/2]

QDetectorConstruction::~QDetectorConstruction

(

)

Definition at line 57 of file QDetectorConstruction.cc.

{
}

QDetectorConstruction() [2/2]

QDetectorConstruction::QDetectorConstruction

(

)

~QDetectorConstruction() [2/2]

QDetectorConstruction::~QDetectorConstruction

(

)

Member Function Documentation

CloneF()

void G4VUserDetectorConstruction::CloneF ( )

virtualinherited

Definition at line 126 of file G4VUserDetectorConstruction.cc.

{
  using FMtoFMmap = std::map<G4FieldManager*, G4FieldManager*>;
  using FMpair = std::pair<G4FieldManager*, G4FieldManager*>;
 
  FMtoFMmap masterToWorker;
  G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
  for(auto it = logVolStore->cbegin(); it != logVolStore->cend(); ++it)
  {
    G4LogicalVolume* g4LogicalVolume = *it;
    // 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);
  }
}

References G4FieldManager::Clone(), FatalException, G4Exception(), G4LogicalVolumeStore::GetInstance(), second, and G4LogicalVolume::SetFieldManager().

CloneSD()

void G4VUserDetectorConstruction::CloneSD ( )

virtualinherited

Definition at line 177 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(auto it = logVolStore->cbegin(); it != logVolStore->cend(); ++it)
  {
    G4LogicalVolume* g4LogicalVolume = *it;
    // 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);
  }
}

References G4VSensitiveDetector::Clone(), FatalException, G4Exception(), G4VSensitiveDetector::GetFullPathName(), G4LogicalVolumeStore::GetInstance(), G4VSensitiveDetector::GetName(), second, and G4LogicalVolume::SetSensitiveDetector().

Construct() [1/2]

G4VPhysicalVolume * QDetectorConstruction::Construct ( )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 63 of file QDetectorConstruction.cc.

{
  G4Material* mate;
  G4VisAttributes* va;
 
  // ==============================================================
  // world volume
  // ==============================================================
  G4Box* areaSolid= new G4Box("AREA",
                  DXYZ_AREA/2., DXYZ_AREA/2., DXYZ_AREA/2.);
 
  G4Material* vacuum= G4Material::GetMaterial("Vacuum");
  G4LogicalVolume* areaLV= new G4LogicalVolume(areaSolid, vacuum, "AREA_LV");
  G4PVPlacement* area= new G4PVPlacement(0, G4ThreeVector(), "AREA_PV",
                     areaLV, 0, false, 0);
  // vis. attributes
  va= new G4VisAttributes(G4Color(1.,1.,1.));
  va-> SetForceWireframe(true);
  areaLV-> SetVisAttributes(va);
 
  // ==============================================================
  // detectors
  // ==============================================================
  // voxel
  const G4double dvoxel= 10.*mm;
  const G4double dl= 10.*cm;
 
  G4Box* svoxel= new G4Box("voxel", dvoxel, dl, dvoxel);
  mate= G4Material::GetMaterial("Vacuum");
  G4LogicalVolume* lvoxel= new G4LogicalVolume(svoxel, mate, "voxel");
  va= new G4VisAttributes(G4Color(0.,0.8,0.8));
  va-> SetVisibility(false);
  lvoxel-> SetVisAttributes(va);
 
  G4int ix, iz;
  G4int index=0;
  for (iz=0; iz<5; iz++) {
    for (ix=-7; ix<=7; ix++) {
      G4double x0= (2.*ix)*cm;
      G4double z0= (-13.+2.*iz)*cm;
      /*G4PVPlacement* pvoxel=*/ new G4PVPlacement(0, G4ThreeVector(x0, 0., z0),
              lvoxel, "voxel", areaLV, false, index);
      index++;
    }
  }
 
  // tube
  //G4Tubs* stube= new G4Tubs("tube", 15./2.*mm, 19./2.*mm, dl,
  G4Tubs* stube= new G4Tubs("tube", 0.*mm, 19./2.*mm, dl,
                0., 360.*deg);
  mate= G4Material::GetMaterial("Al");
  G4LogicalVolume* ltube= new G4LogicalVolume(stube, mate, "tube");
  va= new G4VisAttributes(G4Color(0.,0.8,0.8));
  ltube-> SetVisAttributes(va);
 
  G4RotationMatrix* rmtube= new G4RotationMatrix;
  rmtube-> rotateX(-90.*deg);
  /*G4PVPlacement* ptube=*/ new G4PVPlacement(rmtube, G4ThreeVector(),
          ltube, "tube", lvoxel, false, 0);
 
  // cal
  const G4double dxycal= 25.*mm;
  const G4double dzcal= 3.*cm;
 
  G4Box* scal= new G4Box("cal", dxycal, dxycal, dzcal);
  mate= G4Material::GetMaterial("CsI");
  G4LogicalVolume* lcal= new G4LogicalVolume(scal, mate, "cal");
  va= new G4VisAttributes(G4Color(0.5,0.5,0.));
  lcal-> SetVisAttributes(va);
 
  index= 0;
  for (ix=-2; ix<=2; ix++) {
    G4double x0= (5.*ix)*cm;
    /*G4PVPlacement* pcal=*/ new G4PVPlacement(0, G4ThreeVector(x0, 0., 2.*cm),
            lcal, "cal", areaLV, false, index);
    index++;
  }
 
  return area;
}

References cm, deg, DXYZ_AREA, G4Material::GetMaterial(), mm, and G4InuclParticleNames::z0.

Construct() [2/2]

virtual G4VPhysicalVolume * QDetectorConstruction::Construct ( )

virtual

Implements G4VUserDetectorConstruction.

ConstructParallelGeometries()

G4int G4VUserDetectorConstruction::ConstructParallelGeometries ( )

inherited

Definition at line 73 of file G4VUserDetectorConstruction.cc.

{
  G4int nP = 0;
  for(auto pwItr = parallelWorld.cbegin();
           pwItr != parallelWorld.cend(); ++pwItr)
  {
    (*pwItr)->Construct();
    ++nP;
  }
  return nP;
}

References G4VUserDetectorConstruction::parallelWorld.

Referenced by G4RunManager::InitializeGeometry().

ConstructParallelSD()

void G4VUserDetectorConstruction::ConstructParallelSD ( )

inherited

Definition at line 86 of file G4VUserDetectorConstruction.cc.

{
  for(auto pwItr = parallelWorld.cbegin();
           pwItr != parallelWorld.cend(); ++pwItr)
  {
    (*pwItr)->ConstructSD();
  }
}

References G4VUserDetectorConstruction::parallelWorld.

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

ConstructSDandField()

void G4VUserDetectorConstruction::ConstructSDandField ( )

virtualinherited

Definition at line 111 of file G4VUserDetectorConstruction.cc.

{
  // G4RunManager::RMType rmtype =
  // G4RunManager::GetRunManager()->GetRunManagerType(); if(rmtype !=
  // G4RunManager::sequentialRM)
  // {
  //  G4cout
  //  << "User-derived detector construction class does not implement \n"
  //  << "ConstructSDandFiled method: workers will not have SD and fields!\n"
  //  << "The user can safely ignore this message if (s)he has no sensitive\n"
  //  << "detector or field in her/his application." << G4endl;
  // }
}

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

GetNumberOfParallelWorld()

G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld ( ) const

inherited

Definition at line 96 of file G4VUserDetectorConstruction.cc.

{
  return parallelWorld.size();
}

References G4VUserDetectorConstruction::parallelWorld.

Referenced by G4VUserDetectorConstruction::GetParallelWorld().

GetParallelWorld()

G4VUserParallelWorld * G4VUserDetectorConstruction::GetParallelWorld ( G4int  i ) const

inherited

Definition at line 103 of file G4VUserDetectorConstruction.cc.

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

References G4VUserDetectorConstruction::GetNumberOfParallelWorld(), and G4VUserDetectorConstruction::parallelWorld.

RegisterParallelWorld()

void G4VUserDetectorConstruction::RegisterParallelWorld ( G4VUserParallelWorld *  aPW )

inherited

Definition at line 57 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);
}

References FatalErrorInArgument, G4Exception(), G4VUserParallelWorld::GetName(), and G4VUserDetectorConstruction::parallelWorld.

SetSensitiveDetector() [1/2]

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

protectedinherited

Definition at line 229 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 (std::size_t i = 0; i < pos->second.size(); ++i)
    {
      SetSensitiveDetector(pos->second[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);
  }
}

References FatalErrorInArgument, G4Exception(), G4LogicalVolumeStore::GetInstance(), G4LogicalVolumeStore::GetMap(), G4VSensitiveDetector::GetName(), pos, and G4VUserDetectorConstruction::SetSensitiveDetector().

Referenced by MyDetectorConstruction::SetSDtoScoreVoxel(), and G4VUserDetectorConstruction::SetSensitiveDetector().

SetSensitiveDetector() [2/2]

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

protectedinherited

Definition at line 268 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
  {
    G4MultiSensitiveDetector* 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);
    }
  }
}

References G4SDManager::AddNewDetector(), G4MultiSensitiveDetector::AddSD(), G4Exception(), G4VSensitiveDetector::GetName(), G4LogicalVolume::GetName(), G4SDManager::GetSDMpointer(), G4LogicalVolume::GetSensitiveDetector(), JustWarning, and G4LogicalVolume::SetSensitiveDetector().

Field Documentation

parallelWorld

std::vector<G4VUserParallelWorld*> G4VUserDetectorConstruction::parallelWorld

privateinherited

Definition at line 82 of file G4VUserDetectorConstruction.hh.

Referenced by G4VUserDetectorConstruction::ConstructParallelGeometries(), G4VUserDetectorConstruction::ConstructParallelSD(), G4VUserDetectorConstruction::GetNumberOfParallelWorld(), G4VUserDetectorConstruction::GetParallelWorld(), and G4VUserDetectorConstruction::RegisterParallelWorld().

---

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

• environments/g4py/tests/g4pytest/Qgeom/QDetectorConstruction.hh
• environments/g4py/tests/gtest01/module/QDetectorConstruction.hh
• environments/g4py/tests/g4pytest/Qgeom/QDetectorConstruction.cc
• environments/g4py/tests/gtest01/module/QDetectorConstruction.cc