DDG4ProductionCuts Class Reference

#include <DDG4ProductionCuts.h>

Public Member Functions
	DDG4ProductionCuts (const G4LogicalVolumeToDDLogicalPartMap *, int, bool)
	DDG4ProductionCuts (const dd4hep::SpecParRegistry *, const dd4hep::sim::Geant4GeometryMaps::VolumeMap *, int, bool)

Private Member Functions
void	dd4hepInitialize ()
void	initialize ()
void	setProdCuts (const DDLogicalPart, G4Region *)
void	setProdCuts (const dd4hep::SpecPar *, G4Region *)

Private Attributes
const dd4hep::sim::Geant4GeometryMaps::VolumeMap *	dd4hepMap_ = nullptr
std::vector< std::pair< G4LogicalVolume *, const dd4hep::SpecPar * > >	dd4hepVec_
const std::string	keywordRegion_
const G4LogicalVolumeToDDLogicalPartMap *	map_ = nullptr
const bool	protonCut_
const dd4hep::SpecParRegistry *	specPars_
G4LogicalVolumeToDDLogicalPartMap::Vector	vec_
const int	verbosity_

Detailed Description

Definition at line 15 of file DDG4ProductionCuts.h.

Constructor & Destructor Documentation

DDG4ProductionCuts() [1/2]

DDG4ProductionCuts::DDG4ProductionCuts ( const G4LogicalVolumeToDDLogicalPartMap *  map, int  verb, bool  pcut  )

explicit

Definition at line 53 of file DDG4ProductionCuts.cc.

References initialize().

    : map_(map), keywordRegion_("CMSCutsRegion"), verbosity_(verb), protonCut_(pcut) {
  initialize();
}

DDG4ProductionCuts() [2/2]

DDG4ProductionCuts::DDG4ProductionCuts ( const dd4hep::SpecParRegistry *  specPars, const dd4hep::sim::Geant4GeometryMaps::VolumeMap *  map, int  verb, bool  pcut  )

explicit

Definition at line 58 of file DDG4ProductionCuts.cc.

References dd4hepInitialize().

    : dd4hepMap_(map), specPars_(specPars), keywordRegion_("CMSCutsRegion"), verbosity_(verb), protonCut_(pcut) {
  dd4hepInitialize();
}

Member Function Documentation

dd4hepInitialize()

void DDG4ProductionCuts::dd4hepInitialize ( )

private

Definition at line 114 of file DDG4ProductionCuts.cc.

References dd4hepMap_, dd4hepVec_, mps_fire::end, findQualityFiles::jj, keywordRegion_, dqm-mbProfile::log, Skims_PA_cff::name, HLT_2022v14_cff::region, corrVsCorr::selection, setProdCuts(), jetUpdater_cfi::sort, specPars_, HistogramManager_cfi::specs, and verbosity_.

Referenced by DDG4ProductionCuts().

                                          {
  dd4hep::SpecParRefs specs;
  specPars_->filter(specs, keywordRegion_);

  // LOOP ON ALL LOGICAL VOLUMES
  for (auto const& it : *dd4hepMap_) {
    bool foundMatch = false;  // Same behavior as in DDD: when matching SpecPar is found, stop search!
    // SEARCH ON ALL SPECPARS
    for (auto const& fit : specs) {
      for (auto const& pit : fit.second->paths) {
        const std::string_view selection = dd4hep::dd::noNamespace(dd4hep::dd::realTopName(pit));
        const std::string_view name = dd4hep::dd::noNamespace(it.first.name());
        if (!(dd4hep::dd::isRegex(selection))
                ? dd4hep::dd::compareEqual(name, selection)
                : std::regex_match(name.begin(), name.end(), std::regex(selection.begin(), selection.end()))) {
          dd4hepVec_.emplace_back(std::make_pair<G4LogicalVolume*, const dd4hep::SpecPar*>(&*it.second, &*fit.second));
          foundMatch = true;
          break;
        }
      }
      if (foundMatch)
        break;
    }  // Search on all SpecPars
  }    // Loop on all logical volumes

  // sort all root volumes - to get the same sequence at every run of the application.
  sort(begin(dd4hepVec_), end(dd4hepVec_), &sortByName);

  // Now generate all the regions
  for (auto const& it : dd4hepVec_) {
    auto regName = it.second->strValue(keywordRegion_);
    G4Region* region = G4RegionStore::GetInstance()->FindOrCreateRegion({regName.data(), regName.size()});

    region->AddRootLogicalVolume(it.first);
    edm::LogVerbatim("Geometry") << it.first->GetName() << ": " << regName;
    edm::LogVerbatim("Geometry") << " MakeRegions: added " << it.first->GetName() << " to region " << region->GetName();

    // Also treat reflected volumes
    const G4String& nonReflectedG4Name = it.first->GetName();
    const G4String& reflectedG4Name = nonReflectedG4Name + "_refl";
    const G4LogicalVolumeStore* const allG4LogicalVolumes = G4LogicalVolumeStore::GetInstance();
    const auto reflectedG4LogicalVolumeIt = std::find_if(
        allG4LogicalVolumes->begin(), allG4LogicalVolumes->end(), [&](const G4LogicalVolume* const aG4LogicalVolume) {
          return (aG4LogicalVolume->GetName() == reflectedG4Name);
        });
    // If G4 Logical volume has a reflected volume, add it to the region as well.
    if (reflectedG4LogicalVolumeIt != allG4LogicalVolumes->end()) {
      region->AddRootLogicalVolume(*reflectedG4LogicalVolumeIt);
      edm::LogVerbatim("Geometry") << " MakeRegions: added " << (*reflectedG4LogicalVolumeIt)->GetName()
                                   << " to region " << region->GetName();
    }

    edm::LogVerbatim("Geometry").log([&](auto& log) {
      for (auto const& sit : it.second->spars) {
        log << sit.first << " =  " << sit.second[0] << "\n";
      }
    });
    setProdCuts(it.second, region);
  }

  if (verbosity_ > 0) {
    edm::LogVerbatim("SimG4CoreGeometry") << " DDG4ProductionCuts (New) : starting\n"
                                          << " DDG4ProductionCuts : Got " << dd4hepVec_.size() << " region roots.\n"
                                          << " DDG4ProductionCuts : List of all roots:";
    for (size_t jj = 0; jj < dd4hepVec_.size(); ++jj)
      edm::LogVerbatim("SimG4CoreGeometry") << "   DDG4ProductionCuts : root=" << dd4hepVec_[jj].first->GetName()
                                            << " , " << dd4hepVec_[jj].second->paths.at(0);
  }
}

initialize()

void DDG4ProductionCuts::initialize ( void  )

private

Definition at line 66 of file DDG4ProductionCuts.cc.

References DDMapper< KeyType, ValueType >::all(), Exception, keywordRegion_, map_, EgammaValidation_cff::num, HLT_2022v14_cff::region, setProdCuts(), jetUpdater_cfi::sort, AlCaHLTBitMon_QueryRunRegistry::string, DDMapper< KeyType, ValueType >::toString(), vec_, and verbosity_.

Referenced by DDG4ProductionCuts().

                                    {
  vec_ = map_->all(keywordRegion_);
  // sort all root volumes - to get the same sequence at every run of the application.
  // (otherwise, the sequence will depend on the pointer (memory address) of the
  // involved objects, because 'new' does no guarantee that you allways get a
  // higher (or lower) address when allocating an object of the same type ...
  sort(vec_.begin(), vec_.end(), &dd_is_greater);
  if (verbosity_ > 0) {
    edm::LogVerbatim("Geometry") << " DDG4ProductionCuts : got " << vec_.size() << " region roots.\n"
                                 << " DDG4ProductionCuts : List of all roots:";
    for (auto const& vv : vec_)
      edm::LogVerbatim("Geometry") << "    " << vv.first->GetName() << " : " << vv.second.name();
  }

  // Now generate all the regions
  std::string curName = "";
  std::string regionName = "";
  G4Region* region = nullptr;
  G4RegionStore* store = G4RegionStore::GetInstance();
  for (auto const& vv : vec_) {
    unsigned int num = map_->toString(keywordRegion_, vv.second, regionName);
    edm::LogVerbatim("Geometry") << "  num  " << num << " regionName: " << regionName << ", the store of size "
                                 << store->size();
    if (num != 1) {
      throw cms::Exception("SimG4CoreGeometry", " DDG4ProductionCuts::initialize: Problem with Region tags.");
      return;
    }
    if (regionName != curName) {
      edm::LogVerbatim("Geometry") << "DDG4ProductionCuts : regionName " << regionName << ", the store of size "
                                   << store->size();
      region = store->FindOrCreateRegion(regionName);
      edm::LogVerbatim("Geometry") << "DDG4ProductionCuts : region " << region->GetName();
      if (nullptr == region) {
        throw cms::Exception("SimG4CoreGeometry", " DDG4ProductionCuts::initialize: Problem with Region tags.");
        return;
      }
      curName = regionName;
      edm::LogVerbatim("Geometry") << "DDG4ProductionCuts : new G4Region " << vv.first->GetName();
      setProdCuts(vv.second, region);
    }
    if (nullptr != region) {
      region->AddRootLogicalVolume(vv.first);
      if (verbosity_ > 0)
        edm::LogVerbatim("Geometry") << "  added " << vv.first->GetName() << " to region " << region->GetName();
    }
  }
}

setProdCuts() [1/2]

void DDG4ProductionCuts::setProdCuts ( const DDLogicalPart  lpart, G4Region *  region  )

private

Definition at line 184 of file DDG4ProductionCuts.cc.

References Exception, map_, protonCut_, HLT_2022v14_cff::region, groupFilesInBlocks::temp, DDMapper< KeyType, ValueType >::toDouble(), and verbosity_.

Referenced by dd4hepInitialize(), and initialize().

                                                                                {
  //
  // search for production cuts
  // you must have four of them: e+ e- gamma proton
  //
  double gammacut = 0.0;
  double electroncut = 0.0;
  double positroncut = 0.0;
  double protoncut = 0.0;
  int temp = map_->toDouble("ProdCutsForGamma", lpart, gammacut);
  if (temp != 1) {
    throw cms::Exception(
        "SimG4CorePhysics",
        " DDG4ProductionCuts::setProdCuts: Problem with Region tags - no/more than one ProdCutsForGamma.");
  }
  temp = map_->toDouble("ProdCutsForElectrons", lpart, electroncut);
  if (temp != 1) {
    throw cms::Exception(
        "SimG4CorePhysics",
        " DDG4ProductionCuts::setProdCuts: Problem with Region tags - no/more than one ProdCutsForElectrons.");
  }
  temp = map_->toDouble("ProdCutsForPositrons", lpart, positroncut);
  if (temp != 1) {
    throw cms::Exception(
        "SimG4CorePhysics",
        " DDG4ProductionCuts::setProdCuts: Problem with Region tags - no/more than one ProdCutsForPositrons.");
  }
  temp = map_->toDouble("ProdCutsForProtons", lpart, protoncut);
  if (temp == 0) {
    // There is no ProdCutsForProtons set in XML,
    // check if it's a legacy geometry scenario without it
    if (protonCut_) {
      protoncut = electroncut;
    } else {
      protoncut = 0.;
    }
  } else if (temp != 1) {
    throw cms::Exception(
        "SimG4CorePhysics",
        " DDG4ProductionCuts::setProdCuts: Problem with Region tags - more than one ProdCutsForProtons.");
  }

  //
  // Create and fill production cuts
  //
  G4ProductionCuts* prodCuts = region->GetProductionCuts();
  if (nullptr == prodCuts) {
    prodCuts = new G4ProductionCuts();
    region->SetProductionCuts(prodCuts);
  }
  prodCuts->SetProductionCut(gammacut, idxG4GammaCut);
  prodCuts->SetProductionCut(electroncut, idxG4ElectronCut);
  prodCuts->SetProductionCut(positroncut, idxG4PositronCut);
  prodCuts->SetProductionCut(protoncut, idxG4ProtonCut);
  if (verbosity_ > 0) {
    edm::LogVerbatim("Geometry") << "DDG4ProductionCuts : Setting cuts for " << region->GetName()
                                 << "\n    Electrons: " << electroncut << "\n    Positrons: " << positroncut
                                 << "\n    Gamma    : " << gammacut << "\n    Proton   : " << protoncut;
  }
}

setProdCuts() [2/2]

void DDG4ProductionCuts::setProdCuts ( const dd4hep::SpecPar *  spec, G4Region *  region  )

private

Definition at line 245 of file DDG4ProductionCuts.cc.

References HLT_2022v14_cff::region, and verbosity_.

                                                                                {
  //
  // Create and fill production cuts
  //
  G4ProductionCuts* prodCuts = region->GetProductionCuts();
  if (!prodCuts) {
    //
    // search for production cuts
    // you must have four of them: e+ e- gamma proton
    //
    double gammacut = spec->dblValue("ProdCutsForGamma") / dd4hep::mm;  // Convert from DD4hep units to mm
    double electroncut = spec->dblValue("ProdCutsForElectrons") / dd4hep::mm;
    double positroncut = spec->dblValue("ProdCutsForPositrons") / dd4hep::mm;
    double protoncut = spec->dblValue("ProdCutsForProtons") / dd4hep::mm;
    if (protoncut == 0) {
      protoncut = electroncut;
    }

    prodCuts = new G4ProductionCuts();
    region->SetProductionCuts(prodCuts);

    prodCuts->SetProductionCut(gammacut, idxG4GammaCut);
    prodCuts->SetProductionCut(electroncut, idxG4ElectronCut);
    prodCuts->SetProductionCut(positroncut, idxG4PositronCut);
    prodCuts->SetProductionCut(protoncut, idxG4ProtonCut);
    if (verbosity_ > 0) {
      edm::LogVerbatim("Geometry") << "DDG4ProductionCuts : Setting cuts for " << region->GetName()
                                   << "\n    Electrons: " << electroncut << "\n    Positrons: " << positroncut
                                   << "\n    Gamma    : " << gammacut << "\n    Proton   : " << protoncut;
    }
  } else {
    if (verbosity_ > 0) {
      edm::LogVerbatim("Geometry")
          << "DDG4ProductionCuts : Cuts are already set for " << region->GetName()
          << "\n    Electrons: " << region->GetProductionCuts()->GetProductionCut(idxG4ElectronCut)
          << "\n    Positrons: " << region->GetProductionCuts()->GetProductionCut(idxG4PositronCut)
          << "\n    Gamma    : " << region->GetProductionCuts()->GetProductionCut(idxG4GammaCut)
          << "\n    Proton   : " << region->GetProductionCuts()->GetProductionCut(idxG4ProtonCut);
    }
  }
}

Member Data Documentation

dd4hepMap_

const dd4hep::sim::Geant4GeometryMaps::VolumeMap* DDG4ProductionCuts::dd4hepMap_ = nullptr

private

Definition at line 37 of file DDG4ProductionCuts.h.

Referenced by dd4hepInitialize().

dd4hepVec_

std::vector<std::pair<G4LogicalVolume*, const dd4hep::SpecPar*> > DDG4ProductionCuts::dd4hepVec_

private

Definition at line 38 of file DDG4ProductionCuts.h.

Referenced by dd4hepInitialize().

keywordRegion_

const std::string DDG4ProductionCuts::keywordRegion_

private

Definition at line 43 of file DDG4ProductionCuts.h.

Referenced by dd4hepInitialize(), and initialize().

map_

const G4LogicalVolumeToDDLogicalPartMap* DDG4ProductionCuts::map_ = nullptr

private

Definition at line 28 of file DDG4ProductionCuts.h.

Referenced by initialize(), and setProdCuts().

protonCut_

const bool DDG4ProductionCuts::protonCut_

private

Definition at line 45 of file DDG4ProductionCuts.h.

Referenced by setProdCuts().

specPars_

const dd4hep::SpecParRegistry* DDG4ProductionCuts::specPars_

private

Definition at line 39 of file DDG4ProductionCuts.h.

Referenced by dd4hepInitialize().

vec_

G4LogicalVolumeToDDLogicalPartMap::Vector DDG4ProductionCuts::vec_

private

Definition at line 29 of file DDG4ProductionCuts.h.

Referenced by initialize().

verbosity_

const int DDG4ProductionCuts::verbosity_

private

Definition at line 44 of file DDG4ProductionCuts.h.

Referenced by dd4hepInitialize(), initialize(), and setProdCuts().