#include <HGCalVFEProcessorSums.h>

Inheritance diagram for HGCalVFEProcessorSums:

Public Member Functions
	HGCalVFEProcessorSums (const edm::ParameterSet &conf)

void	run (const HGCalDigiCollection &digiColl, l1t::HGCalTriggerCellBxCollection &triggerCellColl, const edm::EventSetup &es) override

Public Member Functions inherited from HGCalProcessorBaseT< InputCollection, OutputCollection >
virtual void	eventSetup (const edm::EventSetup &es)

	HGCalProcessorBaseT (const edm::ParameterSet &conf)

const std::string &	name () const

virtual void	run (const InputCollection &inputColl, OutputCollection &outColl, const edm::EventSetup &es)=0

void	setGeometry (const HGCalTriggerGeometryBase *const geom)

virtual	~HGCalProcessorBaseT ()

Private Attributes
std::unique_ptr< HGCalTriggerCellCalibration >	calibrationEE_

std::unique_ptr< HGCalTriggerCellCalibration >	calibrationHEsc_

std::unique_ptr< HGCalTriggerCellCalibration >	calibrationHEsi_

std::unique_ptr< HGCalTriggerCellCalibration >	calibrationNose_

HGCalTriggerTools	triggerTools_

std::unique_ptr< HGCalVFECompressionImpl >	vfeCompressionHDMImpl_

std::unique_ptr< HGCalVFECompressionImpl >	vfeCompressionLDMImpl_

std::unique_ptr< HGCalVFELinearizationImpl >	vfeLinearizationScImpl_

std::unique_ptr< HGCalVFELinearizationImpl >	vfeLinearizationSiImpl_

std::unique_ptr< HGCalVFESummationImpl >	vfeSummationImpl_

Additional Inherited Members
Protected Attributes inherited from HGCalProcessorBaseT< InputCollection, OutputCollection >
const HGCalTriggerGeometryBase *	geometry_

Detailed Description

Definition at line 12 of file HGCalVFEProcessorSums.h.

Constructor & Destructor Documentation

◆ HGCalVFEProcessorSums()

HGCalVFEProcessorSums::HGCalVFEProcessorSums ( const edm::ParameterSet & conf )

Definition at line 5 of file HGCalVFEProcessorSums.cc.

                                                                         : HGCalVFEProcessorBase(conf) {
   vfeLinearizationSiImpl_ =
       std::make_unique<HGCalVFELinearizationImpl>(conf.getParameter<edm::ParameterSet>("linearizationCfg_si"));
   vfeLinearizationScImpl_ =
       std::make_unique<HGCalVFELinearizationImpl>(conf.getParameter<edm::ParameterSet>("linearizationCfg_sc"));
  
   vfeSummationImpl_ = std::make_unique<HGCalVFESummationImpl>(conf.getParameter<edm::ParameterSet>("summationCfg"));
  
   vfeCompressionLDMImpl_ =
       std::make_unique<HGCalVFECompressionImpl>(conf.getParameter<edm::ParameterSet>("compressionCfg_ldm"));
   vfeCompressionHDMImpl_ =
       std::make_unique<HGCalVFECompressionImpl>(conf.getParameter<edm::ParameterSet>("compressionCfg_hdm"));
  
   calibrationEE_ =
       std::make_unique<HGCalTriggerCellCalibration>(conf.getParameter<edm::ParameterSet>("calibrationCfg_ee"));
   calibrationHEsi_ =
       std::make_unique<HGCalTriggerCellCalibration>(conf.getParameter<edm::ParameterSet>("calibrationCfg_hesi"));
   calibrationHEsc_ =
       std::make_unique<HGCalTriggerCellCalibration>(conf.getParameter<edm::ParameterSet>("calibrationCfg_hesc"));
   calibrationNose_ =
       std::make_unique<HGCalTriggerCellCalibration>(conf.getParameter<edm::ParameterSet>("calibrationCfg_nose"));
 }

References calibrationEE_, calibrationHEsc_, calibrationHEsi_, calibrationNose_, edm::ParameterSet::getParameter(), vfeCompressionHDMImpl_, vfeCompressionLDMImpl_, vfeLinearizationScImpl_, vfeLinearizationSiImpl_, and vfeSummationImpl_.

Member Function Documentation

◆ run()

void HGCalVFEProcessorSums::run	(	const HGCalDigiCollection &	digiColl,
		l1t::HGCalTriggerCellBxCollection &	triggerCellColl,
		const edm::EventSetup &	es
	)

override

Definition at line 28 of file HGCalVFEProcessorSums.cc.

                                                          {
   vfeSummationImpl_->eventSetup(es);
   calibrationEE_->eventSetup(es);
   calibrationHEsi_->eventSetup(es);
   calibrationHEsc_->eventSetup(es);
   calibrationNose_->eventSetup(es);
   triggerTools_.eventSetup(es);
  
   std::vector<HGCalDataFrame> dataframes;
   std::vector<std::pair<DetId, uint32_t>> linearized_dataframes;
   std::unordered_map<uint32_t, uint32_t> tc_payload;
   std::unordered_map<uint32_t, std::array<uint32_t, 2>> tc_compressed_payload;
  
   // Remove disconnected modules and invalid cells
   for (const auto& digiData : digiColl) {
     if (DetId(digiData.id()).det() == DetId::Hcal && HcalDetId(digiData.id()).subdetId() != HcalEndcap)
       continue;
     if (!geometry_->validCell(digiData.id()))
       continue;
     uint32_t module = geometry_->getModuleFromCell(digiData.id());
  
     // no disconnected layer for HFNose
     if (DetId(digiData.id()).subdetId() != ForwardSubdetector::HFNose) {
       if (geometry_->disconnectedModule(module))
         continue;
     }
  
     dataframes.emplace_back(digiData.id());
     for (int i = 0; i < digiData.size(); i++) {
       dataframes.back().setSample(i, digiData.sample(i));
     }
   }
   if (dataframes.empty())
     return;
  
   constexpr int kHighDensityThickness = 0;
   bool isSilicon = triggerTools_.isSilicon(dataframes[0].id());
   bool isEM = triggerTools_.isEm(dataframes[0].id());
   bool isNose = triggerTools_.isNose(dataframes[0].id());
   int thickness = triggerTools_.thicknessIndex(dataframes[0].id(), true);
   // Linearization of ADC and TOT values to the same LSB
   if (isSilicon) {
     vfeLinearizationSiImpl_->linearize(dataframes, linearized_dataframes);
   } else {
     vfeLinearizationScImpl_->linearize(dataframes, linearized_dataframes);
   }
   // Sum of sensor cells into trigger cells
   vfeSummationImpl_->triggerCellSums(linearized_dataframes, tc_payload);
   // Compression of trigger cell charges to a floating point format
   if (thickness == kHighDensityThickness) {
     vfeCompressionHDMImpl_->compress(tc_payload, tc_compressed_payload);
   } else {
     vfeCompressionLDMImpl_->compress(tc_payload, tc_compressed_payload);
   }
  
   // Transform map to trigger cell vector
   for (const auto& [tc_id, tc_value] : tc_payload) {
     if (tc_value > 0) {
       const auto& [tc_compressed_code, tc_compressed_value] = tc_compressed_payload[tc_id];
       l1t::HGCalTriggerCell triggerCell(reco::LeafCandidate::LorentzVector(), tc_compressed_value, 0, 0, 0, tc_id);
       triggerCell.setCompressedCharge(tc_compressed_code);
       triggerCell.setUncompressedCharge(tc_value);
       GlobalPoint point = geometry_->getTriggerCellPosition(tc_id);
  
       // 'value' is hardware, so p4 is meaningless, except for eta and phi
       math::PtEtaPhiMLorentzVector p4((double)tc_compressed_value / cosh(point.eta()), point.eta(), point.phi(), 0.);
       triggerCell.setP4(p4);
       triggerCell.setPosition(point);
  
       // calibration
       if (triggerCell.hwPt() > 0) {
         l1t::HGCalTriggerCell calibratedtriggercell(triggerCell);
         if (isNose) {
           calibrationNose_->calibrateInGeV(calibratedtriggercell);
         } else if (isSilicon) {
           if (isEM) {
             calibrationEE_->calibrateInGeV(calibratedtriggercell);
           } else {
             calibrationHEsi_->calibrateInGeV(calibratedtriggercell);
           }
         } else {
           calibrationHEsc_->calibrateInGeV(calibratedtriggercell);
         }
         triggerCellColl.push_back(0, calibratedtriggercell);
       }
     }
   }
 }