"MarlinReco"  1.32.0
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
ILDCaloDigi Class Reference

=== ILDCaloDigi Processor ===
Simple calorimeter digitizer Processor. More...

#include <ILDCaloDigi.h>

Inheritance diagram for ILDCaloDigi:

Public Member Functions

 ILDCaloDigi (const ILDCaloDigi &)=delete
 
ILDCaloDigi & operator= (const ILDCaloDigi &)=delete
 
virtual Processor * newProcessor ()
 
virtual void init ()
 
virtual void processRunHeader (LCRunHeader *run)
 
virtual void processEvent (LCEvent *evt)
 
virtual void check (LCEvent *evt)
 
virtual void end ()
 
virtual void fillECALGaps ()
 
float digitalHcalCalibCoeff (CHT::Layout, float energy)
 
float analogueHcalCalibCoeff (CHT::Layout, int layer)
 
float digitalEcalCalibCoeff (int layer)
 
float analogueEcalCalibCoeff (int layer)
 

Protected Types

enum  {
  SQUARE, STRIP_ALIGN_ALONG_SLAB, STRIP_ALIGN_ACROSS_SLAB, SIECAL =0,
  SCECAL
}
 

Protected Member Functions

float ecalEnergyDigi (float energy, int id0, int id1)
 
float ahcalEnergyDigi (float energy, int id0, int id1)
 
float siliconDigi (float energy)
 
float scintillatorDigi (float energy, bool isEcal)
 
LCCollection * combineVirtualStripCells (LCCollection *col, bool isBarrel, int orientation)
 
int getNumberOfVirtualCells ()
 
std::vector< std::pair< int,
int > > & 		getLayerConfig ()
 
void checkConsistency (std::string colName, int layer)
 
std::pair< int, int > getLayerProperties (std::string colName, int layer)
 
int getStripOrientationFromColName (std::string colName)
 

Protected Attributes

int _nRun {}
 
int _nEvt {}
 
LCFlagImpl _flag {}
 
std::vector< std::string > _ecalCollections {}
 
std::vector< std::string > _hcalCollections {}
 
std::vector< std::string > _outputEcalCollections {}
 
std::vector< std::string > _outputHcalCollections {}
 
std::string _outputRelCollection {}
 
float _thresholdEcal {}
 
std::string _unitThresholdEcal {}
 
std::vector< float > _thresholdHcal {}
 
std::string _unitThresholdHcal {}
 
int _digitalEcal {}
 
int _mapsEcalCorrection {}
 
int _digitalHcal {}
 
bool _ECAL_stripHits {}
 
std::vector< float > _calibrCoeffEcal {}
 
std::vector< float > _calibrCoeffHcalBarrel {}
 
std::vector< float > _calibrCoeffHcalEndCap {}
 
std::vector< float > _calibrCoeffHcalOther {}
 
std::vector< int > _ecalLayers {}
 
std::vector< int > _hcalLayers {}
 
int _ecalGapCorrection {}
 
float _ecalGapCorrectionFactor {}
 
float _ecalModuleGapCorrectionFactor {}
 
float _ecalEndcapCorrectionFactor {}
 
float _hcalEndcapCorrectionFactor {}
 
int _hcalGapCorrection {}
 
float _hcalModuleGapCorrectionFactor {}
 
std::vector< CalorimeterHitImpl * > _calHitsByStaveLayer [MAX_STAVES][MAX_LAYERS]
 
std::vector< int > _calHitsByStaveLayerModule [MAX_STAVES][MAX_LAYERS]
 
float _zOfEcalEndcap {}
 
float _barrelPixelSizeT [MAX_LAYERS] {}
 
float _barrelPixelSizeZ [MAX_LAYERS] {}
 
float _endcapPixelSizeX [MAX_LAYERS] {}
 
float _endcapPixelSizeY [MAX_LAYERS] {}
 
float _barrelStaveDir [MAX_STAVES][2] {}
 
int _histograms {}
 
int _useEcalTiming {}
 
int _ecalCorrectTimesForPropagation {}
 
float _ecalTimeWindowMin {}
 
float _ecalBarrelTimeWindowMax {}
 
float _ecalEndcapTimeWindowMax {}
 
float _ecalDeltaTimeHitResolution {}
 
float _ecalTimeResolution {}
 
bool _ecalSimpleTimingCut {}
 
int _useHcalTiming {}
 
int _hcalCorrectTimesForPropagation {}
 
float _hcalTimeWindowMin {}
 
float _hcalBarrelTimeWindowMax {}
 
float _hcalEndcapTimeWindowMax {}
 
float _hcalDeltaTimeHitResolution {}
 
float _hcalTimeResolution {}
 
bool _hcalSimpleTimingCut {}
 
ScintillatorPpdDigi * _scEcalDigi {}
 
ScintillatorPpdDigi * _scHcalDigi {}
 
float _calibEcalMip {}
 
int _applyEcalDigi {}
 
float _ecal_PPD_pe_per_mip {}
 
int _ecal_PPD_n_pixels {}
 
float _ehEnergy {}
 
float _ecal_misCalibNpix {}
 
float _misCalibEcal_uncorrel {}
 
bool _misCalibEcal_uncorrel_keep {}
 
float _misCalibEcal_correl {}
 
float _deadCellFractionEcal {}
 
bool _deadCellEcal_keep {}
 
float _strip_abs_length {}
 
float _ecal_pixSpread {}
 
float _ecal_elec_noise {}
 
float _ecalMaxDynMip {}
 
int _ecalStrip_default_nVirt {}
 
std::string _ecal_deafult_layer_config {}
 
float _calibHcalMip {}
 
int _applyHcalDigi {}
 
float _hcal_PPD_pe_per_mip {}
 
int _hcal_PPD_n_pixels {}
 
float _hcal_misCalibNpix {}
 
float _misCalibHcal_uncorrel {}
 
bool _misCalibHcal_uncorrel_keep {}
 
float _misCalibHcal_correl {}
 
float _deadCellFractionHcal {}
 
bool _deadCellHcal_keep {}
 
float _hcal_pixSpread {}
 
float _hcal_elec_noise {}
 
float _hcalMaxDynMip {}
 
std::vector< std::pair< int,
int > > 		_layerTypes {}
 
int _strip_virt_cells {}
 
int _countWarnings {}
 
std::string _ecalLayout {}
 
float _event_correl_miscalib_ecal {}
 
float _event_correl_miscalib_hcal {}
 
CLHEP::MTwistEngine * _randomEngineDeadCellEcal {}
 
CLHEP::MTwistEngine * _randomEngineDeadCellHcal {}
 
std::map< std::pair< int, int >
, float > 		_ECAL_cell_miscalibs {}
 
std::map< std::pair< int, int >
, bool > 		_ECAL_cell_dead {}
 
std::map< std::pair< int, int >
, float > 		_HCAL_cell_miscalibs {}
 
std::map< std::pair< int, int >
, bool > 		_HCAL_cell_dead {}
 
std::string _cellIDLayerString {}
 
std::string _cellIDModuleString {}
 
std::string _cellIDStaveString {}
 
std::string _cellIDIndexIString {}
 
std::string _cellIDIndexJString {}
 
TH1F * fEcal {}
 
TH1F * fHcal {}
 
TH1F * fEcalC {}
 
TH1F * fHcalC {}
 
TH1F * fEcalC1 {}
 
TH1F * fHcalC1 {}
 
TH1F * fEcalC2 {}
 
TH1F * fHcalC2 {}
 
TH2F * fHcalCvsE {}
 
TH2F * fHcalLayer1 {}
 
TH2F * fHcalLayer11 {}
 
TH2F * fHcalLayer21 {}
 
TH2F * fHcalLayer31 {}
 
TH2F * fHcalLayer41 {}
 
TH2F * fHcalLayer51 {}
 
TH2F * fHcalLayer61 {}
 
TH2F * fHcalLayer71 {}
 
TH1F * fHcalRLayer1 {}
 
TH1F * fHcalRLayer11 {}
 
TH1F * fHcalRLayer21 {}
 
TH1F * fHcalRLayer31 {}
 
TH1F * fHcalRLayer41 {}
 
TH1F * fHcalRLayer51 {}
 
TH1F * fHcalRLayer61 {}
 
TH1F * fHcalRLayer71 {}
 
TH1F * fHcalRLayerNorm {}
 
TH1F * fEcalRLayerNorm {}
 
TH2F * fEcalLayer1 {}
 
TH2F * fEcalLayer11 {}
 
TH2F * fEcalLayer21 {}
 
TH1F * fEcalRLayer1 {}
 
TH1F * fEcalRLayer11 {}
 
TH1F * fEcalRLayer21 {}
 

Detailed Description

=== ILDCaloDigi Processor ===
Simple calorimeter digitizer Processor.


Takes SimCalorimeterHit Collections and
produces CalorimeterHit Collections.
Simulated energy depositions in active
layers of calorimeters are
converted into physical energy. This is done
taking into account sampling fractions of
ECAL and HCAL.
User has to specify ECAL and HCAL SimCalorimeterHit
collections with processor parameters
HCALCollections and ECALCollections.
The names of the output CalorimeterHit Collections
are specified with processor parameters
ECALOutputCollection and HCALOutputCollection.
Conversion factors for ECAL and HCAL
are specified via processor parameters
CalibrECAL and CalibrHCAL.
It should be noted that ECAL and HCAL may consist
of several sections with different sampling fractions.
To handle this situation, calibration coefficients for
ECAL and HCAL are passed as arrays of floats with each element
in this array corresponding to certain section with
a given sampling fraction.
List of layer numbers terminating each section are given through
processor parameters ECALLayers and HCALLayers
There is an option to perform digitization of
both ECAL and HCAL in a digital mode.
Digital mode is activated by
setting processor parameters
IfDigitalEcal / IfDigitalHcal to 1.
In this case CalibrECAL / CalibrHCAL will
convert the number of hits into physical energy.
Thresholds on hit energies in ECAL and HCAL
are set with processor parameters
ECALThreshold and HCALThreshold.
Relations between CalorimeterHits and SimCalorimeterHits
are held in the corresponding relation collection.
The name of this relation collection is specified
via processor parameter RelationOutputCollection.

Input collections and prerequisites

SimCalorimeterHit collections

Output

CalorimeterHit collections for ECal and HCal.
Collection of relations
between CalorimeterHits and SimCalorimeterHits.
For ECal Calorimeter hits the variable type is set to 0,
whereas for HCal Calorimeter hits the type is set to 1

Author
A. Raspereza (DESY)
M. Thomson (DESY)
Version
$Id$
The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.5