TG4SDConstruction.cxx

Go to the documentation of this file.

//------------------------------------------------
// The Geant4 Virtual Monte Carlo package
// Copyright (C) 2007 - 2015 Ivana Hrivnacova
// All rights reserved.
//
// For the licensing terms see geant4_vmc/LICENSE.
// Contact: root-vmc@cern.ch
//-------------------------------------------------

 
#include "TG4SDConstruction.h"
 
#include "TG4GeometryServices.h"
#include "TG4GflashSensitiveDetector.h"
#include "TG4SDServices.h"
#include "TG4SensitiveDetector.h"
#include "TG4StateManager.h"
 
#include <G4LogicalVolume.hh>
#include <G4LogicalVolumeStore.hh>
#include <G4SDManager.hh>
#include <G4Threading.hh>
 
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TVirtualMCApplication.h>
#include <TVirtualMCSensitiveDetector.h>
 
#include <TVirtualMC.h>
 
const G4String TG4SDConstruction::fgkDefaultSVLabel = "SV";
 
//_____________________________________________________________________________
TG4SDConstruction::TG4SDConstruction()
  : TG4Verbose("SDConstruction"),
    fMessenger(this),
    fExclusiveSDScoring(false),
    fSelectionFromTGeo(false),
    fSVLabel(fgkDefaultSVLabel),
    fSelection(),
    fIsGflash(false)
{
}
 
//_____________________________________________________________________________
TG4SDConstruction::~TG4SDConstruction()
{
}
 
//
// private methods
//
 
//_____________________________________________________________________________
void TG4SDConstruction::CreateSD(
  G4LogicalVolume* lv, TVirtualMCSensitiveDetector* userSD) const
{
 
  if (VerboseLevel() > 2) {
    G4cout << "TG4SDConstruction::CreateSD:  lv=" << lv->GetName()
           << " userSD=" << userSD << G4endl;
  }
 
  TG4GeometryServices* geometryServices = TG4GeometryServices::Instance();
  G4SDManager* pSDManager = G4SDManager::GetSDMpointer();
 
  G4String sdName;
  if (userSD) {
    sdName = userSD->GetName();
  }
  else {
    sdName = "/" + geometryServices->UserVolumeName(lv);
  }
 
  // create/retrieve the sensitive detector
  G4VSensitiveDetector* sd = 0;
  sd = pSDManager->FindSensitiveDetector(sdName, false);
  if (!sd) {
 
    G4int mediumId = TG4GeometryServices::Instance()->GetMediumId(lv);
 
    TG4SensitiveDetector* newSD = 0;
    if (fIsGflash) {
      newSD = new TG4GflashSensitiveDetector(sdName, mediumId);
      if (VerboseLevel() > 2) {
        G4cout << "Created TG4GflashSensitiveDetector with sdName=" << sdName
               << " mediumId=" << mediumId << G4endl;
      }
    }
    else if (userSD) {
      newSD = new TG4SensitiveDetector(userSD, mediumId, fExclusiveSDScoring);
      if (VerboseLevel() > 2) {
        G4cout << "Created TG4SensitiveDetector with userSD=" << userSD
               << " mediumId=" << mediumId
               << " exclusiveSoring=" << fExclusiveSDScoring << G4endl;
      }
    }
    else {
      newSD = new TG4SensitiveDetector(sdName, mediumId);
      if (VerboseLevel() > 2) {
        G4cout << "Created TG4SensitiveDetector with sdName=" << sdName
               << " mediumId=" << mediumId << G4endl;
      }
    }
    pSDManager->AddNewDetector(newSD);
    if (VerboseLevel() > 1) {
      G4cout << "Sensitive detector " << sdName << "  ID=" << newSD->GetID()
             << "  medium ID=" << newSD->GetMediumID() << " has been created."
             << G4endl;
    }
    else {
      if (VerboseLevel() > 2) {
        G4cout << "Sensitive detector " << sdName << ", " << sd
               << " already exists." << G4endl;
      }
    }
    sd = newSD;
  }
  lv->SetSensitiveDetector(sd);
}
 
//_____________________________________________________________________________
void TG4SDConstruction::FillSDSelectionFromTGeo()
{
 
  if (!gGeoManager) {
    TG4Globals::Exception(
      "TG4SDServices", "FillSDSelectionFromTGeo", "TGeo manager not defined.");
  }
 
  TObjArray* volumes = gGeoManager->GetListOfVolumes();
  TIterator* it = volumes->MakeIterator();
  TGeoVolume* volume = 0;
  while ((volume = (static_cast<TGeoVolume*>(it->Next())))) {
    if (TString(volume->GetOption()) == TString(fSVLabel.data())) {
      G4cout << "Adding volume " << volume->GetName() << " in SD selection"
             << G4endl;
      fSelection.insert(volume->GetName());
    }
  }
 
  if (!fSelection.size()) {
    TString text = "No volumes with the option = \"";
    text += TString(fSVLabel.data());
    text += "\" were found in TGeo geometry.\n";
    text += "    The SD selection will not be applied.";
    TG4Globals::Warning("TG4SDServices", "FillSDSelectionFromTGeo", text);
  }
}
 
//_____________________________________________________________________________
void TG4SDConstruction::MapVolumesToInstanceIds()
{
  // Use the first instance ID as the candidate for each source volume.
  // MapVolume reuses that ID for all other representations of the source.
 
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
  for (G4int i = 0; i < G4int(lvStore->size()); i++) {
    G4LogicalVolume* lv = (*lvStore)[i];
 
    if (VerboseLevel() > 1) {
      G4cout << "Candidate volId from instance Id "
             << lv->GetInstanceID() + TG4SDServices::GetFirstVolumeId()
             << " to " << lv->GetName() << G4endl;
    }
 
    TG4SDServices::Instance()->MapVolume(
      lv, lv->GetInstanceID() + TG4SDServices::GetFirstVolumeId(), true);
  }
}
 
//_____________________________________________________________________________
void TG4SDConstruction::MapVolumesToSDIds()
{
 
  // Set volume IDs to volumes which have not SD
  G4int counter = TG4SensitiveDetector::GetTotalNofSensitiveDetectors() + 1;
 
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
  for (G4int i = 0; i < G4int(lvStore->size()); i++) {
    G4LogicalVolume* lv = (*lvStore)[i];
 
    G4int id = 0;
    if (lv->GetSensitiveDetector()) {
      id =
        static_cast<TG4SensitiveDetector*>(lv->GetSensitiveDetector())->GetID();
    }
    else {
      id = counter++;
    }
 
    if (VerboseLevel() > 1) {
      G4cout << "Candidate volId from SD id " << id << " to " << lv->GetName()
             << G4endl;
    }
 
    TG4SDServices::Instance()->MapVolume(lv, id, true);
  }
}
 
//
// public methods
//
 
//_____________________________________________________________________________
void TG4SDConstruction::Construct()
{
 
  if (VerboseLevel() > 1) G4cout << "TG4SDConstruction::Construct" << G4endl;
 
  G4bool isMaster = !G4Threading::IsWorkerThread();
 
  // Get volumes selected as SD in TGeo geometry
  if (fSelectionFromTGeo && isMaster) FillSDSelectionFromTGeo();
 
  // Construct user SDs
  TG4StateManager::Instance()->SetNewState(kConstructSD);
  TVirtualMCApplication::Instance()->ConstructSensitiveDetectors();
  TG4StateManager::Instance()->SetNewState(kNotInApplication);
 
  if (isMaster) TG4GeometryServices::Instance()->BuildConstituentVolumes();
 
  G4bool isUserSD = false;
  G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance();
 
  for (G4int i = 0; i < G4int(lvStore->size()); i++) {
    G4LogicalVolume* lv = (*lvStore)[i];
 
    const G4String selectionName =
      TG4GeometryServices::Instance()->UserVolumeName(lv);
 
    // Check if a user SD is defined
    TVirtualMCSensitiveDetector* userSD =
      TG4SDServices::Instance()->GetUserSD(selectionName, false);
 
    // Create SD calling user sensitive detector
 
    if (userSD) {
      CreateSD(lv, userSD);
      // if ( isMaster ) TG4SDServices::Instance()->MapVolume(lv, sdID);
      isUserSD = true;
    }
    else {
      // Create SD calling MCApplication::Stepping
      // if exclusive scoring via user sensitive detectors is not activated and
      // if selection is empty or if selection is defined and the volume name is
      // in selection
      if ((!fExclusiveSDScoring) &&
          (!fSelection.size() ||
            fSelection.find(selectionName) != fSelection.end())) {
 
        CreateSD(lv, 0);
      }
    }
  }
 
  // Define volume Ids if VMC SD is not defined for all volumes
  // (either due to user defined SDs or user selection of sensitive volumes)
  if (isMaster) {
    TG4SDServices::Instance()->ClearVolumeMaps();
    if (isUserSD) {
      MapVolumesToInstanceIds();
    }
    else {
      MapVolumesToSDIds();
    }
  }
 
  // Initialize user geometry
  TG4StateManager::Instance()->SetNewState(kInitGeometry);
  TVirtualMCApplication::Instance()->InitGeometry();
  TG4StateManager::Instance()->SetNewState(kNotInApplication);
 
  // Initialize user SDs
  if (TG4SDServices::Instance()->GetUserSDs()) {
    for (auto& userSD : (*TG4SDServices::Instance()->GetUserSDs())) {
      userSD->Initialize();
    }
  }
 
  if (VerboseLevel() > 1) {
    TG4SDServices::Instance()->PrintVolNameToIdMap();
    TG4SDServices::Instance()->PrintVolIdToLVMap();
    if (fSelection.size()) {
      TG4SDServices::Instance()->PrintSensitiveVolumes();
    }
    if (TG4SDServices::Instance()->GetUserSDs()) {
      TG4SDServices::Instance()->PrintUserSensitiveDetectors();
    }
  }
 
  if (VerboseLevel() > 1)
    G4cout << "TG4SDConstruction::Construct done" << G4endl;
}
 
//_____________________________________________________________________________
void TG4SDConstruction::AddSelection(const G4String& selection)
{
 
  std::istringstream is(selection);
  G4String token;
  while (is >> token) {
    if (VerboseLevel() > 1) {
      G4cout << "Adding volume " << token << " in SD selection." << G4endl;
    }
    fSelection.insert(token);
  }
}