#include "LArG4Detector_service.h"

Inheritance diagram for larg4::LArG4DetectorService:

Public Member Functions
	LArG4DetectorService (fhicl::ParameterSet const &)

virtual void	initialize ()

void	buildLVs ()

std::vector< G4VPhysicalVolume * >	placeToPVs (std::vector< G4LogicalVolume * > motherLVs)

void	callArtProduces (art::ProducesCollector &produces_coll)

void	fillEventWithArtHits (G4HCofThisEvent *hc)

std::vector< G4VPhysicalVolume * >	pvs () const

std::vector< G4LogicalVolume * >	lvs () const

std::string const &	myName () const

std::string const &	category () const

std::string const &	motherCategory () const

fhicl::ParameterSet const &	parameters () const

Private Member Functions
std::vector< G4LogicalVolume * >	doBuildLVs () override

std::vector< G4VPhysicalVolume * >	doPlaceToPVs (std::vector< G4LogicalVolume * >) override

void	setStepLimits ()

std::string	instanceName (std::string const &) const

void	doCallArtProduces (art::ProducesCollector &collector) override

void	doFillEventWithArtHits (G4HCofThisEvent *hc) override

Private Attributes
std::string	gdmlFileName_

bool	checkOverlaps_

bool	updateSimEnergyDeposits_

bool	updateAuxDetHits_

std::vector< std::string >	volumeNames_

std::vector< float >	stepLimits_

size_t	inputVolumes_

bool	dumpMP_

std::vector< std::pair< std::string, std::string > >	detectors_ {}

std::map< std::string, G4double >	overrideGDMLStepLimit_Map {}

std::unordered_map< std::string, float >	setGDMLVolumes_ {}

Detailed Description

Definition at line 54 of file LArG4Detector_service.h.

Constructor & Destructor Documentation

larg4::LArG4DetectorService::LArG4DetectorService ( fhicl::ParameterSet const & p )

explicit

Definition at line 76 of file LArG4Detector.cc.

References checkOverlaps_, dumpMP_, fhicl::ParameterSet::get(), inputVolumes_, overrideGDMLStepLimit_Map, util::size(), stepLimits_, updateAuxDetHits_, updateSimEnergyDeposits_, and volumeNames_.

   : artg4tk::DetectorBase(p,
                           p.get<string>("name", "LArG4DetectorService"),
                           p.get<string>("category", "World"),
                           p.get<string>("mother_category", ""))
   , gdmlFileName_{p.get<std::string>("gdmlFileName_", "")}
   , checkOverlaps_{p.get<bool>("CheckOverlaps", false)}
   , updateSimEnergyDeposits_{p.get<bool>("UpdateSimEnergyDeposits", true)}
   , updateAuxDetHits_{p.get<bool>("UpdateAuxDetHits", true)}
   , volumeNames_{p.get<std::vector<std::string>>("volumeNames", {})}
   , stepLimits_{p.get<std::vector<float>>("stepLimits", {})}
   , inputVolumes_{size(volumeNames_)}
   , dumpMP_{p.get<bool>("DumpMaterialProperties", false)}
 {
   // Make sure units are defined.
   G4UnitDefinition::GetUnitsTable();
 
   // -- D.R. : Check for valid volume, steplimit pairs
   if (inputVolumes_ != size(stepLimits_)) {
     throw cet::exception("LArG4DetectorService") << "Configuration error: volumeNames:[] and"
                                                  << " stepLimits:[] have different sizes!"
                                                  << "\n";
   }
 
   //-- define commonly used units, that we might need
   new G4UnitDefinition("volt/cm", "V/cm", "Electric field", CLHEP::volt / CLHEP::cm);
 
   if (inputVolumes_ > 0) {
     mf::LogInfo("LArG4DetectorService::Ctr")
       << "Reading stepLimit(s) from the configuration file, for volume(s):";
   }
   for (size_t i = 0; i < inputVolumes_; ++i) {
     if (stepLimits_[i] < 0) {
       throw cet::exception("LArG4DetectorService")
         << "Invalid stepLimits found. Step limits must be"
         << " positive! Bad value : stepLimits[" << i << "] = " << stepLimits_.at(i) << " [mm]\n";
     }
 
     overrideGDMLStepLimit_Map.emplace(volumeNames_[i], stepLimits_[i] * CLHEP::mm);
     mf::LogInfo("LArG4DetectorService::Ctr")
       << "Volume: " << volumeNames_[i] << ", stepLimit: " << stepLimits_[i];
   } //--loop over inputVolumes
 } //--Ctor

Member Function Documentation

void artg4tk::DetectorBase::buildLVs ( )

inlineinherited

Definition at line 100 of file DetectorBase.hh.

     {
       _myLVs = doBuildLVs();
     }

void artg4tk::DetectorBase::callArtProduces ( art::ProducesCollector & produces_coll )

inlineinherited

Definition at line 118 of file DetectorBase.hh.

     {
       doCallArtProduces(produces_coll);
     }

std::string const& artg4tk::DetectorBase::category ( ) const

inlineinherited

Definition at line 156 of file DetectorBase.hh.

Referenced by artg4tk::DetectorHolderService::addDBtoCategoryMap(), and artg4tk::DetectorHolderService::placeDetector().

     {
       return _category;
     }

std::vector< G4LogicalVolume * > larg4::LArG4DetectorService::doBuildLVs ( )

overrideprivatevirtual

Implements artg4tk::DetectorBase.

Definition at line 122 of file LArG4Detector.cc.

References checkOverlaps_, detectors_, dumpMP_, gdmlFileName_, inputVolumes_, MF_LOG_DEBUG, MF_LOG_WARNING, parser(), setGDMLVolumes_, setStepLimits(), and value.

 {
   ColorReader reader;
   G4GDMLParser parser(&reader);
   parser.SetOverlapCheck(checkOverlaps_);
   cet::search_path sp{"FW_SEARCH_PATH"};
   std::string fullGDMLFileName;
   if (!sp.find_file(gdmlFileName_, fullGDMLFileName)) {
     throw cet::exception("LArG4DetectorService") << "Cannot find file: " << gdmlFileName_;
   }
   parser.Read(fullGDMLFileName, false);
   G4VPhysicalVolume* World = parser.GetWorldVolume();
 
   std::stringstream ss;
   ss << World->GetTranslation() << "\n\n";
   ss << "Found World:  " << World->GetName() << "\n";
   ss << "World LV:  " << World->GetLogicalVolume()->GetName() << "\n";
   G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance();
   ss << "Found " << pLVStore->size() << " logical volumes."
      << "\n\n";
   G4PhysicalVolumeStore* pPVStore = G4PhysicalVolumeStore::GetInstance();
   ss << "Found " << pPVStore->size() << " physical volumes."
      << "\n\n";
   G4SDManager* SDman = G4SDManager::GetSDMpointer();
   const G4GDMLAuxMapType* auxmap = parser.GetAuxMap();
   ss << "Found " << auxmap->size() << " volume(s) with auxiliary information."
      << "\n\n";
   ss << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
   mf::LogInfo("LArG4DetectorService::doBuildLVs") << ss.str();
 
   for (auto const& [volume, auxes] : *auxmap) {
     G4cout << "Volume " << volume->GetName()
            << " has the following list of auxiliary information: \n";
     for (auto const& aux : auxes) {
       G4cout << "--> Type: " << aux.type << " Value: " << aux.value << "\n";
 
       G4double value = atof(aux.value);
       G4double val_unit = 1; //--no unit
       G4String provided_category = "NONE";
       if ((aux.unit) && (aux.unit != "")) { // -- if provided and non-NULL
         val_unit = G4UnitDefinition::GetValueOf(aux.unit);
         provided_category = G4UnitDefinition::GetCategory(aux.unit);
         mf::LogInfo("AuxUnit") << " Unit parsed = " << aux.unit
                                << " from unit category: " << provided_category.c_str();
         value *=
           val_unit; //-- Now do something with the value, making sure that the unit is appropriate
       }
 
       if (aux.type == "StepLimit") {
         G4UserLimits* fStepLimit = new G4UserLimits();
         G4AutoDelete::Register(fStepLimit);
 
         //-- check that steplimit has valid length unit category
         G4String steplimit_category = "Length";
         if (provided_category == steplimit_category) {
           mf::LogInfo("AuxUnit") << "Valid StepLimit unit category obtained: "
                                  << provided_category.c_str();
           // -- convert length to mm
           value = (value / CLHEP::mm) * CLHEP::mm;
           fStepLimit->SetMaxAllowedStep(value);
           mf::LogInfo("fStepLimit")
             << "fStepLimit:  " << value << "  " << value / CLHEP::cm << " cm\n";
         }
         else if (provided_category ==
                  "NONE") { //--no unit category provided, use the default CLHEP::mm
           MF_LOG_WARNING("StepLimitUnit") << "StepLimit in geometry file does not have a unit!"
                                           << " Defaulting to mm...";
           value *= CLHEP::mm;
           fStepLimit->SetMaxAllowedStep(value);
           mf::LogInfo("fStepLimit")
             << "fStepLimit:  " << value << "  " << value / CLHEP::cm << " cm\n";
         }
         else { //--wrong unit category provided
           throw cet::exception("StepLimitUnit")
             << "StepLimit does not have a valid length unit!\n"
             << " Category of unit provided = " << provided_category << ".\n";
         }
 
         volume->SetUserLimits(fStepLimit);
         // -- D.R. insert into map <volName,stepLimit> to cross-check later
         MF_LOG_DEBUG("LArG4DetectorService::")
           << "Set stepLimit for volume: " << volume->GetName() << " from the GDML file.";
         setGDMLVolumes_.insert(std::make_pair(volume->GetName(), (float)(value / CLHEP::mm)));
       }
       if (aux.type == "ExcitationEnergy") {
         G4String ExcitationEnergy_category = "Energy";
         if (provided_category == ExcitationEnergy_category) {
           G4cout << "Valid ExcitationEnergy unit category obtained: " << provided_category.c_str()
                  << G4endl;
           G4cout << " unit Value:" << val_unit << "  Value:  " << value << G4endl;
           G4cout << " unit Value:" << val_unit << "  Value:  " << value / CLHEP::eV << " eV"
                  << G4endl;
           volume->GetMaterial()->GetIonisation()->SetMeanExcitationEnergy(value);
           G4cout << " Mean Ionization energy:  "
                  << volume->GetMaterial()->GetIonisation()->GetMeanExcitationEnergy() << G4endl;
         }
       }
 
       if (aux.type == "SensDet") {
         if (aux.value == "DRCalorimeter") {
           G4String name = volume->GetName() + "_DRCalorimeter";
           artg4tk::DRCalorimeterSD* aDRCalorimeterSD = new artg4tk::DRCalorimeterSD(name);
           SDman->AddNewDetector(aDRCalorimeterSD);
           volume->SetSensitiveDetector(aDRCalorimeterSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "Calorimeter") {
           G4String name = volume->GetName() + "_Calorimeter";
           artg4tk::CalorimeterSD* aCalorimeterSD = new artg4tk::CalorimeterSD(name);
           SDman->AddNewDetector(aCalorimeterSD);
           volume->SetSensitiveDetector(aCalorimeterSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "PhotonDetector") {
           G4String name = volume->GetName() + "_PhotonDetector";
           artg4tk::PhotonSD* aPhotonSD = new artg4tk::PhotonSD(name);
           SDman->AddNewDetector(aPhotonSD);
           volume->SetSensitiveDetector(aPhotonSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "Tracker") {
           G4String name = volume->GetName() + "_Tracker";
           artg4tk::TrackerSD* aTrackerSD = new artg4tk::TrackerSD(name);
           SDman->AddNewDetector(aTrackerSD);
           volume->SetSensitiveDetector(aTrackerSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.push_back(std::make_pair(volume->GetName(), aux.value));
         }
         else if (aux.value == "SimEnergyDeposit") {
           G4String name = volume->GetName() + "_SimEnergyDeposit";
           SimEnergyDepositSD* aSimEnergyDepositSD = new SimEnergyDepositSD(name);
           SDman->AddNewDetector(aSimEnergyDepositSD);
           volume->SetSensitiveDetector(aSimEnergyDepositSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "AuxDet") {
           G4String name = volume->GetName() + "_AuxDet";
           AuxDetSD* aAuxDetSD = new AuxDetSD(name);
           SDman->AddNewDetector(aAuxDetSD);
           volume->SetSensitiveDetector(aAuxDetSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "HadInteraction") {
           G4String name = volume->GetName() + "_HadInteraction";
           artg4tk::HadInteractionSD* aHadInteractionSD = new artg4tk::HadInteractionSD(name);
           // NOTE: This will be done in the HadInteractionSD ctor
           // SDman->AddNewDetector(aHadInteractionSD);
           volume->SetSensitiveDetector(aHadInteractionSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
         else if (aux.value == "HadIntAndEdepTrk") {
           G4String name = volume->GetName() + "_HadIntAndEdepTrk";
           artg4tk::HadIntAndEdepTrkSD* aHadIntAndEdepTrkSD = new artg4tk::HadIntAndEdepTrkSD(name);
           // NOTE: This will be done in the HadIntAndEdepTrkSD ctor
           // SDman->AddNewDetector(aHadIntAndEdepTrkSD);
           volume->SetSensitiveDetector(aHadIntAndEdepTrkSD);
           std::cout << "Attaching sensitive Detector: " << aux.value
                     << " to Volume:  " << volume->GetName() << "\n";
           detectors_.emplace_back(volume->GetName(), aux.value);
         }
       }
     }
     std::cout
       << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
   }
   if (dumpMP_) { G4cout << *(G4Material::GetMaterialTable()) << G4endl; }
   if (inputVolumes_ > 0) { setStepLimits(); }
   std::cout << "List SD Tree: \n";
   SDman->ListTree();
   std::cout << " Collection Capacity:  " << SDman->GetCollectionCapacity() << "\n";
   G4HCtable* hctable = SDman->GetHCtable();
   for (G4int j = 0; j < SDman->GetCollectionCapacity(); ++j) {
     std::cout << "HC Name: " << hctable->GetHCname(j) << "   SD Name:  " << hctable->GetSDname(j)
               << "\n";
   }
   std::cout << "==================================================\n";
   // Return our logical volumes.
   std::vector<G4LogicalVolume*> myLVvec;
   myLVvec.push_back(pLVStore->at(0)); // only need to return the LV of the world
   std::cout << "nr of LV ======================:  " << myLVvec.size() << "\n";
 
   return myLVvec;
 }

void larg4::LArG4DetectorService::doCallArtProduces ( art::ProducesCollector & collector )

overrideprivatevirtual

Reimplemented from artg4tk::DetectorBase.

Definition at line 395 of file LArG4Detector.cc.

References detectors_, instance, instanceName(), and art::ProducesCollector::produces().

 {
   // Tell Art what we produce, and label the entries
   for (auto const& [volume_name, sd_name] : detectors_) {
     if (sd_name == "DRCalorimeter") {
       auto const instance = instanceName(volume_name);
       collector.produces<artg4tk::DRCalorimeterHitCollection>(instance);
       collector.produces<artg4tk::ByParticle>(instance + "Edep");
       collector.produces<artg4tk::ByParticle>(instance + "NCeren");
     }
     else if (sd_name == "Calorimeter") {
       collector.produces<artg4tk::CalorimeterHitCollection>(instanceName(volume_name));
     }
     else if (sd_name == "PhotonDetector") {
       collector.produces<artg4tk::PhotonHitCollection>(instanceName(volume_name));
     }
     else if (sd_name == "Tracker") {
       collector.produces<artg4tk::TrackerHitCollection>(instanceName(volume_name));
     }
     else if (sd_name == "SimEnergyDeposit") {
       collector.produces<sim::SimEnergyDepositCollection>(instanceName(volume_name));
     }
     else if (sd_name == "AuxDet") {
       collector.produces<sim::AuxDetHitCollection>(instanceName(volume_name));
     }
     else if (sd_name == "HadInteraction") {
       collector.produces<artg4tk::ArtG4tkVtx>(); // do NOT use product instance name (for now)
     }
     else if (sd_name == "HadIntAndEdepTrk") {
       collector.produces<artg4tk::ArtG4tkVtx>();
       collector.produces<artg4tk::TrackerHitCollection>();
     }
   }
 }

void larg4::LArG4DetectorService::doFillEventWithArtHits ( G4HCofThisEvent * hc )

overrideprivatevirtual

Reimplemented from artg4tk::DetectorBase.

Definition at line 430 of file LArG4Detector.cc.

References detectors_, e, artg4tk::DetectorHolderService::getCurrArtEvent(), larg4::SimEnergyDepositSD::GetHits(), larg4::AuxDetSD::GetHits(), larg4::ParticleListActionService::GetTargetIDMap(), instanceName(), art::Event::put(), updateAuxDetHits_, and updateSimEnergyDeposits_.

 {
   //
   // NOTE(JVY): 1st hadronic interaction will be fetched as-is from HadInteractionSD
   //            a copy (via copy ctor) will be placed directly into art::Event
   //
   G4SDManager* sdman = G4SDManager::GetSDMpointer();
   art::ServiceHandle<artg4tk::DetectorHolderService> detectorHolder;
   art::Event& e = detectorHolder->getCurrArtEvent();
 
   //add in PartliceListActionService ...
   art::ServiceHandle<larg4::ParticleListActionService> particleListAction;
 
   for (auto const& [volume_name, sd_name] : detectors_) {
     auto sd = sdman->FindSensitiveDetector(volume_name + "_" + sd_name);
     if (sd_name == "HadInteraction") {
       if (auto hisd = dynamic_cast<artg4tk::HadInteractionSD*>(sd)) {
         if (auto const& inter = hisd->Get1stInteraction(); inter.GetNumOutcoming() > 0) {
           e.put(make_product(inter));
         }
         hisd->clear();
       }
     }
     else if (sd_name == "HadIntAndEdepTrk") {
       if (auto trksd = dynamic_cast<artg4tk::HadIntAndEdepTrkSD*>(sd)) {
         if (auto const& inter = trksd->Get1stInteraction(); inter.GetNumOutcoming() > 0) {
           e.put(make_product(inter));
         }
         if (auto const& trkhits = trksd->GetEdepTrkHits(); !trkhits.empty()) {
           e.put(make_product(trkhits));
         }
         trksd->clear();
       }
     }
     else if (sd_name == "Tracker") {
       auto trsd = dynamic_cast<artg4tk::TrackerSD*>(sd);
       e.put(make_product(trsd->GetHits()), instanceName(volume_name));
     }
     else if (sd_name == "SimEnergyDeposit") {
       auto sedsd = dynamic_cast<SimEnergyDepositSD*>(sd);
       sim::SimEnergyDepositCollection hitCollection = sedsd->GetHits();
       std::map<int, int> tmap = particleListAction->GetTargetIDMap();
       if (updateSimEnergyDeposits_) {
         for (auto& hit : hitCollection) {
           hit.setTrackID(tmap[hit.TrackID()]);
         }
       }
       e.put(make_product(hitCollection), instanceName(volume_name));
     }
     else if (sd_name == "AuxDet") {
       auto auxsd = dynamic_cast<AuxDetSD*>(sd);
       sim::AuxDetHitCollection hitCollection = auxsd->GetHits();
       std::map<int, int> tmap = particleListAction->GetTargetIDMap();
       if (updateAuxDetHits_) {
         for (auto& hit : hitCollection) {
           hit.SetTrackID(tmap[hit.GetTrackID()]);
         }
       }
       e.put(make_product(auxsd->GetHits()), instanceName(volume_name));
     }
     else if (sd_name == "Calorimeter") {
       auto calsd = dynamic_cast<artg4tk::CalorimeterSD*>(sd);
       e.put(make_product(calsd->GetHits()), instanceName(volume_name));
     }
     else if (sd_name == "DRCalorimeter") {
       auto drcalsd = dynamic_cast<artg4tk::DRCalorimeterSD*>(sd);
       auto const identifier = instanceName(volume_name);
       e.put(make_product(drcalsd->GetHits()), identifier);
       e.put(make_product(drcalsd->GetEbyParticle()), identifier + "Edep");
       e.put(make_product(drcalsd->GetNCerenbyParticle()), identifier + "NCeren");
     }
     else if (sd_name == "PhotonDetector") {
       auto phsd = dynamic_cast<artg4tk::PhotonSD*>(sd);
       e.put(make_product(phsd->GetHits()), instanceName(volume_name));
     }
   }
 }

std::vector< G4VPhysicalVolume * > larg4::LArG4DetectorService::doPlaceToPVs ( std::vector< G4LogicalVolume * > )

overrideprivatevirtual

Implements artg4tk::DetectorBase.

Definition at line 319 of file LArG4Detector.cc.

 {
   // Note we don't use our input.
   std::vector<G4VPhysicalVolume*> myPVvec;
   G4PhysicalVolumeStore* pPVStore = G4PhysicalVolumeStore::GetInstance();
   myPVvec.push_back(pPVStore->at(
     pPVStore->size() - 1)); // only need to return the PV of the world  (last entry in Volume Store)
   return myPVvec;
 }

void artg4tk::DetectorBase::fillEventWithArtHits ( G4HCofThisEvent * hc )

inlineinherited

Definition at line 126 of file DetectorBase.hh.

     {
       doFillEventWithArtHits(hc);
     }

virtual void artg4tk::DetectorBase::initialize ( )

inlinevirtualinherited

Definition at line 95 of file DetectorBase.hh.

95 {};

std::string larg4::LArG4DetectorService::instanceName ( std::string const & volume_name ) const

private

Definition at line 390 of file LArG4Detector.cc.

References artg4tk::DetectorBase::myName().

Referenced by doCallArtProduces(), and doFillEventWithArtHits().

 {
   return myName() + volume_name;
 }

std::vector<G4LogicalVolume*> artg4tk::DetectorBase::lvs ( ) const

inlineinherited

Definition at line 142 of file DetectorBase.hh.

     {
       return _myLVs;
     }

std::string const& artg4tk::DetectorBase::motherCategory ( ) const

inlineinherited

Definition at line 163 of file DetectorBase.hh.

Referenced by artg4tk::DetectorHolderService::placeDetector().

     {
       return _motherCategory;
     }

std::string const& artg4tk::DetectorBase::myName ( ) const

inlineinherited

Definition at line 149 of file DetectorBase.hh.

Referenced by instanceName(), and artg4tk::DetectorHolderService::registerDetector().

     {
       return _myName;
     }

fhicl::ParameterSet const& artg4tk::DetectorBase::parameters ( ) const

inlineinherited

Definition at line 170 of file DetectorBase.hh.

Referenced by artg4tk::DetectorHolderService::getParametersForCategory().

     {
       return _myParams;
     }

std::vector<G4VPhysicalVolume*> artg4tk::DetectorBase::placeToPVs ( std::vector< G4LogicalVolume * > motherLVs )

inlineinherited

Definition at line 109 of file DetectorBase.hh.

Referenced by artg4tk::DetectorHolderService::placeDetector().

     {
       _myPVs = doPlaceToPVs(motherLVs);
       return _myPVs;
     }

std::vector<G4VPhysicalVolume*> artg4tk::DetectorBase::pvs ( ) const

inlineinherited

Definition at line 135 of file DetectorBase.hh.

     {
       return _myPVs;
     }

void larg4::LArG4DetectorService::setStepLimits ( )

private

Definition at line 330 of file LArG4Detector.cc.

References MF_LOG_DEBUG, MF_LOG_WARNING, overrideGDMLStepLimit_Map, and setGDMLVolumes_.

Referenced by doBuildLVs().

 {
   // -- D. Rivera : This function sets step limits for volumes provided in the configuration file
   //                and overrides the step limit (if any) set for the same volumes but from the GMDL
   //                geometry file. The GDML step limit (if provided in the gdml file) is set first
   //                and later overriden by this method if a valid volumeName,setStepLimit is provided.
   MF_LOG_WARNING("LArG4DetectorService::setStepLimits")
     << "Setting step limits from configuration"
     << " file. This will OVERRIDE redundant stepLimit(s) set in the GDML file. Note"
     << " that stepLimits are only active if enabled in the physicsListService via the"
     << " appropriate parameter.";
 
   std::string volumeName = "";
   G4LogicalVolume* setVol = nullptr;
   for (auto const& [name, newStepLimit] : overrideGDMLStepLimit_Map) {
     G4double previousStepLimit = 0.;
 
     // -- Check whether the volumeName provided corresponds to a valid volumeName in the geometry
     if (setVol = G4LogicalVolumeStore::GetInstance()->GetVolume(name, false); !setVol) {
       throw cet::exception("invalidInputVolumeName")
         << "Provided volume name : " << name << " not found!\n";
     }
 
     // -- get the G4LogicalVolume corresponding to the selectedVolume
     volumeName = setVol->GetName();
     MF_LOG_DEBUG("LArG4DetectorService::setStepLimits")
       << "Got logical volume with name: " << volumeName;
 
     G4UserLimits* fStepLimitOverride = new G4UserLimits();
     G4AutoDelete::Register(fStepLimitOverride);
 
     // -- check if a stepLimit for this volume has been set before:
     auto search = setGDMLVolumes_.find(volumeName);
     if (search != setGDMLVolumes_.end()) { // -- volume name found in override list
       previousStepLimit = (G4double)(search->second);
       if (newStepLimit != previousStepLimit) {
         MF_LOG_WARNING("LArG4DetectorService::setStepLimits")
           << "OVERRIDING PREVIOUSLY SET"
           << " STEPLIMIT FOR VOLUME : " << volumeName << " FROM " << previousStepLimit << " mm TO "
           << newStepLimit << " mm";
       }
       else {
         MF_LOG_WARNING("LArG4DetectorService::setStepLimits")
           << "New stepLimit matches previously"
           << " set stepLimit from the GDML file for volume : " << volumeName
           << " stepLimit : " << newStepLimit << " mm. Nothing will be changed.";
         continue;
       }
     } //--check if new steplimit differs from a previously set value
 
     fStepLimitOverride->SetMaxAllowedStep(newStepLimit); // -- !
     mf::LogInfo("LArG4DetectorService::setStepLimits")
       << "fStepLimitOverride:  " << newStepLimit / CLHEP::mm << " mm " << newStepLimit / CLHEP::cm
       << " cm "
       << "for volume: " << volumeName << "\n"
       << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
     setVol->SetUserLimits(fStepLimitOverride);
   } //--loop over input volumes
 } //--end of setStepLimit()