#include <HcalHitReconstructor.h>

Inheritance diagram for HcalHitReconstructor:

Public Member Functions
virtual void	beginRun (edm::Run const &r, edm::EventSetup const &es) overridefinal

virtual void	endRun (edm::Run const &r, edm::EventSetup const &es) overridefinal

	HcalHitReconstructor (const edm::ParameterSet &ps)

virtual void	produce (edm::Event &e, const edm::EventSetup &c) override

virtual	~HcalHitReconstructor ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef void(HcalSimpleRecAlgo::*	SetCorrectionFcn )(boost::shared_ptr< AbsOOTPileupCorrection >)

typedef void(HBHENegativeFlagSetter::*	SetCorrectionFcnForNegative )(boost::shared_ptr< AbsOOTPileupCorrection >)

Private Attributes
std::string	cat_

int	cntprtCorrMethod_

bool	correctTiming_

std::string	corrName_

std::string	dataOOTCorrectionCategory_

std::string	dataOOTCorrectionName_

DetId::Detector	det_

bool	digiTimeFromDB_

bool	dropZSmarkedPassed_

bool	first_

int	firstAuxTS_

int	firstSample_

HBHEStatusBitSetter *	hbheFlagSetter_

HBHETimeProfileStatusBitSetter *	hbheHSCPFlagSetter_

HBHENegativeFlagSetter *	hbheNegativeFlagSetter_

HBHEPulseShapeFlagSetter *	hbhePulseShapeFlagSetter_

HBHETimingShapedFlagSetter *	hbheTimingShapedFlagSetter_

HcalHFStatusBitFromDigis *	hfdigibit_

std::unique_ptr < HcalFlagHFDigiTimeParams >	HFDigiTimeParams

HcalHF_PETalgorithm *	hfPET_

HcalHF_S9S1algorithm *	hfS8S1_

HcalHF_S9S1algorithm *	hfS9S1_

HFTimingTrustFlag *	HFTimingTrustFlagSetter_

edm::InputTag	inputLabel_

std::string	mcOOTCorrectionCategory_

std::string	mcOOTCorrectionName_

HcalRecoParams *	paramTS

int	puCorrMethod_

HcalSimpleRecAlgo	reco_

bool	recoParamsFromDB_

int	samplesToAdd_

HcalADCSaturationFlag *	saturationFlagSetter_

bool	setHSCPFlags_

bool	setNegativeFlags_

bool	setNoiseFlags_

SetCorrectionFcn	setPileupCorrection_

SetCorrectionFcnForNegative	setPileupCorrectionForNegative_

bool	setPulseShapeFlags_

bool	setSaturationFlags_

bool	setTimingTrustFlags_

int	subdet_

HcalOtherSubdetector	subdetOther_

edm::EDGetTokenT < HcalCalibDigiCollection >	tok_calib_

edm::EDGetTokenT < HBHEDigiCollection >	tok_hbhe_

edm::EDGetTokenT < HFDigiCollection >	tok_hf_

edm::EDGetTokenT < HODigiCollection >	tok_ho_

bool	tsFromDB_

bool	useLeakCorrection_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Author: J. Temple & E. Yazgan Based on HcalSimpleReconstructor.h by J. Mans

Definition at line 46 of file HcalHitReconstructor.h.

Member Typedef Documentation

typedef void(HcalSimpleRecAlgo::* HcalHitReconstructor::SetCorrectionFcn)(boost::shared_ptr< AbsOOTPileupCorrection >)

private

Definition at line 56 of file HcalHitReconstructor.h.

typedef void(HBHENegativeFlagSetter::* HcalHitReconstructor::SetCorrectionFcnForNegative)(boost::shared_ptr< AbsOOTPileupCorrection >)

private

Definition at line 57 of file HcalHitReconstructor.h.

Constructor & Destructor Documentation

HcalHitReconstructor::HcalHitReconstructor ( const edm::ParameterSet & ps )

explicit

Definition at line 24 of file HcalHitReconstructor.cc.

References DetId::Calo, dataOOTCorrectionCategory_, dataOOTCorrectionName_, det_, digiTimeFromDB_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), hbheFlagSetter_, hbheHSCPFlagSetter_, hbheNegativeFlagSetter_, hbhePulseShapeFlagSetter_, hbheTimingShapedFlagSetter_, HcalBarrel, HcalCalibration, HcalForward, HcalOther, HcalOuter, hfdigibit_, hfPET_, hfS8S1_, hfS9S1_, HFTimingTrustFlagSetter_, inputLabel_, mcOOTCorrectionCategory_, mcOOTCorrectionName_, puCorrMethod_, reco_, recoParamsFromDB_, saturationFlagSetter_, HBHENegativeFlagSetter::setHBHEPileupCorrection(), HcalSimpleRecAlgo::setHBHEPileupCorrection(), HcalSimpleRecAlgo::setHFPileupCorrection(), HcalSimpleRecAlgo::setHOPileupCorrection(), setHSCPFlags_, setNegativeFlags_, setNoiseFlags_, setPileupCorrection_, setPileupCorrectionForNegative_, HcalSimpleRecAlgo::setpuCorrMethod(), HcalSimpleRecAlgo::setpuCorrParams(), setPulseShapeFlags_, setSaturationFlags_, setTimingTrustFlags_, AlCaHLTBitMon_QueryRunRegistry::string, subdet_, HcalZDCDetId::SubdetectorId, subdetOther_, tok_calib_, tok_hbhe_, tok_hf_, and tok_ho_.

                                                                      :
   reco_(conf.getParameter<bool>("correctForTimeslew"),
     conf.getParameter<bool>("correctForPhaseContainment"),
     conf.getParameter<double>("correctionPhaseNS")),
   det_(DetId::Hcal),
   inputLabel_(conf.getParameter<edm::InputTag>("digiLabel")),
   correctTiming_(conf.getParameter<bool>("correctTiming")),
   setNoiseFlags_(conf.getParameter<bool>("setNoiseFlags")),
   setHSCPFlags_(conf.getParameter<bool>("setHSCPFlags")),
   setSaturationFlags_(conf.getParameter<bool>("setSaturationFlags")),
   setTimingTrustFlags_(conf.getParameter<bool>("setTimingTrustFlags")),
   setPulseShapeFlags_(conf.getParameter<bool>("setPulseShapeFlags")),
   setNegativeFlags_(false),
   dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")),
   firstAuxTS_(conf.getParameter<int>("firstAuxTS")),
   firstSample_(conf.getParameter<int>("firstSample")),
   samplesToAdd_(conf.getParameter<int>("samplesToAdd")),
   tsFromDB_(conf.getParameter<bool>("tsFromDB")),
   useLeakCorrection_(conf.getParameter<bool>("useLeakCorrection")),
   dataOOTCorrectionName_(""),
   dataOOTCorrectionCategory_("Data"),
   mcOOTCorrectionName_(""),
   mcOOTCorrectionCategory_("MC"),
   setPileupCorrection_(0),
   setPileupCorrectionForNegative_(0),
   paramTS(0),
   puCorrMethod_(conf.existsAs<int>("puCorrMethod") ? conf.getParameter<int>("puCorrMethod") : 0),
   cntprtCorrMethod_(0),
   first_(true)
 
 {
   // register for data access
   tok_hbhe_ = consumes<HBHEDigiCollection>(inputLabel_);
   tok_ho_ = consumes<HODigiCollection>(inputLabel_);
   tok_hf_ = consumes<HFDigiCollection>(inputLabel_);
   tok_calib_ = consumes<HcalCalibDigiCollection>(inputLabel_);
 
   std::string subd=conf.getParameter<std::string>("Subdetector");
   //Set all FlagSetters to 0
   /* Important to do this!  Otherwise, if the setters are turned off,
      the "if (XSetter_) delete XSetter_;" commands can crash
   */
 
   recoParamsFromDB_ = conf.getParameter<bool>("recoParamsFromDB");
   //  recoParamsFromDB_ = false ; //  trun off for now.
 
   // std::cout<<"  HcalHitReconstructor   recoParamsFromDB_ "<<recoParamsFromDB_<<std::endl;
 
   if (conf.existsAs<bool>("setNegativeFlags"))
       setNegativeFlags_ = conf.getParameter<bool>("setNegativeFlags");
 
   hbheFlagSetter_             = 0;
   hbheHSCPFlagSetter_         = 0;
   hbhePulseShapeFlagSetter_   = 0;
   hbheNegativeFlagSetter_     = 0;
   hbheTimingShapedFlagSetter_ = 0;
   hfdigibit_                  = 0;
 
   hfS9S1_                     = 0;
   hfS8S1_                     = 0;
   hfPET_                      = 0;
   saturationFlagSetter_       = 0;
   HFTimingTrustFlagSetter_    = 0;
   digiTimeFromDB_             = false; // only need for HF
   
   if (setSaturationFlags_)
     {
       const edm::ParameterSet& pssat      = conf.getParameter<edm::ParameterSet>("saturationParameters");
       saturationFlagSetter_ = new HcalADCSaturationFlag(pssat.getParameter<int>("maxADCvalue"));
     }
 
   if (!strcasecmp(subd.c_str(),"HBHE")) {
     subdet_=HcalBarrel;
 
     setPileupCorrection_            = 0;
     if(puCorrMethod_ == 1) setPileupCorrection_            = &HcalSimpleRecAlgo::setHBHEPileupCorrection;    
     setPileupCorrectionForNegative_ = &HBHENegativeFlagSetter::setHBHEPileupCorrection;
 
     bool timingShapedCutsFlags = conf.getParameter<bool>("setTimingShapedCutsFlags");
     if (timingShapedCutsFlags)
       {
     const edm::ParameterSet& psTshaped = conf.getParameter<edm::ParameterSet>("timingshapedcutsParameters");
     hbheTimingShapedFlagSetter_ = new HBHETimingShapedFlagSetter(psTshaped.getParameter<std::vector<double> >("tfilterEnvelope"),
                                      psTshaped.getParameter<bool>("ignorelowest"),
                                      psTshaped.getParameter<bool>("ignorehighest"),
                                      psTshaped.getParameter<double>("win_offset"),
                                      psTshaped.getParameter<double>("win_gain"));
       }
       
     if (setNoiseFlags_)
       {
     const edm::ParameterSet& psdigi    =conf.getParameter<edm::ParameterSet>("flagParameters");
     hbheFlagSetter_=new HBHEStatusBitSetter(psdigi.getParameter<double>("nominalPedestal"),
                         psdigi.getParameter<double>("hitEnergyMinimum"),
                         psdigi.getParameter<int>("hitMultiplicityThreshold"),
                         psdigi.getParameter<std::vector<edm::ParameterSet> >("pulseShapeParameterSets")
      );
       } // if (setNoiseFlags_)
     if (setHSCPFlags_)
       {
     const edm::ParameterSet& psHSCP = conf.getParameter<edm::ParameterSet>("hscpParameters");
     hbheHSCPFlagSetter_ = new HBHETimeProfileStatusBitSetter(psHSCP.getParameter<double>("r1Min"),
                                  psHSCP.getParameter<double>("r1Max"),
                                  psHSCP.getParameter<double>("r2Min"),
                                  psHSCP.getParameter<double>("r2Max"),
                                  psHSCP.getParameter<double>("fracLeaderMin"),
                                  psHSCP.getParameter<double>("fracLeaderMax"),
                                  psHSCP.getParameter<double>("slopeMin"),
                                  psHSCP.getParameter<double>("slopeMax"),
                                  psHSCP.getParameter<double>("outerMin"),
                                  psHSCP.getParameter<double>("outerMax"),
                                  psHSCP.getParameter<double>("TimingEnergyThreshold"));
       } // if (setHSCPFlags_) 
     if (setPulseShapeFlags_)
       {
         const edm::ParameterSet &psPulseShape = conf.getParameter<edm::ParameterSet>("pulseShapeParameters");
         hbhePulseShapeFlagSetter_ = new HBHEPulseShapeFlagSetter(
                                  psPulseShape.getParameter<double>("MinimumChargeThreshold"),
                                  psPulseShape.getParameter<double>("TS4TS5ChargeThreshold"),
                                  psPulseShape.getParameter<unsigned int>("TrianglePeakTS"),
                                  psPulseShape.getParameter<std::vector<double> >("LinearThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("LinearCut"),
                                  psPulseShape.getParameter<std::vector<double> >("RMS8MaxThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("RMS8MaxCut"),
                                  psPulseShape.getParameter<std::vector<double> >("LeftSlopeThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("LeftSlopeCut"),
                                  psPulseShape.getParameter<std::vector<double> >("RightSlopeThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("RightSlopeCut"),
                                  psPulseShape.getParameter<std::vector<double> >("RightSlopeSmallThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("RightSlopeSmallCut"),
                                  psPulseShape.getParameter<std::vector<double> >("TS4TS5LowerThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("TS4TS5LowerCut"),
                                  psPulseShape.getParameter<std::vector<double> >("TS4TS5UpperThreshold"),
                                  psPulseShape.getParameter<std::vector<double> >("TS4TS5UpperCut"),
                                  psPulseShape.getParameter<bool>("UseDualFit"),
                          psPulseShape.getParameter<bool>("TriangleIgnoreSlow"));
       }  // if (setPulseShapeFlags_)
     if (setNegativeFlags_)
       {
         const edm::ParameterSet &psNegative = conf.getParameter<edm::ParameterSet>("negativeParameters");
         hbheNegativeFlagSetter_ = new HBHENegativeFlagSetter(
                        psNegative.getParameter<double>("MinimumChargeThreshold"),
                        psNegative.getParameter<double>("TS4TS5ChargeThreshold"),
                        psNegative.getParameter<int>("First"),
                        psNegative.getParameter<int>("Last"),
                        psNegative.getParameter<std::vector<double> >("Threshold"),
                        psNegative.getParameter<std::vector<double> >("Cut"));
       }
 
     produces<HBHERecHitCollection>();
   } else if (!strcasecmp(subd.c_str(),"HO")) {
     subdet_=HcalOuter;
     setPileupCorrection_ = &HcalSimpleRecAlgo::setHOPileupCorrection;
     setPileupCorrection_ = 0;
     produces<HORecHitCollection>();
   } else if (!strcasecmp(subd.c_str(),"HF")) {
     subdet_=HcalForward;
     setPileupCorrection_ = &HcalSimpleRecAlgo::setHFPileupCorrection;
     setPileupCorrection_ = 0;
     digiTimeFromDB_=conf.getParameter<bool>("digiTimeFromDB");
 
     if (setTimingTrustFlags_) {
       
       const edm::ParameterSet& pstrust      = conf.getParameter<edm::ParameterSet>("hfTimingTrustParameters");
       HFTimingTrustFlagSetter_=new HFTimingTrustFlag(pstrust.getParameter<int>("hfTimingTrustLevel1"),
                              pstrust.getParameter<int>("hfTimingTrustLevel2"));
     }
 
     if (setNoiseFlags_)
       {
     const edm::ParameterSet& psdigi    =conf.getParameter<edm::ParameterSet>("digistat");
     const edm::ParameterSet& psTimeWin =conf.getParameter<edm::ParameterSet>("HFInWindowStat");
     hfdigibit_=new HcalHFStatusBitFromDigis(psdigi,psTimeWin);
 
     const edm::ParameterSet& psS9S1   = conf.getParameter<edm::ParameterSet>("S9S1stat");
     hfS9S1_   = new HcalHF_S9S1algorithm(psS9S1.getParameter<std::vector<double> >("short_optimumSlope"),
                          psS9S1.getParameter<std::vector<double> >("shortEnergyParams"),
                          psS9S1.getParameter<std::vector<double> >("shortETParams"),
                          psS9S1.getParameter<std::vector<double> >("long_optimumSlope"),
                          psS9S1.getParameter<std::vector<double> >("longEnergyParams"),
                          psS9S1.getParameter<std::vector<double> >("longETParams"),
                          psS9S1.getParameter<int>("HcalAcceptSeverityLevel"),
                          psS9S1.getParameter<bool>("isS8S1")
                          );
 
     const edm::ParameterSet& psS8S1   = conf.getParameter<edm::ParameterSet>("S8S1stat");
     hfS8S1_   = new HcalHF_S9S1algorithm(psS8S1.getParameter<std::vector<double> >("short_optimumSlope"),
                          psS8S1.getParameter<std::vector<double> >("shortEnergyParams"),
                          psS8S1.getParameter<std::vector<double> >("shortETParams"),
                          psS8S1.getParameter<std::vector<double> >("long_optimumSlope"),
                          psS8S1.getParameter<std::vector<double> >("longEnergyParams"),
                          psS8S1.getParameter<std::vector<double> >("longETParams"),
                          psS8S1.getParameter<int>("HcalAcceptSeverityLevel"),
                          psS8S1.getParameter<bool>("isS8S1")
                          );
 
     const edm::ParameterSet& psPET    = conf.getParameter<edm::ParameterSet>("PETstat");
     hfPET_    = new HcalHF_PETalgorithm(psPET.getParameter<std::vector<double> >("short_R"),
                         psPET.getParameter<std::vector<double> >("shortEnergyParams"),
                         psPET.getParameter<std::vector<double> >("shortETParams"),
                         psPET.getParameter<std::vector<double> >("long_R"),
                         psPET.getParameter<std::vector<double> >("longEnergyParams"),
                         psPET.getParameter<std::vector<double> >("longETParams"),
                         psPET.getParameter<int>("HcalAcceptSeverityLevel"),
                         psPET.getParameter<std::vector<double> >("short_R_29"),
                         psPET.getParameter<std::vector<double> >("long_R_29")
                         );
       }
     produces<HFRecHitCollection>();
   } else if (!strcasecmp(subd.c_str(),"ZDC")) {
     det_=DetId::Calo;
     subdet_=HcalZDCDetId::SubdetectorId;
     produces<ZDCRecHitCollection>();
   } else if (!strcasecmp(subd.c_str(),"CALIB")) {
     subdet_=HcalOther;
     subdetOther_=HcalCalibration;
     produces<HcalCalibRecHitCollection>();
   } else {
     edm::LogWarning("Configuration") << "HcalHitReconstructor is not associated with a specific subdetector!" << std::endl;
   }
 
   // If no valid OOT pileup correction name specified,
   // disable the correction
   if (conf.existsAs<std::string>("dataOOTCorrectionName"))
       dataOOTCorrectionName_ = conf.getParameter<std::string>("dataOOTCorrectionName");
   if (conf.existsAs<std::string>("dataOOTCorrectionCategory"))
       dataOOTCorrectionCategory_ = conf.getParameter<std::string>("dataOOTCorrectionCategory");
   if (conf.existsAs<std::string>("mcOOTCorrectionName"))
       mcOOTCorrectionName_ = conf.getParameter<std::string>("mcOOTCorrectionName");
   if (conf.existsAs<std::string>("mcOOTCorrectionCategory"))
       mcOOTCorrectionCategory_ = conf.getParameter<std::string>("mcOOTCorrectionCategory");
   if (dataOOTCorrectionName_.empty() && mcOOTCorrectionName_.empty())
   {
       setPileupCorrection_ = 0;
       setPileupCorrectionForNegative_ = 0;
   }
 
   reco_.setpuCorrMethod(puCorrMethod_);
   if(puCorrMethod_ == 2) { 
     reco_.setpuCorrParams(
               conf.getParameter<bool>  ("applyPedConstraint"),
               conf.getParameter<bool>  ("applyTimeConstraint"),
               conf.getParameter<bool>  ("applyPulseJitter"),
               conf.getParameter<bool>  ("applyUnconstrainedFit"),
               conf.getParameter<bool>  ("applyTimeSlew"),
               conf.getParameter<double>("ts4Min"),
               conf.getParameter<double>("ts4Max"),
               conf.getParameter<double>("pulseJitter"),
               conf.getParameter<double>("meanTime"),
               conf.getParameter<double>("timeSigma"),
               conf.getParameter<double>("meanPed"),
               conf.getParameter<double>("pedSigma"),
               conf.getParameter<double>("noise"),
               conf.getParameter<double>("timeMin"),
               conf.getParameter<double>("timeMax"),
               conf.getParameter<double>("ts3chi2"),
               conf.getParameter<double>("ts4chi2"),
               conf.getParameter<double>("ts345chi2"),
               conf.getParameter<double>("chargeMax"), //For the unconstrained Fit
                           conf.getParameter<int>   ("fitTimes")
               );
   }
 }

HcalHitReconstructor::~HcalHitReconstructor ( )

virtual

Definition at line 288 of file HcalHitReconstructor.cc.

References hbheFlagSetter_, hbheHSCPFlagSetter_, hbhePulseShapeFlagSetter_, hfdigibit_, hfPET_, hfS9S1_, and paramTS.

                                             {
   delete hbheFlagSetter_;
   delete hfdigibit_;
   delete hbheHSCPFlagSetter_;
   delete hbhePulseShapeFlagSetter_;
   delete hfS9S1_;
   delete hfPET_;
   delete paramTS;
 }

Member Function Documentation

void HcalHitReconstructor::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

finaloverridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 298 of file HcalHitReconstructor.cc.

References HcalSimpleRecAlgo::beginRun(), digiTimeFromDB_, edm::EventSetup::get(), HFDigiTimeParams, AlCaHLTBitMon_ParallelJobs::p, paramTS, edm::ESHandle< class >::product(), reco_, recoParamsFromDB_, HcalCondObjectContainerBase::setTopo(), and tsFromDB_.

                                                                            {
 
   edm::ESHandle<HcalTopology> htopo;
   es.get<IdealGeometryRecord>().get(htopo);
 
   if ( tsFromDB_== true || recoParamsFromDB_ == true )
     {
       edm::ESHandle<HcalRecoParams> p;
       es.get<HcalRecoParamsRcd>().get(p);
       paramTS = new HcalRecoParams(*p.product());
       paramTS->setTopo(htopo.product());
 
       
 
 
       // std::cout<<" skdump in HcalHitReconstructor::beginRun   dupm RecoParams "<<std::endl;
       // std::ofstream skfile("skdumpRecoParamsNewFormat.txt");
       // HcalDbASCIIIO::dumpObject(skfile, (*paramTS) );
     }
 
   if (digiTimeFromDB_==true)
     {
       edm::ESHandle<HcalFlagHFDigiTimeParams> p;
       es.get<HcalFlagHFDigiTimeParamsRcd>().get(p);
       HFDigiTimeParams.reset( new HcalFlagHFDigiTimeParams( *p ) );
 
       edm::ESHandle<HcalTopology> htopo;
       es.get<IdealGeometryRecord>().get(htopo);
       HFDigiTimeParams->setTopo(htopo.product());
 
     }
 
   reco_.beginRun(es);
 }

void HcalHitReconstructor::endRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

finaloverridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 333 of file HcalHitReconstructor.cc.

References digiTimeFromDB_, HcalSimpleRecAlgo::endRun(), paramTS, reco_, and tsFromDB_.

                                                                          {
   if (tsFromDB_==true)
     {
       delete paramTS; paramTS=0;
     }
   if (digiTimeFromDB_==true)
     {
       //DL delete HFDigiTimeParams; HFDigiTimeParams = 0;
     }
   reco_.endRun();
 }

void HcalHitReconstructor::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 345 of file HcalHitReconstructor.cc.

References funct::abs(), cat_, HBHEStatusBitSetter::Clear(), cntprtCorrMethod_, HcalTimingCorrector::Correct(), HcalRecoParam::correctForPhaseContainment(), HLT_25ns14e33_v1_cff::correctForPhaseContainment, HcalRecoParam::correctForTimeslew(), HLT_25ns14e33_v1_cff::correctForTimeslew, HcalRecoParam::correctionPhaseNS(), HcalRecoParam::correctTiming(), correctTiming_, corrName_, dataOOTCorrectionCategory_, dataOOTCorrectionName_, HLT_25ns14e33_v1_cff::depth, det_, digiTimeFromDB_, HcalSeverityLevelComputer::dropChannel(), dropZSmarkedPassed_, HBHETimeProfileStatusBitSetter::EnergyThreshold(), edm::EventSetup::find(), plotBeamSpotDB::first, first_, HcalRecoParam::firstAuxTS(), firstAuxTS_, HcalRecoParam::firstSample(), firstSample_, edm::EventSetup::get(), edm::eventsetup::EventSetupRecord::get(), edm::Event::getByToken(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), hbheFlagSetter_, hbheHSCPFlagSetter_, hbheNegativeFlagSetter_, hbhePulseShapeFlagSetter_, HBHETimeProfileStatusBitSetter::hbheSetTimeFlagsFromDigi(), hbheTimingShapedFlagSetter_, DetId::Hcal, HcalBarrel, HcalCalibration, HcalEndcap, HcalForward, HcalOther, HcalOuter, hfdigibit_, HcalFlagHFDigiTimeParam::HFdigiflagCoefficients(), HcalFlagHFDigiTimeParam::HFdigiflagExpectedPeak(), HcalFlagHFDigiTimeParam::HFdigiflagFirstSample(), HcalFlagHFDigiTimeParam::HFdigiflagMinEThreshold(), HcalFlagHFDigiTimeParam::HFdigiflagSamplesToAdd(), HFDigiTimeParams, hfPET_, hfS8S1_, hfS9S1_, HcalHFStatusBitFromDigis::hfSetFlagFromDigi(), HcalHF_PETalgorithm::HFSetFlagFromPET(), HcalHF_S9S1algorithm::HFSetFlagFromS9S1(), HFTimingTrustFlagSetter_, i, edm::EventBase::isRealData(), j, relval_steps::k, LogTrace, mcOOTCorrectionCategory_, mcOOTCorrectionName_, AlCaHLTBitMon_ParallelJobs::p, paramTS, HcalRecoParam::pileupCleaningID(), HcalCaloFlagLabels::PresampleADC, edm::ESHandle< class >::product(), puCorrMethod_, edm::Event::put(), DetId::rawId(), reco_, HcalSimpleRecAlgo::reconstruct(), recoParamsFromDB_, HcalHFStatusBitFromDigis::resetParamsFromDB(), edm::Event::run(), HcalRecoParam::samplesToAdd(), samplesToAdd_, saturationFlagSetter_, HBHEStatusBitSetter::SetFlagsFromDigi(), HBHEStatusBitSetter::SetFlagsFromRecHits(), HcalSimpleRecAlgo::setForData(), HFTimingTrustFlag::setHFTimingTrustFlag(), setHSCPFlags_, HcalSimpleRecAlgo::setLeakCorrection(), setNegativeFlags_, setNoiseFlags_, setPileupCorrection_, setPileupCorrectionForNegative_, HBHENegativeFlagSetter::setPulseShapeFlags(), HBHEPulseShapeFlagSetter::SetPulseShapeFlags(), setPulseShapeFlags_, HcalSimpleRecAlgo::setRecoParams(), HcalADCSaturationFlag::setSaturationFlag(), setSaturationFlags_, HBHETimingShapedFlagSetter::SetTimingShapedFlags(), setTimingTrustFlags_, subdet_, subdetOther_, tok_calib_, tok_hbhe_, tok_hf_, tok_ho_, tsFromDB_, HcalRecoParam::useLeakCorrection(), and useLeakCorrection_.

 {
 
   // get conditions
   edm::ESHandle<HcalTopology> topo;
   eventSetup.get<IdealGeometryRecord>().get(topo);
 
   edm::ESHandle<HcalDbService> conditions;
   eventSetup.get<HcalDbRecord>().get(conditions);
 
   // HACK related to HB- corrections
   if ( first_ ) {
     const bool isData = e.isRealData();
     if (isData) reco_.setForData(e.run()); else reco_.setForData(0);
     corrName_ = isData ? dataOOTCorrectionName_ : mcOOTCorrectionName_;
     cat_ = isData ? dataOOTCorrectionCategory_ : mcOOTCorrectionCategory_;
     first_=false;
   }
   if (useLeakCorrection_) reco_.setLeakCorrection();
 
   edm::ESHandle<HcalChannelQuality> p;
   eventSetup.get<HcalChannelQualityRcd>().get("withTopo",p);
   const HcalChannelQuality* myqual = p.product();
 
   edm::ESHandle<HcalSeverityLevelComputer> mycomputer;
   eventSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
   const HcalSeverityLevelComputer* mySeverity = mycomputer.product();
 
   // Configure OOT pileup corrections
   bool isMethod1Set = false;
   if (!corrName_.empty())
   {
       edm::ESHandle<OOTPileupCorrectionColl> pileupCorrections;
       if (eventSetup.find(edm::eventsetup::EventSetupRecordKey::makeKey<HcalOOTPileupCorrectionRcd>()))
           eventSetup.get<HcalOOTPileupCorrectionRcd>().get(pileupCorrections);
       else
           eventSetup.get<HcalOOTPileupCompatibilityRcd>().get(pileupCorrections);
 
       if( setPileupCorrection_ ){
          const OOTPileupCorrData * testMethod1Ptr = dynamic_cast<OOTPileupCorrData*>((pileupCorrections->get(corrName_, cat_)).get());
          if( testMethod1Ptr ) isMethod1Set = true;
          (reco_.*setPileupCorrection_)(pileupCorrections->get(corrName_, cat_));
       }
 
       if(setPileupCorrectionForNegative_ && hbheNegativeFlagSetter_)
         (hbheNegativeFlagSetter_->*setPileupCorrectionForNegative_)(pileupCorrections->get(corrName_, cat_));
    }
 // Only for HBHE
    if( subdet_ == HcalBarrel ){
       if( !cntprtCorrMethod_ ){
          cntprtCorrMethod_++;
          if( puCorrMethod_ == 2 ) LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 2" << std::endl;
          else if( puCorrMethod_ == 1 ){
             if( isMethod1Set ) LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 1" << std::endl;
             else edm::LogWarning("HcalPUcorrMethod") <<"puCorrMethod_ set to be 1 but method 1 is NOT activated (method 0 used instead)!\n"
                                                      <<"Please check GlobalTag usage or method 1 seperately disabled by dataOOTCorrectionName & mcOOTCorrectionName?" << std::endl;
          }else if (puCorrMethod_ == 3) {
            LogTrace("HcalPUcorrMethod") << "Using Hcal Deterministic Fit Method!" << std::endl;
          } else LogTrace("HcalPUcorrMethod") << "Using Hcal OOTPU method 0" << std::endl;
       }
    }
 
   // GET THE BEAM CROSSING INFO HERE, WHEN WE UNDERSTAND HOW THINGS WORK.
   // Then, call "setBXInfo" method of the reco_ object.
   // Also remember to call SetBXInfo in the negative energy flag setter.
 
   if (det_==DetId::Hcal) {
 
     // HBHE -------------------------------------------------------------------
     if (subdet_==HcalBarrel || subdet_==HcalEndcap) {
       edm::Handle<HBHEDigiCollection> digi;
       
       e.getByToken(tok_hbhe_,digi);
       
       // create empty output
       std::auto_ptr<HBHERecHitCollection> rec(new HBHERecHitCollection);
       rec->reserve(digi->size());
       // run the algorithm
       if (setNoiseFlags_) hbheFlagSetter_->Clear();
       HBHEDigiCollection::const_iterator i;
       std::vector<HBHEDataFrame> HBDigis;
       std::vector<int> RecHitIndex;
 
       // Vote on majority TS0 CapId
       int favorite_capid = 0; 
       if (correctTiming_) {
         long capid_votes[4] = {0,0,0,0};
         for (i=digi->begin(); i!=digi->end(); i++) {
           capid_votes[(*i)[0].capid()]++;
         }
         for (int k = 0; k < 4; k++)
           if (capid_votes[k] > capid_votes[favorite_capid])
             favorite_capid = k;
       }
 
       for (i=digi->begin(); i!=digi->end(); i++) {
     HcalDetId cell = i->id();
     DetId detcell=(DetId)cell;
 
         if(tsFromDB_ || recoParamsFromDB_) {
           const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
       if(tsFromDB_) {
         firstSample_  = param_ts->firstSample();
         samplesToAdd_ = param_ts->samplesToAdd();
       }
           if(recoParamsFromDB_) {
              bool correctForTimeslew=param_ts->correctForTimeslew();
              bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
              float phaseNS=param_ts->correctionPhaseNS();
              useLeakCorrection_= param_ts->useLeakCorrection();
              correctTiming_ = param_ts->correctTiming();
              firstAuxTS_ = param_ts->firstAuxTS();
              int pileupCleaningID = param_ts->pileupCleaningID();
 
          /*      
          int sub     = cell.subdet();
          int depth   = cell.depth();
          int inteta  = cell.ieta();
          int intphi  = cell.iphi();
 
          std::cout << "HcalHitReconstructor::produce  cell:" 
                << " sub, ieta, iphi, depth = " 
                << sub << "  " << inteta << "  " << intphi 
                << "  " << depth << std::endl
                << "    first, toadd = " << firstSample_ << ", "
                << samplesToAdd_ << std::endl
                << "    correctForTimeslew " << correctForTimeslew
                << std::endl
                << "    correctForPhaseContainment " 
                <<  correctForPhaseContainment << std::endl
                << "    phaseNS " <<  phaseNS << std::endl
                << "    useLeakCorrection  " << useLeakCorrection_ 
                << std::endl 
                << "    correctTiming " << correctTiming_ << std::endl
                << "    firstAuxTS " << firstAuxTS_  << std::endl
                << "    pileupCleaningID "  << pileupCleaningID
                << std::endl;
          */
 
              reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
           }
         }
 
         int first = firstSample_;
         int toadd = samplesToAdd_;
 
     // check on cells to be ignored and dropped: (rof,20.Feb.09)
     const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
     if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
     if (dropZSmarkedPassed_)
       if (i->zsMarkAndPass()) continue;
 
     const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
     const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
     const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
     HcalCoderDb coder (*channelCoder, *shape);
 
     rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
 
     // Fill first auxiliary word
     unsigned int auxflag=0;
         int fTS = firstAuxTS_;
     if (fTS<0) fTS=0; // silly protection against time slice <0
     for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx) {
           int adcv = i->sample(xx).adc();
       auxflag+=((adcv&0x7F)<<(7*(xx-fTS))); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
     // bits 28 and 29 are reserved for capid of the first time slice saved in aux
     }
     auxflag+=((i->sample(fTS).capid())<<28);
     (rec->back()).setAux(auxflag);
 
     // Fill second auxiliary word
     auxflag=0;
         int fTS2 = (firstAuxTS_-4 < 0) ? 0 : firstAuxTS_-4;  
     for (int xx = fTS2; xx < fTS2+4 && xx<i->size(); ++xx) {
           int adcv = i->sample(xx).adc();
       auxflag+=((adcv&0x7F)<<(7*(xx-fTS2))); 
     }
     auxflag+=((i->sample(fTS2).capid())<<28);
     (rec->back()).setAuxHBHE(auxflag);
 
     (rec->back()).setFlags(0);  // this sets all flag bits to 0
     // Set presample flag
     if (fTS>0)
       (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
 
     if (hbheTimingShapedFlagSetter_!=0)
       hbheTimingShapedFlagSetter_->SetTimingShapedFlags(rec->back());
     if (setNoiseFlags_)
       hbheFlagSetter_->SetFlagsFromDigi(&(*topo),rec->back(),*i,coder,calibrations,first,toadd);
     if (setPulseShapeFlags_ == true)
       hbhePulseShapeFlagSetter_->SetPulseShapeFlags(rec->back(), *i, coder, calibrations);
     if (setNegativeFlags_ == true)
      hbheNegativeFlagSetter_->setPulseShapeFlags(rec->back(), *i, coder, calibrations);
    if (setSaturationFlags_)
       saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
     if (correctTiming_)
       HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
     if (setHSCPFlags_ && i->id().ietaAbs()<16)
       {
         double DigiEnergy=0;
             for(int j=0; j!=i->size(); DigiEnergy += i->sample(j++).nominal_fC());
             if(DigiEnergy > hbheHSCPFlagSetter_->EnergyThreshold())
               {
                 HBDigis.push_back(*i);
                 RecHitIndex.push_back(rec->size()-1);
               }
         
       } // if (set HSCPFlags_ && |ieta|<16)
       } // loop over HBHE digis
 
 
       if (setNoiseFlags_) hbheFlagSetter_->SetFlagsFromRecHits(&(*topo),*rec);
       if (setHSCPFlags_)  hbheHSCPFlagSetter_->hbheSetTimeFlagsFromDigi(rec.get(), HBDigis, RecHitIndex);
       // return result
       e.put(rec);
 
       //  HO ------------------------------------------------------------------
     } else if (subdet_==HcalOuter) {
       edm::Handle<HODigiCollection> digi;
       e.getByToken(tok_ho_,digi);
       
       // create empty output
       std::auto_ptr<HORecHitCollection> rec(new HORecHitCollection);
       rec->reserve(digi->size());
       // run the algorithm
       HODigiCollection::const_iterator i;
 
       // Vote on majority TS0 CapId
       int favorite_capid = 0; 
       if (correctTiming_) {
         long capid_votes[4] = {0,0,0,0};
         for (i=digi->begin(); i!=digi->end(); i++) {
           capid_votes[(*i)[0].capid()]++;
         }
         for (int k = 0; k < 4; k++)
           if (capid_votes[k] > capid_votes[favorite_capid])
             favorite_capid = k;
       }
 
       for (i=digi->begin(); i!=digi->end(); i++) {
     HcalDetId cell = i->id();
     DetId detcell=(DetId)cell;
         // firstSample & samplesToAdd
         if(tsFromDB_ || recoParamsFromDB_) {
           const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
       if(tsFromDB_) {
         firstSample_  = param_ts->firstSample();
         samplesToAdd_ = param_ts->samplesToAdd();
       }
           if(recoParamsFromDB_) {
              bool correctForTimeslew=param_ts->correctForTimeslew();
              bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
              float phaseNS=param_ts->correctionPhaseNS();
              useLeakCorrection_= param_ts->useLeakCorrection();
              correctTiming_ = param_ts->correctTiming();
              firstAuxTS_ = param_ts->firstAuxTS();
              int pileupCleaningID = param_ts->pileupCleaningID();
              reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
           }
         }
 
         int first = firstSample_;
         int toadd = samplesToAdd_;
 
     // check on cells to be ignored and dropped: (rof,20.Feb.09)
     const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
     if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
     if (dropZSmarkedPassed_)
       if (i->zsMarkAndPass()) continue;
 
     const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
     const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
     const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
     HcalCoderDb coder (*channelCoder, *shape);
 
     rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
 
     // Set auxiliary flag
     int auxflag=0;
         int fTS = firstAuxTS_;
     if (fTS<0) fTS=0; //silly protection against negative time slice values
     for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
       auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
     // bits 28 and 29 are reserved for capid of the first time slice saved in aux
     auxflag+=((i->sample(fTS).capid())<<28);
     (rec->back()).setAux(auxflag);
     (rec->back()).setFlags(0);
     // Fill Presample ADC flag
     if (fTS>0)
       (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
 
     if (setSaturationFlags_)
       saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
     if (correctTiming_)
       HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
       }
       // return result
       e.put(rec);    
 
       // HF -------------------------------------------------------------------
     } else if (subdet_==HcalForward) {
       edm::Handle<HFDigiCollection> digi;
       e.getByToken(tok_hf_,digi);
 
 
       // create empty output
       std::auto_ptr<HFRecHitCollection> rec(new HFRecHitCollection);
       rec->reserve(digi->size());
       // run the algorithm
       HFDigiCollection::const_iterator i;
 
       // Vote on majority TS0 CapId
       int favorite_capid = 0; 
       if (correctTiming_) {
         long capid_votes[4] = {0,0,0,0};
         for (i=digi->begin(); i!=digi->end(); i++) {
           capid_votes[(*i)[0].capid()]++;
         }
         for (int k = 0; k < 4; k++)
           if (capid_votes[k] > capid_votes[favorite_capid])
             favorite_capid = k;
       }
 
       for (i=digi->begin(); i!=digi->end(); i++) {
     HcalDetId cell = i->id();
     DetId detcell=(DetId)cell;
 
         if(tsFromDB_ || recoParamsFromDB_) {
           const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
       if(tsFromDB_) {
         firstSample_  = param_ts->firstSample();
         samplesToAdd_ = param_ts->samplesToAdd();
       }
           if(recoParamsFromDB_) {
              bool correctForTimeslew=param_ts->correctForTimeslew();
              bool correctForPhaseContainment= param_ts->correctForPhaseContainment();
              float phaseNS=param_ts->correctionPhaseNS();
              useLeakCorrection_= param_ts->useLeakCorrection();
              correctTiming_ = param_ts->correctTiming();
              firstAuxTS_ = param_ts->firstAuxTS();
              int pileupCleaningID = param_ts->pileupCleaningID();
              reco_.setRecoParams(correctForTimeslew,correctForPhaseContainment,useLeakCorrection_,pileupCleaningID,phaseNS);
           }
         }
 
         int first = firstSample_;
         int toadd = samplesToAdd_;
 
     // check on cells to be ignored and dropped: (rof,20.Feb.09)
     const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
     if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
     if (dropZSmarkedPassed_)
       if (i->zsMarkAndPass()) continue;
 
     const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
     const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
     const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
     HcalCoderDb coder (*channelCoder, *shape);
 
     // Set HFDigiTime flag values from digiTimeFromDB_
     if (digiTimeFromDB_==true && hfdigibit_!=0)
       {
         const HcalFlagHFDigiTimeParam* hfDTparam = HFDigiTimeParams->getValues(detcell.rawId());
         hfdigibit_->resetParamsFromDB(hfDTparam->HFdigiflagFirstSample(),
                       hfDTparam->HFdigiflagSamplesToAdd(),
                       hfDTparam->HFdigiflagExpectedPeak(),
                       hfDTparam->HFdigiflagMinEThreshold(),
                       hfDTparam->HFdigiflagCoefficients()
                       );
       }
 
     //std::cout << "TOADDHF " << toadd << " " << first << " " << std::endl;
     rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
 
     // Set auxiliary flag
     int auxflag=0;
         int fTS = firstAuxTS_;
     if (fTS<0) fTS=0; // silly protection against negative time slice values
     for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
       auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
     // bits 28 and 29 are reserved for capid of the first time slice saved in aux
     auxflag+=((i->sample(fTS).capid())<<28);
     (rec->back()).setAux(auxflag);
 
     // Clear flags
     (rec->back()).setFlags(0);
 
     // Fill Presample ADC flag
     if (fTS>0)
       (rec->back()).setFlagField((i->sample(fTS-1).adc()), HcalCaloFlagLabels::PresampleADC,7);
 
     // This calls the code for setting the HF noise bit determined from digi shape
     if (setNoiseFlags_) 
       hfdigibit_->hfSetFlagFromDigi(rec->back(),*i,coder,calibrations);
     if (setSaturationFlags_)
       saturationFlagSetter_->setSaturationFlag(rec->back(),*i);
     if (setTimingTrustFlags_)
       HFTimingTrustFlagSetter_->setHFTimingTrustFlag(rec->back(),*i);
     if (correctTiming_)
       HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
       } // for (i=digi->begin(); i!=digi->end(); i++) -- loop on all HF digis
 
       // The following flags require the full set of rechits
       // These need to be set consecutively, so an energy check should be the first 
       // test performed on these hits (to minimize the loop time)
       if (setNoiseFlags_) 
     {
       // Step 1:  Set PET flag  (short fibers of |ieta|==29)
       // Neighbor/partner channels that are flagged by Pulse Shape algorithm (HFDigiTime)
       // won't be considered in these calculations
       for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
         {
           int depth=i->id().depth();
           int ieta=i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth==2 || abs(ieta)==29 ) 
         hfPET_->HFSetFlagFromPET(*i,*rec,myqual,mySeverity);
         }
 
       // Step 2:  Set S8S1 flag (short fibers or |ieta|==29)
       for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
         {
           int depth=i->id().depth();
           int ieta=i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth==2 || abs(ieta)==29 ) 
         hfS8S1_->HFSetFlagFromS9S1(*i,*rec,myqual,mySeverity);
         }
 
       // Set 3:  Set S9S1 flag (long fibers)
       for (HFRecHitCollection::iterator i = rec->begin();i!=rec->end();++i)
         {
           int depth=i->id().depth();
           int ieta=i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth==1 && abs(ieta)!=29 ) 
         hfS9S1_->HFSetFlagFromS9S1(*i,*rec,myqual, mySeverity);
         }
     }
 
       // return result
       e.put(rec);     
     } else if (subdet_==HcalOther && subdetOther_==HcalCalibration) {
       edm::Handle<HcalCalibDigiCollection> digi;
       e.getByToken(tok_calib_,digi);
       
       // create empty output
       std::auto_ptr<HcalCalibRecHitCollection> rec(new HcalCalibRecHitCollection);
       rec->reserve(digi->size());
       // run the algorithm
       int first = firstSample_;
       int toadd = samplesToAdd_;
 
       HcalCalibDigiCollection::const_iterator i;
       for (i=digi->begin(); i!=digi->end(); i++) {
     HcalCalibDetId cell = i->id();
     //  HcalDetId cellh = i->id();
     DetId detcell=(DetId)cell;
     // check on cells to be ignored and dropped: (rof,20.Feb.09)
     const HcalChannelStatus* mydigistatus=myqual->getValues(detcell.rawId());
     if (mySeverity->dropChannel(mydigistatus->getValue() ) ) continue;
     if (dropZSmarkedPassed_)
       if (i->zsMarkAndPass()) continue;
 
     const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
     const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
     const HcalQIEShape* shape = conditions->getHcalShape (channelCoder);
     HcalCoderDb coder (*channelCoder, *shape);
 
     // firstSample & samplesToAdd
         if(tsFromDB_) {
       const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
       first = param_ts->firstSample();    
       toadd = param_ts->samplesToAdd();    
     }
     rec->push_back(reco_.reconstruct(*i,first,toadd,coder,calibrations));
 
     /*
       // Flag setting not available for calibration rechits
     // Set auxiliary flag
     int auxflag=0;
         int fTS = firstAuxTS_;
     for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
       auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
     // bits 28 and 29 are reserved for capid of the first time slice saved in aux
     auxflag+=((i->sample(fTS).capid())<<28);
     (rec->back()).setAux(auxflag);
 
     (rec->back()).setFlags(0); // Not yet implemented for HcalCalibRecHit
     */
       }
       // return result
       e.put(rec);     
     }
   } 
   //DL  delete myqual;
 } // void HcalHitReconstructor::produce(...)