CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
EcalDigiProducer.cc
Go to the documentation of this file.
1 #include "FWCore/Framework/interface/Event.h"
2 #include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h"
3 #include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h"
4 #include "SimCalorimetry/EcalSimAlgos/interface/EEHitResponse.h"
5 #include "SimCalorimetry/EcalSimAlgos/interface/ESHitResponse.h"
6 #include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h"
7 #include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h"
8 #include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h"
9 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
10 #include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h"
11 #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h"
12 #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSimFast.h"
13 #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSim.h"
14 //#include "SimCalorimetry/EcalSimAlgos/interface/ESFastTDigitizer.h"
15 #include "SimCalorimetry/EcalSimAlgos/interface/ESDigitizer.h"
16 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
17 #include "CalibFormats/CaloObjects/interface/CaloSamples.h"
18 #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
19 #include "FWCore/Framework/interface/ESHandle.h"
20 #include "DataFormats/Common/interface/Handle.h"
21 #include "FWCore/Framework/interface/ConsumesCollector.h"
22 #include "FWCore/Framework/interface/one/EDProducer.h"
23 #include "FWCore/Framework/interface/Event.h"
24 #include "FWCore/Framework/interface/EventSetup.h"
25 #include "FWCore/Framework/interface/LuminosityBlock.h"
26 #include "FWCore/ParameterSet/interface/ParameterSet.h"
27 #include "FWCore/MessageLogger/interface/MessageLogger.h"
28 #include "FWCore/ServiceRegistry/interface/Service.h"
29 #include "FWCore/Utilities/interface/Exception.h"
30 #include "FWCore/Utilities/interface/RandomNumberGenerator.h"
31 #include "FWCore/Utilities/interface/StreamID.h"
32 #include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h"
33 #include "SimDataFormats/CaloHit/interface/PCaloHit.h"
34 #include "Geometry/Records/interface/CaloGeometryRecord.h"
35 #include "CondFormats/EcalObjects/interface/EcalPedestals.h"
36 #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
37 #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h"
38 #include "CondFormats/DataRecord/interface/EcalIntercalibConstantsMCRcd.h"
39 #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h"
40 #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbRecord.h"
41 #include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h"
42 #include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
43 #include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
44 #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
45 
46 #include "CondFormats/ESObjects/interface/ESIntercalibConstants.h"
47 #include "CondFormats/DataRecord/interface/ESIntercalibConstantsRcd.h"
48 #include "CondFormats/ESObjects/interface/ESMIPToGeVConstant.h"
49 #include "CondFormats/DataRecord/interface/ESMIPToGeVConstantRcd.h"
50 #include "CondFormats/ESObjects/interface/ESGain.h"
51 #include "CondFormats/DataRecord/interface/ESGainRcd.h"
52 #include "CondFormats/ESObjects/interface/ESPedestals.h"
53 #include "CondFormats/DataRecord/interface/ESPedestalsRcd.h"
54 #include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
55 
56 
57 EcalDigiProducer::EcalDigiProducer( const edm::ParameterSet& params, edm::one::EDProducerBase& mixMod, edm::ConsumesCollector& iC) :
58  DigiAccumulatorMixMod(),
59  m_APDShape ( params.getParameter<double>( "apdShapeTstart" ) ,
60  params.getParameter<double>( "apdShapeTau" ) ) ,
61  m_EBShape ( ) ,
62  m_EEShape ( ) ,
63  m_ESShape ( ) ,
64  m_EBdigiCollection ( params.getParameter<std::string>("EBdigiCollection") ) ,
65  m_EEdigiCollection ( params.getParameter<std::string>("EEdigiCollection") ) ,
66  m_ESdigiCollection ( params.getParameter<std::string>("ESdigiCollection") ) ,
67  m_hitsProducerTag ( params.getParameter<std::string>("hitsProducer" ) ) ,
68  m_useLCcorrection ( params.getUntrackedParameter<bool>("UseLCcorrection") ) ,
69  m_apdSeparateDigi ( params.getParameter<bool> ("apdSeparateDigi") ) ,
70 
71  m_EBs25notCont ( params.getParameter<double> ("EBs25notContainment") ) ,
72  m_EEs25notCont ( params.getParameter<double> ("EEs25notContainment") ) ,
73 
74  m_readoutFrameSize ( params.getParameter<int> ("readoutFrameSize") ) ,
75  m_ParameterMap ( new EcalSimParameterMap(
76  params.getParameter<double> ("simHitToPhotoelectronsBarrel") ,
77  params.getParameter<double> ("simHitToPhotoelectronsEndcap") ,
78  params.getParameter<double> ("photoelectronsToAnalogBarrel") ,
79  params.getParameter<double> ("photoelectronsToAnalogEndcap") ,
80  params.getParameter<double> ("samplingFactor") ,
81  params.getParameter<double> ("timePhase") ,
82  m_readoutFrameSize ,
83  params.getParameter<int> ("binOfMaximum") ,
84  params.getParameter<bool> ("doPhotostatistics") ,
85  params.getParameter<bool> ("syncPhase") ) ) ,
86 
87  m_apdDigiTag ( params.getParameter<std::string> ("apdDigiTag" ) ) ,
88  m_apdParameters ( new APDSimParameters(
89  params.getParameter<bool> ("apdAddToBarrel" ) ,
90  m_apdSeparateDigi ,
91  params.getParameter<double> ("apdSimToPELow" ) ,
92  params.getParameter<double> ("apdSimToPEHigh" ) ,
93  params.getParameter<double> ("apdTimeOffset" ) ,
94  params.getParameter<double> ("apdTimeOffWidth" ) ,
95  params.getParameter<bool> ("apdDoPEStats" ) ,
96  m_apdDigiTag ,
97  params.getParameter<std::vector<double> > ( "apdNonlParms" ) ) ) ,
98 
99  m_APDResponse ( !m_apdSeparateDigi ? 0 :
100  new EBHitResponse( m_ParameterMap ,
101  &m_EBShape ,
102  true ,
103  m_apdParameters ,
104  &m_APDShape ) ) ,
105 
106  m_EBResponse ( new EBHitResponse( m_ParameterMap ,
107  &m_EBShape ,
108  false , // barrel
109  m_apdParameters ,
110  &m_APDShape ) ) ,
111 
112  m_EEResponse ( new EEHitResponse( m_ParameterMap,
113  &m_EEShape ) ) ,
114  m_ESResponse ( new ESHitResponse( m_ParameterMap, &m_ESShape ) ) ,
115  m_ESOldResponse ( new CaloHitResponse( m_ParameterMap, &m_ESShape ) ) ,
116 
117  m_addESNoise ( params.getParameter<bool> ("doESNoise") ) ,
118  m_PreMix1 ( params.getParameter<bool> ("EcalPreMixStage1") ) ,
119  m_PreMix2 ( params.getParameter<bool> ("EcalPreMixStage2") ) ,
120 
121  m_doFastES ( params.getParameter<bool> ("doFast" ) ) ,
122 
123  m_ESElectronicsSim ( m_doFastES ? 0 :
124  new ESElectronicsSim( m_addESNoise ) ) ,
125 
126  m_ESOldDigitizer ( m_doFastES ? 0 :
127  new ESOldDigitizer( m_ESOldResponse ,
128  m_ESElectronicsSim ,
129  m_addESNoise ) ) ,
130 
131  m_ESElectronicsSimFast ( !m_doFastES ? 0 :
132  new ESElectronicsSimFast( m_addESNoise ,
133  m_PreMix1) ) ,
134 
135  m_ESDigitizer ( !m_doFastES ? 0 :
136  new ESDigitizer( m_ESResponse ,
137  m_ESElectronicsSimFast ,
138  m_addESNoise ) ) ,
139 
140  m_APDDigitizer ( 0 ) ,
141  m_BarrelDigitizer ( 0 ) ,
142  m_EndcapDigitizer ( 0 ) ,
143  m_ElectronicsSim ( 0 ) ,
144  m_Coder ( 0 ) ,
145  m_APDElectronicsSim ( 0 ) ,
146  m_APDCoder ( 0 ) ,
147  m_Geometry ( 0 ) ,
148  m_EBCorrNoise ( ) ,
149  m_EECorrNoise ( )
150 {
151  if(m_apdSeparateDigi) mixMod.produces<EBDigiCollection>(m_apdDigiTag);
152  mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
153  mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
154  mixMod.produces<ESDigiCollection>(m_ESdigiCollection);
155  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"));
156  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"));
157  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsES"));
158 
159  const std::vector<double> ebCorMatG12 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG12");
160  const std::vector<double> eeCorMatG12 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG12");
161  const std::vector<double> ebCorMatG06 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG06");
162  const std::vector<double> eeCorMatG06 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG06");
163  const std::vector<double> ebCorMatG01 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG01");
164  const std::vector<double> eeCorMatG01 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG01");
165 
166  const bool applyConstantTerm = params.getParameter<bool> ("applyConstantTerm");
167  const double rmsConstantTerm = params.getParameter<double> ("ConstantTerm");
168 
169  const bool addNoise = params.getParameter<bool> ("doENoise");
170  const bool cosmicsPhase = params.getParameter<bool> ("cosmicsPhase");
171  const double cosmicsShift = params.getParameter<double> ("cosmicsShift");
172 
173 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
174 
175  // further phase for cosmics studies
176  if( cosmicsPhase )
177  {
178  m_EBResponse->setPhaseShift( 1. + cosmicsShift ) ;
179  m_EEResponse->setPhaseShift( 1. + cosmicsShift ) ;
180  }
181 
182  EcalCorrMatrix ebMatrix[ 3 ] ;
183  EcalCorrMatrix eeMatrix[ 3 ] ;
184 
185  assert( ebCorMatG12.size() == m_readoutFrameSize ) ;
186  assert( eeCorMatG12.size() == m_readoutFrameSize ) ;
187  assert( ebCorMatG06.size() == m_readoutFrameSize ) ;
188  assert( eeCorMatG06.size() == m_readoutFrameSize ) ;
189  assert( ebCorMatG01.size() == m_readoutFrameSize ) ;
190  assert( eeCorMatG01.size() == m_readoutFrameSize ) ;
191 
192  assert( 1.e-7 > fabs( ebCorMatG12[0] - 1.0 ) ) ;
193  assert( 1.e-7 > fabs( ebCorMatG06[0] - 1.0 ) ) ;
194  assert( 1.e-7 > fabs( ebCorMatG01[0] - 1.0 ) ) ;
195  assert( 1.e-7 > fabs( eeCorMatG12[0] - 1.0 ) ) ;
196  assert( 1.e-7 > fabs( eeCorMatG06[0] - 1.0 ) ) ;
197  assert( 1.e-7 > fabs( eeCorMatG01[0] - 1.0 ) ) ;
198 
199  for ( unsigned int row ( 0 ) ; row != m_readoutFrameSize ; ++row )
200  {
201  assert( 0 == row || 1. >= ebCorMatG12[row] ) ;
202  assert( 0 == row || 1. >= ebCorMatG06[row] ) ;
203  assert( 0 == row || 1. >= ebCorMatG01[row] ) ;
204  assert( 0 == row || 1. >= eeCorMatG12[row] ) ;
205  assert( 0 == row || 1. >= eeCorMatG06[row] ) ;
206  assert( 0 == row || 1. >= eeCorMatG01[row] ) ;
207  for ( unsigned int column ( 0 ) ; column <= row ; ++column )
208  {
209  const unsigned int index ( row - column ) ;
210  ebMatrix[0]( row, column ) = ebCorMatG12[ index ] ;
211  eeMatrix[0]( row, column ) = eeCorMatG12[ index ] ;
212  ebMatrix[1]( row, column ) = ebCorMatG06[ index ] ;
213  eeMatrix[1]( row, column ) = eeCorMatG06[ index ] ;
214  ebMatrix[2]( row, column ) = ebCorMatG01[ index ] ;
215  eeMatrix[2]( row, column ) = eeCorMatG01[ index ] ;
216  }
217  }
218 
219  m_EBCorrNoise[0] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[0] ) ;
220  m_EECorrNoise[0] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[0] ) ;
221  m_EBCorrNoise[1] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[1] ) ;
222  m_EECorrNoise[1] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[1] ) ;
223  m_EBCorrNoise[2] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[2] ) ;
224  m_EECorrNoise[2] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[2] ) ;
225 
226  m_Coder = new EcalCoder( addNoise ,
227  m_PreMix1 ,
228  m_EBCorrNoise[0] ,
229  m_EECorrNoise[0] ,
230  m_EBCorrNoise[1] ,
231  m_EECorrNoise[1] ,
232  m_EBCorrNoise[2] ,
233  m_EECorrNoise[2] ) ;
234 
235  m_ElectronicsSim = new EcalElectronicsSim( m_ParameterMap ,
236  m_Coder ,
237  applyConstantTerm ,
238  rmsConstantTerm ) ;
239 
240  if( m_apdSeparateDigi )
241  {
242  m_APDCoder = new EcalCoder( false ,
243  m_EBCorrNoise[0] ,
244  m_EECorrNoise[0] ,
245  m_EBCorrNoise[1] ,
246  m_EECorrNoise[1] ,
247  m_EBCorrNoise[2] ,
248  m_EECorrNoise[2] ) ;
249 
250  m_APDElectronicsSim = new EcalElectronicsSim( m_ParameterMap ,
251  m_APDCoder ,
252  applyConstantTerm ,
253  rmsConstantTerm ) ;
254 
255  m_APDDigitizer = new EBDigitizer( m_APDResponse ,
256  m_APDElectronicsSim ,
257  false ) ;
258  }
259 
260  m_BarrelDigitizer = new EBDigitizer( m_EBResponse ,
261  m_ElectronicsSim ,
262  addNoise ) ;
263 
264  m_EndcapDigitizer = new EEDigitizer( m_EEResponse ,
265  m_ElectronicsSim ,
266  addNoise ) ;
267 }
268 
269 
270 // duplicate version for Pre-Mixing, for use outside of MixingModule
271 EcalDigiProducer::EcalDigiProducer( const edm::ParameterSet& params, edm::ConsumesCollector& iC) :
272  DigiAccumulatorMixMod(),
273  m_APDShape ( params.getParameter<double>( "apdShapeTstart" ) ,
274  params.getParameter<double>( "apdShapeTau" ) ) ,
275  m_EBShape ( ) ,
276  m_EEShape ( ) ,
277  m_ESShape ( ) ,
278  m_EBdigiCollection ( params.getParameter<std::string>("EBdigiCollection") ) ,
279  m_EEdigiCollection ( params.getParameter<std::string>("EEdigiCollection") ) ,
280  m_ESdigiCollection ( params.getParameter<std::string>("ESdigiCollection") ) ,
281  m_hitsProducerTag ( params.getParameter<std::string>("hitsProducer" ) ) ,
282  m_useLCcorrection ( params.getUntrackedParameter<bool>("UseLCcorrection") ) ,
283  m_apdSeparateDigi ( params.getParameter<bool> ("apdSeparateDigi") ) ,
284 
285  m_EBs25notCont ( params.getParameter<double> ("EBs25notContainment") ) ,
286  m_EEs25notCont ( params.getParameter<double> ("EEs25notContainment") ) ,
287 
288  m_readoutFrameSize ( params.getParameter<int> ("readoutFrameSize") ) ,
289  m_ParameterMap ( new EcalSimParameterMap(
290  params.getParameter<double> ("simHitToPhotoelectronsBarrel") ,
291  params.getParameter<double> ("simHitToPhotoelectronsEndcap") ,
292  params.getParameter<double> ("photoelectronsToAnalogBarrel") ,
293  params.getParameter<double> ("photoelectronsToAnalogEndcap") ,
294  params.getParameter<double> ("samplingFactor") ,
295  params.getParameter<double> ("timePhase") ,
296  m_readoutFrameSize ,
297  params.getParameter<int> ("binOfMaximum") ,
298  params.getParameter<bool> ("doPhotostatistics") ,
299  params.getParameter<bool> ("syncPhase") ) ) ,
300 
301  m_apdDigiTag ( params.getParameter<std::string> ("apdDigiTag" ) ) ,
302  m_apdParameters ( new APDSimParameters(
303  params.getParameter<bool> ("apdAddToBarrel" ) ,
304  m_apdSeparateDigi ,
305  params.getParameter<double> ("apdSimToPELow" ) ,
306  params.getParameter<double> ("apdSimToPEHigh" ) ,
307  params.getParameter<double> ("apdTimeOffset" ) ,
308  params.getParameter<double> ("apdTimeOffWidth" ) ,
309  params.getParameter<bool> ("apdDoPEStats" ) ,
310  m_apdDigiTag ,
311  params.getParameter<std::vector<double> > ( "apdNonlParms" ) ) ) ,
312 
313  m_APDResponse ( !m_apdSeparateDigi ? 0 :
314  new EBHitResponse( m_ParameterMap ,
315  &m_EBShape ,
316  true ,
317  m_apdParameters ,
318  &m_APDShape ) ) ,
319 
320  m_EBResponse ( new EBHitResponse( m_ParameterMap ,
321  &m_EBShape ,
322  false , // barrel
323  m_apdParameters ,
324  &m_APDShape ) ) ,
325 
326  m_EEResponse ( new EEHitResponse( m_ParameterMap,
327  &m_EEShape ) ) ,
328  m_ESResponse ( new ESHitResponse( m_ParameterMap, &m_ESShape ) ) ,
329  m_ESOldResponse ( new CaloHitResponse( m_ParameterMap, &m_ESShape ) ) ,
330 
331  m_addESNoise ( params.getParameter<bool> ("doESNoise") ) ,
332  m_PreMix1 ( params.getParameter<bool> ("EcalPreMixStage1") ) ,
333  m_PreMix2 ( params.getParameter<bool> ("EcalPreMixStage2") ) ,
334 
335  m_doFastES ( params.getParameter<bool> ("doFast" ) ) ,
336 
337  m_ESElectronicsSim ( m_doFastES ? 0 :
338  new ESElectronicsSim( m_addESNoise ) ) ,
339 
340  m_ESOldDigitizer ( m_doFastES ? 0 :
341  new ESOldDigitizer( m_ESOldResponse ,
342  m_ESElectronicsSim ,
343  m_addESNoise ) ) ,
344 
345  m_ESElectronicsSimFast ( !m_doFastES ? 0 :
346  new ESElectronicsSimFast( m_addESNoise,
347  m_PreMix1 ) ) ,
348 
349  m_ESDigitizer ( !m_doFastES ? 0 :
350  new ESDigitizer( m_ESResponse ,
351  m_ESElectronicsSimFast ,
352  m_addESNoise ) ) ,
353 
354  m_APDDigitizer ( 0 ) ,
355  m_BarrelDigitizer ( 0 ) ,
356  m_EndcapDigitizer ( 0 ) ,
357  m_ElectronicsSim ( 0 ) ,
358  m_Coder ( 0 ) ,
359  m_APDElectronicsSim ( 0 ) ,
360  m_APDCoder ( 0 ) ,
361  m_Geometry ( 0 ) ,
362  m_EBCorrNoise ( ) ,
363  m_EECorrNoise ( )
364 {
365  // "produces" statements taken care of elsewhere.
366  // if(m_apdSeparateDigi) mixMod.produces<EBDigiCollection>(m_apdDigiTag);
367  // mixMod.produces<EBDigiCollection>(m_EBdigiCollection);
368  // mixMod.produces<EEDigiCollection>(m_EEdigiCollection);
369  // mixMod.produces<ESDigiCollection>(m_ESdigiCollection);
370  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB"));
371  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsEE"));
372  iC.consumes<std::vector<PCaloHit> >(edm::InputTag(m_hitsProducerTag, "EcalHitsES"));
373 
374  const std::vector<double> ebCorMatG12 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG12");
375  const std::vector<double> eeCorMatG12 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG12");
376  const std::vector<double> ebCorMatG06 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG06");
377  const std::vector<double> eeCorMatG06 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG06");
378  const std::vector<double> ebCorMatG01 = params.getParameter< std::vector<double> >("EBCorrNoiseMatrixG01");
379  const std::vector<double> eeCorMatG01 = params.getParameter< std::vector<double> >("EECorrNoiseMatrixG01");
380 
381  const bool applyConstantTerm = params.getParameter<bool> ("applyConstantTerm");
382  const double rmsConstantTerm = params.getParameter<double> ("ConstantTerm");
383 
384  const bool addNoise = params.getParameter<bool> ("doENoise");
385  const bool cosmicsPhase = params.getParameter<bool> ("cosmicsPhase");
386  const double cosmicsShift = params.getParameter<double> ("cosmicsShift");
387 
388 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
389 
390  // further phase for cosmics studies
391  if( cosmicsPhase )
392  {
393  m_EBResponse->setPhaseShift( 1. + cosmicsShift ) ;
394  m_EEResponse->setPhaseShift( 1. + cosmicsShift ) ;
395  }
396 
397  EcalCorrMatrix ebMatrix[ 3 ] ;
398  EcalCorrMatrix eeMatrix[ 3 ] ;
399 
400  assert( ebCorMatG12.size() == m_readoutFrameSize ) ;
401  assert( eeCorMatG12.size() == m_readoutFrameSize ) ;
402  assert( ebCorMatG06.size() == m_readoutFrameSize ) ;
403  assert( eeCorMatG06.size() == m_readoutFrameSize ) ;
404  assert( ebCorMatG01.size() == m_readoutFrameSize ) ;
405  assert( eeCorMatG01.size() == m_readoutFrameSize ) ;
406 
407  assert( 1.e-7 > fabs( ebCorMatG12[0] - 1.0 ) ) ;
408  assert( 1.e-7 > fabs( ebCorMatG06[0] - 1.0 ) ) ;
409  assert( 1.e-7 > fabs( ebCorMatG01[0] - 1.0 ) ) ;
410  assert( 1.e-7 > fabs( eeCorMatG12[0] - 1.0 ) ) ;
411  assert( 1.e-7 > fabs( eeCorMatG06[0] - 1.0 ) ) ;
412  assert( 1.e-7 > fabs( eeCorMatG01[0] - 1.0 ) ) ;
413 
414  for ( unsigned int row ( 0 ) ; row != m_readoutFrameSize ; ++row )
415  {
416  assert( 0 == row || 1. >= ebCorMatG12[row] ) ;
417  assert( 0 == row || 1. >= ebCorMatG06[row] ) ;
418  assert( 0 == row || 1. >= ebCorMatG01[row] ) ;
419  assert( 0 == row || 1. >= eeCorMatG12[row] ) ;
420  assert( 0 == row || 1. >= eeCorMatG06[row] ) ;
421  assert( 0 == row || 1. >= eeCorMatG01[row] ) ;
422  for ( unsigned int column ( 0 ) ; column <= row ; ++column )
423  {
424  const unsigned int index ( row - column ) ;
425  ebMatrix[0]( row, column ) = ebCorMatG12[ index ] ;
426  eeMatrix[0]( row, column ) = eeCorMatG12[ index ] ;
427  ebMatrix[1]( row, column ) = ebCorMatG06[ index ] ;
428  eeMatrix[1]( row, column ) = eeCorMatG06[ index ] ;
429  ebMatrix[2]( row, column ) = ebCorMatG01[ index ] ;
430  eeMatrix[2]( row, column ) = eeCorMatG01[ index ] ;
431  }
432  }
433 
434  m_EBCorrNoise[0] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[0] ) ;
435  m_EECorrNoise[0] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[0] ) ;
436  m_EBCorrNoise[1] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[1] ) ;
437  m_EECorrNoise[1] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[1] ) ;
438  m_EBCorrNoise[2] = new CorrelatedNoisifier<EcalCorrMatrix>( ebMatrix[2] ) ;
439  m_EECorrNoise[2] = new CorrelatedNoisifier<EcalCorrMatrix>( eeMatrix[2] ) ;
440 
441  m_Coder = new EcalCoder( addNoise ,
442  m_PreMix1 ,
443  m_EBCorrNoise[0] ,
444  m_EECorrNoise[0] ,
445  m_EBCorrNoise[1] ,
446  m_EECorrNoise[1] ,
447  m_EBCorrNoise[2] ,
448  m_EECorrNoise[2] ) ;
449 
450  m_ElectronicsSim = new EcalElectronicsSim( m_ParameterMap ,
451  m_Coder ,
452  applyConstantTerm ,
453  rmsConstantTerm ) ;
454 
455  if( m_apdSeparateDigi )
456  {
457  m_APDCoder = new EcalCoder( false ,
458  m_EBCorrNoise[0] ,
459  m_EECorrNoise[0] ,
460  m_EBCorrNoise[1] ,
461  m_EECorrNoise[1] ,
462  m_EBCorrNoise[2] ,
463  m_EECorrNoise[2] ) ;
464 
465  m_APDElectronicsSim = new EcalElectronicsSim( m_ParameterMap ,
466  m_APDCoder ,
467  applyConstantTerm ,
468  rmsConstantTerm ) ;
469 
470  m_APDDigitizer = new EBDigitizer( m_APDResponse ,
471  m_APDElectronicsSim ,
472  false ) ;
473  }
474 
475  m_BarrelDigitizer = new EBDigitizer( m_EBResponse ,
476  m_ElectronicsSim ,
477  addNoise ) ;
478 
479  m_EndcapDigitizer = new EEDigitizer( m_EEResponse ,
480  m_ElectronicsSim ,
481  addNoise ) ;
482 }
483 
484 
485 EcalDigiProducer::~EcalDigiProducer()
486 {
487  delete m_EndcapDigitizer ;
488  delete m_BarrelDigitizer ;
489  delete m_APDDigitizer ;
490  delete m_APDElectronicsSim ;
491  delete m_APDCoder ;
492  delete m_ElectronicsSim ;
493  delete m_Coder ;
494  delete m_EBCorrNoise[0] ;
495  delete m_EECorrNoise[0] ;
496  delete m_EBCorrNoise[1] ;
497  delete m_EECorrNoise[1] ;
498  delete m_EBCorrNoise[2] ;
499  delete m_EECorrNoise[2] ;
500 
501  delete m_ESDigitizer ;
502  delete m_ESElectronicsSimFast ;
503  delete m_ESOldDigitizer ;
504  delete m_ESElectronicsSim ;
505 
506  delete m_ESOldResponse ;
507  delete m_ESResponse ;
508  delete m_EEResponse ;
509  delete m_EBResponse ;
510  delete m_APDResponse ;
511 
512  delete m_apdParameters ;
513  delete m_ParameterMap ;
514 }
515 
516 void
517 EcalDigiProducer::initializeEvent(edm::Event const& event, edm::EventSetup const& eventSetup) {
518  checkGeometry( eventSetup );
519  checkCalibrations( event, eventSetup );
520  m_BarrelDigitizer->initializeHits();
521  if(m_apdSeparateDigi) {
522  m_APDDigitizer->initializeHits();
523  }
524  m_EndcapDigitizer->initializeHits();
525  if(m_doFastES) {
526  m_ESDigitizer->initializeHits();
527  } else {
528  m_ESOldDigitizer->initializeHits();
529  }
530 }
531 
532 void
533 EcalDigiProducer::accumulateCaloHits(HitsHandle const& ebHandle, HitsHandle const& eeHandle, HitsHandle const& esHandle, int bunchCrossing, CLHEP::HepRandomEngine* engine) {
534  if(ebHandle.isValid()) {
535  m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing, engine);
536 
537  if(m_apdSeparateDigi) {
538  m_APDDigitizer->add(*ebHandle.product(), bunchCrossing, engine);
539  }
540  }
541 
542  if(eeHandle.isValid()) {
543  m_EndcapDigitizer->add(*eeHandle.product(), bunchCrossing, engine);
544  }
545 
546  if(esHandle.isValid()) {
547  if(m_doFastES) {
548  m_ESDigitizer->add(*esHandle.product(), bunchCrossing, engine);
549  } else {
550  m_ESOldDigitizer->add(*esHandle.product(), bunchCrossing, engine);
551  }
552  }
553 }
554 
555 void
556 EcalDigiProducer::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) {
557  // Step A: Get Inputs
558  edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
559  edm::Handle<std::vector<PCaloHit> > ebHandle;
560  e.getByLabel(ebTag, ebHandle);
561 
562  edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
563  edm::Handle<std::vector<PCaloHit> > eeHandle;
564  e.getByLabel(eeTag, eeHandle);
565 
566  edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
567  edm::Handle<std::vector<PCaloHit> > esHandle;
568  e.getByLabel(esTag, esHandle);
569 
570  accumulateCaloHits(ebHandle, eeHandle, esHandle, 0, randomEngine(e.streamID()));
571 }
572 
573 void
574 EcalDigiProducer::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const& streamID) {
575  // Step A: Get Inputs
576  edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB");
577  edm::Handle<std::vector<PCaloHit> > ebHandle;
578  e.getByLabel(ebTag, ebHandle);
579 
580  edm::InputTag eeTag(m_hitsProducerTag, "EcalHitsEE");
581  edm::Handle<std::vector<PCaloHit> > eeHandle;
582  e.getByLabel(eeTag, eeHandle);
583 
584  edm::InputTag esTag(m_hitsProducerTag, "EcalHitsES");
585  edm::Handle<std::vector<PCaloHit> > esHandle;
586  e.getByLabel(esTag, esHandle);
587 
588  accumulateCaloHits(ebHandle, eeHandle, esHandle, e.bunchCrossing(), randomEngine(streamID));
589 }
590 
591 void
592 EcalDigiProducer::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) {
593  // Step B: Create empty output
594  std::auto_ptr<EBDigiCollection> apdResult ( !m_apdSeparateDigi ? 0 :
595  new EBDigiCollection() ) ;
596  std::auto_ptr<EBDigiCollection> barrelResult ( new EBDigiCollection() ) ;
597  std::auto_ptr<EEDigiCollection> endcapResult ( new EEDigiCollection() ) ;
598  std::auto_ptr<ESDigiCollection> preshowerResult( new ESDigiCollection() ) ;
599 
600  // run the algorithm
601 
602  m_BarrelDigitizer->run( *barrelResult, randomEngine(event.streamID()) ) ;
603  cacheEBDigis( &*barrelResult ) ;
604 
605  edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size() ;
606 
607  if( m_apdSeparateDigi ) {
608  m_APDDigitizer->run( *apdResult, randomEngine(event.streamID()) ) ;
609  edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size() ;
610  }
611 
612  m_EndcapDigitizer->run( *endcapResult, randomEngine(event.streamID()) ) ;
613  edm::LogInfo("EcalDigi") << "EE Digis: " << endcapResult->size() ;
614  cacheEEDigis( &*endcapResult ) ;
615 
616  if(m_doFastES) {
617  m_ESDigitizer->run( *preshowerResult, randomEngine(event.streamID()) ) ;
618  } else {
619  m_ESOldDigitizer->run( *preshowerResult, randomEngine(event.streamID()) ) ;
620  }
621  edm::LogInfo("EcalDigi") << "ES Digis: " << preshowerResult->size();
622 
623 
624  // Step D: Put outputs into event
625  if( m_apdSeparateDigi ) {
626  //event.put( apdResult, m_apdDigiTag ) ;
627  }
628 
629  event.put( barrelResult, m_EBdigiCollection ) ;
630  event.put( endcapResult, m_EEdigiCollection ) ;
631  event.put( preshowerResult, m_ESdigiCollection ) ;
632 }
633 
634 void
635 EcalDigiProducer::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup)
636 {
637  edm::Service<edm::RandomNumberGenerator> rng;
638  if ( ! rng.isAvailable() ) {
639  throw cms::Exception("Configuration") <<
640  "RandomNumberGenerator service is not available.\n"
641  "You must add the service in the configuration file\n"
642  "or remove the module that requires it.";
643  }
644  CLHEP::HepRandomEngine* engine = &rng->getEngine(lumi.index());
645 
646  if( 0 != m_APDResponse ) m_APDResponse->initialize(engine);
647  m_EBResponse->initialize(engine);
648 }
649 
650 void
651 EcalDigiProducer::checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup )
652 {
653  // Pedestals from event setup
654 
655  edm::ESHandle<EcalPedestals> dbPed ;
656  eventSetup.get<EcalPedestalsRcd>().get( dbPed ) ;
657  const EcalPedestals* pedestals ( dbPed.product() ) ;
658 
659  m_Coder->setPedestals( pedestals ) ;
660  if( 0 != m_APDCoder ) m_APDCoder->setPedestals( pedestals ) ;
661 
662  // Ecal Intercalibration Constants
663  edm::ESHandle<EcalIntercalibConstantsMC> pIcal ;
664  eventSetup.get<EcalIntercalibConstantsMCRcd>().get( pIcal ) ;
665  const EcalIntercalibConstantsMC* ical ( pIcal.product() ) ;
666 
667  m_Coder->setIntercalibConstants( ical ) ;
668  if( 0 != m_APDCoder) m_APDCoder->setIntercalibConstants( ical ) ;
669 
670  m_EBResponse->setIntercal( ical ) ;
671  if( 0 != m_APDResponse ) m_APDResponse->setIntercal( ical ) ;
672 
673  // Ecal LaserCorrection Constants
674  edm::ESHandle<EcalLaserDbService> laser;
675  eventSetup.get<EcalLaserDbRecord>().get(laser);
676  const edm::TimeValue_t eventTimeValue = event.time().value();
677 
678  m_EBResponse->setEventTime(eventTimeValue);
679  m_EBResponse->setLaserConstants(laser.product(), m_useLCcorrection);
680 
681  m_EEResponse->setEventTime(eventTimeValue);
682  m_EEResponse->setLaserConstants(laser.product(), m_useLCcorrection);
683 
684  // ADC -> GeV Scale
685  edm::ESHandle<EcalADCToGeVConstant> pAgc;
686  eventSetup.get<EcalADCToGeVConstantRcd>().get(pAgc);
687  const EcalADCToGeVConstant* agc = pAgc.product();
688 
689  // Gain Ratios
690  edm::ESHandle<EcalGainRatios> pRatio;
691  eventSetup.get<EcalGainRatiosRcd>().get(pRatio);
692  const EcalGainRatios* gr = pRatio.product();
693 
694  m_Coder->setGainRatios( gr );
695  if( 0 != m_APDCoder) m_APDCoder->setGainRatios( gr );
696 
697  EcalMGPAGainRatio * defaultRatios = new EcalMGPAGainRatio();
698 
699  double theGains[m_Coder->NGAINS+1];
700  theGains[0] = 0.;
701  theGains[3] = 1.;
702  theGains[2] = defaultRatios->gain6Over1() ;
703  theGains[1] = theGains[2]*(defaultRatios->gain12Over6()) ;
704 
705  LogDebug("EcalDigi") << " Gains: " << "\n" << " g1 = " << theGains[1]
706  << "\n" << " g2 = " << theGains[2]
707  << "\n" << " g3 = " << theGains[3] ;
708 
709  delete defaultRatios;
710 
711  const double EBscale (
712  ( agc->getEBValue())*theGains[1]*(m_Coder->MAXADC)*m_EBs25notCont ) ;
713 
714  LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue()
715  << "\n" << " notCont = " << m_EBs25notCont
716  << "\n" << " saturation for EB = " << EBscale
717  << ", " << m_EBs25notCont ;
718 
719  const double EEscale (
720  (agc->getEEValue())*theGains[1]*(m_Coder->MAXADC)*m_EEs25notCont ) ;
721 
722  LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEEValue()
723  << "\n" << " notCont = " << m_EEs25notCont
724  << "\n" << " saturation for EB = " << EEscale
725  << ", " << m_EEs25notCont ;
726 
727  m_Coder->setFullScaleEnergy( EBscale ,
728  EEscale ) ;
729  if( 0 != m_APDCoder ) m_APDCoder->setFullScaleEnergy( EBscale ,
730  EEscale ) ;
731 
732  if( 0 != m_ESOldDigitizer ||
733  0 != m_ESDigitizer )
734  {
735  // ES condition objects
736  edm::ESHandle<ESGain> hesgain ;
737  edm::ESHandle<ESMIPToGeVConstant> hesMIPToGeV ;
738  edm::ESHandle<ESPedestals> hesPedestals ;
739  edm::ESHandle<ESIntercalibConstants> hesMIPs ;
740 
741  eventSetup.get<ESGainRcd>(). get( hesgain ) ;
742  eventSetup.get<ESMIPToGeVConstantRcd>(). get( hesMIPToGeV ) ;
743  eventSetup.get<ESPedestalsRcd>(). get( hesPedestals ) ;
744  eventSetup.get<ESIntercalibConstantsRcd>().get( hesMIPs ) ;
745 
746  const ESGain* esgain ( hesgain.product() ) ;
747  const ESPedestals* espeds ( hesPedestals.product() ) ;
748  const ESIntercalibConstants* esmips ( hesMIPs.product() ) ;
749  const ESMIPToGeVConstant* esMipToGeV ( hesMIPToGeV.product() ) ;
750  const int ESGain ( 1.1 > esgain->getESGain() ? 1 : 2 ) ;
751  const double ESMIPToGeV ( ( 1 == ESGain ) ?
752  esMipToGeV->getESValueLow() :
753  esMipToGeV->getESValueHigh() ) ;
754 
755  m_ESShape.setGain( ESGain );
756 
757  if( !m_doFastES )
758  {
759  m_ESElectronicsSim->setGain( ESGain ) ;
760  m_ESElectronicsSim->setPedestals( espeds ) ;
761  m_ESElectronicsSim->setMIPs( esmips ) ;
762  m_ESElectronicsSim->setMIPToGeV( ESMIPToGeV ) ;
763  }
764  else
765  {
766  m_ESDigitizer->setGain( ESGain ) ;
767  m_ESElectronicsSimFast->setPedestals( espeds ) ;
768  m_ESElectronicsSimFast->setMIPs( esmips ) ;
769  m_ESElectronicsSimFast->setMIPToGeV( ESMIPToGeV ) ;
770  }
771  }
772 }
773 
774 void
775 EcalDigiProducer::checkGeometry( const edm::EventSetup & eventSetup )
776 {
777  // TODO find a way to avoid doing this every event
778  edm::ESHandle<CaloGeometry> hGeometry ;
779  eventSetup.get<CaloGeometryRecord>().get( hGeometry ) ;
780 
781  const CaloGeometry* pGeometry = &*hGeometry;
782 
783  if( pGeometry != m_Geometry )
784  {
785  m_Geometry = pGeometry;
786  updateGeometry();
787  }
788 }
789 
790 void
791 EcalDigiProducer::updateGeometry()
792 {
793  if( 0 != m_APDResponse ) m_APDResponse->setGeometry(
794  m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ;
795  m_EBResponse->setGeometry(
796  m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ;
797  m_EEResponse->setGeometry(
798  m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalEndcap ) ) ;
799  m_ESResponse->setGeometry(
800  m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalPreshower ) ) ;
801  m_ESOldResponse->setGeometry( m_Geometry ) ;
802 
803  const std::vector<DetId>* theESDets (
804  0 != m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower) ?
805  &m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)->getValidDetIds() : 0 ) ;
806 
807  if( !m_doFastES )
808  {
809  if( 0 != m_ESOldDigitizer &&
810  0 != theESDets )
811  m_ESOldDigitizer->setDetIds( *theESDets ) ;
812  }
813  else
814  {
815  if( 0 != m_ESDigitizer &&
816  0 != theESDets )
817  m_ESDigitizer->setDetIds( *theESDets ) ;
818  }
819 }
820 
821 CLHEP::HepRandomEngine* EcalDigiProducer::randomEngine(edm::StreamID const& streamID) {
822  unsigned int index = streamID.value();
823  if(index >= randomEngines_.size()) {
824  randomEngines_.resize(index + 1, nullptr);
825  }
826  CLHEP::HepRandomEngine* ptr = randomEngines_[index];
827  if(!ptr) {
828  edm::Service<edm::RandomNumberGenerator> rng;
829  ptr = &rng->getEngine(streamID);
830  randomEngines_[index] = ptr;
831  }
832  return ptr;
833 }
834 
835 void EcalDigiProducer::setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator) {
836  //noiseGenerator->setParameterMap(theParameterMap);
837  if(m_BarrelDigitizer) m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator);
838 }
839 
840 void EcalDigiProducer::setEENoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator) {
841  //noiseGenerator->setParameterMap(theParameterMap);
842  if(m_EndcapDigitizer) m_EndcapDigitizer->setNoiseSignalGenerator(noiseGenerator);
843 }
844 
845 void EcalDigiProducer::setESNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator) {
846  //noiseGenerator->setParameterMap(theParameterMap);
847  if(m_ESDigitizer) m_ESDigitizer->setNoiseSignalGenerator(noiseGenerator);
848 }
849 
850 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
EcalCondDBWriter_cfi.laser
string laser
Definition: EcalCondDBWriter_cfi.py:45
EcalDigiProducer::m_EndcapDigitizer
EEDigitizer * m_EndcapDigitizer
Definition: EcalDigiProducer.h:138
EcalDigiProducer::accumulate
virtual void accumulate(edm::Event const &e, edm::EventSetup const &c)
Definition: EcalDigiProducer.cc:556
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:41
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
CaloGeometry::getSubdetectorGeometry
const CaloSubdetectorGeometry * getSubdetectorGeometry(const DetId &id) const
access the subdetector geometry for the given subdetector directly
Definition: CaloGeometry.cc:43
CaloHitResponse::setGeometry
void setGeometry(const CaloGeometry *geometry)
geometry needed for time-of-flight
Definition: CaloHitResponse.h:55
EcalTDigitizer::add
void add(const std::vector< PCaloHit > &hits, int bunchCrossing, CLHEP::HepRandomEngine *)
ESElectronicsSimFast::setMIPToGeV
void setMIPToGeV(double MIPToGeV)
Definition: ESElectronicsSimFast.cc:38
EcalDigiProducer::m_ESOldResponse
CaloHitResponse * m_ESOldResponse
Definition: EcalDigiProducer.h:123
ESElectronicsSim::setGain
void setGain(const int gain)
Definition: ESElectronicsSim.h:26
EcalDigiProducer::~EcalDigiProducer
virtual ~EcalDigiProducer()
Definition: EcalDigiProducer.cc:485
EEDigitizer
EcalTDigitizer< EEDigitizerTraits > EEDigitizer
Definition: EcalDigiProducer.h:22
EcalDigiProducer::m_EBCorrNoise
CorrelatedNoisifier< EcalCorrMatrix > * m_EBCorrNoise[3]
Definition: EcalDigiProducer.h:148
CaloTDigitizer::initializeHits
void initializeHits()
Definition: CaloTDigitizer.h:68
edm::LuminosityBlock::index
LuminosityBlockIndex index() const
Definition: LuminosityBlock.cc:23
EcalDigiProducer::m_ESdigiCollection
const std::string m_ESdigiCollection
Definition: EcalDigiProducer.h:100
EcalDigiProducer::m_ParameterMap
const EcalSimParameterMap * m_ParameterMap
Definition: EcalDigiProducer.h:112
ESGain
Definition: ESGain.h:7
ESShape::setGain
void setGain(const int gain)
Definition: ESShape.h:26
ESDigitizer::setDetIds
void setDetIds(const std::vector< DetId > &detIds)
tell the digitizer which cells exist; cannot change during a run
Definition: ESDigitizer.cc:36
EcalHitResponse::setEventTime
void setEventTime(const edm::TimeValue_t &iTime)
Definition: EcalHitResponse.cc:109
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
EcalDigiProducer::m_hitsProducerTag
const std::string m_hitsProducerTag
Definition: EcalDigiProducer.h:101
ESElectronicsSim::setMIPs
void setMIPs(const ESIntercalibConstants *mips)
Definition: ESElectronicsSim.h:28
CaloTDigitizer::add
void add(const std::vector< PCaloHit > &hits, int bunchCrossing, CLHEP::HepRandomEngine *engine)
Definition: CaloTDigitizer.h:60
ESElectronicsSim::setMIPToGeV
void setMIPToGeV(const double MIPToGeV)
Definition: ESElectronicsSim.h:29
EcalCoder::setIntercalibConstants
void setIntercalibConstants(const EcalIntercalibConstantsMC *ical)
Definition: EcalCoder.cc:63
EcalDigiProducer::initializeEvent
virtual void initializeEvent(edm::Event const &e, edm::EventSetup const &c)
Definition: EcalDigiProducer.cc:517
EcalDigiProducer::m_ESOldDigitizer
ESOldDigitizer * m_ESOldDigitizer
Definition: EcalDigiProducer.h:132
EcalTDigitizer::setNoiseSignalGenerator
void setNoiseSignalGenerator(EcalBaseSignalGenerator *noiseSignalGenerator)
EcalDigiProducer::EcalDigiProducer
EcalDigiProducer(const edm::ParameterSet &params, edm::one::EDProducerBase &mixMod, edm::ConsumesCollector &iC)
Definition: EcalDigiProducer.cc:57
EcalDigiProducer::m_EEdigiCollection
const std::string m_EEdigiCollection
Definition: EcalDigiProducer.h:99
EcalDigiProducer::m_ESElectronicsSimFast
ESElectronicsSimFast * m_ESElectronicsSimFast
Definition: EcalDigiProducer.h:133
EcalTDigitizer::initializeHits
virtual void initializeHits()
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
EcalDigiProducer::m_ESDigitizer
ESDigitizer * m_ESDigitizer
Definition: EcalDigiProducer.h:134
EcalDigiProducer::m_apdParameters
const APDSimParameters * m_apdParameters
Definition: EcalDigiProducer.h:115
CaloSubdetectorGeometry::getValidDetIds
virtual const std::vector< DetId > & getValidDetIds(DetId::Detector det=DetId::Detector(0), int subdet=0) const
Get a list of valid detector ids (for the given subdetector)
Definition: CaloSubdetectorGeometry.cc:37
EcalDigiProducer::setEENoiseSignalGenerator
void setEENoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator)
Definition: EcalDigiProducer.cc:840
ESElectronicsSimFast::setPedestals
void setPedestals(const ESPedestals *peds)
Definition: ESElectronicsSimFast.cc:26
ESElectronicsSim::setPedestals
void setPedestals(const ESPedestals *peds)
Definition: ESElectronicsSim.h:27
EcalDigiProducer::m_EECorrNoise
CorrelatedNoisifier< EcalCorrMatrix > * m_EECorrNoise[3]
Definition: EcalDigiProducer.h:149
EcalDigiProducer::m_readoutFrameSize
const unsigned int m_readoutFrameSize
Definition: EcalDigiProducer.h:110
EcalHitResponse::setLaserConstants
void setLaserConstants(const EcalLaserDbService *laser, bool &useLCcorrection)
Definition: EcalHitResponse.cc:115
EcalDigiProducer::m_ElectronicsSim
EcalElectronicsSim * m_ElectronicsSim
Definition: EcalDigiProducer.h:140
EcalDigiProducer::setEBNoiseSignalGenerator
void setEBNoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator)
Definition: EcalDigiProducer.cc:835
EcalDigiProducer::setESNoiseSignalGenerator
void setESNoiseSignalGenerator(EcalBaseSignalGenerator *noiseGenerator)
Definition: EcalDigiProducer.cc:845
EBHitResponse::setIntercal
void setIntercal(const EcalIntercalibConstantsMC *ical)
Definition: EBHitResponse.cc:157
EcalDigiProducer::m_APDResponse
EBHitResponse * m_APDResponse
Definition: EcalDigiProducer.h:117
CaloHitResponse
Creates electronics signals from hits.
Definition: CaloHitResponse.h:34
EcalDigiProducer::m_EBs25notCont
const double m_EBs25notCont
Definition: EcalDigiProducer.h:107
EcalCoder::setPedestals
void setPedestals(const EcalPedestals *pedestals)
can be fetched every event from the EventSetup
Definition: EcalCoder.cc:51
EcalDigiProducer::m_EBResponse
EBHitResponse * m_EBResponse
Definition: EcalDigiProducer.h:119
EcalHitResponse::setPhaseShift
void setPhaseShift(double phaseShift)
Definition: EcalHitResponse.cc:79
edm::Service::isAvailable
bool isAvailable() const
Definition: Service.h:46
ESDigitizer::setGain
void setGain(const int gain)
Definition: ESDigitizer.cc:44
EcalDigiProducer::m_ESElectronicsSim
ESElectronicsSim * m_ESElectronicsSim
Definition: EcalDigiProducer.h:131
EcalDigiProducer::beginLuminosityBlock
virtual void beginLuminosityBlock(edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override
Definition: EcalDigiProducer.cc:635
EcalDigiProducer::m_BarrelDigitizer
EBDigitizer * m_BarrelDigitizer
Definition: EcalDigiProducer.h:137
EcalMGPAGainRatio::gain6Over1
float gain6Over1() const
Definition: EcalMGPAGainRatio.h:21
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
EcalCorrMatrix
math::ErrorD< CaloSamples::MAXSAMPLES >::type EcalCorrMatrix
Definition: EcalCorrelatedNoiseMatrix.h:7
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
edm::TimeValue_t
unsigned long long TimeValue_t
Definition: Timestamp.h:28
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:402
EcalDigiProducer::m_Geometry
const CaloGeometry * m_Geometry
Definition: EcalDigiProducer.h:146
EcalDigiProducer::checkCalibrations
void checkCalibrations(const edm::Event &event, const edm::EventSetup &eventSetup)
Definition: EcalDigiProducer.cc:651
EcalDigiProducer::m_APDCoder
EcalCoder * m_APDCoder
Definition: EcalDigiProducer.h:144
EcalDigiProducer::checkGeometry
void checkGeometry(const edm::EventSetup &eventSetup)
Definition: EcalDigiProducer.cc:775
EcalDigiProducer::m_ESResponse
ESHitResponse * m_ESResponse
Definition: EcalDigiProducer.h:122
EcalHitResponse::setGeometry
void setGeometry(const CaloSubdetectorGeometry *geometry)
Definition: EcalHitResponse.cc:73
EcalCoder::setGainRatios
void setGainRatios(const EcalGainRatios *gainRatios)
Definition: EcalCoder.cc:57
CaloTDigitizer::run
void run(MixCollection< PCaloHit > &, DigiCollection &)
turns hits into digis
Definition: CaloTDigitizer.h:73
edm::StreamID::value
unsigned int value() const
Definition: StreamID.h:46
edm::Handle::product
T const * product() const
Definition: Handle.h:81
column
#define column(...)
Definition: DbCore.h:74
EcalDigiProducer::cacheEBDigis
virtual void cacheEBDigis(const EBDigiCollection *ebDigiPtr) const
Definition: EcalDigiProducer.h:79
EcalCoder::setFullScaleEnergy
void setFullScaleEnergy(double EBscale, double EEscale)
Definition: EcalCoder.cc:42
EBDigitizer
EcalTDigitizer< EBDigitizerTraits > EBDigitizer
Definition: EcalDigiProducer.h:21
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
EcalMGPAGainRatio::gain12Over6
float gain12Over6() const
Definition: EcalMGPAGainRatio.h:20
EcalDigiProducer::m_APDDigitizer
EBDigitizer * m_APDDigitizer
Definition: EcalDigiProducer.h:136
edm::RandomNumberGenerator::getEngine
virtual CLHEP::HepRandomEngine & getEngine(StreamID const &) const =0
Use this engine in event methods.
EcalDigiProducer::m_apdSeparateDigi
const bool m_apdSeparateDigi
Definition: EcalDigiProducer.h:105
EcalDigiProducer::finalizeEvent
virtual void finalizeEvent(edm::Event &e, edm::EventSetup const &c)
Definition: EcalDigiProducer.cc:592
EcalDigiProducer::randomEngine
CLHEP::HepRandomEngine * randomEngine(edm::StreamID const &streamID)
Definition: EcalDigiProducer.cc:821
EcalTDigitizer::run
virtual void run(DigiCollection &output, CLHEP::HepRandomEngine *)
EcalDigiProducer::accumulateCaloHits
void accumulateCaloHits(HitsHandle const &ebHandle, HitsHandle const &eeHandle, HitsHandle const &esHandle, int bunchCrossing, CLHEP::HepRandomEngine *)
Definition: EcalDigiProducer.cc:533
EBHitResponse::initialize
void initialize(CLHEP::HepRandomEngine *)
Definition: EBHitResponse.cc:61
PileUpEventPrincipal::getByLabel
bool getByLabel(edm::InputTag const &tag, edm::Handle< T > &result) const
Definition: PileUpEventPrincipal.h:40
edm::Event::streamID
StreamID streamID() const
Definition: Event.h:72
EcalDigiProducer::m_apdDigiTag
const std::string m_apdDigiTag
Definition: EcalDigiProducer.h:114
CaloTDigitizer::setDetIds
void setDetIds(const std::vector< DetId > &detIds)
Definition: CaloTDigitizer.h:48
EcalDigiProducer::randomEngines_
std::vector< CLHEP::HepRandomEngine * > randomEngines_
Definition: EcalDigiProducer.h:151
ESDigitizer::run
virtual void run(ESDigiCollection &output, CLHEP::HepRandomEngine *) override
turns hits into digis
Definition: ESDigitizer.cc:167
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
ESElectronicsSimFast::setMIPs
void setMIPs(const ESIntercalibConstants *mips)
Definition: ESElectronicsSimFast.cc:32
EcalDigiProducer::cacheEEDigis
virtual void cacheEEDigis(const EEDigiCollection *eeDigiPtr) const
Definition: EcalDigiProducer.h:80
EcalDigiProducer::m_EBdigiCollection
const std::string m_EBdigiCollection
Definition: EcalDigiProducer.h:98
HcalObjRepresent::setup
void setup(std::vector< TH2F > &depth, std::string name, std::string units="")
Definition: HcalObjRepresent.h:628
EcalDigiProducer::m_APDElectronicsSim
EcalElectronicsSim * m_APDElectronicsSim
Definition: EcalDigiProducer.h:143
EcalDigiProducer::m_EEs25notCont
const double m_EEs25notCont
Definition: EcalDigiProducer.h:108
EcalDigiProducer::m_EEResponse
EEHitResponse * m_EEResponse
Definition: EcalDigiProducer.h:120
Generated for CMSSW Reference Manual by doxygen 1.8.5