add access to number of thickness from geometry

Author: jbsauvan

L1Trigger/L1THGCal/interface/HGCalCoarseTriggerCellMapping.h

@@ -13,8 +13,11 @@ class HGCalCoarseTriggerCellMapping {
   std::vector<uint32_t> getConstituentTriggerCells(uint32_t ctcId) const;
   GlobalPoint getCoarseTriggerCellPosition(uint32_t ctcId) const;
   uint32_t getCoarseTriggerCellId(uint32_t detid) const;
-  void checkSizeValidity(int ctcSize) const;
-  void setGeometry(const HGCalTriggerGeometryBase* const geom) { triggerTools_.setGeometry(geom); }
+  void checkSizeValidity() const;
+  void setGeometry(const HGCalTriggerGeometryBase* const geom) {
+    triggerTools_.setGeometry(geom);
+    checkSizeValidity();
+  }
 
   static constexpr int kCTCsizeCoarse_ = 16;
   static constexpr int kCTCsizeMid_ = 8;
@@ -26,7 +29,6 @@ class HGCalCoarseTriggerCellMapping {
   static const std::map<int, int> kSplit_;
   static const std::map<int, int> kSplit_Scin_;
   static constexpr int kSTCidMaskInv_ = ~0xf;
-  static constexpr int kNThicknesses_ = 5;  // 4 silicon types + 1 for scintillator
   static constexpr int kNHGCalLayersMax_ = 52;
 
   static constexpr int kSplit_Coarse_ = 0;

L1Trigger/L1THGCal/interface/HGCalTriggerTools.h

@@ -42,6 +42,7 @@ class HGCalTriggerTools {
   GlobalPoint getTCPosition(const DetId& id) const;
   unsigned layers(ForwardSubdetector type) const;
   unsigned layers(DetId::Detector type) const;
+  unsigned nSiWaferTypes() const;
   unsigned layer(const DetId&) const;
   unsigned layerWithOffset(const DetId&) const;
   bool isEm(const DetId&) const;
@@ -86,8 +87,6 @@ class HGCalTriggerTools {
   DetId simToReco(const DetId&, const HGCalTopology&) const;
   unsigned triggerLayer(const unsigned id) const { return geom_->triggerLayer(id); }
 
-  static constexpr unsigned kScintillatorPseudoThicknessIndex_ = 4;
-
   enum SubDetectorType {
     hgcal_silicon_CEE,
     hgcal_silicon_CEH,
@@ -102,6 +101,7 @@ class HGCalTriggerTools {
   unsigned bhLayers_;
   unsigned noseLayers_;
   unsigned totalLayers_;
+  unsigned scintillatorPseudoThicknessIndex_;
 };
 
 #endif

L1Trigger/L1THGCal/interface/veryfrontend/HGCalVFESummationImpl.h

@@ -14,13 +14,16 @@ class HGCalVFESummationImpl {
 public:
   HGCalVFESummationImpl(const edm::ParameterSet& conf);
 
-  void setGeometry(const HGCalTriggerGeometryBase* const geom) { triggerTools_.setGeometry(geom); }
+  void setGeometry(const HGCalTriggerGeometryBase* const geom) {
+    triggerTools_.setGeometry(geom);
+    checkSizeValidity();
+  }
+  void checkSizeValidity() const;
   void triggerCellSums(const std::vector<std::pair<DetId, uint32_t> >&, std::unordered_map<uint32_t, uint32_t>&);
 
 private:
   double lsb_silicon_fC_;
   double lsb_scintillator_MIP_;
-  uint32_t nThickness_;
   std::vector<double> thresholds_silicon_;
   double threshold_scintillator_;
 

L1Trigger/L1THGCal/python/l1tHGCalConcentratorProducer_cfi.py

@@ -1,6 +1,6 @@
 import FWCore.ParameterSet.Config as cms
 import SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi as digiparam
-from Configuration.Eras.Modifier_phase2_hgcalV19_cff import phase2_hgcalV19
+from HLTrigger.Configuration.HLT_75e33.psets.hgcal_reco_constants_cfi import HGCAL_reco_constants as HGCAL_reco_constants
 
 # Digitization parameters
 adcSaturationBH_MIP = digiparam.hgchebackDigitizer.digiCfg.feCfg.adcSaturation_fC
@@ -12,14 +12,10 @@
 # <V19: 3 different silicon thicknesses/types (HD120, LD200, LD300) + scintillator portion
 # >=V19: 4 different silicon thicknesses/types (HD120, LD200, LD300, HD200) + scintillator portion
 MAX_LAYERS = 52
-N_THICKNESSES = 3
+N_THICKNESSES = HGCAL_reco_constants.numberOfThicknesses.value()
 CTC_2_SIZES = cms.vuint32( [2]*(MAX_LAYERS+1)*(N_THICKNESSES+1) )
 STC_4_AND_16_SIZES = cms.vuint32( [4]*(MAX_LAYERS+1)+ [16]*(MAX_LAYERS+1)*N_THICKNESSES )
 STC_4_AND_8_SIZES = cms.vuint32( [4]*(MAX_LAYERS+1)+ [8]*(MAX_LAYERS+1)*N_THICKNESSES )
-N_THICKNESSES_V19 = 4
-CTC_2_SIZES_V19 = cms.vuint32( [2]*(MAX_LAYERS+1)*(N_THICKNESSES_V19+1) )
-STC_4_AND_16_SIZES_V19 = cms.vuint32( [4]*(MAX_LAYERS+1)+ [16]*(MAX_LAYERS+1)*N_THICKNESSES_V19 )
-STC_4_AND_8_SIZES_V19 = cms.vuint32( [4]*(MAX_LAYERS+1)+ [8]*(MAX_LAYERS+1)*N_THICKNESSES_V19 )
 
 threshold_conc_proc = cms.PSet(ProcessorName  = cms.string('HGCalConcentratorProcessorSelection'),
                                Method = cms.vstring(['thresholdSelect']*3),
@@ -31,9 +27,6 @@
                                ctcSize = CTC_2_SIZES,
                                )
 
-phase2_hgcalV19.toModify(threshold_conc_proc, 
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 # Column is Nlinks, Row is NWafers
 # Requested size = 8(links)x8(wafers)
@@ -91,9 +84,6 @@
                           superTCCalibration_nose = vfe_proc.calibrationCfg_nose.clone(),
                           ctcSize = CTC_2_SIZES,
                           )
-phase2_hgcalV19.toModify(best_conc_proc, 
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 supertc_conc_proc = cms.PSet(ProcessorName  = cms.string('HGCalConcentratorProcessorSelection'),
                              Method = cms.vstring(['superTriggerCellSelect']*3),
@@ -110,10 +100,6 @@
                              superTCCalibration_hesc = vfe_proc.calibrationCfg_hesc.clone(),
                              superTCCalibration_nose = vfe_proc.calibrationCfg_nose.clone(),
                              )
-phase2_hgcalV19.toModify(supertc_conc_proc, 
-                         stcSize = STC_4_AND_16_SIZES_V19,
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 
 custom_conc_proc = cms.PSet(ProcessorName  = cms.string('HGCalConcentratorProcessorSelection'),
@@ -134,10 +120,6 @@
                           superTCCalibration_hesc = vfe_proc.calibrationCfg_hesc.clone(),
                           superTCCalibration_nose = vfe_proc.calibrationCfg_nose.clone(),
                           )
-phase2_hgcalV19.toModify(custom_conc_proc, 
-                         stcSize = STC_4_AND_16_SIZES_V19,
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 
 coarsetc_onebitfraction_proc = cms.PSet(ProcessorName  = cms.string('HGCalConcentratorProcessorSelection'),
@@ -158,10 +140,6 @@
                              superTCCalibration_hesc = vfe_proc.calibrationCfg_hesc.clone(),
                              superTCCalibration_nose = vfe_proc.calibrationCfg_nose.clone(),
                              )
-phase2_hgcalV19.toModify(coarsetc_onebitfraction_proc, 
-                         stcSize = STC_4_AND_8_SIZES_V19,
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 
 coarsetc_equalshare_proc = cms.PSet(ProcessorName  = cms.string('HGCalConcentratorProcessorSelection'),
@@ -179,10 +157,6 @@
                              superTCCalibration_hesc = vfe_proc.calibrationCfg_hesc.clone(),
                              superTCCalibration_nose = vfe_proc.calibrationCfg_nose.clone(),
 )
-phase2_hgcalV19.toModify(coarsetc_equalshare_proc, 
-                         stcSize = STC_4_AND_8_SIZES_V19,
-                         ctcSize = CTC_2_SIZES_V19,
-                         ) 
 
 
 autoencoder_triggerCellRemap = [0,16, 32,

L1Trigger/L1THGCal/python/l1tHGCalVFEProducer_cfi.py

@@ -143,11 +143,7 @@
     eeDigis = cms.InputTag('simHGCalUnsuppressedDigis:EE'),
     fhDigis = cms.InputTag('simHGCalUnsuppressedDigis:HEfront'),
     bhDigis = cms.InputTag('simHGCalUnsuppressedDigis:HEback'),
-    ProcessorParameters = vfe_proc.clone(
-        summationCfg = vfe_proc.summationCfg.clone(
-            numberOfThicknesses = HGCAL_reco_constants.numberOfThicknesses
-        )
-    )
+    ProcessorParameters = vfe_proc.clone()
 )
 
 l1tHFnoseVFEProducer = cms.EDProducer(

L1Trigger/L1THGCal/src/HGCalCoarseTriggerCellMapping.cc

@@ -2,16 +2,7 @@
 #include "DataFormats/ForwardDetId/interface/HGCalTriggerDetId.h"
 
 HGCalCoarseTriggerCellMapping::HGCalCoarseTriggerCellMapping(const std::vector<unsigned>& ctcSize)
-    : ctcSize_(!ctcSize.empty() ? ctcSize
-                                : std::vector<unsigned>{kNHGCalLayersMax_ * kNThicknesses_, kCTCsizeVeryFine_}) {
-  if (ctcSize_.size() != (kNHGCalLayersMax_ + 1) * kNThicknesses_) {
-    throw cms::Exception("HGCTriggerParameterError")
-        << "Inconsistent size of coarse trigger cell size vector " << ctcSize_.size();
-  }
-
-  for (auto ctc : ctcSize_)
-    checkSizeValidity(ctc);
-}
+    : ctcSize_(ctcSize) {}
 
 const std::map<int, int> HGCalCoarseTriggerCellMapping::kSplit_ = {
     {kCTCsizeIndividual_, kSplit_Individual_},
@@ -29,12 +20,19 @@ const std::map<int, int> HGCalCoarseTriggerCellMapping::kSplit_Scin_ = {
     {kCTCsizeCoarse_, kSplit_Scin_Coarse_},
 };
 
-void HGCalCoarseTriggerCellMapping::checkSizeValidity(int ctcSize) const {
-  if (ctcSize != kCTCsizeFine_ && ctcSize != kCTCsizeCoarse_ && ctcSize != kCTCsizeMid_ &&
-      ctcSize != kCTCsizeVeryFine_ && ctcSize != kCTCsizeIndividual_) {
+void HGCalCoarseTriggerCellMapping::checkSizeValidity() const {
+  unsigned nThickness = triggerTools_.nSiWaferTypes() + 1;  // +1 for scintillator
+  if (ctcSize_.size() != (kNHGCalLayersMax_ + 1) * nThickness) {
     throw cms::Exception("HGCTriggerParameterError")
-        << "Coarse Trigger Cell should be of size " << kCTCsizeIndividual_ << " or " << kCTCsizeVeryFine_ << " or "
-        << kCTCsizeFine_ << " or " << kCTCsizeMid_ << " or " << kCTCsizeCoarse_;
+        << "Inconsistent size of coarse trigger cell size vector " << ctcSize_.size();
+  }
+  for (auto ctcSize : ctcSize_) {
+    if (ctcSize != kCTCsizeFine_ && ctcSize != kCTCsizeCoarse_ && ctcSize != kCTCsizeMid_ &&
+        ctcSize != kCTCsizeVeryFine_ && ctcSize != kCTCsizeIndividual_) {
+      throw cms::Exception("HGCTriggerParameterError")
+          << "Coarse Trigger Cell should be of size " << kCTCsizeIndividual_ << " or " << kCTCsizeVeryFine_ << " or "
+          << kCTCsizeFine_ << " or " << kCTCsizeMid_ << " or " << kCTCsizeCoarse_;
+    }
   }
 }
 

L1Trigger/L1THGCal/src/HGCalTriggerTools.cc

@@ -46,6 +46,7 @@ void HGCalTriggerTools::setGeometry(const HGCalTriggerGeometryBase* const geom)
 
   bhLayers_ = geom_->hscTopology().dddConstants().layers(true);
   totalLayers_ = eeLayers_ + fhLayers_;
+  scintillatorPseudoThicknessIndex_ = nSiWaferTypes() + 1;
 }
 
 GlobalPoint HGCalTriggerTools::getTCPosition(const DetId& id) const {
@@ -105,6 +106,8 @@ unsigned HGCalTriggerTools::layers(DetId::Detector type) const {
   return layers;
 }
 
+unsigned HGCalTriggerTools::nSiWaferTypes() const { return geom_->eeTopology().dddConstants().waferTypes(); }
+
 unsigned HGCalTriggerTools::layer(const DetId& id) const {
   unsigned int layer = std::numeric_limits<unsigned int>::max();
   if (id.det() == DetId::Forward && id.subdetId() == ForwardSubdetector::HFNose) {
@@ -266,7 +269,7 @@ int HGCalTriggerTools::zside(const DetId& id) const {
 
 int HGCalTriggerTools::thicknessIndex(const DetId& id) const {
   if (isScintillator(id)) {
-    return kScintillatorPseudoThicknessIndex_;
+    return scintillatorPseudoThicknessIndex_;
   }
   unsigned det = id.det();
   int thickness = 0;

L1Trigger/L1THGCal/src/veryfrontend/HGCalVFESummationImpl.cc

@@ -3,14 +3,9 @@
 
 HGCalVFESummationImpl::HGCalVFESummationImpl(const edm::ParameterSet& conf)
     : lsb_silicon_fC_(conf.getParameter<double>("siliconCellLSB_fC")),
-      lsb_scintillator_MIP_(conf.getParameter<double>("scintillatorCellLSB_MIP")),
-      nThickness_(conf.getParameter<uint32_t>("numberOfThicknesses")) {
+      lsb_scintillator_MIP_(conf.getParameter<double>("scintillatorCellLSB_MIP")) {
   thresholds_silicon_ =
       conf.getParameter<edm::ParameterSet>("noiseSilicon").getParameter<std::vector<double>>("values");
-  if (thresholds_silicon_.size() != nThickness_) {
-    throw cms::Exception("Configuration") << thresholds_silicon_.size() << " silicon thresholds are given instead of "
-                                          << nThickness_ << " (the number of sensor thicknesses)";
-  }
   threshold_scintillator_ = conf.getParameter<edm::ParameterSet>("noiseScintillator").getParameter<double>("noise_MIP");
   const auto threshold = conf.getParameter<double>("noiseThreshold");
   std::transform(
@@ -20,6 +15,14 @@ HGCalVFESummationImpl::HGCalVFESummationImpl(const edm::ParameterSet& conf)
   threshold_scintillator_ *= threshold;
 }
 
+void HGCalVFESummationImpl::checkSizeValidity() const {
+  unsigned nThickness = triggerTools_.nSiWaferTypes();
+  if (thresholds_silicon_.size() != nThickness) {
+    throw cms::Exception("Configuration") << thresholds_silicon_.size() << " silicon thresholds are given instead of "
+                                          << nThickness << " (the number of sensor thicknesses)";
+  }
+}
+
 void HGCalVFESummationImpl::triggerCellSums(const std::vector<std::pair<DetId, uint32_t>>& input_dataframes,
                                             std::unordered_map<uint32_t, uint32_t>& triggercells) {
   if (input_dataframes.empty())

L1Trigger/L1THGCalUtilities/test/testHGCalL1T_multialgo_V19_cfg.py

@@ -0,0 +1,117 @@
+import FWCore.ParameterSet.Config as cms 
+
+from Configuration.Eras.Era_Phase2C26I13M9_cff import Phase2C26I13M9
+process = cms.Process('DIGI',Phase2C26I13M9)
+
+# import of standard configurations
+process.load('Configuration.StandardSequences.Services_cff')
+process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load('Configuration.EventContent.EventContent_cff')
+process.load('SimGeneral.MixingModule.mixNoPU_cfi')
+process.load('Configuration.Geometry.GeometryExtendedRun4D120Reco_cff')
+process.load('Configuration.StandardSequences.MagneticField_cff')
+process.load('Configuration.StandardSequences.Generator_cff')
+process.load('IOMC.EventVertexGenerators.VtxSmearedHLLHC14TeV_cfi')
+process.load('GeneratorInterface.Core.genFilterSummary_cff')
+process.load('Configuration.StandardSequences.SimIdeal_cff')
+process.load('Configuration.StandardSequences.Digi_cff')
+process.load('Configuration.StandardSequences.SimL1Emulator_cff')
+process.load('Configuration.StandardSequences.DigiToRaw_cff')
+process.load('Configuration.StandardSequences.EndOfProcess_cff')
+process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
+
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(5)
+)
+
+# Input source
+process.source = cms.Source("PoolSource",
+                            fileNames = cms.untracked.vstring('file:step2.root'),
+       inputCommands=cms.untracked.vstring(
+           'keep *',
+           )
+       )
+
+process.options = cms.untracked.PSet(
+
+)
+
+# Production Info
+process.configurationMetadata = cms.untracked.PSet(
+    version = cms.untracked.string('$Revision: 1.20 $'),
+    annotation = cms.untracked.string('SingleElectronPt10_cfi nevts:10'),
+    name = cms.untracked.string('Applications')
+)
+
+# Output definition
+process.TFileService = cms.Service(
+    "TFileService",
+    fileName = cms.string("ntuple.root")
+    )
+
+# Other statements
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_T21', '')
+
+# load HGCAL TPG simulation
+process.load('L1Trigger.L1THGCal.hgcalTriggerPrimitives_cff')
+process.load('L1Trigger.L1THGCalUtilities.HGC3DClusterGenMatchSelector_cff')
+process.load('L1Trigger.L1THGCalUtilities.hgcalTriggerNtuples_cff')
+from L1Trigger.L1THGCalUtilities.hgcalTriggerChains import HGCalTriggerChains
+import L1Trigger.L1THGCalUtilities.vfe as vfe
+import L1Trigger.L1THGCalUtilities.concentrator as concentrator
+import L1Trigger.L1THGCalUtilities.clustering2d as clustering2d
+import L1Trigger.L1THGCalUtilities.clustering3d as clustering3d
+import L1Trigger.L1THGCalUtilities.selectors as selectors
+import L1Trigger.L1THGCalUtilities.customNtuples as ntuple
+
+
+chains = HGCalTriggerChains()
+# Register algorithms
+## VFE
+chains.register_vfe("Floatingpoint", vfe.CreateVfe())
+## ECON
+chains.register_concentrator("Supertriggercell", concentrator.CreateSuperTriggerCell())
+chains.register_concentrator("Threshold", concentrator.CreateThreshold())
+chains.register_concentrator("Bestchoice", concentrator.CreateBestChoice())
+chains.register_concentrator("Mixed", concentrator.CreateMixedFeOptions())
+## BE1
+chains.register_backend1("Dummy", clustering2d.CreateDummy())
+## BE2
+chains.register_backend2("Histomax", clustering3d.CreateHistoMax())
+# Register selector
+chains.register_selector("Genmatch", selectors.CreateGenMatch())
+
+
+# Register ntuples
+ntuple_list = ['event', 'gen', 'multiclusters']
+chains.register_ntuple("Genclustersntuple", ntuple.CreateNtuple(ntuple_list))
+
+# Register trigger chains
+concentrator_algos = ['Supertriggercell', 'Threshold', 'Bestchoice', 'Mixed']
+backend_algos = ['Histomax']
+## Make cross product fo ECON and BE algos
+import itertools
+for cc,be in itertools.product(concentrator_algos,backend_algos):
+    chains.register_chain('Floatingpoint', cc, 'Dummy', be, 'Genmatch', 'Genclustersntuple')
+
+process = chains.create_sequences(process)
+
+# Remove towers from sequence
+process.L1THGCalTriggerPrimitives.remove(process.L1THGCalTowerMap)
+process.L1THGCalTriggerPrimitives.remove(process.L1THGCalTower)
+
+process.hgcl1tpg_step = cms.Path(process.L1THGCalTriggerPrimitives)
+process.selector_step = cms.Path(process.L1THGCalTriggerSelector)
+process.ntuple_step = cms.Path(process.L1THGCalTriggerNtuples)
+
+# Schedule definition
+process.schedule = cms.Schedule(process.hgcl1tpg_step, process.selector_step, process.ntuple_step)
+
+# Add early deletion of temporary data products to reduce peak memory need
+from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete
+process = customiseEarlyDelete(process)
+# End adding early deletion
+