Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Fix consumes for phase2 premixing and reduce code duplication in EcalDigiProducer #22581

Merged
merged 2 commits into from
Mar 30, 2018
Merged

Fix consumes for phase2 premixing and reduce code duplication in EcalDigiProducer #22581

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
89b9db0
Have to treat getByLabel() similarly to consumes()
makortel Feb 20, 2018
b5e8e59
Reduce code duplication and fix a bug for m_apdSeparateDigi=true in p…
makortel Mar 12, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
255 changes: 27 additions & 228 deletions SimCalorimetry/EcalSimProducers/src/EcalDigiProducer.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -55,230 +55,16 @@


EcalDigiProducer::EcalDigiProducer( const edm::ParameterSet& params, edm::ProducerBase& mixMod, edm::ConsumesCollector& iC) :
DigiAccumulatorMixMod(),
m_APDShape ( params.getParameter<double>( "apdShapeTstart" ) ,
params.getParameter<double>( "apdShapeTau" ) ) ,
m_EBShape ( ) ,
m_EEShape ( ) ,
m_ESShape ( ) ,
m_EBdigiCollection ( params.getParameter<std::string>("EBdigiCollection") ) ,
m_EEdigiCollection ( params.getParameter<std::string>("EEdigiCollection") ) ,
m_ESdigiCollection ( params.getParameter<std::string>("ESdigiCollection") ) ,
m_hitsProducerTag ( params.getParameter<std::string>("hitsProducer" ) ) ,
m_useLCcorrection ( params.getUntrackedParameter<bool>("UseLCcorrection") ) ,
m_apdSeparateDigi ( params.getParameter<bool> ("apdSeparateDigi") ) ,

m_EBs25notCont ( params.getParameter<double> ("EBs25notContainment") ) ,
m_EEs25notCont ( params.getParameter<double> ("EEs25notContainment") ) ,

m_readoutFrameSize ( params.getParameter<int> ("readoutFrameSize") ) ,
m_ParameterMap ( new EcalSimParameterMap(
params.getParameter<double> ("simHitToPhotoelectronsBarrel") ,
params.getParameter<double> ("simHitToPhotoelectronsEndcap") ,
params.getParameter<double> ("photoelectronsToAnalogBarrel") ,
params.getParameter<double> ("photoelectronsToAnalogEndcap") ,
params.getParameter<double> ("samplingFactor") ,
params.getParameter<double> ("timePhase") ,
m_readoutFrameSize ,
params.getParameter<int> ("binOfMaximum") ,
params.getParameter<bool> ("doPhotostatistics") ,
params.getParameter<bool> ("syncPhase") ) ) ,

m_apdDigiTag ( params.getParameter<std::string> ("apdDigiTag" ) ) ,
m_apdParameters ( new APDSimParameters(
params.getParameter<bool> ("apdAddToBarrel" ) ,
m_apdSeparateDigi ,
params.getParameter<double> ("apdSimToPELow" ) ,
params.getParameter<double> ("apdSimToPEHigh" ) ,
params.getParameter<double> ("apdTimeOffset" ) ,
params.getParameter<double> ("apdTimeOffWidth" ) ,
params.getParameter<bool> ("apdDoPEStats" ) ,
m_apdDigiTag ,
params.getParameter<std::vector<double> > ( "apdNonlParms" ) ) ) ,

m_APDResponse ( !m_apdSeparateDigi ? nullptr :
new EBHitResponse( m_ParameterMap.get() ,
&m_EBShape ,
true ,
m_apdParameters.get() ,
&m_APDShape ) ) ,

m_EBResponse ( new EBHitResponse( m_ParameterMap.get() ,
&m_EBShape ,
false , // barrel
m_apdParameters.get() ,
&m_APDShape ) ) ,

m_EEResponse ( new EEHitResponse( m_ParameterMap.get(),
&m_EEShape ) ) ,
m_ESResponse ( new ESHitResponse( m_ParameterMap.get(), &m_ESShape ) ) ,
m_ESOldResponse ( new CaloHitResponse( m_ParameterMap.get(), &m_ESShape ) ) ,

m_addESNoise ( params.getParameter<bool> ("doESNoise") ) ,
m_PreMix1 ( params.getParameter<bool> ("EcalPreMixStage1") ) ,
m_PreMix2 ( params.getParameter<bool> ("EcalPreMixStage2") ) ,

m_doFastES ( params.getParameter<bool> ("doFast" ) ) ,

m_doEB ( params.getParameter<bool> ("doEB" ) ) ,
m_doEE ( params.getParameter<bool> ("doEE" ) ) ,
m_doES ( params.getParameter<bool> ("doES" ) ) ,

m_ESElectronicsSim ( m_doFastES ? nullptr :
new ESElectronicsSim( m_addESNoise ) ) ,

m_ESOldDigitizer ( m_doFastES ? nullptr :
new ESOldDigitizer( m_ESOldResponse.get() ,
m_ESElectronicsSim.get() ,
m_addESNoise ) ) ,

m_ESElectronicsSimFast ( !m_doFastES ? nullptr :
new ESElectronicsSimFast( m_addESNoise ,
m_PreMix1) ) ,

m_ESDigitizer ( !m_doFastES ? nullptr :
new ESDigitizer( m_ESResponse.get() ,
m_ESElectronicsSimFast.get() ,
m_addESNoise ) ) ,

m_APDDigitizer ( nullptr ) ,
m_BarrelDigitizer ( nullptr ) ,
m_EndcapDigitizer ( nullptr ) ,
m_ElectronicsSim ( nullptr ) ,
m_Coder ( nullptr ) ,
m_APDElectronicsSim ( nullptr ) ,
m_APDCoder ( nullptr ) ,
m_Geometry ( nullptr ) ,
m_EBCorrNoise ( { {nullptr, nullptr, nullptr} } ) ,
m_EECorrNoise ( { {nullptr, nullptr, nullptr} } )
EcalDigiProducer(params, iC)
{
if(m_apdSeparateDigi) mixMod.produces<EBDigiCollection>(m_apdDigiTag);

mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
mixMod.produces<ESDigiCollection>(m_ESdigiCollection);

if( m_doEB ) iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"));
if( m_doEE ) iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"));
if( m_doES ) iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsES"));

const std::vector<double> ebCorMatG12 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG12");
const std::vector<double> eeCorMatG12 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG12");
const std::vector<double> ebCorMatG06 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG06");
const std::vector<double> eeCorMatG06 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG06");
const std::vector<double> ebCorMatG01 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG01");
const std::vector<double> eeCorMatG01 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG01");

const bool applyConstantTerm = params.getParameter<bool> ("applyConstantTerm");
const double rmsConstantTerm = params.getParameter<double> ("ConstantTerm");

const bool addNoise = params.getParameter<bool> ("doENoise");
const bool cosmicsPhase = params.getParameter<bool> ("cosmicsPhase");
const double cosmicsShift = params.getParameter<double> ("cosmicsShift");

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// further phase for cosmics studies
if( cosmicsPhase )
{
if( m_doEB ) m_EBResponse->setPhaseShift( 1. + cosmicsShift ) ;
if( m_doEE ) m_EEResponse->setPhaseShift( 1. + cosmicsShift ) ;
}

EcalCorrMatrix ebMatrix[ 3 ] ;
EcalCorrMatrix eeMatrix[ 3 ] ;

assert( ebCorMatG12.size() == m_readoutFrameSize ) ;
assert( eeCorMatG12.size() == m_readoutFrameSize ) ;
assert( ebCorMatG06.size() == m_readoutFrameSize ) ;
assert( eeCorMatG06.size() == m_readoutFrameSize ) ;
assert( ebCorMatG01.size() == m_readoutFrameSize ) ;
assert( eeCorMatG01.size() == m_readoutFrameSize ) ;

assert( 1.e-7 > fabs( ebCorMatG12[0] - 1.0 ) ) ;
assert( 1.e-7 > fabs( ebCorMatG06[0] - 1.0 ) ) ;
assert( 1.e-7 > fabs( ebCorMatG01[0] - 1.0 ) ) ;
assert( 1.e-7 > fabs( eeCorMatG12[0] - 1.0 ) ) ;
assert( 1.e-7 > fabs( eeCorMatG06[0] - 1.0 ) ) ;
assert( 1.e-7 > fabs( eeCorMatG01[0] - 1.0 ) ) ;

for ( unsigned int row ( 0 ) ; row != m_readoutFrameSize ; ++row )
{
assert( 0 == row || 1. >= ebCorMatG12[row] ) ;
assert( 0 == row || 1. >= ebCorMatG06[row] ) ;
assert( 0 == row || 1. >= ebCorMatG01[row] ) ;
assert( 0 == row || 1. >= eeCorMatG12[row] ) ;
assert( 0 == row || 1. >= eeCorMatG06[row] ) ;
assert( 0 == row || 1. >= eeCorMatG01[row] ) ;
for ( unsigned int column ( 0 ) ; column <= row ; ++column )
{
const unsigned int index ( row - column ) ;
ebMatrix[0]( row, column ) = ebCorMatG12[ index ] ;
eeMatrix[0]( row, column ) = eeCorMatG12[ index ] ;
ebMatrix[1]( row, column ) = ebCorMatG06[ index ] ;
eeMatrix[1]( row, column ) = eeCorMatG06[ index ] ;
ebMatrix[2]( row, column ) = ebCorMatG01[ index ] ;
eeMatrix[2]( row, column ) = eeCorMatG01[ index ] ;
}
}

m_EBCorrNoise[0].reset( new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[0] ) );
m_EECorrNoise[0].reset( new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[0] ) );
m_EBCorrNoise[1].reset( new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[1] ) );
m_EECorrNoise[1].reset( new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[1] ) );
m_EBCorrNoise[2].reset( new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[2] ) );
m_EECorrNoise[2].reset( new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[2] ) );

m_Coder.reset( new EcalCoder( addNoise ,
m_PreMix1 ,
m_EBCorrNoise[0].get() ,
m_EECorrNoise[0].get() ,
m_EBCorrNoise[1].get() ,
m_EECorrNoise[1].get() ,
m_EBCorrNoise[2].get() ,
m_EECorrNoise[2].get() ) );

m_ElectronicsSim.reset( new EcalElectronicsSim( m_ParameterMap.get() ,
m_Coder.get() ,
applyConstantTerm ,
rmsConstantTerm ) );

if( m_apdSeparateDigi )
{
m_APDCoder.reset( new EcalCoder( false ,
m_PreMix1 ,
m_EBCorrNoise[0].get() ,
m_EECorrNoise[0].get() ,
m_EBCorrNoise[1].get() ,
m_EECorrNoise[1].get() ,
m_EBCorrNoise[2].get() ,
m_EECorrNoise[2].get() ) );

m_APDElectronicsSim.reset( new EcalElectronicsSim( m_ParameterMap.get() ,
m_APDCoder.get() ,
applyConstantTerm ,
rmsConstantTerm ) );

m_APDDigitizer.reset( new EBDigitizer( m_APDResponse.get() ,
m_APDElectronicsSim.get() ,
false ) );
}

if( m_doEB ) {
m_BarrelDigitizer.reset( new EBDigitizer( m_EBResponse.get() ,
m_ElectronicsSim.get() ,
addNoise ) );
}

if ( m_doEE ) {
m_EndcapDigitizer.reset( new EEDigitizer( m_EEResponse.get() ,
m_ElectronicsSim.get() ,
addNoise ) );
}
}


// duplicate version for Pre-Mixing, for use outside of MixingModule
// version for Pre-Mixing, for use outside of MixingModule
EcalDigiProducer::EcalDigiProducer( const edm::ParameterSet& params, edm::ConsumesCollector& iC) :
DigiAccumulatorMixMod(),
m_APDShape ( params.getParameter<double>( "apdShapeTstart" ) ,
Expand Down Expand Up @@ -470,6 +256,7 @@ EcalDigiProducer::EcalDigiProducer( const edm::ParameterSet& params, edm::Consu
if( m_apdSeparateDigi )
{
m_APDCoder.reset( new EcalCoder( false ,
m_PreMix1 ,
m_EBCorrNoise[0].get() ,
m_EECorrNoise[0].get() ,
m_EBCorrNoise[1].get() ,
Expand Down Expand Up @@ -552,35 +339,47 @@ EcalDigiProducer::accumulateCaloHits(HitsHandle const& ebHandle, HitsHandle cons
void
EcalDigiProducer::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) {
// Step A: Get Inputs
edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
edm::Handle<std::vector<PCaloHit> > ebHandle;
e.getByLabel(ebTag, ebHandle);
if(m_doEB) {
edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
e.getByLabel(ebTag, ebHandle);
}

edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
edm::Handle<std::vector<PCaloHit> > eeHandle;
e.getByLabel(eeTag, eeHandle);
if(m_doEE) {
edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
e.getByLabel(eeTag, eeHandle);
}

edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
edm::Handle<std::vector<PCaloHit> > esHandle;
e.getByLabel(esTag, esHandle);
if(m_doES) {
edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
e.getByLabel(esTag, esHandle);
}

accumulateCaloHits(ebHandle, eeHandle, esHandle, 0, randomEngine(e.streamID()));
}

void
EcalDigiProducer::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const& streamID) {
// Step A: Get Inputs
edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
edm::Handle<std::vector<PCaloHit> > ebHandle;
e.getByLabel(ebTag, ebHandle);
if(m_doEB) {
edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
e.getByLabel(ebTag, ebHandle);
}

edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
edm::Handle<std::vector<PCaloHit> > eeHandle;
e.getByLabel(eeTag, eeHandle);
if(m_doEE) {
edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
e.getByLabel(eeTag, eeHandle);
}

edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
edm::Handle<std::vector<PCaloHit> > esHandle;
e.getByLabel(esTag, esHandle);
if(m_doES) {
edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
e.getByLabel(esTag, esHandle);
}

accumulateCaloHits(ebHandle, eeHandle, esHandle, e.bunchCrossing(), randomEngine(streamID));
}
Expand Down