EcalMixingModuleValidation Class Reference

#include <EcalMixingModuleValidation.h>

Inheritance diagram for EcalMixingModuleValidation:

Public Member Functions
void	bookHistograms (DQMStore::IBooker &i, edm::Run const &, edm::EventSetup const &) override
	EcalMixingModuleValidation (const edm::ParameterSet &ps)
	Constructor. More...
	~EcalMixingModuleValidation () override
	Destructor. More...
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
	DQMEDAnalyzer ()
	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete
void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) override
void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override
	~DQMEDAnalyzer () override=default
Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDProducerBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &c) override
	Analyze. More...
void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override
void	endRun (const edm::Run &r, const edm::EventSetup &c) override
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)

Private Types
typedef std::map< uint32_t, float, std::less< uint32_t > >	MapType

Private Member Functions
void	bunchSumTest (std::vector< MonitorElement * > &theBunches, MonitorElement *&theTotal, MonitorElement *&theRatio, int nSample)
void	checkCalibrations (edm::EventSetup const &c)
void	checkPedestals (const edm::EventSetup &c)
void	computeSDBunchDigi (const edm::EventSetup &eventSetup, const MixCollection< PCaloHit > &theHits, MapType &ebSignalSimMap, const EcalSubdetector &thisDet, const double &theSimThreshold, CLHEP::HepRandomEngine *)
void	findPedestal (const DetId &detId, int gainId, double &ped) const
CLHEP::HepRandomEngine *	randomEngine (edm::StreamID const &streamID)

Private Attributes
double	barrelADCtoGeV_
edm::EDGetTokenT< CrossingFrame< PCaloHit > >	crossingFramePCaloHitEBToken_
edm::EDGetTokenT< CrossingFrame< PCaloHit > >	crossingFramePCaloHitEEToken_
edm::EDGetTokenT< CrossingFrame< PCaloHit > >	crossingFramePCaloHitESToken_
DQMStore *	dbe_
edm::EDGetTokenT< EBDigiCollection >	EBdigiCollectionToken_
edm::EDGetTokenT< EEDigiCollection >	EEdigiCollectionToken_
double	endcapADCtoGeV_
double	esADCtokeV_
double	esBaseline_
edm::EDGetTokenT< ESDigiCollection >	ESdigiCollectionToken_
double	esThreshold_
std::map< int, double, std::less< int > >	gainConv_
edm::EDGetTokenT< edm::HepMCProduct >	HepMCToken_
double	m_ESeffwei
int	m_ESgain
const ESIntercalibConstants *	m_ESmips
const ESPedestals *	m_ESpeds
MonitorElement *	meEBbunchCrossing_
MonitorElement *	meEBBunchShape_ [nBunch]
MonitorElement *	meEBDigiMixRatiogt100ADC_
MonitorElement *	meEBDigiMixRatioOriggt50pc_
MonitorElement *	meEBShape_
MonitorElement *	meEBShapeRatio_
MonitorElement *	meEEbunchCrossing_
MonitorElement *	meEEBunchShape_ [nBunch]
MonitorElement *	meEEDigiMixRatiogt100ADC_
MonitorElement *	meEEDigiMixRatioOriggt40pc_
MonitorElement *	meEEShape_
MonitorElement *	meEEShapeRatio_
MonitorElement *	meESbunchCrossing_
MonitorElement *	meESBunchShape_ [nBunch]
MonitorElement *	meESShape_
MonitorElement *	meESShapeRatio_
std::string	outputFile_
std::vector< CLHEP::HepRandomEngine * >	randomEngines_
CaloHitResponse *	theEBResponse
const EBShape *	theEBShape
CaloHitResponse *	theEEResponse
const EEShape *	theEEShape
CaloHitResponse *	theESResponse
ESShape *	theESShape
const CaloGeometry *	theGeometry
int	theMaxBunch
int	theMinBunch
const EcalSimParameterMap *	theParameterMap
const EcalPedestals *	thePedestals
bool	verbose_

Static Private Attributes
static const int	nBunch = 21

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 75 of file EcalMixingModuleValidation.h.

Member Typedef Documentation

typedef std::map<uint32_t,float,std::less<uint32_t> > EcalMixingModuleValidation::MapType

private

Definition at line 77 of file EcalMixingModuleValidation.h.

Constructor & Destructor Documentation

EcalMixingModuleValidation::EcalMixingModuleValidation

(

const edm::ParameterSet &

ps

)

Constructor.

Definition at line 19 of file EcalMixingModuleValidation.cc.

References barrelADCtoGeV_, ecalEBTriggerPrimitiveDigis_cfi::binOfMaximum, ecalSimParameterMap_cff::doPhotostatistics, endcapADCtoGeV_, gainConv_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, meEBbunchCrossing_, meEBBunchShape_, meEBDigiMixRatiogt100ADC_, meEBDigiMixRatioOriggt50pc_, meEBShape_, meEBShapeRatio_, meEEbunchCrossing_, meEEBunchShape_, meEEDigiMixRatiogt100ADC_, meEEDigiMixRatioOriggt40pc_, meEEShape_, meEEShapeRatio_, meESbunchCrossing_, meESBunchShape_, meESShape_, meESShapeRatio_, nBunch, ecalSimParameterMap_cff::photoelectronsToAnalogBarrel, ecalSimParameterMap_cff::photoelectronsToAnalogEndcap, ecalSimParameterMap_cff::readoutFrameSize, ecalSimParameterMap_cff::samplingFactor, ecalSimParameterMap_cff::simHitToPhotoelectronsBarrel, ecalSimParameterMap_cff::simHitToPhotoelectronsEndcap, ecalSimParameterMap_cff::syncPhase, theEBResponse, theEBShape, theEEResponse, theEEShape, theESResponse, theESShape, theMaxBunch, theMinBunch, theParameterMap, ecalSimParameterMap_cff::timePhase, and verbose_.

                                                                               :
  HepMCToken_( consumes<edm::HepMCProduct>( edm::InputTag( ps.getParameter<std::string>( "moduleLabelMC" ) ) ) ),
  EBdigiCollectionToken_( consumes<EBDigiCollection>( ps.getParameter<edm::InputTag>( "EBdigiCollection" ) ) ),
  EEdigiCollectionToken_( consumes<EEDigiCollection>( ps.getParameter<edm::InputTag>( "EEdigiCollection" ) ) ),
  ESdigiCollectionToken_( consumes<ESDigiCollection>( ps.getParameter<edm::InputTag>( "ESdigiCollection" ) ) ),
  crossingFramePCaloHitEBToken_( consumes< CrossingFrame<PCaloHit> >( edm::InputTag( std::string( "mix" )
                                           , ps.getParameter<std::string>( "hitsProducer" ) + std::string( "EcalHitsEB" )
                                           )
                                    )
                   ),
  crossingFramePCaloHitEEToken_( consumes< CrossingFrame<PCaloHit> >( edm::InputTag( std::string( "mix" )
                                           , ps.getParameter<std::string>( "hitsProducer" ) + std::string( "EcalHitsEE" )
                                           )
                                    )
                   ),
  crossingFramePCaloHitESToken_( consumes< CrossingFrame<PCaloHit> >( edm::InputTag( std::string( "mix" )
                                           , ps.getParameter<std::string>( "hitsProducer" ) + std::string( "EcalHitsES" )
                                           )
                                    )
                   ) {


  // needed for MixingModule checks

  double simHitToPhotoelectronsBarrel = ps.getParameter<double>("simHitToPhotoelectronsBarrel");
  double simHitToPhotoelectronsEndcap = ps.getParameter<double>("simHitToPhotoelectronsEndcap");
  double photoelectronsToAnalogBarrel = ps.getParameter<double>("photoelectronsToAnalogBarrel");
  double photoelectronsToAnalogEndcap = ps.getParameter<double>("photoelectronsToAnalogEndcap");
  double samplingFactor = ps.getParameter<double>("samplingFactor");
  double timePhase = ps.getParameter<double>("timePhase");
  int readoutFrameSize = ps.getParameter<int>("readoutFrameSize");
  int binOfMaximum = ps.getParameter<int>("binOfMaximum");
  bool doPhotostatistics = ps.getParameter<bool>("doPhotostatistics");
  bool syncPhase = ps.getParameter<bool>("syncPhase");

  doPhotostatistics = false;
    
  theParameterMap = new EcalSimParameterMap(simHitToPhotoelectronsBarrel, simHitToPhotoelectronsEndcap, 
                                            photoelectronsToAnalogBarrel, photoelectronsToAnalogEndcap, 
                                            samplingFactor, timePhase, readoutFrameSize, binOfMaximum,
                                            doPhotostatistics, syncPhase);
  //theEcalShape = new EcalShape(timePhase);

  //theEcalResponse = new CaloHitResponse(theParameterMap, theEcalShape);

/*
  int ESGain = ps.getParameter<int>("ESGain");
  double ESNoiseSigma = ps.getParameter<double> ("ESNoiseSigma");
  int ESBaseline = ps.getParameter<int>("ESBaseline");
  double ESMIPADC = ps.getParameter<double>("ESMIPADC");
  double ESMIPkeV = ps.getParameter<double>("ESMIPkeV");
*/

  theESShape = new ESShape();
  theEBShape = new EBShape(); 
  theEEShape = new EEShape(); 

  theESResponse = new CaloHitResponse(theParameterMap, theESShape);
  theEBResponse = new CaloHitResponse(theParameterMap, theEBShape);
  theEEResponse = new CaloHitResponse(theParameterMap, theEEShape);

//  double effwei = 1.;

/*
  if (ESGain == 0)
    effwei = 1.45;
  else if (ESGain == 1)
    effwei = 0.9066;
  else if (ESGain == 2)
    effwei = 0.8815;
 
  esBaseline_ = (double)ESBaseline;
  esADCtokeV_ = 1000000.*ESMIPADC/ESMIPkeV;
  esThreshold_ = 3.*effwei*ESNoiseSigma/esADCtokeV_;
*/
  theMinBunch = -10;
  theMaxBunch = 10;
    
 
  // verbosity switch
  verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
                                                                                                                                           
  gainConv_[1] = 1.;
  gainConv_[2] = 2.;
  gainConv_[3] = 12.;
  gainConv_[0] = 12.;
  barrelADCtoGeV_ = 0.035;
  endcapADCtoGeV_ = 0.06;
 
  meEBDigiMixRatiogt100ADC_ = nullptr;
  meEEDigiMixRatiogt100ADC_ = nullptr;
    
  meEBDigiMixRatioOriggt50pc_ = nullptr;
  meEEDigiMixRatioOriggt40pc_ = nullptr;
    
  meEBbunchCrossing_ = nullptr;
  meEEbunchCrossing_ = nullptr;
  meESbunchCrossing_ = nullptr;
    
  for ( int i = 0 ; i < nBunch ; i++ ) {
    meEBBunchShape_[i] = nullptr;
    meEEBunchShape_[i] = nullptr;
    meESBunchShape_[i] = nullptr;
  }

  meEBShape_ = nullptr;
  meEEShape_ = nullptr;
  meESShape_ = nullptr;

  meEBShapeRatio_ = nullptr;
  meEEShapeRatio_ = nullptr;
  meESShapeRatio_ = nullptr;
 
}

EcalMixingModuleValidation::~EcalMixingModuleValidation ( )

override

Destructor.

Definition at line 134 of file EcalMixingModuleValidation.cc.

{}

Member Function Documentation

void EcalMixingModuleValidation::analyze ( edm::Event const &  e, edm::EventSetup const &  c  )

overrideprotectedvirtual

Analyze.

Reimplemented from DQMEDAnalyzer.

Definition at line 286 of file EcalMixingModuleValidation.cc.

References ESSample::adc(), EcalMGPASample::adc(), barrelADCtoGeV_, cosmicBasicClusters_cfi::barrelHits, checkPedestals(), computeSDBunchDigi(), crossingFramePCaloHitEBToken_, crossingFramePCaloHitEEToken_, crossingFramePCaloHitESToken_, EBdigiCollectionToken_, EcalBarrel, EcalEndcap, EcalPreshower, EEdigiCollectionToken_, edm::DataFrameContainer::empty(), endcapADCtoGeV_, cosmicBasicClusters_cfi::endcapHits, esADCtokeV_, esBaseline_, ESdigiCollectionToken_, esThreshold_, MonitorElement::Fill(), ESCondObjectContainer< T >::find(), findPedestal(), gainConv_, EcalMGPASample::gainId(), edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), ESCondObjectContainer< T >::getMap(), HepMCToken_, mps_fire::i, ESDataFrame::id(), EEDataFrame::id(), EBDataFrame::id(), EBDetId::ieta(), createfilelist::int, EBDetId::iphi(), gedGsfElectrons_cfi::isBarrel, GeomDetEnumerators::isEndcap(), edm::HandleBase::isValid(), EEDetId::ix(), EEDetId::iy(), LogDebug, m_ESeffwei, m_ESmips, m_ESpeds, ESDataFrame::MAXSAMPLES, EcalDataFrame::MAXSAMPLES, meEBbunchCrossing_, meEBDigiMixRatiogt100ADC_, meEBDigiMixRatioOriggt50pc_, meEBShape_, meEEbunchCrossing_, meEEDigiMixRatiogt100ADC_, meEEDigiMixRatioOriggt40pc_, meEEShape_, meESbunchCrossing_, meESShape_, ecalTB2006H4_GenSimDigiReco_cfg::mySample, AlCaHLTBitMon_ParallelJobs::p, ESDetId::plane(), dataAnalyzerFineBiningParameters_cff::Pmax, gedPhotons_cfi::preshowerHits, edm::Handle< T >::product(), randomEngine(), DetId::rawId(), edm::DataFrameContainer::reserve(), simplePhotonAnalyzer_cfi::sample, ESDetId::six(), ESDetId::siy(), ESDataFrame::size(), EcalDataFrame::size(), edm::DataFrameContainer::size(), edm::Event::streamID(), ESDetId::strip(), ESDetId::zside(), and EEDetId::zside().

                                                                                   {

  //LogInfo("EventInfo") << " Run = " << e.id().run() << " Event = " << e.id().event();

  checkPedestals(c);

  std::vector<SimTrack> theSimTracks;
  std::vector<SimVertex> theSimVertexes;

  edm::Handle<edm::HepMCProduct> MCEvt;
  edm::Handle<CrossingFrame<PCaloHit> > crossingFrame;
  edm::Handle<EBDigiCollection> EcalDigiEB;
  edm::Handle<EEDigiCollection> EcalDigiEE;
  edm::Handle<ESDigiCollection> EcalDigiES;

  
  bool skipMC = false;
  e.getByToken( HepMCToken_, MCEvt );
  if (!MCEvt.isValid()) { skipMC = true; }

  const EBDigiCollection* EBdigis =nullptr;
  const EEDigiCollection* EEdigis =nullptr;
  const ESDigiCollection* ESdigis =nullptr;

  bool isBarrel = true;
  e.getByToken( EBdigiCollectionToken_, EcalDigiEB );
  if (EcalDigiEB.isValid()) { 
    EBdigis = EcalDigiEB.product();
    LogDebug("DigiInfo") << "total # EBdigis: " << EBdigis->size() ;
    if ( EBdigis->empty() ) isBarrel = false;
  } else {
    isBarrel = false; 
  }

  bool isEndcap = true;
  e.getByToken( EEdigiCollectionToken_, EcalDigiEE );
  if (EcalDigiEE.isValid()) {
    EEdigis = EcalDigiEE.product();
    LogDebug("DigiInfo") << "total # EEdigis: " << EEdigis->size() ;
    if ( EEdigis->empty() ) isEndcap = false;
  } else {
    isEndcap = false; 
  }

  bool isPreshower = true;
  e.getByToken( ESdigiCollectionToken_, EcalDigiES );
  if (EcalDigiES.isValid()) {
    ESdigis = EcalDigiES.product();
    LogDebug("DigiInfo") << "total # ESdigis: " << ESdigis->size() ;
    if ( ESdigis->empty() ) isPreshower = false;
  } else {
    isPreshower = false; 
  }

  double theGunEnergy = 0.;
  if ( ! skipMC ) {
     for ( HepMC::GenEvent::particle_const_iterator p = MCEvt->GetEvent()->particles_begin();
          p != MCEvt->GetEvent()->particles_end(); ++p ) {
      
      theGunEnergy = (*p)->momentum().e();
      }
  }
  // in case no HepMC available, assume an arbitrary average energy for an interesting "gun"
  else { 
    edm::LogWarning("DigiInfo") << "No HepMC available, using 30 GeV as giun energy";
    theGunEnergy = 30.; 
  }

  // BARREL

  // loop over simHits

  if ( isBarrel ) {

    e.getByToken( crossingFramePCaloHitEBToken_, crossingFrame );
    const MixCollection<PCaloHit> barrelHits(crossingFrame.product());
    
    MapType ebSignalSimMap;

    double ebSimThreshold = 0.5*theGunEnergy;

    for ( auto const &iHit : barrelHits ) {
      
      EBDetId ebid = EBDetId(iHit.id()) ;
      
      LogDebug("HitInfo") 
        << " CaloHit " << iHit.getName() << "\n" 
        << " DetID = "<<iHit.id()<< " EBDetId = " << ebid.ieta() << " " << ebid.iphi() << "\n"  
        << " Time = " << iHit.time() << " Event id. = " << iHit.eventId().rawId() << "\n"
        << " Track Id = " << iHit.geantTrackId() << "\n"
        << " Energy = " << iHit.energy();

      uint32_t crystid = ebid.rawId();

      if ( iHit.eventId().rawId() == 0 ) ebSignalSimMap[crystid] += iHit.energy();
      
      if ( meEBbunchCrossing_ ) meEBbunchCrossing_->Fill(iHit.eventId().bunchCrossing()); 
      
    }
    
    // loop over Digis
    
    const EBDigiCollection * barrelDigi = EcalDigiEB.product () ;
    
    std::vector<double> ebAnalogSignal ;
    std::vector<double> ebADCCounts ;
    std::vector<double> ebADCGains ;
    ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES);
    ebADCCounts.reserve(EBDataFrame::MAXSAMPLES);
    ebADCGains.reserve(EBDataFrame::MAXSAMPLES);
    
    for (unsigned int digis=0; digis<EcalDigiEB->size(); ++digis) {

      EBDataFrame ebdf=(*barrelDigi)[digis];
      int nrSamples=ebdf.size();
      
      EBDetId ebid = ebdf.id () ;
      
      double Emax = 0. ;
      int Pmax = 0 ;
      
      for (int sample = 0 ; sample < nrSamples; ++sample) {
    ebAnalogSignal[sample] = 0.;
    ebADCCounts[sample] = 0.;
    ebADCGains[sample] = -1.;
      }
      
      for (int sample = 0 ; sample < nrSamples; ++sample) {

    EcalMGPASample mySample = ebdf[sample];
    
    ebADCCounts[sample] = (mySample.adc()) ;
    ebADCGains[sample]  = (mySample.gainId ()) ;
    ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_);
    if (Emax < ebAnalogSignal[sample] ) {
      Emax = ebAnalogSignal[sample] ;
      Pmax = sample ;
    }
    LogDebug("DigiInfo") << "EB sample " << sample << " ADC counts = " << ebADCCounts[sample] << " Gain Id = " << ebADCGains[sample] << " Analog eq = " << ebAnalogSignal[sample];
      }
      double pedestalPreSampleAnalog = 0.;
      findPedestal( ebid, (int)ebADCGains[Pmax] , pedestalPreSampleAnalog);
      pedestalPreSampleAnalog *= gainConv_[(int)ebADCGains[Pmax]]*barrelADCtoGeV_;
      double Erec = Emax - pedestalPreSampleAnalog;
      
      if ( ebSignalSimMap[ebid.rawId()] != 0. ) {
    LogDebug("DigiInfo") << " Digi / Signal Hit = " << Erec << " / " << ebSignalSimMap[ebid.rawId()] << " gainConv " << gainConv_[(int)ebADCGains[Pmax]];
    if ( Erec > 100.*barrelADCtoGeV_  && meEBDigiMixRatiogt100ADC_  ) meEBDigiMixRatiogt100ADC_->Fill( Erec/ebSignalSimMap[ebid.rawId()] );
    if ( ebSignalSimMap[ebid.rawId()] > ebSimThreshold  && meEBDigiMixRatioOriggt50pc_ ) meEBDigiMixRatioOriggt50pc_->Fill( Erec/ebSignalSimMap[ebid.rawId()] );
    if ( ebSignalSimMap[ebid.rawId()] > ebSimThreshold  && meEBShape_ ) {
      for ( int i = 0; i < 10 ; i++ ) {
        pedestalPreSampleAnalog = 0.;
        findPedestal( ebid, (int)ebADCGains[i] , pedestalPreSampleAnalog);
        pedestalPreSampleAnalog *= gainConv_[(int)ebADCGains[i]]*barrelADCtoGeV_;
        meEBShape_->Fill(i, ebAnalogSignal[i]-pedestalPreSampleAnalog );
      }
    }
      }
      
    } 
    
    EcalSubdetector thisDet = EcalBarrel;
    computeSDBunchDigi(c, barrelHits, ebSignalSimMap, thisDet, ebSimThreshold, randomEngine(e.streamID()));
  }
  
  
  // ENDCAP

  // loop over simHits

  if ( isEndcap ) {

    e.getByToken( crossingFramePCaloHitEEToken_, crossingFrame );
    const MixCollection<PCaloHit> endcapHits(crossingFrame.product());
    MapType eeSignalSimMap;

    double eeSimThreshold = 0.4*theGunEnergy;
    
    for ( auto const & iHit : endcapHits ) {
      
      EEDetId eeid = EEDetId(iHit.id()) ;
      
      LogDebug("HitInfo") 
        << " CaloHit " << iHit.getName() << "\n" 
        << " DetID = "<<iHit.id()<< " EEDetId side = " << eeid.zside() << " = " << eeid.ix() << " " << eeid.iy() << "\n"
        << " Time = " << iHit.time() << " Event id. = " << iHit.eventId().rawId() << "\n"
        << " Track Id = " << iHit.geantTrackId() << "\n"
        << " Energy = " << iHit.energy();
      
      uint32_t crystid = eeid.rawId();

      if ( iHit.eventId().rawId() == 0 ) eeSignalSimMap[crystid] += iHit.energy();
      
      if ( meEEbunchCrossing_ ) meEEbunchCrossing_->Fill(iHit.eventId().bunchCrossing()); 

    }
    
    // loop over Digis
    
    const EEDigiCollection * endcapDigi = EcalDigiEE.product () ;
    
    std::vector<double> eeAnalogSignal ;
    std::vector<double> eeADCCounts ;
    std::vector<double> eeADCGains ;
    eeAnalogSignal.reserve(EEDataFrame::MAXSAMPLES);
    eeADCCounts.reserve(EEDataFrame::MAXSAMPLES);
    eeADCGains.reserve(EEDataFrame::MAXSAMPLES);
    
    for (unsigned int digis=0; digis<EcalDigiEE->size(); ++digis) {

      EEDataFrame eedf=(*endcapDigi)[digis];
      int nrSamples=eedf.size();
      
      EEDetId eeid = eedf.id () ;
      
      double Emax = 0. ;
      int Pmax = 0 ;
      
      for (int sample = 0 ; sample < nrSamples; ++sample) {
    eeAnalogSignal[sample] = 0.;
    eeADCCounts[sample] = 0.;
    eeADCGains[sample] = -1.;
      }
      
      for (int sample = 0 ; sample < nrSamples; ++sample) {
    
    EcalMGPASample mySample = eedf[sample];
    
    eeADCCounts[sample] = (mySample.adc()) ;
    eeADCGains[sample]  = (mySample.gainId()) ;
    eeAnalogSignal[sample] = (eeADCCounts[sample]*gainConv_[(int)eeADCGains[sample]]*endcapADCtoGeV_);
    if (Emax < eeAnalogSignal[sample] ) {
      Emax = eeAnalogSignal[sample] ;
      Pmax = sample ;
    }
    LogDebug("DigiInfo") << "EE sample " << sample << " ADC counts = " << eeADCCounts[sample] << " Gain Id = " << eeADCGains[sample] << " Analog eq = " << eeAnalogSignal[sample];
      }
      double pedestalPreSampleAnalog = 0.;
      findPedestal( eeid, (int)eeADCGains[Pmax] , pedestalPreSampleAnalog);
      pedestalPreSampleAnalog *= gainConv_[(int)eeADCGains[Pmax]]*endcapADCtoGeV_;
      double Erec = Emax - pedestalPreSampleAnalog;
      
      if ( eeSignalSimMap[eeid.rawId()] != 0. ) {
    LogDebug("DigiInfo") << " Digi / Signal Hit = " << Erec << " / " << eeSignalSimMap[eeid.rawId()] << " gainConv " << gainConv_[(int)eeADCGains[Pmax]];
    if ( Erec > 100.*endcapADCtoGeV_  && meEEDigiMixRatiogt100ADC_  ) meEEDigiMixRatiogt100ADC_->Fill( Erec/eeSignalSimMap[eeid.rawId()] );
    if ( eeSignalSimMap[eeid.rawId()] > eeSimThreshold  && meEEDigiMixRatioOriggt40pc_ ) meEEDigiMixRatioOriggt40pc_->Fill( Erec/eeSignalSimMap[eeid.rawId()] );
    if ( eeSignalSimMap[eeid.rawId()] > eeSimThreshold  && meEBShape_ ) {
      for ( int i = 0; i < 10 ; i++ ) {
        pedestalPreSampleAnalog = 0.;
        findPedestal( eeid, (int)eeADCGains[i] , pedestalPreSampleAnalog);
        pedestalPreSampleAnalog *= gainConv_[(int)eeADCGains[i]]*endcapADCtoGeV_;
        meEEShape_->Fill(i, eeAnalogSignal[i]-pedestalPreSampleAnalog );
      }
          }
      }
    }
    
    EcalSubdetector thisDet = EcalEndcap;
    computeSDBunchDigi(c, endcapHits, eeSignalSimMap, thisDet, eeSimThreshold, randomEngine(e.streamID()));
  }

  if ( isPreshower) {

    e.getByToken(crossingFramePCaloHitESToken_, crossingFrame );
    const MixCollection<PCaloHit> preshowerHits(crossingFrame.product());

    MapType esSignalSimMap;

    for ( auto const & iHit : preshowerHits ) {
      
      ESDetId esid = ESDetId(iHit.id()) ;
      
      LogDebug("HitInfo") 
        << " CaloHit " << iHit.getName() << "\n" 
        << " DetID = "<<iHit.id()<< "ESDetId: z side " << esid.zside() << "  plane " << esid.plane() << esid.six() << ',' << esid.siy() << ':' << esid.strip() << "\n"
        << " Time = " << iHit.time() << " Event id. = " << iHit.eventId().rawId() << "\n"
        << " Track Id = " << iHit.geantTrackId() << "\n"
        << " Energy = " << iHit.energy();

      uint32_t stripid = esid.rawId();

      if ( iHit.eventId().rawId() == 0 ) esSignalSimMap[stripid] += iHit.energy();
      
      if ( meESbunchCrossing_ ) meESbunchCrossing_->Fill(iHit.eventId().bunchCrossing()); 
  
      // loop over Digis

      const ESDigiCollection * preshowerDigi = EcalDigiES.product () ;

      std::vector<double> esADCCounts ;
      std::vector<double> esADCAnalogSignal ;
      esADCCounts.reserve(ESDataFrame::MAXSAMPLES);
      esADCAnalogSignal.reserve(ESDataFrame::MAXSAMPLES);

      for (unsigned int digis=0; digis<EcalDigiES->size(); ++digis) {

    ESDataFrame esdf=(*preshowerDigi)[digis];
    int nrSamples=esdf.size();
    
    ESDetId esid = esdf.id () ;
    
    for (int sample = 0 ; sample < nrSamples; ++sample) {
      esADCCounts[sample] = 0.;
      esADCAnalogSignal[sample] = 0.;
    }
    
    for (int sample = 0 ; sample < nrSamples; ++sample) {

      ESSample mySample = esdf[sample];
      
      esADCCounts[sample] = (mySample.adc()) ;
      esBaseline_ = m_ESpeds->find(esid)->getMean() ;
      const double factor ( esADCtokeV_/(*(m_ESmips->getMap().find(esid)) ) ) ;
      esThreshold_ = 3.*m_ESeffwei*( (*m_ESpeds->find(esid)).getRms())/factor;
      esADCAnalogSignal[sample] = (esADCCounts[sample]-esBaseline_)/factor;
    }
    LogDebug("DigiInfo") << "Preshower Digi for ESDetId: z side " << esid.zside() << "  plane " << esid.plane() << esid.six() << ',' << esid.siy() << ':' << esid.strip();
    for ( int i = 0; i < 3 ; i++ ) {
      LogDebug("DigiInfo") << "sample " << i << " ADC = " << esADCCounts[i] << " Analog eq = " << esADCAnalogSignal[i];
    }
    
    if ( esSignalSimMap[esid.rawId()] > esThreshold_  && meESShape_ ) {
      for ( int i = 0; i < 3 ; i++ ) {
        meESShape_->Fill(i, esADCAnalogSignal[i] );
      }
    }
    
      } 
      
    }
    
    EcalSubdetector thisDet = EcalPreshower;
    computeSDBunchDigi(c, preshowerHits, esSignalSimMap, thisDet, esThreshold_, randomEngine(e.streamID()));
    
  }
  
}                                                                                       

void EcalMixingModuleValidation::bookHistograms ( DQMStore::IBooker &  i, edm::Run const &  , edm::EventSetup const &    )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 142 of file EcalMixingModuleValidation.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::bookProfile(), trackerHits::histo, mps_fire::i, meEBbunchCrossing_, meEBBunchShape_, meEBDigiMixRatiogt100ADC_, meEBDigiMixRatioOriggt50pc_, meEBShape_, meEBShapeRatio_, meEEbunchCrossing_, meEEBunchShape_, meEEDigiMixRatiogt100ADC_, meEEDigiMixRatioOriggt40pc_, meEEShape_, meEEShapeRatio_, meESbunchCrossing_, meESBunchShape_, meESShape_, meESShapeRatio_, nBunch, and DQMStore::IBooker::setCurrentFolder().

                                                                                                            {

    Char_t histo[200];

    ibooker.setCurrentFolder("EcalDigisV/EcalDigiTask");
  
    sprintf (histo, "EcalDigiTask Barrel maximum Digi over sim signal ratio gt 100 ADC" ) ;
    meEBDigiMixRatiogt100ADC_ = ibooker.book1D(histo, histo, 200, 0., 100.) ;
      
    sprintf (histo, "EcalDigiTask Endcap maximum Digi over sim signal ratio gt 100 ADC" ) ;
    meEEDigiMixRatiogt100ADC_ = ibooker.book1D(histo, histo, 200, 0., 100.) ;
      
    sprintf (histo, "EcalDigiTask Barrel maximum Digi over sim signal ratio signal gt 50pc gun" ) ;
    meEBDigiMixRatioOriggt50pc_ = ibooker.book1D(histo, histo, 200, 0., 100.) ;
      
    sprintf (histo, "EcalDigiTask Endcap maximum Digi over sim signal ratio signal gt 40pc gun" ) ;
    meEEDigiMixRatioOriggt40pc_ = ibooker.book1D(histo, histo, 200, 0., 100.) ;
      
    sprintf (histo, "EcalDigiTask Barrel bunch crossing" ) ;
    meEBbunchCrossing_ = ibooker.book1D(histo, histo, 20, -10., 10.) ;
      
    sprintf (histo, "EcalDigiTask Endcap bunch crossing" ) ;
    meEEbunchCrossing_ = ibooker.book1D(histo, histo, 20, -10., 10.) ;
      
    sprintf (histo, "EcalDigiTask Preshower bunch crossing" ) ;
    meESbunchCrossing_ = ibooker.book1D(histo, histo, 20, -10., 10.) ;

    for ( int i = 0 ; i < nBunch ; i++ ) {

      sprintf (histo, "EcalDigiTask Barrel shape bunch crossing %02d", i-10 );
      meEBBunchShape_[i] = ibooker.bookProfile(histo, histo, 10, 0, 10, 4000, 0., 400.);

      sprintf (histo, "EcalDigiTask Endcap shape bunch crossing %02d", i-10 );
      meEEBunchShape_[i] = ibooker.bookProfile(histo, histo, 10, 0, 10, 4000, 0., 400.);

      sprintf (histo, "EcalDigiTask Preshower shape bunch crossing %02d", i-10 );
      meESBunchShape_[i] = ibooker.bookProfile(histo, histo, 3, 0, 3, 4000, 0., 400.);

    }

    sprintf (histo, "EcalDigiTask Barrel shape digi");
    meEBShape_ = ibooker.bookProfile(histo, histo, 10, 0, 10, 4000, 0., 2000.);

    sprintf (histo, "EcalDigiTask Endcap shape digi");
    meEEShape_ = ibooker.bookProfile(histo, histo, 10, 0, 10, 4000, 0., 2000.);

    sprintf (histo, "EcalDigiTask Preshower shape digi");
    meESShape_ = ibooker.bookProfile(histo, histo, 3, 0, 3, 4000, 0., 2000.);

    sprintf (histo, "EcalDigiTask Barrel shape digi ratio");
    meEBShapeRatio_ = ibooker.book1D(histo, histo, 10, 0, 10.);

    sprintf (histo, "EcalDigiTask Endcap shape digi ratio");
    meEEShapeRatio_ = ibooker.book1D(histo, histo, 10, 0, 10.);

    sprintf (histo, "EcalDigiTask Preshower shape digi ratio");
    meESShapeRatio_ = ibooker.book1D(histo, histo, 3, 0, 3.);
     
}

void EcalMixingModuleValidation::bunchSumTest ( std::vector< MonitorElement * > &  theBunches, MonitorElement *&  theTotal, MonitorElement *&  theRatio, int  nSample  )

private

Definition at line 228 of file EcalMixingModuleValidation.cc.

References gather_cfg::cout, MonitorElement::getBinContent(), MonitorElement::getBinError(), funct::pow(), particleFlowDisplacedVertex_cfi::ratio, MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), theMaxBunch, theMinBunch, and pileupDistInMC::total.

Referenced by endRun().

{

  std::vector<double> bunchSum;
  bunchSum.reserve(nSample);
  std::vector<double> bunchSumErro;
  bunchSumErro.reserve(nSample);
  std::vector<double> total;
  total.reserve(nSample);
  std::vector<double> totalErro;
  totalErro.reserve(nSample);
  std::vector<double> ratio;
  ratio.reserve(nSample);
  std::vector<double> ratioErro;
  ratioErro.reserve(nSample);


  for ( int iEl = 0 ; iEl < nSample ; iEl++ ) {
    bunchSum[iEl] = 0.;
    bunchSumErro[iEl] = 0.;
    total[iEl] = 0.;
    totalErro[iEl] = 0.;
    ratio[iEl] = 0.;
    ratioErro[iEl] = 0.;
  }

  for ( int iSample = 0 ; iSample < nSample ; iSample++ ) { 

    total[iSample] += theTotal->getBinContent(iSample+1);
    totalErro[iSample] += theTotal->getBinError(iSample+1);

    for ( int iBunch = theMinBunch; iBunch <= theMaxBunch; iBunch++ ) {

      int iHisto = iBunch - theMinBunch;

      bunchSum[iSample] += theBunches[iHisto]->getBinContent(iSample+1);
      bunchSumErro[iSample] += pow(theBunches[iHisto]->getBinError(iSample+1),2);

    }
    bunchSumErro[iSample] = sqrt(bunchSumErro[iSample]);

    if ( bunchSum[iSample] > 0. ) { 
      ratio[iSample] = total[iSample]/bunchSum[iSample];
      ratioErro[iSample] = sqrt(pow(totalErro[iSample]/bunchSum[iSample],2)+
                                pow((total[iSample]*bunchSumErro[iSample])/(bunchSum[iSample]*bunchSum[iSample]),2));
    }

    std::cout << " Sample = " << iSample << " Total = " << total[iSample] << " +- " << totalErro[iSample] << "\n" 
              << " Sum   = " << bunchSum[iSample] << " +- " << bunchSumErro[iSample] << "\n" 
              << " Ratio = " << ratio[iSample] << " +- " << ratioErro[iSample] << std::endl;
      
    theRatio->setBinContent(iSample+1, (float)ratio[iSample]);
    theRatio->setBinError(iSample+1, (float)ratioErro[iSample]);

  }

} 

void EcalMixingModuleValidation::checkCalibrations ( edm::EventSetup const &  c )

private

Definition at line 624 of file EcalMixingModuleValidation.cc.

References barrelADCtoGeV_, endcapADCtoGeV_, esADCtokeV_, EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), gainConv_, edm::EventSetup::get(), EcalADCToGeVConstant::getEBValue(), EcalADCToGeVConstant::getEEValue(), ESGain::getESGain(), ESMIPToGeVConstant::getESValueHigh(), ESMIPToGeVConstant::getESValueLow(), createfilelist::int, LogDebug, m_ESeffwei, m_ESgain, m_ESmips, m_ESpeds, edm::ESHandle< T >::product(), ESShape::setGain(), and theESShape.

Referenced by dqmBeginRun().

                                                                                    {
  
  // ADC -> GeV Scale
  edm::ESHandle<EcalADCToGeVConstant> pAgc;
  eventSetup.get<EcalADCToGeVConstantRcd>().get(pAgc);
  const EcalADCToGeVConstant* agc = pAgc.product();
  
  EcalMGPAGainRatio * defaultRatios = new EcalMGPAGainRatio();

  gainConv_[1] = 1.;
  gainConv_[2] = defaultRatios->gain12Over6() ;
  gainConv_[3] = gainConv_[2]*(defaultRatios->gain6Over1()) ;
  gainConv_[0] = gainConv_[2]*(defaultRatios->gain6Over1()) ;

  LogDebug("EcalDigi") << " Gains conversions: " << "\n" << " g1 = " << gainConv_[1] << "\n" << " g2 = " << gainConv_[2] << "\n" << " g3 = " << gainConv_[3];

  delete defaultRatios;

  const double barrelADCtoGeV_  = agc->getEBValue();
  LogDebug("EcalDigi") << " Barrel GeV/ADC = " << barrelADCtoGeV_;
  const double endcapADCtoGeV_ = agc->getEEValue();
  LogDebug("EcalDigi") << " Endcap GeV/ADC = " << endcapADCtoGeV_;


   // ES condition objects
   edm::ESHandle<ESGain> esgain_;
   edm::ESHandle<ESMIPToGeVConstant> esMIPToGeV_;
   edm::ESHandle<ESPedestals> esPedestals_;
   edm::ESHandle<ESIntercalibConstants> esMIPs_;

   eventSetup.get<ESGainRcd>().get(esgain_);
   eventSetup.get<ESMIPToGeVConstantRcd>().get(esMIPToGeV_);
   eventSetup.get<ESPedestalsRcd>().get(esPedestals_);
   eventSetup.get<ESIntercalibConstantsRcd>().get(esMIPs_);

   const ESGain *esgain = esgain_.product();
   m_ESpeds = esPedestals_.product();
   m_ESmips = esMIPs_.product();
   const ESMIPToGeVConstant *esMipToGeV = esMIPToGeV_.product();
   m_ESgain = (int) esgain->getESGain();  
   const double valESMIPToGeV = (m_ESgain == 1) ? esMipToGeV->getESValueLow() : esMipToGeV->getESValueHigh(); 

   theESShape->setGain(m_ESgain);

   esADCtokeV_ = 1000000.*valESMIPToGeV ;
 
   m_ESeffwei = ( 0 == m_ESgain ? 1.45 :
          ( 1 == m_ESgain ? 0.9066 :
            ( 2 == m_ESgain ? 0.8815 : 1.0 ) ) ) ;

}

void EcalMixingModuleValidation::checkPedestals ( const edm::EventSetup &  c )

private

Definition at line 676 of file EcalMixingModuleValidation.cc.

References edm::EventSetup::get(), edm::ESHandle< T >::product(), and thePedestals.

Referenced by analyze().

{

  // Pedestals from event setup

  edm::ESHandle<EcalPedestals> dbPed;
  eventSetup.get<EcalPedestalsRcd>().get( dbPed );
  thePedestals=dbPed.product();
  
}

void EcalMixingModuleValidation::computeSDBunchDigi ( const edm::EventSetup &  eventSetup, const MixCollection< PCaloHit > &  theHits, MapType &  ebSignalSimMap, const EcalSubdetector &  thisDet, const double &  theSimThreshold, CLHEP::HepRandomEngine *  engine  )

private

Definition at line 717 of file EcalMixingModuleValidation.cc.

References CaloHitResponse::clear(), DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, MonitorElement::Fill(), CaloHitResponse::findSignal(), edm::EventSetup::get(), CaloGeometry::getValidDetIds(), mps_fire::i, CaloSamples::id(), MessageLogger_cfi::limit, ESDataFrame::MAXSAMPLES, CaloSamples::MAXSAMPLES, meEBBunchShape_, meEEBunchShape_, meESBunchShape_, hcalSimParameters_cfi::photoelectronsToAnalog, CaloHitResponse::run(), CaloHitResponse::setBunchRange(), CaloHitResponse::setGeometry(), EcalSimParameterMap::simParameters(), theEBResponse, theEEResponse, theESResponse, theGeometry, theMaxBunch, theMinBunch, and theParameterMap.

Referenced by analyze().

{

  if ( thisDet != EcalBarrel && thisDet != EcalEndcap && thisDet != EcalPreshower ) {
    edm::LogError("EcalMMValid") << "Invalid subdetector type";
    return;
  }
  //bool isCrystal = true;
  //if ( thisDet == EcalPreshower ) isCrystal = false;

  // load the geometry

  edm::ESHandle<CaloGeometry> hGeometry;
  eventSetup.get<CaloGeometryRecord>().get(hGeometry);

  const CaloGeometry * pGeometry = &*hGeometry;
  
  // see if we need to update
  if(pGeometry != theGeometry) {
    theGeometry = pGeometry;
    //theEcalResponse->setGeometry(theGeometry); 
    theESResponse->setGeometry(theGeometry); 
    theEEResponse->setGeometry(theGeometry); 
    theEBResponse->setGeometry(theGeometry); 

  }

  // vector of DetId with energy above a fraction of the gun's energy

  const std::vector<DetId>& theSDId = theGeometry->getValidDetIds( DetId::Ecal, thisDet );

  std::vector<DetId> theOverThresholdId;
  for ( unsigned int i = 0 ; i < theSDId.size() ; i++ ) {

    int sdId = theSDId[i].rawId();
    if ( SignalSimMap[sdId] > theSimThreshold ) theOverThresholdId.push_back( theSDId[i] );

  }

  int limit = CaloSamples::MAXSAMPLES;
  if ( thisDet == EcalPreshower ) limit = ESDataFrame::MAXSAMPLES;

   for (int iBunch = theMinBunch ; iBunch <= theMaxBunch ; iBunch++ ) {

     //if ( isCrystal ) {
     if( thisDet == EcalBarrel ) {
       theEBResponse->setBunchRange(iBunch, iBunch);
       theEBResponse->clear();
       theEBResponse->run(theHits, engine);
     }
     else if( thisDet == EcalEndcap ) {
       theEEResponse->setBunchRange(iBunch, iBunch);
       theEEResponse->clear();
       theEEResponse->run(theHits, engine);
     }
     else {
       theESResponse->setBunchRange(iBunch, iBunch);
       theESResponse->clear();
       theESResponse->run(theHits, engine);
     }

     int iHisto = iBunch - theMinBunch;

     for ( std::vector<DetId>::const_iterator idItr = theOverThresholdId.begin() ; idItr != theOverThresholdId.end() ; ++idItr ) {
       
       CaloSamples * analogSignal;
       //if ( isCrystal ) 
       if( thisDet == EcalBarrel ) { 
         analogSignal = theEBResponse->findSignal(*idItr); 
       }
       else if( thisDet == EcalEndcap ) { 
     analogSignal = theEEResponse->findSignal(*idItr);
       }
       else { 
     analogSignal = theESResponse->findSignal(*idItr); 
       }

       if ( analogSignal ) {
        
         (*analogSignal) *= theParameterMap->simParameters(analogSignal->id()).photoelectronsToAnalog();

         for ( int i = 0 ; i < limit ; i++ ) {
           if ( thisDet == EcalBarrel ) { meEBBunchShape_[iHisto]->Fill(i,(float)(*analogSignal)[i]); }
           else if ( thisDet == EcalEndcap ) { meEEBunchShape_[iHisto]->Fill(i,(float)(*analogSignal)[i]); }
           else if ( thisDet == EcalPreshower ) { meESBunchShape_[iHisto]->Fill(i,(float)(*analogSignal)[i]); }
         }
       }

     }

   }

 }

void EcalMixingModuleValidation::dqmBeginRun ( edm::Run const &  , edm::EventSetup const &  c  )

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 136 of file EcalMixingModuleValidation.cc.

References checkCalibrations().

                                                                                  {

  checkCalibrations(c);

}

void EcalMixingModuleValidation::endRun ( const edm::Run &  r, const edm::EventSetup &  c  )

overrideprotected

Definition at line 202 of file EcalMixingModuleValidation.cc.

References bunchSumTest(), mps_fire::i, ESDataFrame::MAXSAMPLES, EcalDataFrame::MAXSAMPLES, meEBBunchShape_, meEBShape_, meEBShapeRatio_, meEEBunchShape_, meEEShape_, meEEShapeRatio_, meESBunchShape_, meESShape_, meESShapeRatio_, and nBunch.

                                                                                {

  // add shapes for each bunch crossing and divide the digi by the result
  
  std::vector<MonitorElement *> theBunches;
  for ( int i = 0 ; i < nBunch ; i++ ) {
    theBunches.push_back(meEBBunchShape_[i]);
  }
  bunchSumTest(theBunches , meEBShape_ , meEBShapeRatio_ , EcalDataFrame::MAXSAMPLES);
  
  theBunches.clear();
  
  for ( int i = 0 ; i < nBunch ; i++ ) {
    theBunches.push_back(meEEBunchShape_[i]);
  }
  bunchSumTest(theBunches , meEEShape_ , meEEShapeRatio_ , EcalDataFrame::MAXSAMPLES);
  
  theBunches.clear();
  
  for ( int i = 0 ; i < nBunch ; i++ ) {
    theBunches.push_back(meESBunchShape_[i]);
  }
  bunchSumTest(theBunches , meESShape_ , meESShapeRatio_ , ESDataFrame::MAXSAMPLES);
  
}

void EcalMixingModuleValidation::findPedestal ( const DetId &  detId, int  gainId, double &  ped  ) const

private

Definition at line 687 of file EcalMixingModuleValidation.cc.

References EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), ecalMGPA::gainId(), EcalCondObjectContainer< T >::getMap(), LogDebug, EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, DetId::rawId(), EcalCondObjectContainer< T >::size(), and thePedestals.

Referenced by analyze().

{
  EcalPedestalsMapIterator mapItr 
    = thePedestals->getMap().find(detId);
  // should I care if it doesn't get found?
  if(mapItr == thePedestals->getMap().end()) {
    edm::LogError("EcalMMValid") << "Could not find pedestal for " << detId.rawId() << " among the " << thePedestals->getMap().size();
  } else {
    EcalPedestals::Item item = (*mapItr);

    switch(gainId) {
    case 0:
      ped = item.mean_x1;
    case 1:
      ped = item.mean_x12;
      break;
    case 2:
      ped = item.mean_x6;
      break;
    case 3:
      ped = item.mean_x1;
      break;
    default:
      edm::LogError("EcalMMValid") << "Bad Pedestal " << gainId;
      break;
    }
    LogDebug("EcalMMValid") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" << "Mean = " << ped;
  }
}

CLHEP::HepRandomEngine * EcalMixingModuleValidation::randomEngine ( edm::StreamID const &  streamID )

private

Definition at line 811 of file EcalMixingModuleValidation.cc.

References edm::RandomNumberGenerator::getEngine(), randomEngines_, and edm::StreamID::value().

Referenced by analyze().

                                                                                          {
  unsigned int index = streamID.value();
  if(index >= randomEngines_.size()) {
    randomEngines_.resize(index + 1, nullptr);
  }
  CLHEP::HepRandomEngine* ptr = randomEngines_[index];
  if(!ptr) {
    edm::Service<edm::RandomNumberGenerator> rng;
    ptr = &rng->getEngine(streamID);
    randomEngines_[index] = ptr;
  }
  return ptr;
}

Member Data Documentation

double EcalMixingModuleValidation::barrelADCtoGeV_

private

Definition at line 124 of file EcalMixingModuleValidation.h.

Referenced by analyze(), checkCalibrations(), and EcalMixingModuleValidation().

edm::EDGetTokenT< CrossingFrame<PCaloHit> > EcalMixingModuleValidation::crossingFramePCaloHitEBToken_

private

Definition at line 120 of file EcalMixingModuleValidation.h.

Referenced by analyze().

edm::EDGetTokenT< CrossingFrame<PCaloHit> > EcalMixingModuleValidation::crossingFramePCaloHitEEToken_

private

Definition at line 120 of file EcalMixingModuleValidation.h.

Referenced by analyze().

edm::EDGetTokenT< CrossingFrame<PCaloHit> > EcalMixingModuleValidation::crossingFramePCaloHitESToken_

private

Definition at line 120 of file EcalMixingModuleValidation.h.

Referenced by analyze().

DQMStore* EcalMixingModuleValidation::dbe_

private

Definition at line 110 of file EcalMixingModuleValidation.h.

edm::EDGetTokenT<EBDigiCollection> EcalMixingModuleValidation::EBdigiCollectionToken_

private

Definition at line 116 of file EcalMixingModuleValidation.h.

Referenced by analyze().

edm::EDGetTokenT<EEDigiCollection> EcalMixingModuleValidation::EEdigiCollectionToken_

private

Definition at line 117 of file EcalMixingModuleValidation.h.

Referenced by analyze().

double EcalMixingModuleValidation::endcapADCtoGeV_

private

Definition at line 125 of file EcalMixingModuleValidation.h.

Referenced by analyze(), checkCalibrations(), and EcalMixingModuleValidation().

double EcalMixingModuleValidation::esADCtokeV_

private

Definition at line 170 of file EcalMixingModuleValidation.h.

Referenced by analyze(), and checkCalibrations().

double EcalMixingModuleValidation::esBaseline_

private

Definition at line 169 of file EcalMixingModuleValidation.h.

Referenced by analyze().

edm::EDGetTokenT<ESDigiCollection> EcalMixingModuleValidation::ESdigiCollectionToken_

private

Definition at line 118 of file EcalMixingModuleValidation.h.

Referenced by analyze().

double EcalMixingModuleValidation::esThreshold_

private

Definition at line 171 of file EcalMixingModuleValidation.h.

Referenced by analyze().

std::map<int, double, std::less<int> > EcalMixingModuleValidation::gainConv_

private

Definition at line 122 of file EcalMixingModuleValidation.h.

Referenced by analyze(), checkCalibrations(), and EcalMixingModuleValidation().

edm::EDGetTokenT<edm::HepMCProduct> EcalMixingModuleValidation::HepMCToken_

private

Definition at line 114 of file EcalMixingModuleValidation.h.

Referenced by analyze().

double EcalMixingModuleValidation::m_ESeffwei

private

Definition at line 184 of file EcalMixingModuleValidation.h.

Referenced by analyze(), and checkCalibrations().

int EcalMixingModuleValidation::m_ESgain

private

Definition at line 181 of file EcalMixingModuleValidation.h.

Referenced by checkCalibrations().

const ESIntercalibConstants* EcalMixingModuleValidation::m_ESmips

private

Definition at line 183 of file EcalMixingModuleValidation.h.

Referenced by analyze(), and checkCalibrations().

const ESPedestals* EcalMixingModuleValidation::m_ESpeds

private

Definition at line 182 of file EcalMixingModuleValidation.h.

Referenced by analyze(), and checkCalibrations().

MonitorElement* EcalMixingModuleValidation::meEBbunchCrossing_

private

Definition at line 133 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEBBunchShape_[nBunch]

private

Definition at line 139 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), computeSDBunchDigi(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meEBDigiMixRatiogt100ADC_

private

Definition at line 127 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEBDigiMixRatioOriggt50pc_

private

Definition at line 130 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEBShape_

private

Definition at line 143 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meEBShapeRatio_

private

Definition at line 147 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meEEbunchCrossing_

private

Definition at line 134 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEEBunchShape_[nBunch]

private

Definition at line 140 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), computeSDBunchDigi(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meEEDigiMixRatiogt100ADC_

private

Definition at line 128 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEEDigiMixRatioOriggt40pc_

private

Definition at line 131 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meEEShape_

private

Definition at line 144 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meEEShapeRatio_

private

Definition at line 148 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meESbunchCrossing_

private

Definition at line 135 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), and EcalMixingModuleValidation().

MonitorElement* EcalMixingModuleValidation::meESBunchShape_[nBunch]

private

Definition at line 141 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), computeSDBunchDigi(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meESShape_

private

Definition at line 145 of file EcalMixingModuleValidation.h.

Referenced by analyze(), bookHistograms(), EcalMixingModuleValidation(), and endRun().

MonitorElement* EcalMixingModuleValidation::meESShapeRatio_

private

Definition at line 149 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), EcalMixingModuleValidation(), and endRun().

const int EcalMixingModuleValidation::nBunch = 21

staticprivate

Definition at line 137 of file EcalMixingModuleValidation.h.

Referenced by bookHistograms(), EcalMixingModuleValidation(), and endRun().

std::string EcalMixingModuleValidation::outputFile_

private

Definition at line 112 of file EcalMixingModuleValidation.h.

std::vector<CLHEP::HepRandomEngine*> EcalMixingModuleValidation::randomEngines_

private

Definition at line 186 of file EcalMixingModuleValidation.h.

Referenced by randomEngine().

CaloHitResponse* EcalMixingModuleValidation::theEBResponse

private

Definition at line 160 of file EcalMixingModuleValidation.h.

Referenced by computeSDBunchDigi(), and EcalMixingModuleValidation().

const EBShape* EcalMixingModuleValidation::theEBShape

private

Definition at line 154 of file EcalMixingModuleValidation.h.

Referenced by EcalMixingModuleValidation().

CaloHitResponse* EcalMixingModuleValidation::theEEResponse

private

Definition at line 161 of file EcalMixingModuleValidation.h.

Referenced by computeSDBunchDigi(), and EcalMixingModuleValidation().

const EEShape* EcalMixingModuleValidation::theEEShape

private

Definition at line 155 of file EcalMixingModuleValidation.h.

Referenced by EcalMixingModuleValidation().

CaloHitResponse* EcalMixingModuleValidation::theESResponse

private

Definition at line 159 of file EcalMixingModuleValidation.h.

Referenced by computeSDBunchDigi(), and EcalMixingModuleValidation().

ESShape* EcalMixingModuleValidation::theESShape

private

Definition at line 153 of file EcalMixingModuleValidation.h.

Referenced by checkCalibrations(), and EcalMixingModuleValidation().

const CaloGeometry* EcalMixingModuleValidation::theGeometry

private

Definition at line 176 of file EcalMixingModuleValidation.h.

Referenced by computeSDBunchDigi().

int EcalMixingModuleValidation::theMaxBunch

private

Definition at line 174 of file EcalMixingModuleValidation.h.

Referenced by bunchSumTest(), computeSDBunchDigi(), and EcalMixingModuleValidation().

int EcalMixingModuleValidation::theMinBunch

private

Definition at line 173 of file EcalMixingModuleValidation.h.

Referenced by bunchSumTest(), computeSDBunchDigi(), and EcalMixingModuleValidation().

const EcalSimParameterMap* EcalMixingModuleValidation::theParameterMap

private

Definition at line 151 of file EcalMixingModuleValidation.h.

Referenced by computeSDBunchDigi(), and EcalMixingModuleValidation().

const EcalPedestals* EcalMixingModuleValidation::thePedestals

private

Definition at line 179 of file EcalMixingModuleValidation.h.

Referenced by checkPedestals(), and findPedestal().

bool EcalMixingModuleValidation::verbose_

private

Definition at line 108 of file EcalMixingModuleValidation.h.

Referenced by EcalMixingModuleValidation().