#include <GsfElectronMCAnalyzer.h>

Inheritance diagram for GsfElectronMCAnalyzer:

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override

void	beginJob () override

void	endJob () override

	GsfElectronMCAnalyzer (const edm::ParameterSet &conf)

	~GsfElectronMCAnalyzer () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () 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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
double	deltaR_

double	detamatchmax

double	detamatchmin

double	detamax

double	detamin

double	dphimatchmax

double	dphimatchmin

double	dphimax

double	dphimin

edm::InputTag	electronCollection_

double	eopmax

double	eopmaxsht

double	etamax

double	etamin

double	fhitsmax

TH1F *	h_ele_ambiguousTracks

TH2F *	h_ele_ambiguousTracksVsEta

TH2F *	h_ele_ambiguousTracksVsPhi

TH2F *	h_ele_ambiguousTracksVsPt

TH1F *	h_ele_charge

TH1F *	h_ele_ChargeMnChargeTrue

TH2F *	h_ele_chargeVsEta

TH2F *	h_ele_chargeVsPhi

TH2F *	h_ele_chargeVsPt

TH1F *	h_ele_chi2

TH1F *	h_ele_chi2_barrel

TH1F *	h_ele_chi2_endcaps

TH2F *	h_ele_chi2VsEta

TH2F *	h_ele_chi2VsPhi

TH2F *	h_ele_chi2VsPt

TH1F *	h_ele_classes

TH1F *	h_ele_dEtaCl_propOut

TH1F *	h_ele_dEtaCl_propOut_all

TH1F *	h_ele_dEtaCl_propOut_all_barrel

TH1F *	h_ele_dEtaCl_propOut_all_endcaps

TH1F *	h_ele_dEtaCl_propOut_barrel

TH1F *	h_ele_dEtaCl_propOut_eg

TH1F *	h_ele_dEtaCl_propOut_eg_barrel

TH1F *	h_ele_dEtaCl_propOut_eg_endcaps

TH1F *	h_ele_dEtaCl_propOut_endcaps

TH2F *	h_ele_dEtaClVsEta_propOut

TH2F *	h_ele_dEtaClVsPhi_propOut

TH2F *	h_ele_dEtaClVsPt_propOut

TH1F *	h_ele_dEtaEleCl_propOut

TH1F *	h_ele_dEtaEleCl_propOut_barrel

TH1F *	h_ele_dEtaEleCl_propOut_eg

TH1F *	h_ele_dEtaEleCl_propOut_eg_barrel

TH1F *	h_ele_dEtaEleCl_propOut_eg_endcaps

TH1F *	h_ele_dEtaEleCl_propOut_endcaps

TH2F *	h_ele_dEtaEleClVsEta_propOut

TH2F *	h_ele_dEtaEleClVsPhi_propOut

TH2F *	h_ele_dEtaEleClVsPt_propOut

TH1F *	h_ele_dEtaSc_propVtx

TH1F *	h_ele_dEtaSc_propVtx_all

TH1F *	h_ele_dEtaSc_propVtx_all_barrel

TH1F *	h_ele_dEtaSc_propVtx_all_endcaps

TH1F *	h_ele_dEtaSc_propVtx_barrel

TH1F *	h_ele_dEtaSc_propVtx_eg

TH1F *	h_ele_dEtaSc_propVtx_eg_barrel

TH1F *	h_ele_dEtaSc_propVtx_eg_endcaps

TH1F *	h_ele_dEtaSc_propVtx_endcaps

TH2F *	h_ele_dEtaScVsEta_propVtx

TH2F *	h_ele_dEtaScVsPhi_propVtx

TH2F *	h_ele_dEtaScVsPt_propVtx

TH1F *	h_ele_dPhiCl_propOut

TH1F *	h_ele_dPhiCl_propOut_all

TH1F *	h_ele_dPhiCl_propOut_all_barrel

TH1F *	h_ele_dPhiCl_propOut_all_endcaps

TH1F *	h_ele_dPhiCl_propOut_barrel

TH1F *	h_ele_dPhiCl_propOut_eg

TH1F *	h_ele_dPhiCl_propOut_eg_barrel

TH1F *	h_ele_dPhiCl_propOut_eg_endcaps

TH1F *	h_ele_dPhiCl_propOut_endcaps

TH2F *	h_ele_dPhiClVsEta_propOut

TH2F *	h_ele_dPhiClVsPhi_propOut

TH2F *	h_ele_dPhiClVsPt_propOut

TH1F *	h_ele_dPhiEleCl_propOut

TH1F *	h_ele_dPhiEleCl_propOut_barrel

TH1F *	h_ele_dPhiEleCl_propOut_eg

TH1F *	h_ele_dPhiEleCl_propOut_eg_barrel

TH1F *	h_ele_dPhiEleCl_propOut_eg_endcaps

TH1F *	h_ele_dPhiEleCl_propOut_endcaps

TH2F *	h_ele_dPhiEleClVsEta_propOut

TH2F *	h_ele_dPhiEleClVsPhi_propOut

TH2F *	h_ele_dPhiEleClVsPt_propOut

TH1F *	h_ele_dPhiSc_propVtx

TH1F *	h_ele_dPhiSc_propVtx_all

TH1F *	h_ele_dPhiSc_propVtx_all_barrel

TH1F *	h_ele_dPhiSc_propVtx_all_endcaps

TH1F *	h_ele_dPhiSc_propVtx_barrel

TH1F *	h_ele_dPhiSc_propVtx_eg

TH1F *	h_ele_dPhiSc_propVtx_eg_barrel

TH1F *	h_ele_dPhiSc_propVtx_eg_endcaps

TH1F *	h_ele_dPhiSc_propVtx_endcaps

TH2F *	h_ele_dPhiScVsEta_propVtx

TH2F *	h_ele_dPhiScVsPhi_propVtx

TH2F *	h_ele_dPhiScVsPt_propVtx

TH2F *	h_ele_E2mnE1vsMee_all

TH2F *	h_ele_E2mnE1vsMee_egeg_all

TH1F *	h_ele_ecalRecHitSumEt_dr03

TH1F *	h_ele_ecalRecHitSumEt_dr04

TH1F *	h_ele_EeleOPout

TH1F *	h_ele_EeleOPout_all

TH1F *	h_ele_EeleOPout_all_barrel

TH1F *	h_ele_EeleOPout_all_endcaps

TH1F *	h_ele_EeleOPout_barrel

TH1F *	h_ele_EeleOPout_eg

TH1F *	h_ele_EeleOPout_eg_barrel

TH1F *	h_ele_EeleOPout_eg_endcaps

TH1F *	h_ele_EeleOPout_endcaps

TH2F *	h_ele_EeleOPoutVsE

TH2F *	h_ele_EeleOPoutVsEta

TH2F *	h_ele_EeleOPoutVsPhi

TH1F *	h_ele_EoP

TH1F *	h_ele_EoP_barrel

TH1F *	h_ele_EoP_eg

TH1F *	h_ele_EoP_eg_barrel

TH1F *	h_ele_EoP_eg_endcaps

TH1F *	h_ele_EoP_endcaps

TH1F *	h_ele_EoPout

TH1F *	h_ele_EoPout_all

TH1F *	h_ele_EoPout_all_barrel

TH1F *	h_ele_EoPout_all_endcaps

TH1F *	h_ele_EoPout_barrel

TH1F *	h_ele_EoPout_eg

TH1F *	h_ele_EoPout_eg_barrel

TH1F *	h_ele_EoPout_eg_endcaps

TH1F *	h_ele_EoPout_endcaps

TH2F *	h_ele_EoPoutVsE

TH2F *	h_ele_EoPoutVsEta

TH2F *	h_ele_EoPoutVsPhi

TH2F *	h_ele_EoPVsE

TH2F *	h_ele_EoPVsEta

TH2F *	h_ele_EoPVsPhi

TH1F *	h_ele_EoverP_all

TH1F *	h_ele_EoverP_all_barrel

TH1F *	h_ele_EoverP_all_endcaps

TH1F *	h_ele_EseedOP

TH1F *	h_ele_EseedOP_all

TH1F *	h_ele_EseedOP_all_barrel

TH1F *	h_ele_EseedOP_all_endcaps

TH1F *	h_ele_EseedOP_barrel

TH1F *	h_ele_EseedOP_eg

TH1F *	h_ele_EseedOP_eg_barrel

TH1F *	h_ele_EseedOP_eg_endcaps

TH1F *	h_ele_EseedOP_endcaps

TH2F *	h_ele_EseedOPVsE

TH2F *	h_ele_EseedOPVsEta

TH2F *	h_ele_EseedOPVsPhi

TH1F *	h_ele_Et

TH1F *	h_ele_Et_all

TH1F *	h_ele_eta

TH1F *	h_ele_eta_bbrem

TH1F *	h_ele_eta_golden

TH1F *	h_ele_eta_narrow

TH1F *	h_ele_eta_shower

TH1F *	h_ele_EtaMnEtaTrue

TH1F *	h_ele_EtaMnEtaTrue_barrel

TH1F *	h_ele_EtaMnEtaTrue_endcaps

TH2F *	h_ele_EtaMnEtaTrueVsEta

TH2F *	h_ele_EtaMnEtaTrueVsPhi

TH2F *	h_ele_EtaMnEtaTrueVsPt

TH1F *	h_ele_fbrem

TH1F *	h_ele_fbrem_eg

TProfile *	h_ele_fbremVsEta_mean

TProfile *	h_ele_fbremVsEta_mode

TH1F *	h_ele_foundHits

TH1F *	h_ele_foundHits_barrel

TH1F *	h_ele_foundHits_endcaps

TH2F *	h_ele_foundHitsVsEta

TH2F *	h_ele_foundHitsVsPhi

TH2F *	h_ele_foundHitsVsPt

TH1F *	h_ele_hcalDepth1TowerSumEt_dr03

TH1F *	h_ele_hcalDepth1TowerSumEt_dr04

TH1F *	h_ele_hcalDepth2TowerSumEt_dr03

TH1F *	h_ele_hcalDepth2TowerSumEt_dr04

TH1F *	h_ele_HoE

TH1F *	h_ele_HoE_all

TH1F *	h_ele_HoE_all_barrel

TH1F *	h_ele_HoE_all_endcaps

TH1F *	h_ele_HoE_barrel

TH1F *	h_ele_HoE_eg

TH1F *	h_ele_HoE_eg_barrel

TH1F *	h_ele_HoE_eg_endcaps

TH1F *	h_ele_HoE_endcaps

TH1F *	h_ele_HoE_fiducial

TH2F *	h_ele_HoEVsE

TH2F *	h_ele_HoEVsEta

TH2F *	h_ele_HoEVsPhi

TH1F *	h_ele_lostHits

TH1F *	h_ele_lostHits_barrel

TH1F *	h_ele_lostHits_endcaps

TH2F *	h_ele_lostHitsVsEta

TH2F *	h_ele_lostHitsVsPhi

TH2F *	h_ele_lostHitsVsPt

TH1F *	h_ele_mee_all

TH1F *	h_ele_mee_os

TH1F *	h_ele_mee_os_bb

TH1F *	h_ele_mee_os_ebeb

TH1F *	h_ele_mee_os_ebee

TH1F *	h_ele_mee_os_eeee

TH1F *	h_ele_mee_os_gb

TH1F *	h_ele_mee_os_gg

TH1F *	h_ele_mva

TH1F *	h_ele_mva_eg

TH1F *	h_ele_outerP

TH1F *	h_ele_outerP_mode

TH1F *	h_ele_outerPt

TH1F *	h_ele_outerPt_mode

TH2F *	h_ele_outerPtVsEta_mode

TH2F *	h_ele_outerPtVsPhi_mode

TH2F *	h_ele_outerPtVsPt_mode

TH2F *	h_ele_outerPVsEta_mode

TH1F *	h_ele_PhiMnPhiTrue

TH1F *	h_ele_PhiMnPhiTrue2

TH1F *	h_ele_PhiMnPhiTrue_barrel

TH1F *	h_ele_PhiMnPhiTrue_endcaps

TH2F *	h_ele_PhiMnPhiTrueVsEta

TH2F *	h_ele_PhiMnPhiTrueVsPhi

TH2F *	h_ele_PhiMnPhiTrueVsPt

TH1F *	h_ele_PinMnPout

TH1F *	h_ele_PinMnPout_mode

TH2F *	h_ele_PinMnPoutVsChi2_mode

TH2F *	h_ele_PinMnPoutVsE_mode

TH2F *	h_ele_PinMnPoutVsEta_mode

TH2F *	h_ele_PinMnPoutVsPhi_mode

TH2F *	h_ele_PinMnPoutVsPt_mode

TH2F *	h_ele_PinVsPoutGolden_mean

TH2F *	h_ele_PinVsPoutGolden_mode

TH2F *	h_ele_PinVsPoutShowering_mean

TH2F *	h_ele_PinVsPoutShowering_mode

TH1F *	h_ele_PoPtrue

TH1F *	h_ele_PoPtrue_barrel

TH1F *	h_ele_PoPtrue_endcaps

TH1F *	h_ele_PoPtrue_golden_barrel

TH1F *	h_ele_PoPtrue_golden_endcaps

TH1F *	h_ele_PoPtrue_showering_barrel

TH1F *	h_ele_PoPtrue_showering_endcaps

TH2F *	h_ele_PoPtrueVsEta

TH2F *	h_ele_PoPtrueVsPhi

TH2F *	h_ele_PoPtrueVsPt

TH1F *	h_ele_provenance

TH2F *	h_ele_PtinVsPtoutGolden_mean

TH2F *	h_ele_PtinVsPtoutGolden_mode

TH2F *	h_ele_PtinVsPtoutShowering_mean

TH2F *	h_ele_PtinVsPtoutShowering_mode

TH1F *	h_ele_PtoPttrue

TH1F *	h_ele_PtoPttrue_barrel

TH1F *	h_ele_PtoPttrue_endcaps

TH1F *	h_ele_seed_dphi2_

TH2F *	h_ele_seed_dphi2VsEta_

TH2F *	h_ele_seed_dphi2VsPt_

TH1F *	h_ele_seed_drz2_

TH2F *	h_ele_seed_drz2VsEta_

TH2F *	h_ele_seed_drz2VsPt_

TH1F *	h_ele_seed_subdet2_

TH1F *	h_ele_simAbsEta_matched

TH1F *	h_ele_simAbsEta_matched_qmisid

TH1F *	h_ele_simEta_matched

TH1F *	h_ele_simEta_matched_qmisid

TH1F *	h_ele_simPhi_matched

TH1F *	h_ele_simPhi_matched_qmisid

TH1F *	h_ele_simPt_matched

TH1F *	h_ele_simPt_matched_qmisid

TH2F *	h_ele_simPtEta_matched

TH1F *	h_ele_simZ_matched

TH1F *	h_ele_simZ_matched_qmisid

TH1F *	h_ele_TIP_all

TH1F *	h_ele_TIP_all_barrel

TH1F *	h_ele_TIP_all_endcaps

TH1F *	h_ele_tkSumPt_dr03

TH1F *	h_ele_tkSumPt_dr04

TH1F *	h_ele_vertexAbsEta

TH1F *	h_ele_vertexEta

TH1F *	h_ele_vertexEta_all

TH2F *	h_ele_vertexEtaVsPhi

TH1F *	h_ele_vertexP

TH1F *	h_ele_vertexPhi

TH1F *	h_ele_vertexPt

TH1F *	h_ele_vertexPt_5100

TH1F *	h_ele_vertexPt_all

TH2F *	h_ele_vertexPtVsEta

TH2F *	h_ele_vertexPtVsPhi

TH1F *	h_ele_vertexTIP

TH2F *	h_ele_vertexTIPVsEta

TH2F *	h_ele_vertexTIPVsPhi

TH2F *	h_ele_vertexTIPVsPt

TH1F *	h_ele_vertexX

TH1F *	h_ele_vertexY

TH1F *	h_ele_vertexZ

TH1F *	h_eleNum

TH1F *	h_gamNum

TH1F *	h_mcNum

TH1F *	h_simAbsEta

TH1F *	h_simEta

TH1F *	h_simP

TH1F *	h_simPhi

TH1F *	h_simPt

TH2F *	h_simPtEta

TH1F *	h_simZ

TFile *	histfile_

TH1F *	histNum_

TH1F *	histSclE1x5_

TH1F *	histSclE1x5_barrel_

TH1F *	histSclE1x5_eg_

TH1F *	histSclE1x5_eg_barrel_

TH1F *	histSclE1x5_eg_endcaps_

TH1F *	histSclE1x5_endcaps_

TH1F *	histSclE2x5max_

TH1F *	histSclE2x5max_barrel_

TH1F *	histSclE2x5max_eg_

TH1F *	histSclE2x5max_eg_barrel_

TH1F *	histSclE2x5max_eg_endcaps_

TH1F *	histSclE2x5max_endcaps_

TH1F *	histSclE5x5_

TH1F *	histSclE5x5_barrel_

TH1F *	histSclE5x5_eg_

TH1F *	histSclE5x5_eg_barrel_

TH1F *	histSclE5x5_eg_endcaps_

TH1F *	histSclE5x5_endcaps_

TH1F *	histSclEn_

TH1F *	histSclEoEtrue_barrel

TH1F *	histSclEoEtrue_barrel_eg

TH1F *	histSclEoEtrue_barrel_eg_new

TH1F *	histSclEoEtrue_barrel_etagap

TH1F *	histSclEoEtrue_barrel_etagap_new

TH1F *	histSclEoEtrue_barrel_new

TH1F *	histSclEoEtrue_barrel_phigap

TH1F *	histSclEoEtrue_barrel_phigap_new

TH1F *	histSclEoEtrue_ebeegap

TH1F *	histSclEoEtrue_ebeegap_new

TH1F *	histSclEoEtrue_endcaps

TH1F *	histSclEoEtrue_endcaps_deegap

TH1F *	histSclEoEtrue_endcaps_deegap_new

TH1F *	histSclEoEtrue_endcaps_eg

TH1F *	histSclEoEtrue_endcaps_eg_new

TH1F *	histSclEoEtrue_endcaps_new

TH1F *	histSclEoEtrue_endcaps_ringgap

TH1F *	histSclEoEtrue_endcaps_ringgap_new

TH1F *	histSclEoEtrueGolden_barrel

TH1F *	histSclEoEtrueGolden_endcaps

TH2F *	histSclEoEtruePfVsEg

TH1F *	histSclEoEtrueShowering_barrel

TH1F *	histSclEoEtrueShowering_endcaps

TH1F *	histSclEt_

TH1F *	histSclEta_

TH2F *	histSclEtaVsPhi_

TH2F *	histSclEtVsEta_

TH2F *	histSclEtVsPhi_

TH1F *	histSclPhi_

TH1F *	histSclSigEtaEta_

TH1F *	histSclSigEtaEta_barrel_

TH1F *	histSclSigEtaEta_eg_

TH1F *	histSclSigEtaEta_eg_barrel_

TH1F *	histSclSigEtaEta_eg_endcaps_

TH1F *	histSclSigEtaEta_endcaps_

TH1F *	histSclSigIEtaIEta_

TH1F *	histSclSigIEtaIEta_barrel_

TH1F *	histSclSigIEtaIEta_eg_

TH1F *	histSclSigIEtaIEta_eg_barrel_

TH1F *	histSclSigIEtaIEta_eg_endcaps_

TH1F *	histSclSigIEtaIEta_endcaps_

double	hoemax

double	hoemin

double	lhitsmax

std::vector< int >	matchingIDs_

std::vector< int >	matchingMotherIDs_

double	maxAbsEta_

double	maxPt_

float	mcEnergy [10]

float	mcEta [10]

float	mcPhi [10]

float	mcPt [10]

float	mcQ [10]

edm::InputTag	mcTruthCollection_

double	meemax

double	meemin

int	nbindeta

int	nbindetamatch

int	nbindetamatch2D

int	nbindphi

int	nbindphimatch

int	nbindphimatch2D

int	nbineop

int	nbineop2D

int	nbineta

int	nbineta2D

int	nbinfhits

int	nbinhoe

int	nbinlhits

int	nbinmee

int	nbinp

int	nbinp2D

int	nbinphi

int	nbinphi2D

int	nbinpoptrue

int	nbinpt

int	nbinpt2D

int	nbinpteff

int	nbinxyz

std::string	outputFile_

edm::ESHandle< TrackerGeometry >	pDD

double	phimax

double	phimin

double	pmax

double	poptruemax

double	poptruemin

double	ptmax

bool	readAOD_

float	seedEta [10]

float	seedMomentum [10]

float	seedPhi [10]

float	seedPt [10]

float	seedQ [10]

float	superclusterEnergy [10]

float	superclusterEt [10]

float	superclusterEta [10]

float	superclusterPhi [10]

edm::ESHandle< MagneticField >	theMagField

TrajectoryStateTransform	transformer_

TTree *	tree_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

Detailed Description

Description: GsfElectrons analyzer using MC truth

Implementation: <Notes on="" implementation>="">

Definition at line 38 of file GsfElectronMCAnalyzer.h.

Constructor & Destructor Documentation

GsfElectronMCAnalyzer::GsfElectronMCAnalyzer ( const edm::ParameterSet & conf )

explicit

Definition at line 51 of file GsfElectronMCAnalyzer.cc.

References deltaR_, edm::ParameterSet::getParameter(), phimax, phimin, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

  {
   outputFile_ = conf.getParameter<std::string>("outputFile");
   histfile_ = new TFile(outputFile_.c_str(),"RECREATE");
   electronCollection_=conf.getParameter<edm::InputTag>("electronCollection");
   mcTruthCollection_ = conf.getParameter<edm::InputTag>("mcTruthCollection");
   readAOD_ = conf.getParameter<bool>("readAOD");
   maxPt_ = conf.getParameter<double>("MaxPt");
   maxAbsEta_ = conf.getParameter<double>("MaxAbsEta");
   deltaR_ = conf.getParameter<double>("DeltaR");
   matchingIDs_ = conf.getParameter<std::vector<int> >("MatchingID");
   matchingMotherIDs_ = conf.getParameter<std::vector<int> >("MatchingMotherID");
   edm::ParameterSet pset =
    conf.getParameter<edm::ParameterSet>("HistosConfigurationMC") ;
 
   etamin=pset.getParameter<double>("Etamin");
   etamax=pset.getParameter<double>("Etamax");
   phimin=pset.getParameter<double>("Phimin");
   phimax=pset.getParameter<double>("Phimax");
   ptmax=pset.getParameter<double>("Ptmax");
   pmax=pset.getParameter<double>("Pmax");
   eopmax=pset.getParameter<double>("Eopmax");
   eopmaxsht=pset.getParameter<double>("Eopmaxsht");
   detamin=pset.getParameter<double>("Detamin");
   detamax=pset.getParameter<double>("Detamax");
   dphimin=pset.getParameter<double>("Dphimin");
   dphimax=pset.getParameter<double>("Dphimax");
   detamatchmin=pset.getParameter<double>("Detamatchmin");
   detamatchmax=pset.getParameter<double>("Detamatchmax");
   dphimatchmin=pset.getParameter<double>("Dphimatchmin");
   dphimatchmax=pset.getParameter<double>("Dphimatchmax");
   fhitsmax=pset.getParameter<double>("Fhitsmax");
   lhitsmax=pset.getParameter<double>("Lhitsmax");
   nbineta=pset.getParameter<int>("Nbineta");
   nbineta2D=pset.getParameter<int>("Nbineta2D");
   nbinp=pset.getParameter<int>("Nbinp");
   nbinpt=pset.getParameter<int>("Nbinpt");
   nbinp2D=pset.getParameter<int>("Nbinp2D");
   nbinpt2D=pset.getParameter<int>("Nbinpt2D");
   nbinpteff=pset.getParameter<int>("Nbinpteff");
   nbinphi=pset.getParameter<int>("Nbinphi");
   nbinphi2D=pset.getParameter<int>("Nbinphi2D");
   nbineop=pset.getParameter<int>("Nbineop");
   nbineop2D=pset.getParameter<int>("Nbineop2D");
   nbinfhits=pset.getParameter<int>("Nbinfhits");
   nbinlhits=pset.getParameter<int>("Nbinlhits");
   nbinxyz=pset.getParameter<int>("Nbinxyz");
   nbindeta=pset.getParameter<int>("Nbindeta");
   nbindphi=pset.getParameter<int>("Nbindphi");
   nbindetamatch=pset.getParameter<int>("Nbindetamatch");
   nbindphimatch=pset.getParameter<int>("Nbindphimatch");
   nbindetamatch2D=pset.getParameter<int>("Nbindetamatch2D");
   nbindphimatch2D=pset.getParameter<int>("Nbindphimatch2D");
   nbinpoptrue= pset.getParameter<int>("Nbinpoptrue");
   poptruemin=pset.getParameter<double>("Poptruemin");
   poptruemax=pset.getParameter<double>("Poptruemax");
   nbinmee= pset.getParameter<int>("Nbinmee");
   meemin=pset.getParameter<double>("Meemin");
   meemax=pset.getParameter<double>("Meemax");
   nbinhoe= pset.getParameter<int>("Nbinhoe");
   hoemin=pset.getParameter<double>("Hoemin");
   hoemax=pset.getParameter<double>("Hoemax");
  }

GsfElectronMCAnalyzer::~GsfElectronMCAnalyzer ( )

override

Definition at line 1726 of file GsfElectronMCAnalyzer.cc.

 {
 
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
   histfile_->Write();
   histfile_->Close();
 
 }

Member Function Documentation

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

override

Definition at line 1742 of file GsfElectronMCAnalyzer.cc.

 {
   std::cout << "analyzing new event " << std::endl;
   // get electrons
 
   edm::Handle<GsfElectronCollection> gsfElectrons;
   iEvent.getByLabel(electronCollection_,gsfElectrons);
   edm::LogInfo("")<<"\n\n =================> Treating event "<<iEvent.id()<<" Number of electrons "<<gsfElectrons.product()->size();
 
   edm::Handle<GenParticleCollection> genParticles;
   iEvent.getByLabel(mcTruthCollection_, genParticles);
 
   histNum_->Fill((*gsfElectrons).size());
 
   // all rec electrons
   for (reco::GsfElectronCollection::const_iterator gsfIter=gsfElectrons->begin();
    gsfIter!=gsfElectrons->end(); gsfIter++){
     // preselect electrons
     if (gsfIter->pt()>maxPt_ || std::abs(gsfIter->eta())>maxAbsEta_) continue;
     h_ele_EoverP_all     -> Fill( gsfIter->eSuperClusterOverP() );
     h_ele_EseedOP_all     -> Fill( gsfIter->eSeedClusterOverP() );
     h_ele_EoPout_all     -> Fill( gsfIter->eSeedClusterOverPout() );
     h_ele_EeleOPout_all     -> Fill( gsfIter->eEleClusterOverPout() );
     h_ele_dEtaSc_propVtx_all -> Fill(gsfIter->deltaEtaSuperClusterTrackAtVtx());
     h_ele_dPhiSc_propVtx_all -> Fill(gsfIter->deltaPhiSuperClusterTrackAtVtx());
     h_ele_dEtaCl_propOut_all -> Fill(gsfIter->deltaEtaSeedClusterTrackAtCalo());
     h_ele_dPhiCl_propOut_all -> Fill(gsfIter->deltaPhiSeedClusterTrackAtCalo());
     h_ele_HoE_all     -> Fill( gsfIter->hadronicOverEm() );
     double d = gsfIter->vertex().x()*gsfIter->vertex().x()+gsfIter->vertex().y()*gsfIter->vertex().y();
     h_ele_TIP_all     -> Fill( sqrt(d) );
     h_ele_vertexEta_all     -> Fill( gsfIter->eta() );
     h_ele_vertexPt_all      -> Fill( gsfIter->pt() );
     h_ele_Et_all      -> Fill( gsfIter->superCluster()->energy()/cosh(gsfIter->superCluster()->eta()));
     float enrj1=gsfIter->superCluster()->energy();
     // mee
     for (reco::GsfElectronCollection::const_iterator gsfIter2=gsfIter+1;
      gsfIter2!=gsfElectrons->end(); gsfIter2++){
         math::XYZTLorentzVector p12 = (*gsfIter).p4()+(*gsfIter2).p4();
         float mee2 = p12.Dot(p12);
         float enrj2=gsfIter2->superCluster()->energy();
     h_ele_mee_all -> Fill(sqrt(mee2));
         h_ele_E2mnE1vsMee_all->Fill(sqrt(mee2),enrj2-enrj1);
         if (gsfIter->ecalDrivenSeed() && gsfIter2->ecalDrivenSeed()) h_ele_E2mnE1vsMee_egeg_all->Fill(sqrt(mee2),enrj2-enrj1);
     if (gsfIter->charge()*gsfIter2->charge()<0.) {
       h_ele_mee_os -> Fill(sqrt(mee2));
       if (gsfIter->isEB() && gsfIter2->isEB()) h_ele_mee_os_ebeb -> Fill(sqrt(mee2));
       if ((gsfIter->isEB() && gsfIter2->isEE()) || (gsfIter->isEE() && gsfIter2->isEB())) h_ele_mee_os_ebee -> Fill(sqrt(mee2));
       if (gsfIter->isEE() && gsfIter2->isEE()) h_ele_mee_os_eeee -> Fill(sqrt(mee2));
       if ((gsfIter->classification()==GsfElectron::GOLDEN && gsfIter2->classification()==GsfElectron::GOLDEN) ||
          (gsfIter->classification()==GsfElectron::GOLDEN && gsfIter2->classification()==GsfElectron::BIGBREM) ||
          //(gsfIter->classification()==GsfElectron::GOLDEN && gsfIter2->classification()==GsfElectron::OLDNARROW) ||
          (gsfIter->classification()==GsfElectron::BIGBREM && gsfIter2->classification()==GsfElectron::GOLDEN) ||
          (gsfIter->classification()==GsfElectron::BIGBREM && gsfIter2->classification()==GsfElectron::BIGBREM)/* ||
          (gsfIter->classification()==GsfElectron::BIGBREM && gsfIter2->classification()==GsfElectron::OLDNARROW) ||
          (gsfIter->classification()==GsfElectron::OLDNARROW && gsfIter2->classification()==GsfElectron::GOLDEN) ||
          (gsfIter->classification()==GsfElectron::OLDNARROW && gsfIter2->classification()==GsfElectron::BIGBREM) ||
          (gsfIter->classification()==GsfElectron::OLDNARROW && gsfIter2->classification()==GsfElectron::OLDNARROW)*/ )
        { h_ele_mee_os_gg -> Fill(sqrt(mee2));}
       else if (
          (gsfIter->classification()==GsfElectron::SHOWERING && gsfIter2->classification()==GsfElectron::SHOWERING) ||
          (gsfIter->classification()==GsfElectron::SHOWERING && gsfIter2->isGap()) ||
          (gsfIter->isGap() && gsfIter2->classification()==GsfElectron::SHOWERING) ||
          (gsfIter->isGap() && gsfIter2->isGap()))
        { h_ele_mee_os_bb -> Fill(sqrt(mee2));}
       else
        { h_ele_mee_os_gb -> Fill(sqrt(mee2));}
         }
     }
   }
 
   int mcNum=0, gamNum=0, eleNum=0;
   bool matchingID, matchingMotherID;
 
   // charge mis-ID
   for (reco::GenParticleCollection::const_iterator mcIter=genParticles->begin(); mcIter != genParticles->end(); mcIter++ ) {
 
     // select requested matching gen particle
     matchingID=false;
     for (unsigned int i=0; i<matchingIDs_.size(); i++)
      if ( mcIter->pdgId() == matchingIDs_[i] ) matchingID=true;
 
     if (matchingID) {
 
       // select requested mother matching gen particle
       // always include single particle with no mother
       const Candidate * mother = mcIter->mother();
       matchingMotherID=false;
       for (unsigned int i=0; i<matchingMotherIDs_.size(); i++)
         if ((mother == nullptr) || ((mother != nullptr) &&  mother->pdgId() == matchingMotherIDs_[i]) ) matchingMotherID=true;
 
       if (matchingMotherID) {
 
       if (mcIter->pt()> maxPt_ || std::abs(mcIter->eta())> maxAbsEta_) continue;
 
       // suppress the endcaps
       //if (std::abs(mcIter->eta()) > 1.5) continue;
       // select central z
       //if ( std::abs(mcIter->production_vertex()->position().z())>50.) continue;
 
       // looking for the best matching gsf electron
       bool okGsfFound = false;
       double gsfOkRatio = 999999.;
 
       // find best matched electron
       reco::GsfElectron bestGsfElectron;
       for (reco::GsfElectronCollection::const_iterator gsfIter=gsfElectrons->begin();
        gsfIter!=gsfElectrons->end(); gsfIter++){
 
         double dphi = gsfIter->phi()-mcIter->phi();
         if (std::abs(dphi)>CLHEP::pi)
          dphi = dphi < 0? (CLHEP::twopi) + dphi : dphi - CLHEP::twopi;
         double deltaR = sqrt(std::pow((gsfIter->eta()-mcIter->eta()),2) + std::pow(dphi,2));
     if ( deltaR < deltaR_ ){
       double mc_charge = mcIter->pdgId() == 11 ? -1. : 1. ;
       h_ele_ChargeMnChargeTrue  -> Fill( std::abs(gsfIter->charge()-mc_charge));
       // require here a charge mismatch
       if ( ( (mcIter->pdgId() == 11) && (gsfIter->charge() > 0.) ) ||
            ( (mcIter->pdgId() == -11) && (gsfIter->charge() < 0.) ) )
        {
         double tmpGsfRatio = gsfIter->p()/mcIter->p();
         if ( std::abs(tmpGsfRatio-1) < std::abs(gsfOkRatio-1) ) {
           gsfOkRatio = tmpGsfRatio;
           bestGsfElectron=*gsfIter;
           okGsfFound = true;
         }
       }
     }
       } // loop over rec ele to look for the best one
 
       // analysis when the mc track is found
       if (okGsfFound)
        {
 
     // generated distributions for matched electrons
     h_ele_simPt_matched_qmisid      -> Fill( mcIter->pt() );
         h_ele_simPhi_matched_qmisid   -> Fill( mcIter->phi() );
     h_ele_simAbsEta_matched_qmisid     -> Fill( std::abs(mcIter->eta()) );
     h_ele_simEta_matched_qmisid     -> Fill( mcIter->eta() );
     h_ele_simZ_matched_qmisid     -> Fill( mcIter->vz() );
 
        }
       }
     }
 
   }
 
   // association mc-reco
   for (reco::GenParticleCollection::const_iterator mcIter=genParticles->begin(); mcIter != genParticles->end(); mcIter++ ) {
 
     // number of mc particles
     mcNum++;
 
     // counts photons
     if (mcIter->pdgId() == 22 ){ gamNum++; }
 
       // select requested matching gen particle
       matchingID=false;
       for (unsigned int i=0; i<matchingIDs_.size(); i++)
        if ( mcIter->pdgId() == matchingIDs_[i] ) matchingID=true;
 
       if (matchingID) {
 
       // select requested mother matching gen particle
       // always include single particle with no mother
       const Candidate * mother = mcIter->mother();
       matchingMotherID=false;
       for (unsigned int i=0; i<matchingMotherIDs_.size(); i++)
        if ((mother == nullptr) || ((mother != nullptr) &&  mother->pdgId() == matchingMotherIDs_[i]) ) matchingMotherID=true;
 
       if (matchingMotherID) {
 
       if (mcIter->pt()> maxPt_ || std::abs(mcIter->eta())> maxAbsEta_) continue;
 
       // suppress the endcaps
       //if (std::abs(mcIter->eta()) > 1.5) continue;
       // select central z
       //if ( std::abs(mcIter->production_vertex()->position().z())>50.) continue;
 
       eleNum++;
       h_simEta -> Fill( mcIter->eta() );
       h_simAbsEta -> Fill( std::abs(mcIter->eta()) );
       h_simP   -> Fill( mcIter->p() );
       h_simPt   -> Fill( mcIter->pt() );
       h_simPhi   -> Fill( mcIter->phi() );
       h_simZ   -> Fill( mcIter->vz() );
       h_simPtEta   -> Fill( mcIter->eta(),mcIter->pt() );
 
       // looking for the best matching gsf electron
       bool okGsfFound = false;
       double gsfOkRatio = 999999.;
 
       // find best matched electron
       reco::GsfElectron bestGsfElectron;
       for (reco::GsfElectronCollection::const_iterator gsfIter=gsfElectrons->begin();
        gsfIter!=gsfElectrons->end(); gsfIter++){
 
         double dphi = gsfIter->phi()-mcIter->phi();
         if (std::abs(dphi)>CLHEP::pi)
          dphi = dphi < 0? (CLHEP::twopi) + dphi : dphi - CLHEP::twopi;
         double deltaR = sqrt(std::pow((gsfIter->eta()-mcIter->eta()),2) + std::pow(dphi,2));
     if ( deltaR < deltaR_ ){
       if ( ( (mcIter->pdgId() == 11) && (gsfIter->charge() < 0.) ) ||
            ( (mcIter->pdgId() == -11) && (gsfIter->charge() > 0.) ) )
        {
         double tmpGsfRatio = gsfIter->p()/mcIter->p();
         if ( std::abs(tmpGsfRatio-1) < std::abs(gsfOkRatio-1) ) {
           gsfOkRatio = tmpGsfRatio;
           bestGsfElectron=*gsfIter;
           okGsfFound = true;
         }
       }
     }
       } // loop over rec ele to look for the best one
 
       // analysis when the mc track is found
      if (okGsfFound){
 
     // electron related distributions
     h_ele_charge        -> Fill( bestGsfElectron.charge() );
     h_ele_chargeVsEta        -> Fill( bestGsfElectron.eta(),bestGsfElectron.charge() );
     h_ele_chargeVsPhi        -> Fill( bestGsfElectron.phi(),bestGsfElectron.charge() );
     h_ele_chargeVsPt        -> Fill( bestGsfElectron.pt(),bestGsfElectron.charge() );
     h_ele_vertexP       -> Fill( bestGsfElectron.p() );
     h_ele_vertexPt      -> Fill( bestGsfElectron.pt() );
         h_ele_Et      -> Fill( bestGsfElectron.superCluster()->energy()/cosh(bestGsfElectron.superCluster()->eta()));
     h_ele_vertexPtVsEta      -> Fill(  bestGsfElectron.eta(),bestGsfElectron.pt() );
     h_ele_vertexPtVsPhi      -> Fill(  bestGsfElectron.phi(),bestGsfElectron.pt() );
     h_ele_vertexEta     -> Fill( bestGsfElectron.eta() );
     // generated distributions for matched electrons
     h_ele_simPt_matched      -> Fill( mcIter->pt() );
         h_ele_simPhi_matched   -> Fill( mcIter->phi() );
     h_ele_simAbsEta_matched     -> Fill( std::abs(mcIter->eta()) );
     h_ele_simEta_matched     -> Fill( mcIter->eta() );
     h_ele_simPtEta_matched      -> Fill(  mcIter->eta(),mcIter->pt() );
     h_ele_vertexEtaVsPhi     -> Fill(  bestGsfElectron.phi(),bestGsfElectron.eta() );
     h_ele_vertexPhi     -> Fill( bestGsfElectron.phi() );
     h_ele_vertexX     -> Fill( bestGsfElectron.vertex().x() );
     h_ele_vertexY     -> Fill( bestGsfElectron.vertex().y() );
     h_ele_vertexZ     -> Fill( bestGsfElectron.vertex().z() );
         h_ele_simZ_matched   -> Fill( mcIter->vz() );
     double d = (bestGsfElectron.vertex().x()-mcIter->vx())
               *(bestGsfElectron.vertex().x()-mcIter->vx())+
                (bestGsfElectron.vertex().y()-mcIter->vy())
           *(bestGsfElectron.vertex().y()-mcIter->vy());
     d = sqrt(d);
     h_ele_vertexTIP     -> Fill( d );
     h_ele_vertexTIPVsEta     -> Fill(  bestGsfElectron.eta(), d );
     h_ele_vertexTIPVsPhi     -> Fill(  bestGsfElectron.phi(), d );
     h_ele_vertexTIPVsPt     -> Fill(  bestGsfElectron.pt(), d );
     h_ele_EtaMnEtaTrue  -> Fill( bestGsfElectron.eta()-mcIter->eta());
     if (bestGsfElectron.isEB()) h_ele_EtaMnEtaTrue_barrel  -> Fill( bestGsfElectron.eta()-mcIter->eta());
     if (bestGsfElectron.isEE()) h_ele_EtaMnEtaTrue_endcaps  -> Fill( bestGsfElectron.eta()-mcIter->eta());
     h_ele_EtaMnEtaTrueVsEta  -> Fill( bestGsfElectron.eta(), bestGsfElectron.eta()-mcIter->eta());
     h_ele_EtaMnEtaTrueVsPhi  -> Fill( bestGsfElectron.phi(), bestGsfElectron.eta()-mcIter->eta());
     h_ele_EtaMnEtaTrueVsPt  -> Fill( bestGsfElectron.pt(), bestGsfElectron.eta()-mcIter->eta());
     h_ele_PhiMnPhiTrue  -> Fill( bestGsfElectron.phi()-mcIter->phi());
     if (bestGsfElectron.isEB()) h_ele_PhiMnPhiTrue_barrel  -> Fill( bestGsfElectron.phi()-mcIter->phi());
     if (bestGsfElectron.isEE()) h_ele_PhiMnPhiTrue_endcaps  -> Fill( bestGsfElectron.phi()-mcIter->phi());
     h_ele_PhiMnPhiTrue2  -> Fill( bestGsfElectron.phi()-mcIter->phi());
     h_ele_PhiMnPhiTrueVsEta  -> Fill( bestGsfElectron.eta(), bestGsfElectron.phi()-mcIter->phi());
     h_ele_PhiMnPhiTrueVsPhi  -> Fill( bestGsfElectron.phi(), bestGsfElectron.phi()-mcIter->phi());
     h_ele_PhiMnPhiTrueVsPt  -> Fill( bestGsfElectron.pt(), bestGsfElectron.phi()-mcIter->phi());
     h_ele_PoPtrue       -> Fill( bestGsfElectron.p()/mcIter->p());
     h_ele_PtoPttrue       -> Fill( bestGsfElectron.pt()/mcIter->pt());
     h_ele_PoPtrueVsEta       -> Fill( bestGsfElectron.eta(), bestGsfElectron.p()/mcIter->p());
     h_ele_PoPtrueVsPhi       -> Fill( bestGsfElectron.phi(), bestGsfElectron.p()/mcIter->p());
     h_ele_PoPtrueVsPt       -> Fill( bestGsfElectron.py(), bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEB()) h_ele_PoPtrue_barrel       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEE()) h_ele_PoPtrue_endcaps       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEB() && bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PoPtrue_golden_barrel       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEE() && bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PoPtrue_golden_endcaps       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEB() && bestGsfElectron.classification() == GsfElectron::SHOWERING) h_ele_PoPtrue_showering_barrel       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEE() && bestGsfElectron.classification() == GsfElectron::SHOWERING) h_ele_PoPtrue_showering_endcaps       -> Fill( bestGsfElectron.p()/mcIter->p());
     if (bestGsfElectron.isEB()) h_ele_PtoPttrue_barrel       -> Fill( bestGsfElectron.pt()/mcIter->pt());
     if (bestGsfElectron.isEE()) h_ele_PtoPttrue_endcaps       -> Fill( bestGsfElectron.pt()/mcIter->pt());
 
     // supercluster related distributions
     reco::SuperClusterRef sclRef = bestGsfElectron.superCluster();
     if (!bestGsfElectron.ecalDrivenSeed()&&bestGsfElectron.trackerDrivenSeed()) sclRef = bestGsfElectron.parentSuperCluster();
         histSclEn_->Fill(sclRef->energy());
         double R=TMath::Sqrt(sclRef->x()*sclRef->x() + sclRef->y()*sclRef->y() +sclRef->z()*sclRef->z());
         double Rt=TMath::Sqrt(sclRef->x()*sclRef->x() + sclRef->y()*sclRef->y());
         histSclEt_->Fill(sclRef->energy()*(Rt/R));
         histSclEtVsEta_->Fill(sclRef->eta(),sclRef->energy()*(Rt/R));
         histSclEtVsPhi_->Fill(sclRef->phi(),sclRef->energy()*(Rt/R));
         if (bestGsfElectron.isEB())  histSclEoEtrue_barrel->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE())  histSclEoEtrue_endcaps->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.ecalDrivenSeed())  histSclEoEtrue_barrel_eg->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.ecalDrivenSeed())  histSclEoEtrue_endcaps_eg->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.isEBEtaGap())  histSclEoEtrue_barrel_etagap->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.isEBPhiGap())  histSclEoEtrue_barrel_phigap->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEBEEGap())  histSclEoEtrue_ebeegap->Fill(sclRef->energy()/mcIter->p());
         //if (bestGsfElectron.isEE())  histSclEoEtrue_endcaps->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.isEEDeeGap())  histSclEoEtrue_endcaps_deegap->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.isEERingGap())  histSclEoEtrue_endcaps_ringgap->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB())  histSclEoEtrue_barrel_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE())  histSclEoEtrue_endcaps_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.ecalDrivenSeed())  histSclEoEtrue_barrel_eg_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.ecalDrivenSeed())  histSclEoEtrue_endcaps_eg_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.isEBEtaGap())  histSclEoEtrue_barrel_etagap_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEB() && bestGsfElectron.isEBPhiGap())  histSclEoEtrue_barrel_phigap_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEBEEGap())  histSclEoEtrue_ebeegap_new->Fill(sclRef->energy()/mcIter->p());
         //if (bestGsfElectron.isEE())  histSclEoEtrue_endcaps_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.isEEDeeGap())  histSclEoEtrue_endcaps_deegap_new->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.isEE() && bestGsfElectron.isEERingGap())  histSclEoEtrue_endcaps_ringgap_new->Fill(sclRef->energy()/mcIter->p());
         histSclEta_->Fill(sclRef->eta());
         histSclEtaVsPhi_->Fill(sclRef->phi(),sclRef->eta());
         histSclPhi_->Fill(sclRef->phi());
         histSclSigEtaEta_->Fill(bestGsfElectron.scSigmaEtaEta());
         if (bestGsfElectron.isEB()) histSclSigEtaEta_barrel_->Fill(bestGsfElectron.scSigmaEtaEta());
         if (bestGsfElectron.isEE()) histSclSigEtaEta_endcaps_->Fill(bestGsfElectron.scSigmaEtaEta());
         histSclSigIEtaIEta_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         if (bestGsfElectron.isEB()) histSclSigIEtaIEta_barrel_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         if (bestGsfElectron.isEE()) histSclSigIEtaIEta_endcaps_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         histSclE1x5_->Fill(bestGsfElectron.scE1x5());
         if (bestGsfElectron.isEB()) histSclE1x5_barrel_->Fill(bestGsfElectron.scE1x5());
         if (bestGsfElectron.isEE()) histSclE1x5_endcaps_->Fill(bestGsfElectron.scE1x5());
         histSclE2x5max_->Fill(bestGsfElectron.scE2x5Max());
         if (bestGsfElectron.isEB()) histSclE2x5max_barrel_->Fill(bestGsfElectron.scE2x5Max());
         if (bestGsfElectron.isEE()) histSclE2x5max_endcaps_->Fill(bestGsfElectron.scE2x5Max());
         histSclE5x5_->Fill(bestGsfElectron.scE5x5());
         if (bestGsfElectron.isEB()) histSclE5x5_barrel_->Fill(bestGsfElectron.scE5x5());
         if (bestGsfElectron.isEE()) histSclE5x5_endcaps_->Fill(bestGsfElectron.scE5x5());
         if (bestGsfElectron.ecalDrivenSeed()) histSclSigIEtaIEta_eg_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) histSclSigIEtaIEta_eg_barrel_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) histSclSigIEtaIEta_eg_endcaps_->Fill(bestGsfElectron.scSigmaIEtaIEta());
         if (bestGsfElectron.ecalDrivenSeed())histSclE1x5_eg_->Fill(bestGsfElectron.scE1x5());
         if (bestGsfElectron.isEB() && bestGsfElectron.ecalDrivenSeed())histSclE1x5_eg_barrel_->Fill(bestGsfElectron.scE1x5());
         if (bestGsfElectron.isEE() && bestGsfElectron.ecalDrivenSeed())histSclE1x5_eg_endcaps_->Fill(bestGsfElectron.scE1x5());
         if (bestGsfElectron.ecalDrivenSeed())histSclE2x5max_eg_->Fill(bestGsfElectron.scE2x5Max());
         if (bestGsfElectron.isEB() && bestGsfElectron.ecalDrivenSeed())histSclE2x5max_eg_barrel_->Fill(bestGsfElectron.scE2x5Max());
         if (bestGsfElectron.isEE() && bestGsfElectron.ecalDrivenSeed())histSclE2x5max_eg_endcaps_->Fill(bestGsfElectron.scE2x5Max());
         if (bestGsfElectron.ecalDrivenSeed())histSclE5x5_eg_->Fill(bestGsfElectron.scE5x5());
         if (bestGsfElectron.isEB() && bestGsfElectron.ecalDrivenSeed())histSclE5x5_eg_barrel_->Fill(bestGsfElectron.scE5x5());
         if (bestGsfElectron.isEE() && bestGsfElectron.ecalDrivenSeed())histSclE5x5_eg_endcaps_->Fill(bestGsfElectron.scE5x5());
         float pfEnergy=0., egEnergy=0.;
     if (!bestGsfElectron.superCluster().isNull()) egEnergy = bestGsfElectron.superCluster()->energy();
     if (!bestGsfElectron.parentSuperCluster().isNull()) pfEnergy = bestGsfElectron.parentSuperCluster()->energy();
     histSclEoEtruePfVsEg->Fill(egEnergy/mcIter->p(),pfEnergy/mcIter->p());
 
     // track related distributions
     h_ele_ambiguousTracks     -> Fill( bestGsfElectron.ambiguousGsfTracksSize() );
     h_ele_ambiguousTracksVsEta     -> Fill( bestGsfElectron.eta(), bestGsfElectron.ambiguousGsfTracksSize() );
     h_ele_ambiguousTracksVsPhi     -> Fill( bestGsfElectron.phi(), bestGsfElectron.ambiguousGsfTracksSize() );
     h_ele_ambiguousTracksVsPt     -> Fill( bestGsfElectron.pt(), bestGsfElectron.ambiguousGsfTracksSize() );
     if (!readAOD_) { // track extra does not exist in AOD
       h_ele_foundHits     -> Fill( bestGsfElectron.gsfTrack()->numberOfValidHits() );
       if (bestGsfElectron.isEB()) h_ele_foundHits_barrel     -> Fill( bestGsfElectron.gsfTrack()->numberOfValidHits() );
       if (bestGsfElectron.isEE()) h_ele_foundHits_endcaps     -> Fill( bestGsfElectron.gsfTrack()->numberOfValidHits() );
       h_ele_foundHitsVsEta     -> Fill( bestGsfElectron.eta(), bestGsfElectron.gsfTrack()->numberOfValidHits() );
       h_ele_foundHitsVsPhi     -> Fill( bestGsfElectron.phi(), bestGsfElectron.gsfTrack()->numberOfValidHits() );
       h_ele_foundHitsVsPt     -> Fill( bestGsfElectron.pt(), bestGsfElectron.gsfTrack()->numberOfValidHits() );
       h_ele_lostHits      -> Fill( bestGsfElectron.gsfTrack()->numberOfLostHits() );
       if (bestGsfElectron.isEB()) h_ele_lostHits_barrel      -> Fill( bestGsfElectron.gsfTrack()->numberOfLostHits() );
       if (bestGsfElectron.isEE()) h_ele_lostHits_endcaps      -> Fill( bestGsfElectron.gsfTrack()->numberOfLostHits() );
       h_ele_lostHitsVsEta      -> Fill( bestGsfElectron.eta(), bestGsfElectron.gsfTrack()->numberOfLostHits() );
       h_ele_lostHitsVsPhi      -> Fill( bestGsfElectron.phi(), bestGsfElectron.gsfTrack()->numberOfLostHits() );
       h_ele_lostHitsVsPt      -> Fill( bestGsfElectron.pt(), bestGsfElectron.gsfTrack()->numberOfLostHits() );
       h_ele_chi2          -> Fill( bestGsfElectron.gsfTrack()->normalizedChi2() );
       if (bestGsfElectron.isEB()) h_ele_chi2_barrel          -> Fill( bestGsfElectron.gsfTrack()->normalizedChi2() );
       if (bestGsfElectron.isEE()) h_ele_chi2_endcaps          -> Fill( bestGsfElectron.gsfTrack()->normalizedChi2() );
       h_ele_chi2VsEta          -> Fill( bestGsfElectron.eta(), bestGsfElectron.gsfTrack()->normalizedChi2() );
       h_ele_chi2VsPhi          -> Fill( bestGsfElectron.phi(), bestGsfElectron.gsfTrack()->normalizedChi2() );
       h_ele_chi2VsPt          -> Fill( bestGsfElectron.pt(), bestGsfElectron.gsfTrack()->normalizedChi2() );
     }
     // from gsf track interface, hence using mean
     if (!readAOD_) { // track extra does not exist in AOD
       h_ele_PinMnPout     -> Fill( bestGsfElectron.gsfTrack()->innerMomentum().R() - bestGsfElectron.gsfTrack()->outerMomentum().R() );
       h_ele_outerP        -> Fill( bestGsfElectron.gsfTrack()->outerMomentum().R() );
       h_ele_outerPt       -> Fill( bestGsfElectron.gsfTrack()->outerMomentum().Rho() );
         }
     // from electron interface, hence using mode
     h_ele_PinMnPout_mode     -> Fill( bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     h_ele_PinMnPoutVsEta_mode     -> Fill(  bestGsfElectron.eta(), bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     h_ele_PinMnPoutVsPhi_mode     -> Fill(  bestGsfElectron.phi(), bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     h_ele_PinMnPoutVsPt_mode     -> Fill(  bestGsfElectron.pt(), bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     h_ele_PinMnPoutVsE_mode     -> Fill(  bestGsfElectron.caloEnergy(), bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     if (!readAOD_)  // track extra does not exist in AOD
      h_ele_PinMnPoutVsChi2_mode     -> Fill(  bestGsfElectron.gsfTrack()->normalizedChi2(), bestGsfElectron.trackMomentumAtVtx().R() - bestGsfElectron.trackMomentumOut().R() );
     h_ele_outerP_mode        -> Fill( bestGsfElectron.trackMomentumOut().R() );
     h_ele_outerPVsEta_mode        -> Fill(bestGsfElectron.eta(),  bestGsfElectron.trackMomentumOut().R() );
     h_ele_outerPt_mode       -> Fill( bestGsfElectron.trackMomentumOut().Rho() );
     h_ele_outerPtVsEta_mode       -> Fill(bestGsfElectron.eta(),  bestGsfElectron.trackMomentumOut().Rho() );
     h_ele_outerPtVsPhi_mode       -> Fill(bestGsfElectron.phi(),  bestGsfElectron.trackMomentumOut().Rho() );
     h_ele_outerPtVsPt_mode       -> Fill(bestGsfElectron.pt(),  bestGsfElectron.trackMomentumOut().Rho() );
 
     if (!readAOD_) { // track extra does not exist in AOD
           edm::RefToBase<TrajectorySeed> seed = bestGsfElectron.gsfTrack()->extra()->seedRef();
       ElectronSeedRef elseed=seed.castTo<ElectronSeedRef>();
       h_ele_seed_dphi2_-> Fill(elseed->dPhi2());
           h_ele_seed_dphi2VsEta_-> Fill(bestGsfElectron.eta(), elseed->dPhi2());
           h_ele_seed_dphi2VsPt_-> Fill(bestGsfElectron.pt(), elseed->dPhi2()) ;
           h_ele_seed_drz2_-> Fill(elseed->dRz2());
           h_ele_seed_drz2VsEta_-> Fill(bestGsfElectron.eta(), elseed->dRz2());
           h_ele_seed_drz2VsPt_-> Fill(bestGsfElectron.pt(), elseed->dRz2());
           h_ele_seed_subdet2_-> Fill(elseed->subDet2());
         }
     // match distributions
     h_ele_EoP    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_EoP_eg    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     if (bestGsfElectron.isEB()) h_ele_EoP_barrel    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EoP_eg_barrel    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     if (bestGsfElectron.isEE()) h_ele_EoP_endcaps    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EoP_eg_endcaps    -> Fill( bestGsfElectron.eSuperClusterOverP() );
     h_ele_EoPVsEta    -> Fill(bestGsfElectron.eta(),  bestGsfElectron.eSuperClusterOverP() );
     h_ele_EoPVsPhi    -> Fill(bestGsfElectron.phi(),  bestGsfElectron.eSuperClusterOverP() );
     h_ele_EoPVsE    -> Fill(bestGsfElectron.caloEnergy(),  bestGsfElectron.eSuperClusterOverP() );
     h_ele_EseedOP    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_EseedOP_eg    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     if (bestGsfElectron.isEB()) h_ele_EseedOP_barrel    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EseedOP_eg_barrel    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     if (bestGsfElectron.isEE()) h_ele_EseedOP_endcaps    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EseedOP_eg_endcaps    -> Fill( bestGsfElectron.eSeedClusterOverP() );
     h_ele_EseedOPVsEta    -> Fill(bestGsfElectron.eta(),  bestGsfElectron.eSeedClusterOverP() );
     h_ele_EseedOPVsPhi    -> Fill(bestGsfElectron.phi(),  bestGsfElectron.eSeedClusterOverP() );
     h_ele_EseedOPVsE    -> Fill(bestGsfElectron.caloEnergy(),  bestGsfElectron.eSeedClusterOverP() );
     h_ele_EoPout -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_EoPout_eg -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     if (bestGsfElectron.isEB()) h_ele_EoPout_barrel -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EoPout_eg_barrel -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     if (bestGsfElectron.isEE()) h_ele_EoPout_endcaps -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EoPout_eg_endcaps -> Fill( bestGsfElectron.eSeedClusterOverPout() );
     h_ele_EoPoutVsEta -> Fill( bestGsfElectron.eta(), bestGsfElectron.eSeedClusterOverPout() );
     h_ele_EoPoutVsPhi -> Fill( bestGsfElectron.phi(), bestGsfElectron.eSeedClusterOverPout() );
     h_ele_EoPoutVsE -> Fill( bestGsfElectron.caloEnergy(), bestGsfElectron.eSeedClusterOverPout() );
     h_ele_EeleOPout -> Fill( bestGsfElectron.eEleClusterOverPout() );
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_EeleOPout_eg -> Fill( bestGsfElectron.eEleClusterOverPout() );
     if (bestGsfElectron.isEB()) h_ele_EeleOPout_barrel -> Fill( bestGsfElectron.eEleClusterOverPout() );
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EeleOPout_eg_barrel -> Fill( bestGsfElectron.eEleClusterOverPout() );
     if (bestGsfElectron.isEE()) h_ele_EeleOPout_endcaps -> Fill( bestGsfElectron.eEleClusterOverPout() );
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_EeleOPout_eg_endcaps -> Fill( bestGsfElectron.eEleClusterOverPout() );
     h_ele_EeleOPoutVsEta -> Fill( bestGsfElectron.eta(), bestGsfElectron.eEleClusterOverPout() );
     h_ele_EeleOPoutVsPhi -> Fill( bestGsfElectron.phi(), bestGsfElectron.eEleClusterOverPout() );
     h_ele_EeleOPoutVsE -> Fill( bestGsfElectron.caloEnergy(), bestGsfElectron.eEleClusterOverPout() );
     h_ele_dEtaSc_propVtx -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaSc_propVtx_eg -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEB()) h_ele_dEtaSc_propVtx_barrel -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaSc_propVtx_eg_barrel -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEE())h_ele_dEtaSc_propVtx_endcaps -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaSc_propVtx_eg_endcaps -> Fill(bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     h_ele_dEtaScVsEta_propVtx -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     h_ele_dEtaScVsPhi_propVtx -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     h_ele_dEtaScVsPt_propVtx -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaEtaSuperClusterTrackAtVtx());
     h_ele_dPhiSc_propVtx -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiSc_propVtx_eg -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEB()) h_ele_dPhiSc_propVtx_barrel -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiSc_propVtx_eg_barrel -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEE())h_ele_dPhiSc_propVtx_endcaps -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiSc_propVtx_eg_endcaps -> Fill(bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     h_ele_dPhiScVsEta_propVtx -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     h_ele_dPhiScVsPhi_propVtx -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     h_ele_dPhiScVsPt_propVtx -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaPhiSuperClusterTrackAtVtx());
     h_ele_dEtaCl_propOut -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaCl_propOut_eg -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEB()) h_ele_dEtaCl_propOut_barrel -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaCl_propOut_eg_barrel -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEE()) h_ele_dEtaCl_propOut_endcaps -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaCl_propOut_eg_endcaps -> Fill(bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     h_ele_dEtaClVsEta_propOut -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     h_ele_dEtaClVsPhi_propOut -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     h_ele_dEtaClVsPt_propOut -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaEtaSeedClusterTrackAtCalo());
     h_ele_dPhiCl_propOut -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiCl_propOut_eg -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEB()) h_ele_dPhiCl_propOut_barrel -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiCl_propOut_eg_barrel -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEE()) h_ele_dPhiCl_propOut_endcaps -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiCl_propOut_eg_endcaps -> Fill(bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     h_ele_dPhiClVsEta_propOut -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     h_ele_dPhiClVsPhi_propOut -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     h_ele_dPhiClVsPt_propOut -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaPhiSeedClusterTrackAtCalo());
     h_ele_dEtaEleCl_propOut -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaEleCl_propOut_eg -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     if (bestGsfElectron.isEB()) h_ele_dEtaEleCl_propOut_barrel -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaEleCl_propOut_eg_barrel -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     if (bestGsfElectron.isEE()) h_ele_dEtaEleCl_propOut_endcaps -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dEtaEleCl_propOut_eg_endcaps -> Fill(bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     h_ele_dEtaEleClVsEta_propOut -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     h_ele_dEtaEleClVsPhi_propOut -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     h_ele_dEtaEleClVsPt_propOut -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaEtaEleClusterTrackAtCalo());
     h_ele_dPhiEleCl_propOut -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiEleCl_propOut_eg -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     if (bestGsfElectron.isEB()) h_ele_dPhiEleCl_propOut_barrel -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiEleCl_propOut_eg_barrel -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     if (bestGsfElectron.isEE()) h_ele_dPhiEleCl_propOut_endcaps -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_dPhiEleCl_propOut_eg_endcaps -> Fill(bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     h_ele_dPhiEleClVsEta_propOut -> Fill( bestGsfElectron.eta(),bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     h_ele_dPhiEleClVsPhi_propOut -> Fill(bestGsfElectron.phi(),bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     h_ele_dPhiEleClVsPt_propOut -> Fill(bestGsfElectron.pt(),bestGsfElectron.deltaPhiEleClusterTrackAtCalo());
     h_ele_HoE -> Fill(bestGsfElectron.hadronicOverEm());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_HoE_eg -> Fill(bestGsfElectron.hadronicOverEm());
     if (bestGsfElectron.isEB()) h_ele_HoE_barrel -> Fill(bestGsfElectron.hadronicOverEm());
     if (bestGsfElectron.isEB()&&bestGsfElectron.ecalDrivenSeed()) h_ele_HoE_eg_barrel -> Fill(bestGsfElectron.hadronicOverEm());
     if (bestGsfElectron.isEE()) h_ele_HoE_endcaps -> Fill(bestGsfElectron.hadronicOverEm());
     if (bestGsfElectron.isEE()&&bestGsfElectron.ecalDrivenSeed()) h_ele_HoE_eg_endcaps -> Fill(bestGsfElectron.hadronicOverEm());
     if (!bestGsfElectron.isEBEtaGap() && !bestGsfElectron.isEBPhiGap()&& !bestGsfElectron.isEBEEGap() &&
         !bestGsfElectron.isEERingGap() && !bestGsfElectron.isEEDeeGap()) h_ele_HoE_fiducial -> Fill(bestGsfElectron.hadronicOverEm());
     h_ele_HoEVsEta -> Fill( bestGsfElectron.eta(),bestGsfElectron.hadronicOverEm());
     h_ele_HoEVsPhi -> Fill(bestGsfElectron.phi(),bestGsfElectron.hadronicOverEm());
     h_ele_HoEVsE -> Fill(bestGsfElectron.caloEnergy(),bestGsfElectron.hadronicOverEm());
 
     //classes
     int eleClass = bestGsfElectron.classification();
     if (bestGsfElectron.isEE()) eleClass+=10;
     h_ele_classes ->Fill(eleClass);
 
         if (bestGsfElectron.classification() == GsfElectron::GOLDEN && bestGsfElectron.isEB())  histSclEoEtrueGolden_barrel->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.classification() == GsfElectron::GOLDEN && bestGsfElectron.isEE())  histSclEoEtrueGolden_endcaps->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.classification() == GsfElectron::SHOWERING && bestGsfElectron.isEB())  histSclEoEtrueShowering_barrel->Fill(sclRef->energy()/mcIter->p());
         if (bestGsfElectron.classification() == GsfElectron::SHOWERING && bestGsfElectron.isEE())  histSclEoEtrueShowering_endcaps->Fill(sclRef->energy()/mcIter->p());
 
     //eleClass = eleClass%100; // get rid of barrel/endcap distinction
   h_ele_eta->Fill(std::abs(bestGsfElectron.eta()));
   if (bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_eta_golden ->Fill(std::abs(bestGsfElectron.eta()));
   if (bestGsfElectron.classification() == GsfElectron::BIGBREM) h_ele_eta_bbrem ->Fill(std::abs(bestGsfElectron.eta()));
   //if (bestGsfElectron.classification() == GsfElectron::NARROW) h_ele_eta_narrow ->Fill(std::abs(bestGsfElectron.eta()));
   if (bestGsfElectron.classification() == GsfElectron::SHOWERING) h_ele_eta_shower ->Fill(std::abs(bestGsfElectron.eta()));
 
     //fbrem
     double fbrem_mean=0.;
     if (!readAOD_) // track extra does not exist in AOD
      fbrem_mean =  1. - bestGsfElectron.gsfTrack()->outerMomentum().R()/bestGsfElectron.gsfTrack()->innerMomentum().R();
     double fbrem_mode =  bestGsfElectron.fbrem();
     h_ele_fbrem->Fill(fbrem_mode);
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_fbrem_eg->Fill(fbrem_mode);
     h_ele_fbremVsEta_mode->Fill(bestGsfElectron.eta(),fbrem_mode);
     if (!readAOD_) // track extra does not exist in AOD
      h_ele_fbremVsEta_mean->Fill(bestGsfElectron.eta(),fbrem_mean);
 
         if (bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PinVsPoutGolden_mode -> Fill(bestGsfElectron.trackMomentumOut().R(), bestGsfElectron.trackMomentumAtVtx().R());
         if (bestGsfElectron.classification() == GsfElectron::SHOWERING)
      h_ele_PinVsPoutShowering_mode -> Fill(bestGsfElectron.trackMomentumOut().R(), bestGsfElectron.trackMomentumAtVtx().R());
         if (!readAOD_) { // track extra not available in AOD
           if (bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PinVsPoutGolden_mean -> Fill(bestGsfElectron.gsfTrack()->outerMomentum().R(), bestGsfElectron.gsfTrack()->innerMomentum().R());
           if (bestGsfElectron.classification() == GsfElectron::SHOWERING)
        h_ele_PinVsPoutShowering_mean ->  Fill(bestGsfElectron.gsfTrack()->outerMomentum().R(), bestGsfElectron.gsfTrack()->innerMomentum().R());
         }
     if (bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PtinVsPtoutGolden_mode -> Fill(bestGsfElectron.trackMomentumOut().Rho(), bestGsfElectron.trackMomentumAtVtx().Rho());
         if (bestGsfElectron.classification() == GsfElectron::SHOWERING)
      h_ele_PtinVsPtoutShowering_mode -> Fill(bestGsfElectron.trackMomentumOut().Rho(), bestGsfElectron.trackMomentumAtVtx().Rho());
         if (!readAOD_) { // track extra not available in AOD
       if (bestGsfElectron.classification() == GsfElectron::GOLDEN) h_ele_PtinVsPtoutGolden_mean -> Fill(bestGsfElectron.gsfTrack()->outerMomentum().Rho(), bestGsfElectron.gsfTrack()->innerMomentum().Rho());
           if (bestGsfElectron.classification() == GsfElectron::SHOWERING)
        h_ele_PtinVsPtoutShowering_mean ->  Fill(bestGsfElectron.gsfTrack()->outerMomentum().Rho(), bestGsfElectron.gsfTrack()->innerMomentum().Rho());
         }
 
         h_ele_mva->Fill(bestGsfElectron.mva_e_pi());
         if (bestGsfElectron.ecalDrivenSeed()) h_ele_mva_eg->Fill(bestGsfElectron.mva_e_pi());
     if (bestGsfElectron.ecalDrivenSeed()) h_ele_provenance->Fill(1.);
     if (bestGsfElectron.trackerDrivenSeed()) h_ele_provenance->Fill(-1.);
     if (bestGsfElectron.trackerDrivenSeed()||bestGsfElectron.ecalDrivenSeed()) h_ele_provenance->Fill(0.);
     if (bestGsfElectron.trackerDrivenSeed()&&!bestGsfElectron.ecalDrivenSeed()) h_ele_provenance->Fill(-2.);
     if (!bestGsfElectron.trackerDrivenSeed()&&bestGsfElectron.ecalDrivenSeed()) h_ele_provenance->Fill(2.);
 
         h_ele_tkSumPt_dr03->Fill(bestGsfElectron.dr03TkSumPt());
         h_ele_ecalRecHitSumEt_dr03->Fill(bestGsfElectron.dr03EcalRecHitSumEt());
         h_ele_hcalDepth1TowerSumEt_dr03->Fill(bestGsfElectron.dr03HcalDepth1TowerSumEt());
         h_ele_hcalDepth2TowerSumEt_dr03->Fill(bestGsfElectron.dr03HcalDepth2TowerSumEt());
         h_ele_tkSumPt_dr04->Fill(bestGsfElectron.dr04TkSumPt());
         h_ele_ecalRecHitSumEt_dr04->Fill(bestGsfElectron.dr04EcalRecHitSumEt());
         h_ele_hcalDepth1TowerSumEt_dr04->Fill(bestGsfElectron.dr04HcalDepth1TowerSumEt());
         h_ele_hcalDepth2TowerSumEt_dr04->Fill(bestGsfElectron.dr04HcalDepth2TowerSumEt());
 
       } // gsf electron found
 
     } // mc particle found
 
     }
 
   } // loop over mc particle
 
   h_mcNum->Fill(mcNum);
   h_eleNum->Fill(eleNum);
 
 }

void GsfElectronMCAnalyzer::beginJob ( void )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 115 of file GsfElectronMCAnalyzer.cc.

References phimax, and phimin.

                                     {
 
   histfile_->cd();
 
   // mc truth
   h_mcNum              = new TH1F( "h_mcNum",              "# mc particles",    nbinfhits,0.,fhitsmax );
   h_mcNum->Sumw2();
   h_eleNum             = new TH1F( "h_mcNum_ele",             "# mc electrons",             nbinfhits,0.,fhitsmax);
   h_eleNum->Sumw2();
   h_gamNum             = new TH1F( "h_mcNum_gam",             "# mc gammas",             nbinfhits,0.,fhitsmax);
   h_gamNum->Sumw2();
 
   // rec event
   histNum_= new TH1F("h_recEleNum","# rec electrons",20, 0.,20.);
 
   // mc
   h_simEta             = new TH1F( "h_mc_eta",             "gen #eta",           nbineta,etamin,etamax);
   h_simEta->Sumw2();
   h_simAbsEta             = new TH1F( "h_mc_abseta",             "gen |#eta|",           nbineta/2,0.,etamax);
   h_simAbsEta->Sumw2();
   h_simP               = new TH1F( "h_mc_P",               "gen p",              nbinp,0.,pmax);
   h_simP->Sumw2();
   h_simPt               = new TH1F( "h_mc_Pt",               "gen pt",            nbinpteff,5.,ptmax);
   h_simPt->Sumw2();
   h_simPhi               = new TH1F( "h_mc_phi",               "gen phi",        nbinphi,phimin,phimax);
   h_simPhi->Sumw2();
   h_simZ      = new TH1F( "h_mc_z",      "gen z ",    nbinxyz, -25, 25 );
   h_simZ->Sumw2();
   h_simPtEta           = new TH2F( "h_mc_pteta",   "gen pt vs #eta", nbineta2D,etamin,etamax, nbinpt2D,5.,ptmax );
   h_simPtEta->Sumw2();
 
   // all electrons
   h_ele_EoverP_all       = new TH1F( "h_ele_EoverP_all",       "ele E/P_{vertex}, all reco electrons",  nbineop,0.,eopmax);
   h_ele_EoverP_all->Sumw2();
   h_ele_EoverP_all_barrel       = new TH1F( "h_ele_EoverP_all_barrel",       "ele E/P_{vertex}, all reco electrons, barrel",  nbineop,0.,eopmax);
   h_ele_EoverP_all_barrel->Sumw2();
   h_ele_EoverP_all_endcaps       = new TH1F( "h_ele_EoverP_all_endcaps",       "ele E/P_{vertex}, all reco electrons, endcaps",  nbineop,0.,eopmax);
   h_ele_EoverP_all_endcaps->Sumw2();
   h_ele_EseedOP_all            = new TH1F( "h_ele_EseedOP_all",            "ele E_{seed}/P_{vertex}, all reco electrons",        nbineop,0.,eopmax);
   h_ele_EseedOP_all->Sumw2();
   h_ele_EseedOP_all_barrel            = new TH1F( "h_ele_EseedOP_all_barrel",            "ele E_{seed}/P_{vertex}, all reco electrons, barrel",        nbineop,0.,eopmax);
   h_ele_EseedOP_all_barrel->Sumw2();
   h_ele_EseedOP_all_endcaps            = new TH1F( "h_ele_EseedOP_all_endcaps",            "ele E_{seed}/P_{vertex}, all reco electrons, endcaps",        nbineop,0.,eopmax);
   h_ele_EseedOP_all_endcaps->Sumw2();
   h_ele_EoPout_all         = new TH1F( "h_ele_EoPout_all",         "ele E_{seed}/P_{out}, all reco electrons",           nbineop,0.,eopmax);
   h_ele_EoPout_all->Sumw2();
   h_ele_EoPout_all_barrel         = new TH1F( "h_ele_EoPout_all_barrel",         "ele E_{seed}/P_{out}, all reco electrons barrel",           nbineop,0.,eopmax);
   h_ele_EoPout_all_barrel->Sumw2();
   h_ele_EoPout_all_endcaps         = new TH1F( "h_ele_EoPout_all_endcaps",         "ele E_{seed}/P_{out}, all reco electrons endcaps",           nbineop,0.,eopmax);
   h_ele_EoPout_all_endcaps->Sumw2();
   h_ele_EeleOPout_all         = new TH1F( "h_ele_EeleOPout_all",         "ele E_{ele}/P_{out}, all reco electrons",           nbineop,0.,eopmax);
   h_ele_EeleOPout_all->Sumw2();
   h_ele_EeleOPout_all_barrel         = new TH1F( "h_ele_EeleOPout_all_barrel",         "ele E_{ele}/P_{out}, all reco electrons barrel",           nbineop,0.,eopmax);
   h_ele_EeleOPout_all_barrel->Sumw2();
   h_ele_EeleOPout_all_endcaps         = new TH1F( "h_ele_EeleOPout_all_endcaps",         "ele E_{ele}/P_{out}, all reco electrons endcaps",           nbineop,0.,eopmax);
   h_ele_EeleOPout_all_endcaps->Sumw2();
   h_ele_dEtaSc_propVtx_all = new TH1F( "h_ele_dEtaSc_propVtx_all", "ele #eta_{sc} - #eta_{tr}, prop from vertex, all reco electrons",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_all->Sumw2();
   h_ele_dEtaSc_propVtx_all_barrel = new TH1F( "h_ele_dEtaSc_propVtx_all_barrel", "ele #eta_{sc} - #eta_{tr}, prop from vertex, all reco electrons barrel",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_all_barrel->Sumw2();
   h_ele_dEtaSc_propVtx_all_endcaps = new TH1F( "h_ele_dEtaSc_propVtx_all_endcaps", "ele #eta_{sc} - #eta_{tr}, prop from vertex, all reco electrons endcaps",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_all_endcaps->Sumw2();
   h_ele_dPhiSc_propVtx_all = new TH1F( "h_ele_dPhiSc_propVtx_all", "ele #phi_{sc} - #phi_{tr}, prop from vertex, all reco electrons",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_all->Sumw2();
   h_ele_dPhiSc_propVtx_all_barrel = new TH1F( "h_ele_dPhiSc_propVtx_all_barrel", "ele #phi_{sc} - #phi_{tr}, prop from vertex, all reco electrons barrel",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_all_barrel->Sumw2();
   h_ele_dPhiSc_propVtx_all_endcaps = new TH1F( "h_ele_dPhiSc_propVtx_all_endcaps", "ele #phi_{sc} - #phi_{tr}, prop from vertex, all reco electrons endcaps",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_all_endcaps->Sumw2();
   h_ele_dEtaCl_propOut_all = new TH1F( "h_ele_dEtaCl_propOut_all", "ele #eta_{cl} - #eta_{tr}, prop from outermost, all reco electrons",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_all->Sumw2();
   h_ele_dEtaCl_propOut_all_barrel = new TH1F( "h_ele_dEtaCl_propOut_all_barrel", "ele #eta_{cl} - #eta_{tr}, prop from outermost, all reco electrons barrel",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_all_barrel->Sumw2();
   h_ele_dEtaCl_propOut_all_endcaps = new TH1F( "h_ele_dEtaCl_propOut_all_endcaps", "ele #eta_{cl} - #eta_{tr}, prop from outermost, all reco electrons endcaps",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_all_endcaps->Sumw2();
   h_ele_dPhiCl_propOut_all = new TH1F( "h_ele_dPhiCl_propOut_all", "ele #phi_{cl} - #phi_{tr}, prop from outermost, all reco electrons",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_all->Sumw2();
   h_ele_dPhiCl_propOut_all_barrel = new TH1F( "h_ele_dPhiCl_propOut_all_barrel", "ele #phi_{cl} - #phi_{tr}, prop from outermost, all reco electrons barrel",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_all_endcaps = new TH1F( "h_ele_dPhiCl_propOut_all_endcaps", "ele #phi_{cl} - #phi_{tr}, prop from outermost, all reco electrons endcaps",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_all_barrel->Sumw2();
   h_ele_dPhiCl_propOut_all_endcaps->Sumw2();
   h_ele_HoE_all = new TH1F("h_ele_HoE_all", "ele hadronic energy / em energy, all reco electrons", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_all->Sumw2();
   h_ele_HoE_all_barrel = new TH1F("h_ele_HoE_all_barrel", "ele hadronic energy / em energy, all reco electrons barrel", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_all_barrel->Sumw2();
   h_ele_HoE_all_endcaps = new TH1F("h_ele_HoE_all_endcaps", "ele hadronic energy / em energy, all reco electrons endcaps", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_all_endcaps->Sumw2();
   h_ele_vertexPt_all       = new TH1F( "h_ele_vertexPt_all",       "ele p_{T}, all reco electrons",  nbinpteff,5.,ptmax);
   h_ele_vertexPt_all->Sumw2();
   h_ele_Et_all       = new TH1F( "h_ele_Et_all",       "ele SC E_{T}, all reco electrons",  nbinpteff,5.,ptmax);
   h_ele_Et_all->Sumw2();
   h_ele_vertexEta_all      = new TH1F( "h_ele_vertexEta_all",      "ele eta, all reco electrons",    nbineta,etamin,etamax);
   h_ele_vertexEta_all->Sumw2();
   h_ele_TIP_all       = new TH1F( "h_ele_TIP_all",       "ele vertex transverse radius, all reco electrons",  100,0.,0.2);
   h_ele_TIP_all->Sumw2();
   h_ele_TIP_all_barrel       = new TH1F( "h_ele_TIP_all_barrel",       "ele vertex transverse radius, all reco electrons barrel",  100,0.,0.2);
   h_ele_TIP_all_barrel->Sumw2();
   h_ele_TIP_all_endcaps       = new TH1F( "h_ele_TIP_all_endcaps",       "ele vertex transverse radius, all reco electrons endcaps",  100,0.,0.2);
   h_ele_TIP_all_endcaps->Sumw2();
   h_ele_mee_all      = new TH1F( "h_ele_mee_all", "ele pairs invariant mass, all reco electrons", nbinmee, meemin, meemax );
   h_ele_mee_all->Sumw2();
   h_ele_mee_os      = new TH1F( "h_ele_mee_os", "ele pairs invariant mass, opp. sign", nbinmee, meemin, meemax );
   h_ele_mee_os->Sumw2();
   h_ele_mee_os_ebeb      = new TH1F( "h_ele_mee_os_ebeb", "ele pairs invariant mass, opp. sign, EB-EB", nbinmee, meemin, meemax );
   h_ele_mee_os_ebeb->Sumw2();
   h_ele_mee_os_ebee      = new TH1F( "h_ele_mee_os_ebee", "ele pairs invariant mass, opp. sign, EB-EE", nbinmee, meemin, meemax );
   h_ele_mee_os_ebee->Sumw2();
   h_ele_mee_os_eeee      = new TH1F( "h_ele_mee_os_eeee", "ele pairs invariant mass, opp. sign, EE-EE", nbinmee, meemin, meemax );
   h_ele_mee_os_eeee->Sumw2();
   h_ele_mee_os_gg      = new TH1F( "h_ele_mee_os_gg", "ele pairs invariant mass, opp. sign, good-good", nbinmee, meemin, meemax );
   h_ele_mee_os_gg->Sumw2();
   h_ele_mee_os_gb      = new TH1F( "h_ele_mee_os_gb", "ele pairs invariant mass, opp. sign, good-bad", nbinmee, meemin, meemax );
   h_ele_mee_os_gb->Sumw2();
   h_ele_mee_os_bb      = new TH1F( "h_ele_mee_os_bb", "ele pairs invariant mass, opp. sign, bad-bad", nbinmee, meemin, meemax );
   h_ele_mee_os_bb->Sumw2();
 
   // duplicates
   h_ele_E2mnE1vsMee_all = new TH2F("h_ele_E2mnE1vsMee_all", "E2 - E1 vs ele pairs invariant mass, all electrons", nbinmee, meemin, meemax, 100, -50., 50. );
   h_ele_E2mnE1vsMee_egeg_all = new TH2F("h_ele_E2mnE1vsMee_egeg_all", "E2 - E1 vs ele pairs invariant mass, ecal driven pairs, all electrons", nbinmee, meemin, meemax, 100, -50., 50. );
 
   // charge ID
   h_ele_ChargeMnChargeTrue   = new TH1F( "h_ele_ChargeMnChargeTrue",   "ele charge - gen charge ",5,-1.,4.);
   h_ele_ChargeMnChargeTrue->Sumw2();
   h_ele_simEta_matched_qmisid             = new TH1F( "h_ele_eta_matched_qmisid","charge misid vs gen eta", nbineta,etamin,etamax);
   h_ele_simEta_matched_qmisid->Sumw2();
   h_ele_simAbsEta_matched_qmisid             = new TH1F( "h_ele_abseta_matched_qmisid", "charge misid vs gen |eta|", nbineta/2,0.,etamax);
   h_ele_simAbsEta_matched_qmisid->Sumw2();
   h_ele_simPt_matched_qmisid               = new TH1F( "h_ele_Pt_matched_qmisid", "charge misid vs gen transverse momentum", nbinpteff,5.,ptmax);
   h_ele_simPt_matched_qmisid->Sumw2();
   h_ele_simPhi_matched_qmisid               = new TH1F( "h_ele_phi_matched_qmisid","charge misid vs gen phi", nbinphi,phimin,phimax);
   h_ele_simPhi_matched_qmisid->Sumw2();
   h_ele_simZ_matched_qmisid      = new TH1F( "h_ele_z_matched_qmisid","charge misid vs gen z",nbinxyz, -25, 25 );
   h_ele_simZ_matched_qmisid->Sumw2();
 
   // matched electrons
   h_ele_charge         = new TH1F( "h_ele_charge",         "ele charge",             5,-2.,2.);
   h_ele_charge->Sumw2();
   h_ele_chargeVsEta    = new TH2F( "h_ele_chargeVsEta",         "ele charge vs eta", nbineta2D,etamin,etamax,5,-2.,2.);
   h_ele_chargeVsPhi    = new TH2F( "h_ele_chargeVsPhi",         "ele charge vs phi", nbinphi2D,phimin,phimax,5,-2.,2.);
   h_ele_chargeVsPt    = new TH2F( "h_ele_chargeVsPt",         "ele charge vs pt", nbinpt,0.,100.,5,-2.,2.);
   h_ele_vertexP        = new TH1F( "h_ele_vertexP",        "ele momentum",       nbinp,0.,pmax);
   h_ele_vertexP->Sumw2();
   h_ele_vertexPt       = new TH1F( "h_ele_vertexPt",       "ele transverse momentum",  nbinpt,0.,ptmax);
   h_ele_vertexPt->Sumw2();
   h_ele_Et       = new TH1F( "h_ele_Et",       "ele transverse energy",  nbinpt,0.,ptmax);
   h_ele_Et->Sumw2();
   h_ele_vertexPtVsEta   = new TH2F( "h_ele_vertexPtVsEta",       "ele transverse momentum vs eta",nbineta2D,etamin,etamax,nbinpt2D,0.,ptmax);
   h_ele_vertexPtVsPhi   = new TH2F( "h_ele_vertexPtVsPhi",       "ele transverse momentum vs phi",nbinphi2D,phimin,phimax,nbinpt2D,0.,ptmax);
   h_ele_simPt_matched       = new TH1F( "h_ele_simPt_matched",       "Efficiency vs gen transverse momentum",  nbinpteff,5.,ptmax);
   h_ele_vertexEta      = new TH1F( "h_ele_vertexEta",      "ele momentum eta",    nbineta,etamin,etamax);
   h_ele_vertexEta->Sumw2();
   h_ele_vertexEtaVsPhi  = new TH2F( "h_ele_vertexEtaVsPhi",      "ele momentum eta vs phi",nbineta2D,etamin,etamax,nbinphi2D,phimin,phimax );
   h_ele_simAbsEta_matched      = new TH1F( "h_ele_simAbsEta_matched",      "Efficiency vs gen |eta|",    nbineta/2,0.,2.5);
   h_ele_simAbsEta_matched->Sumw2();
   h_ele_simEta_matched      = new TH1F( "h_ele_simEta_matched",      "Efficiency vs gen eta",    nbineta,etamin,etamax);
   h_ele_simEta_matched->Sumw2();
   h_ele_simPtEta_matched           = new TH2F( "h_ele_simPtEta_matched",   "Efficiency vs pt #eta",  nbineta2D,etamin,etamax, nbinpt2D,5.,ptmax );
   h_ele_simPtEta_matched->Sumw2();
   h_ele_simPhi_matched               = new TH1F( "h_ele_simPhi_matched",               "Efficiency vs gen phi",        nbinphi,phimin,phimax);
   h_ele_simPhi_matched->Sumw2();
   h_ele_vertexPhi      = new TH1F( "h_ele_vertexPhi",      "ele  momentum #phi",    nbinphi,phimin,phimax);
   h_ele_vertexPhi->Sumw2();
   h_ele_vertexX      = new TH1F( "h_ele_vertexX",      "ele vertex x",    nbinxyz,-0.1,0.1 );
   h_ele_vertexX->Sumw2();
   h_ele_vertexY      = new TH1F( "h_ele_vertexY",      "ele vertex y",    nbinxyz,-0.1,0.1 );
   h_ele_vertexY->Sumw2();
   h_ele_vertexZ      = new TH1F( "h_ele_vertexZ",      "ele vertex z",    nbinxyz,-25, 25 );
   h_ele_vertexZ->Sumw2();
   h_ele_simZ_matched      = new TH1F( "h_ele_simZ_matched",      "Efficiency vs gen vertex z",    nbinxyz,-25,25);
   h_ele_simZ_matched->Sumw2();
   h_ele_vertexTIP      = new TH1F( "h_ele_vertexTIP",      "ele transverse impact parameter (wrt gen vtx)",    90,0.,0.15);
   h_ele_vertexTIP->Sumw2();
   h_ele_vertexTIPVsEta      = new TH2F( "h_ele_vertexTIPVsEta",      "ele transverse impact parameter (wrt gen vtx) vs eta", nbineta2D,etamin,etamax,45,0.,0.15);
   h_ele_vertexTIPVsPhi      = new TH2F( "h_ele_vertexTIPVsPhi",      "ele transverse impact parameter (wrt gen vtx) vs phi", nbinphi2D,phimin,phimax,45,0.,0.15);
   h_ele_vertexTIPVsPt      = new TH2F( "h_ele_vertexTIPVsPt",      "ele transverse impact parameter (wrt gen vtx) vs transverse momentum", nbinpt2D,0.,ptmax,45,0.,0.15);
   h_ele_PoPtrue        = new TH1F( "h_ele_PoPtrue",        "ele momentum / gen momentum", nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue->Sumw2();
   h_ele_PtoPttrue        = new TH1F( "h_ele_PtoPttrue",        "ele transverse momentum / gen transverse momentum", nbinpoptrue,poptruemin,poptruemax);
   h_ele_PtoPttrue->Sumw2();
   h_ele_PoPtrueVsEta   = new TH2F( "h_ele_PoPtrueVsEta",        "ele momentum / gen momentum vs eta", nbineta2D,etamin,etamax,50,poptruemin,poptruemax);
   h_ele_PoPtrueVsPhi   = new TH2F( "h_ele_PoPtrueVsPhi",        "ele momentum / gen momentum vs phi", nbinphi2D,phimin,phimax,50,poptruemin,poptruemax);
   h_ele_PoPtrueVsPt   = new TH2F( "h_ele_PoPtrueVsPt",        "ele momentum / gen momentum vs eta", nbinpt2D,0.,ptmax,50,poptruemin,poptruemax);
   h_ele_PoPtrue_barrel         = new TH1F( "h_ele_PoPtrue_barrel",        "ele momentum / gen momentum, barrel",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_barrel->Sumw2();
   h_ele_PoPtrue_endcaps        = new TH1F( "h_ele_PoPtrue_endcaps",        "ele momentum / gen momentum, endcaps",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_endcaps->Sumw2();
   h_ele_PoPtrue_golden_barrel         = new TH1F( "h_ele_PoPtrue_golden_barrel",        "ele momentum / gen momentum, golden, barrel",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_golden_barrel->Sumw2();
   h_ele_PoPtrue_golden_endcaps        = new TH1F( "h_ele_PoPtrue_golden_endcaps",        "ele momentum / gen momentum, golden, endcaps",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_golden_endcaps->Sumw2();
   h_ele_PoPtrue_showering_barrel         = new TH1F( "h_ele_PoPtrue_showering_barrel",        "ele momentum / gen momentum, showering, barrel",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_showering_barrel->Sumw2();
   h_ele_PoPtrue_showering_endcaps        = new TH1F( "h_ele_PoPtrue_showering_endcaps",        "ele momentum / gen momentum, showering, endcaps",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PoPtrue_showering_endcaps->Sumw2();
   h_ele_PtoPttrue_barrel         = new TH1F( "h_ele_PtoPttrue_barrel",        "ele transverse momentum / gen transverse momentum, barrel",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PtoPttrue_barrel->Sumw2();
   h_ele_PtoPttrue_endcaps        = new TH1F( "h_ele_PtoPttrue_endcaps",        "ele transverse momentum / gen transverse momentum, endcaps",nbinpoptrue,poptruemin,poptruemax);
   h_ele_PtoPttrue_endcaps->Sumw2();
   h_ele_EtaMnEtaTrue   = new TH1F( "h_ele_EtaMnEtaTrue",   "ele momentum  eta - gen  eta",nbindeta,detamin,detamax);
   h_ele_EtaMnEtaTrue->Sumw2();
   h_ele_EtaMnEtaTrue_barrel   = new TH1F( "h_ele_EtaMnEtaTrue_barrel",   "ele momentum  eta - gen  eta barrel",nbindeta,detamin,detamax);
   h_ele_EtaMnEtaTrue_barrel->Sumw2();
   h_ele_EtaMnEtaTrue_endcaps   = new TH1F( "h_ele_EtaMnEtaTrue_endcaps",   "ele momentum  eta - gen  eta endcaps",nbindeta,detamin,detamax);
   h_ele_EtaMnEtaTrue_endcaps->Sumw2();
   h_ele_EtaMnEtaTrueVsEta   = new TH2F( "h_ele_EtaMnEtaTrueVsEta",   "ele momentum  eta - gen  eta vs eta",nbineta2D,etamin,etamax,nbindeta/2,detamin,detamax);
   h_ele_EtaMnEtaTrueVsPhi   = new TH2F( "h_ele_EtaMnEtaTrueVsPhi",   "ele momentum  eta - gen  eta vs phi",nbinphi2D,phimin,phimax,nbindeta/2,detamin,detamax);
   h_ele_EtaMnEtaTrueVsPt   = new TH2F( "h_ele_EtaMnEtaTrueVsPt",   "ele momentum  eta - gen  eta vs pt",nbinpt,0.,ptmax,nbindeta/2,detamin,detamax);
   h_ele_PhiMnPhiTrue   = new TH1F( "h_ele_PhiMnPhiTrue",   "ele momentum  phi - gen  phi",nbindphi,dphimin,dphimax);
   h_ele_PhiMnPhiTrue->Sumw2();
   h_ele_PhiMnPhiTrue_barrel   = new TH1F( "h_ele_PhiMnPhiTrue_barrel",   "ele momentum  phi - gen  phi barrel",nbindphi,dphimin,dphimax);
   h_ele_PhiMnPhiTrue_barrel->Sumw2();
   h_ele_PhiMnPhiTrue_endcaps   = new TH1F( "h_ele_PhiMnPhiTrue_endcaps",   "ele momentum  phi - gen  phi endcaps",nbindphi,dphimin,dphimax);
   h_ele_PhiMnPhiTrue_endcaps->Sumw2();
   h_ele_PhiMnPhiTrue2   = new TH1F( "h_ele_PhiMnPhiTrue2",   "ele momentum  phi - gen  phi",nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_PhiMnPhiTrueVsEta   = new TH2F( "h_ele_PhiMnPhiTrueVsEta",   "ele momentum  phi - gen  phi vs eta",nbineta2D,etamin,etamax,nbindphi/2,dphimin,dphimax);
   h_ele_PhiMnPhiTrueVsPhi   = new TH2F( "h_ele_PhiMnPhiTrueVsPhi",   "ele momentum  phi - gen  phi vs phi",nbinphi2D,phimin,phimax,nbindphi/2,dphimin,dphimax);
   h_ele_PhiMnPhiTrueVsPt   = new TH2F( "h_ele_PhiMnPhiTrueVsPt",   "ele momentum  phi - gen  phi vs pt",nbinpt2D,0.,ptmax,nbindphi/2,dphimin,dphimax);
 
   // matched electron, superclusters
   histSclEn_ = new TH1F("h_scl_energy","ele supercluster energy",nbinp,0.,pmax);
   histSclEn_->Sumw2();
   histSclEoEtrue_barrel = new TH1F("h_scl_EoEtrue_barrel","ele supercluster energy / gen energy, barrel",50,0.2,1.2);
   histSclEoEtrue_barrel->Sumw2();
   histSclEoEtrue_barrel_eg = new TH1F("h_scl_EoEtrue_barrel_eg","ele supercluster energy / gen energy, barrel, ecal driven",50,0.2,1.2);
   histSclEoEtrue_barrel_eg->Sumw2();
   histSclEoEtrue_barrel_etagap = new TH1F("h_scl_EoEtrue_barrel_etagap","ele supercluster energy / gen energy, barrel, etagap",50,0.2,1.2);
   histSclEoEtrue_barrel_etagap->Sumw2();
   histSclEoEtrue_barrel_phigap = new TH1F("h_scl_EoEtrue_barrel_phigap","ele supercluster energy / gen energy, barrel, phigap",50,0.2,1.2);
   histSclEoEtrue_barrel_phigap->Sumw2();
   histSclEoEtrue_ebeegap = new TH1F("h_scl_EoEtrue_ebeegap","ele supercluster energy / gen energy, ebeegap",50,0.2,1.2);
   histSclEoEtrue_ebeegap->Sumw2();
   histSclEoEtrue_endcaps = new TH1F("h_scl_EoEtrue_endcaps","ele supercluster energy / gen energy, endcaps",50,0.2,1.2);
   histSclEoEtrue_endcaps->Sumw2();
   histSclEoEtrue_endcaps_eg = new TH1F("h_scl_EoEtrue_endcaps_eg","ele supercluster energy / gen energy, endcaps, ecal driven",50,0.2,1.2);
   histSclEoEtrue_endcaps_eg->Sumw2();
   histSclEoEtrue_endcaps_deegap = new TH1F("h_scl_EoEtrue_endcaps_deegap","ele supercluster energy / gen energy, endcaps, deegap",50,0.2,1.2);
   histSclEoEtrue_endcaps_deegap->Sumw2();
   histSclEoEtrue_endcaps_ringgap = new TH1F("h_scl_EoEtrue_endcaps_ringgap","ele supercluster energy / gen energy, endcaps, ringgap",50,0.2,1.2);
   histSclEoEtrue_endcaps_ringgap->Sumw2();
   histSclEoEtrue_barrel_new = new TH1F("h_scl_EoEtrue_barrel_new","ele supercluster energy / gen energy, barrel",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_barrel_new->Sumw2();
   histSclEoEtrue_barrel_eg_new = new TH1F("h_scl_EoEtrue_barrel_eg_new","ele supercluster energy / gen energy, barrel, ecal driven",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_barrel_eg_new->Sumw2();
   histSclEoEtrue_barrel_etagap_new = new TH1F("h_scl_EoEtrue_barrel_etagap_new","ele supercluster energy / gen energy, barrel, etagap",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_barrel_etagap_new->Sumw2();
   histSclEoEtrue_barrel_phigap_new = new TH1F("h_scl_EoEtrue_barrel_phigap_new","ele supercluster energy / gen energy, barrel, phigap",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_barrel_phigap_new->Sumw2();
   histSclEoEtrue_ebeegap_new = new TH1F("h_scl_EoEtrue_ebeegap_new","ele supercluster energy / gen energy, ebeegap",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_ebeegap_new->Sumw2();
   histSclEoEtrue_endcaps_new = new TH1F("h_scl_EoEtrue_endcaps_new","ele supercluster energy / gen energy, endcaps",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_endcaps_new->Sumw2();
   histSclEoEtrue_endcaps_eg_new = new TH1F("h_scl_EoEtrue_endcaps_eg_new","ele supercluster energy / gen energy, endcaps, ecal driven",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_endcaps_eg_new->Sumw2();
   histSclEoEtrue_endcaps_deegap_new = new TH1F("h_scl_EoEtrue_endcaps_deegap_new","ele supercluster energy / gen energy, endcaps, deegap",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_endcaps_deegap_new->Sumw2();
   histSclEoEtrue_endcaps_ringgap_new = new TH1F("h_scl_EoEtrue_endcaps_ringgap_new","ele supercluster energy / gen energy, endcaps, ringgap",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrue_endcaps_ringgap_new->Sumw2();
   histSclEt_ = new TH1F("h_scl_et","ele supercluster transverse energy",nbinpt,0.,ptmax);
   histSclEt_->Sumw2();
   histSclEtVsEta_ = new TH2F("h_scl_etVsEta","ele supercluster transverse energy vs eta",nbineta2D,etamin,etamax,nbinpt,0.,ptmax);
   histSclEtVsPhi_ = new TH2F("h_scl_etVsPhi","ele supercluster transverse energy vs phi",nbinphi2D,phimin,phimax,nbinpt,0.,ptmax);
   histSclEtaVsPhi_ = new TH2F("h_scl_etaVsPhi","ele supercluster eta vs phi",nbinphi2D,phimin,phimax,nbineta2D,etamin,etamax);
   histSclEta_ = new TH1F("h_scl_eta","ele supercluster eta",nbineta,etamin,etamax);
   histSclEta_->Sumw2();
   histSclPhi_ = new TH1F("h_scl_phi","ele supercluster phi",nbinphi,phimin,phimax);
   histSclPhi_->Sumw2();
 
   histSclSigEtaEta_ =  new TH1F("h_scl_sigetaeta","ele supercluster sigma eta eta",100,0.,0.05);
   histSclSigEtaEta_->Sumw2();
   histSclSigEtaEta_barrel_ =  new TH1F("h_scl_sigetaeta_barrel","ele supercluster sigma eta eta barrel",100,0.,0.05);
   histSclSigEtaEta_barrel_->Sumw2();
   histSclSigEtaEta_endcaps_ =  new TH1F("h_scl_sigetaeta_endcaps","ele supercluster sigma eta eta endcaps",100,0.,0.05);
   histSclSigEtaEta_endcaps_->Sumw2();
   histSclSigIEtaIEta_ =  new TH1F("h_scl_sigietaieta","ele supercluster sigma ieta ieta",100,0.,0.05);
   histSclSigIEtaIEta_->Sumw2();
   histSclSigIEtaIEta_barrel_ =  new TH1F("h_scl_sigietaieta_barrel","ele supercluster sigma ieta ieta, barrel",100,0.,0.05);
   histSclSigIEtaIEta_barrel_->Sumw2();
   histSclSigIEtaIEta_endcaps_ =  new TH1F("h_scl_sigietaieta_endcaps","ele supercluster sigma ieta ieta, endcaps",100,0.,0.05);
   histSclSigIEtaIEta_endcaps_->Sumw2();
   histSclE1x5_ =  new TH1F("h_scl_E1x5","ele supercluster energy in 1x5",nbinp,0., pmax);
   histSclE1x5_->Sumw2();
   histSclE1x5_barrel_ =  new TH1F("h_scl_E1x5_barrel","ele supercluster energy in 1x5 barrel",nbinp,0., pmax);
   histSclE1x5_barrel_->Sumw2();
   histSclE1x5_endcaps_ =  new TH1F("h_scl_E1x5_endcaps","ele supercluster energy in 1x5 endcaps",nbinp,0., pmax);
   histSclE1x5_endcaps_->Sumw2();
   histSclE2x5max_ =  new TH1F("h_scl_E2x5max","ele supercluster energy in 2x5 max",nbinp,0.,pmax);
   histSclE2x5max_->Sumw2();
   histSclE2x5max_barrel_ =  new TH1F("h_scl_E2x5max_barrel","ele supercluster energy in 2x5 max barrel",nbinp,0.,pmax);
   histSclE2x5max_barrel_->Sumw2();
   histSclE2x5max_endcaps_ =  new TH1F("h_scl_E2x5max_endcaps","ele supercluster energy in 2x5 max endcaps",nbinp,0.,pmax);
   histSclE2x5max_endcaps_->Sumw2();
   histSclE5x5_ =  new TH1F("h_scl_E5x5","ele supercluster energy in 5x5",nbinp,0.,pmax);
   histSclE5x5_->Sumw2();
   histSclE5x5_barrel_ =  new TH1F("h_scl_E5x5_barrel","ele supercluster energy in 5x5 barrel",nbinp,0.,pmax);
   histSclE5x5_barrel_->Sumw2();
   histSclE5x5_endcaps_ =  new TH1F("h_scl_E5x5_endcaps","ele supercluster energy in 5x5 endcaps",nbinp,0.,pmax);
   histSclE5x5_endcaps_->Sumw2();
   histSclSigEtaEta_eg_ =  new TH1F("h_scl_sigetaeta_eg","ele supercluster sigma eta eta, ecal driven",100,0.,0.05);
   histSclSigEtaEta_eg_->Sumw2();
   histSclSigEtaEta_eg_barrel_ =  new TH1F("h_scl_sigetaeta_eg_barrel","ele supercluster sigma eta eta, ecal driven barrel",100,0.,0.05);
   histSclSigEtaEta_eg_barrel_->Sumw2();
   histSclSigEtaEta_eg_endcaps_ =  new TH1F("h_scl_sigetaeta_eg_endcaps","ele supercluster sigma eta eta, ecal driven endcaps",100,0.,0.05);
   histSclSigEtaEta_eg_endcaps_->Sumw2();
   histSclSigIEtaIEta_eg_ =  new TH1F("h_scl_sigietaieta_eg","ele supercluster sigma ieta ieta, ecal driven",100,0.,0.05);
   histSclSigIEtaIEta_eg_->Sumw2();
   histSclSigIEtaIEta_eg_barrel_ =  new TH1F("h_scl_sigietaieta_barrel_eg","ele supercluster sigma ieta ieta, barrel, ecal driven",100,0.,0.05);
   histSclSigIEtaIEta_eg_barrel_->Sumw2();
   histSclSigIEtaIEta_eg_endcaps_ =  new TH1F("h_scl_sigietaieta_endcaps_eg","ele supercluster sigma ieta ieta, endcaps, ecal driven",100,0.,0.05);
   histSclSigIEtaIEta_eg_endcaps_->Sumw2();
   histSclE1x5_eg_ =  new TH1F("h_scl_E1x5_eg","ele supercluster energy in 1x5, ecal driven",nbinp,0., pmax);
   histSclE1x5_eg_->Sumw2();
   histSclE1x5_eg_barrel_ =  new TH1F("h_scl_E1x5_eg_barrel","ele supercluster energy in 1x5, ecal driven barrel",nbinp,0., pmax);
   histSclE1x5_eg_barrel_->Sumw2();
   histSclE1x5_eg_endcaps_ =  new TH1F("h_scl_E1x5_eg_endcaps","ele supercluster energy in 1x5, ecal driven endcaps",nbinp,0., pmax);
   histSclE1x5_eg_endcaps_->Sumw2();
   histSclE2x5max_eg_ =  new TH1F("h_scl_E2x5max_eg","ele supercluster energy in 2x5 max, ecal driven",nbinp,0.,pmax);
   histSclE2x5max_eg_->Sumw2();
   histSclE2x5max_eg_barrel_ =  new TH1F("h_scl_E2x5max_eg_barrel","ele supercluster energy in 2x5 max, ecal driven barrel",nbinp,0.,pmax);
   histSclE2x5max_eg_barrel_->Sumw2();
   histSclE2x5max_eg_endcaps_ =  new TH1F("h_scl_E2x5max_eg_endcaps","ele supercluster energy in 2x5 max, ecal driven endcaps",nbinp,0.,pmax);
   histSclE2x5max_eg_endcaps_->Sumw2();
   histSclE5x5_eg_ =  new TH1F("h_scl_E5x5_eg","ele supercluster energy in 5x5, ecal driven",nbinp,0.,pmax);
   histSclE5x5_eg_->Sumw2();
   histSclE5x5_eg_barrel_ =  new TH1F("h_scl_E5x5_eg_barrel","ele supercluster energy in 5x5, ecal driven barrel",nbinp,0.,pmax);
   histSclE5x5_eg_barrel_->Sumw2();
   histSclE5x5_eg_endcaps_ =  new TH1F("h_scl_E5x5_eg_endcaps","ele supercluster energy in 5x5, ecal driven endcaps",nbinp,0.,pmax);
   histSclE5x5_eg_endcaps_->Sumw2();
 
   histSclEoEtruePfVsEg = new TH2F("h_scl_EoEtruePfVsEg","ele supercluster energy / gen energy pflow vs eg",75,-0.1,1.4, 75, -0.1, 1.4);
 
   // matched electron, gsf tracks
   h_ele_ambiguousTracks      = new TH1F( "h_ele_ambiguousTracks", "ele # ambiguous tracks",  5,0.,5.);
   h_ele_ambiguousTracks->Sumw2();
   h_ele_ambiguousTracksVsEta      = new TH2F( "h_ele_ambiguousTracksVsEta","ele # ambiguous tracks  vs eta",  nbineta2D,etamin,etamax,5,0.,5.);
   h_ele_ambiguousTracksVsPhi      = new TH2F( "h_ele_ambiguousTracksVsPhi", "ele # ambiguous tracks  vs phi",  nbinphi2D,phimin,phimax,5,0.,5.);
   h_ele_ambiguousTracksVsPt      = new TH2F( "h_ele_ambiguousTracksVsPt", "ele # ambiguous tracks vs pt",  nbinpt2D,0.,ptmax,5,0.,5.);
   h_ele_foundHits      = new TH1F( "h_ele_foundHits",      "ele track # found hits",      nbinfhits,0.,fhitsmax);
   h_ele_foundHits->Sumw2();
   h_ele_foundHits_barrel      = new TH1F( "h_ele_foundHits_barrel",      "ele track # found hits, barrel",      nbinfhits,0.,fhitsmax);
   h_ele_foundHits_barrel->Sumw2();
   h_ele_foundHits_endcaps      = new TH1F( "h_ele_foundHits_endcaps",      "ele track # found hits, endcaps",      nbinfhits,0.,fhitsmax);
   h_ele_foundHits_endcaps->Sumw2();
   h_ele_foundHitsVsEta      = new TH2F( "h_ele_foundHitsVsEta",      "ele track # found hits vs eta",  nbineta2D,etamin,etamax,nbinfhits,0.,fhitsmax);
   h_ele_foundHitsVsPhi      = new TH2F( "h_ele_foundHitsVsPhi",      "ele track # found hits vs phi",  nbinphi2D,phimin,phimax,nbinfhits,0.,fhitsmax);
   h_ele_foundHitsVsPt      = new TH2F( "h_ele_foundHitsVsPt",      "ele track # found hits vs pt",  nbinpt2D,0.,ptmax,nbinfhits,0.,fhitsmax);
   h_ele_lostHits       = new TH1F( "h_ele_lostHits",       "ele track # lost hits",       5,0.,5.);
   h_ele_lostHits->Sumw2();
   h_ele_lostHits_barrel       = new TH1F( "h_ele_lostHits_barrel",       "ele track # lost hits, barrel",       5,0.,5.);
   h_ele_lostHits_barrel->Sumw2();
   h_ele_lostHits_endcaps       = new TH1F( "h_ele_lostHits_endcaps",       "ele track # lost hits, endcaps",       5,0.,5.);
   h_ele_lostHits_endcaps->Sumw2();
   h_ele_lostHitsVsEta       = new TH2F( "h_ele_lostHitsVsEta",       "ele track # lost hits vs eta",   nbineta2D,etamin,etamax,nbinlhits,0.,lhitsmax);
   h_ele_lostHitsVsPhi       = new TH2F( "h_ele_lostHitsVsPhi",       "ele track # lost hits vs eta",   nbinphi2D,phimin,phimax,nbinlhits,0.,lhitsmax);
   h_ele_lostHitsVsPt       = new TH2F( "h_ele_lostHitsVsPt",       "ele track # lost hits vs eta",   nbinpt2D,0.,ptmax,nbinlhits,0.,lhitsmax);
   h_ele_chi2           = new TH1F( "h_ele_chi2",           "ele track #chi^{2}",         100,0.,15.);
   h_ele_chi2->Sumw2();
   h_ele_chi2_barrel           = new TH1F( "h_ele_chi2_barrel",           "ele track #chi^{2}, barrel",         100,0.,15.);
   h_ele_chi2_barrel->Sumw2();
   h_ele_chi2_endcaps           = new TH1F( "h_ele_chi2_endcaps",           "ele track #chi^{2}, endcaps",         100,0.,15.);
   h_ele_chi2_endcaps->Sumw2();
   h_ele_chi2VsEta           = new TH2F( "h_ele_chi2VsEta",           "ele track #chi^{2} vs eta",  nbineta2D,etamin,etamax,50,0.,15.);
   h_ele_chi2VsPhi           = new TH2F( "h_ele_chi2VsPhi",           "ele track #chi^{2} vs phi",  nbinphi2D,phimin,phimax,50,0.,15.);
   h_ele_chi2VsPt           = new TH2F( "h_ele_chi2VsPt",           "ele track #chi^{2} vs pt",  nbinpt2D,0.,ptmax,50,0.,15.);
   h_ele_PinMnPout      = new TH1F( "h_ele_PinMnPout",      "ele track inner p - outer p, mean of GSF components"   ,nbinp,0.,200.);
   h_ele_PinMnPout->Sumw2();
   h_ele_PinMnPout_mode      = new TH1F( "h_ele_PinMnPout_mode",      "ele track inner p - outer p, mode of GSF components"   ,nbinp,0.,100.);
   h_ele_PinMnPout_mode->Sumw2();
   h_ele_PinMnPoutVsEta_mode = new TH2F( "h_ele_PinMnPoutVsEta_mode",      "ele track inner p - outer p vs eta, mode of GSF components" ,nbineta2D, etamin,etamax,nbinp2D,0.,100.);
   h_ele_PinMnPoutVsPhi_mode = new TH2F( "h_ele_PinMnPoutVsPhi_mode",      "ele track inner p - outer p vs phi, mode of GSF components" ,nbinphi2D, phimin,phimax,nbinp2D,0.,100.);
   h_ele_PinMnPoutVsPt_mode = new TH2F( "h_ele_PinMnPoutVsPt_mode",      "ele track inner p - outer p vs pt, mode of GSF components" ,nbinpt2D, 0.,ptmax,nbinp2D,0.,100.);
   h_ele_PinMnPoutVsE_mode = new TH2F( "h_ele_PinMnPoutVsE_mode",      "ele track inner p - outer p vs E, mode of GSF components" ,nbinp2D, 0.,200.,nbinp2D,0.,100.);
   h_ele_PinMnPoutVsChi2_mode = new TH2F( "h_ele_PinMnPoutVsChi2_mode",      "ele track inner p - outer p vs track chi2, mode of GSF components" ,50, 0.,20.,nbinp2D,0.,100.);
   h_ele_outerP         = new TH1F( "h_ele_outerP",         "ele track outer p, mean of GSF components",          nbinp,0.,pmax);
   h_ele_outerP->Sumw2();
   h_ele_outerP_mode         = new TH1F( "h_ele_outerP_mode",         "ele track outer p, mode of GSF components",          nbinp,0.,pmax);
   h_ele_outerP_mode->Sumw2();
   h_ele_outerPVsEta_mode         = new TH2F( "h_ele_outerPVsEta_mode",         "ele track outer p vs eta mode", nbineta2D,etamin,etamax,50,0.,pmax);
   h_ele_outerPt        = new TH1F( "h_ele_outerPt",        "ele track outer p_{T}, mean of GSF components",      nbinpt,0.,ptmax);
   h_ele_outerPt->Sumw2();
   h_ele_outerPt_mode        = new TH1F( "h_ele_outerPt_mode",        "ele track outer p_{T}, mode of GSF components",      nbinpt,0.,ptmax);
   h_ele_outerPt_mode->Sumw2();
   h_ele_outerPtVsEta_mode        = new TH2F( "h_ele_outerPtVsEta_mode", "ele track outer p_{T} vs eta, mode of GSF components", nbineta2D,etamin,etamax,nbinpt2D,0.,ptmax);
   h_ele_outerPtVsPhi_mode        = new TH2F( "h_ele_outerPtVsPhi_mode", "ele track outer p_{T} vs phi, mode of GSF components", nbinphi2D,phimin,phimax,nbinpt2D,0.,ptmax);
   h_ele_outerPtVsPt_mode        = new TH2F( "h_ele_outerPtVsPt_mode", "ele track outer p_{T} vs pt, mode of GSF components", nbinpt2D,0.,100.,nbinpt2D,0.,ptmax);
 
   // matched electrons, matching
   h_ele_EoP            = new TH1F( "h_ele_EoP",            "ele E/P_{vertex}",        nbineop,0.,eopmax);
   h_ele_EoP->Sumw2();
   h_ele_EoP_eg            = new TH1F( "h_ele_EoP_eg",            "ele E/P_{vertex}, ecal driven",        nbineop,0.,eopmax);
   h_ele_EoP_eg->Sumw2();
   h_ele_EoP_barrel            = new TH1F( "h_ele_EoP_barrel",            "ele E/P_{vertex} barrel",        nbineop,0.,eopmax);
   h_ele_EoP_barrel->Sumw2();
   h_ele_EoP_eg_barrel            = new TH1F( "h_ele_EoP_eg_barrel",            "ele E/P_{vertex}, ecal driven barrel",        nbineop,0.,eopmax);
   h_ele_EoP_eg_barrel->Sumw2();
   h_ele_EoP_endcaps            = new TH1F( "h_ele_EoP_endcaps",            "ele E/P_{vertex} endcaps",        nbineop,0.,eopmax);
   h_ele_EoP_endcaps->Sumw2();
   h_ele_EoP_eg_endcaps            = new TH1F( "h_ele_EoP_eg_endcaps",            "ele E/P_{vertex}, ecal driven endcaps",        nbineop,0.,eopmax);
   h_ele_EoP_eg_endcaps->Sumw2();
   h_ele_EoPVsEta            = new TH2F( "h_ele_EoPVsEta",            "ele E/P_{vertex} vs eta",  nbineta2D,etamin,etamax,nbineop2D,0.,eopmaxsht);
   h_ele_EoPVsPhi            = new TH2F( "h_ele_EoPVsPhi",            "ele E/P_{vertex} vs phi",  nbinphi2D,phimin,phimax,nbineop2D,0.,eopmaxsht);
   h_ele_EoPVsE            = new TH2F( "h_ele_EoPVsE",            "ele E/P_{vertex} vs E",  50,0.,pmax ,50,0.,5.);
   h_ele_EseedOP            = new TH1F( "h_ele_EseedOP",            "ele E_{seed}/P_{vertex}",        nbineop,0.,eopmax);
   h_ele_EseedOP->Sumw2();
   h_ele_EseedOP_eg            = new TH1F( "h_ele_EseedOP_eg",            "ele E_{seed}/P_{vertex}, ecal driven",        nbineop,0.,eopmax);
   h_ele_EseedOP_eg->Sumw2();
   h_ele_EseedOP_barrel            = new TH1F( "h_ele_EseedOP_barrel",            "ele E_{seed}/P_{vertex} barrel",        nbineop,0.,eopmax);
   h_ele_EseedOP_barrel->Sumw2();
   h_ele_EseedOP_eg_barrel            = new TH1F( "h_ele_EseedOP_eg_barrel",            "ele E_{seed}/P_{vertex}, ecal driven barrel",        nbineop,0.,eopmax);
   h_ele_EseedOP_eg_barrel->Sumw2();
   h_ele_EseedOP_endcaps            = new TH1F( "h_ele_EseedOP_endcaps",            "ele E_{seed}/P_{vertex} endcaps",        nbineop,0.,eopmax);
   h_ele_EseedOP_endcaps->Sumw2();
   h_ele_EseedOP_eg_endcaps            = new TH1F( "h_ele_EseedOP_eg_endcaps",            "ele E_{seed}/P_{vertex}, ecal driven, endcaps",        nbineop,0.,eopmax);
   h_ele_EseedOP_eg_endcaps->Sumw2();
   h_ele_EseedOPVsEta            = new TH2F( "h_ele_EseedOPVsEta",            "ele E_{seed}/P_{vertex} vs eta",  nbineta2D,etamin,etamax,nbineop2D,0.,eopmaxsht);
   h_ele_EseedOPVsPhi            = new TH2F( "h_ele_EseedOPVsPhi",            "ele E_{seed}/P_{vertex} vs phi",  nbinphi2D,phimin,phimax,nbineop2D,0.,eopmaxsht);
   h_ele_EseedOPVsE            = new TH2F( "h_ele_EseedOPVsE",            "ele E_{seed}/P_{vertex} vs E",  50,0.,pmax ,50,0.,5.);
   h_ele_EoPout         = new TH1F( "h_ele_EoPout",         "ele E_{seed}/P_{out}",           nbineop,0.,eopmax);
   h_ele_EoPout->Sumw2();
   h_ele_EoPout_eg         = new TH1F( "h_ele_EoPout_eg",         "ele E_{seed}/P_{out}, ecal driven",           nbineop,0.,eopmax);
   h_ele_EoPout_eg->Sumw2();
   h_ele_EoPout_barrel         = new TH1F( "h_ele_EoPout_barrel",         "ele E_{seed}/P_{out} barrel",           nbineop,0.,eopmax);
   h_ele_EoPout_barrel->Sumw2();
   h_ele_EoPout_eg_barrel         = new TH1F( "h_ele_EoPout_eg_barrel",         "ele E_{seed}/P_{out}, ecal driven, barrel",           nbineop,0.,eopmax);
   h_ele_EoPout_eg_barrel->Sumw2();
   h_ele_EoPout_endcaps         = new TH1F( "h_ele_EoPout_endcaps",         "ele E_{seed}/P_{out} endcaps",           nbineop,0.,eopmax);
   h_ele_EoPout_endcaps->Sumw2();
   h_ele_EoPout_eg_endcaps         = new TH1F( "h_ele_EoPout_eg_endcaps",         "ele E_{seed}/P_{out}, ecal driven, endcaps",           nbineop,0.,eopmax);
   h_ele_EoPout_eg_endcaps->Sumw2();
   h_ele_EoPoutVsEta         = new TH2F( "h_ele_EoPoutVsEta",         "ele E_{seed}/P_{out} vs eta",    nbineta2D,etamin,etamax,nbineop2D,0.,eopmaxsht);
   h_ele_EoPoutVsPhi         = new TH2F( "h_ele_EoPoutVsPhi",         "ele E_{seed}/P_{out} vs phi",    nbinphi2D,phimin,phimax,nbineop2D,0.,eopmaxsht);
   h_ele_EoPoutVsE         = new TH2F( "h_ele_EoPoutVsE",         "ele E_{seed}/P_{out} vs E",    nbinp2D,0.,pmax,nbineop2D,0.,eopmaxsht);
   h_ele_EeleOPout         = new TH1F( "h_ele_EeleOPout",         "ele E_{ele}/P_{out}",           nbineop,0.,eopmax);
   h_ele_EeleOPout->Sumw2();
   h_ele_EeleOPout_eg         = new TH1F( "h_ele_EeleOPout_eg",         "ele E_{ele}/P_{out}, ecal driven",           nbineop,0.,eopmax);
   h_ele_EeleOPout_eg->Sumw2();
   h_ele_EeleOPout_barrel         = new TH1F( "h_ele_EeleOPout_barrel",         "ele E_{ele}/P_{out} barrel",           nbineop,0.,eopmax);
   h_ele_EeleOPout_barrel->Sumw2();
   h_ele_EeleOPout_eg_barrel         = new TH1F( "h_ele_EeleOPout_eg_barrel",         "ele E_{ele}/P_{out}, ecal driven, barrel",           nbineop,0.,eopmax);
   h_ele_EeleOPout_eg_barrel->Sumw2();
   h_ele_EeleOPout_endcaps         = new TH1F( "h_ele_EeleOPout_endcaps",         "ele E_{ele}/P_{out} endcaps",           nbineop,0.,eopmax);
   h_ele_EeleOPout_endcaps->Sumw2();
   h_ele_EeleOPout_eg_endcaps         = new TH1F( "h_ele_EeleOPout_eg_endcaps",         "ele E_{ele}/P_{out}, ecal driven, endcaps",           nbineop,0.,eopmax);
   h_ele_EeleOPout_eg_endcaps->Sumw2();
   h_ele_EeleOPoutVsEta         = new TH2F( "h_ele_EeleOPoutVsEta",         "ele E_{ele}/P_{out} vs eta",    nbineta2D,etamin,etamax,nbineop2D,0.,eopmaxsht);
   h_ele_EeleOPoutVsPhi         = new TH2F( "h_ele_EeleOPoutVsPhi",         "ele E_{ele}/P_{out} vs phi",    nbinphi2D,phimin,phimax,nbineop2D,0.,eopmaxsht);
   h_ele_EeleOPoutVsE         = new TH2F( "h_ele_EeleOPoutVsE",         "ele E_{ele}/P_{out} vs E",    nbinp2D,0.,pmax,nbineop2D,0.,eopmaxsht);
   h_ele_dEtaSc_propVtx = new TH1F( "h_ele_dEtaSc_propVtx", "ele #eta_{sc} - #eta_{tr}, prop from vertex",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx->Sumw2();
   h_ele_dEtaSc_propVtx_eg = new TH1F( "h_ele_dEtaSc_propVtx_eg", "ele #eta_{sc} - #eta_{tr}, prop from vertex, ecal driven",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_eg->Sumw2();
   h_ele_dEtaSc_propVtx_barrel = new TH1F( "h_ele_dEtaSc_propVtx_barrel", "ele #eta_{sc} - #eta_{tr}, prop from vertex, barrel",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_barrel->Sumw2();
   h_ele_dEtaSc_propVtx_eg_barrel = new TH1F( "h_ele_dEtaSc_propVtx_eg_barrel", "ele #eta_{sc} - #eta_{tr}, prop from vertex, ecal driven, barrel",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_eg_barrel->Sumw2();
   h_ele_dEtaSc_propVtx_endcaps = new TH1F( "h_ele_dEtaSc_propVtx_endcaps", "ele #eta_{sc} - #eta_{tr}, prop from vertex, endcaps",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_endcaps->Sumw2();
   h_ele_dEtaSc_propVtx_eg_endcaps = new TH1F( "h_ele_dEtaSc_propVtx_eg_endcaps", "ele #eta_{sc} - #eta_{tr}, prop from vertex, ecal driven, endcaps",      nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaSc_propVtx_eg_endcaps->Sumw2();
   h_ele_dEtaScVsEta_propVtx = new TH2F( "h_ele_dEtaScVsEta_propVtx", "ele #eta_{sc} - #eta_{tr} vs eta, prop from vertex", nbineta2D,etamin,etamax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaScVsPhi_propVtx = new TH2F( "h_ele_dEtaScVsPhi_propVtx", "ele #eta_{sc} - #eta_{tr} vs phi, prop from vertex", nbinphi2D,phimin,phimax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaScVsPt_propVtx = new TH2F( "h_ele_dEtaScVsPt_propVtx", "ele #eta_{sc} - #eta_{tr} vs pt, prop from vertex", nbinpt2D,0.,ptmax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dPhiSc_propVtx = new TH1F( "h_ele_dPhiSc_propVtx", "ele #phi_{sc} - #phi_{tr}, prop from vertex",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx->Sumw2();
   h_ele_dPhiSc_propVtx_eg = new TH1F( "h_ele_dPhiSc_propVtx_eg", "ele #phi_{sc} - #phi_{tr}, prop from vertex, ecal driven",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_eg->Sumw2();
   h_ele_dPhiSc_propVtx_barrel = new TH1F( "h_ele_dPhiSc_propVtx_barrel", "ele #phi_{sc} - #phi_{tr}, prop from vertex, barrel",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_barrel->Sumw2();
   h_ele_dPhiSc_propVtx_eg_barrel = new TH1F( "h_ele_dPhiSc_propVtx_eg_barrel", "ele #phi_{sc} - #phi_{tr}, prop from vertex, ecal driven, barrel",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_eg_barrel->Sumw2();
   h_ele_dPhiSc_propVtx_endcaps = new TH1F( "h_ele_dPhiSc_propVtx_endcaps", "ele #phi_{sc} - #phi_{tr}, prop from vertex, endcaps",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_endcaps->Sumw2();
   h_ele_dPhiSc_propVtx_eg_endcaps = new TH1F( "h_ele_dPhiSc_propVtx_eg_endcaps", "ele #phi_{sc} - #phi_{tr}, prop from vertex, ecal driven, endcaps",      nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiSc_propVtx_eg_endcaps->Sumw2();
   h_ele_dPhiScVsEta_propVtx = new TH2F( "h_ele_dPhiScVsEta_propVtx", "ele #phi_{sc} - #phi_{tr} vs eta, prop from vertex", nbineta2D,etamin,etamax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiScVsPhi_propVtx = new TH2F( "h_ele_dPhiScVsPhi_propVtx", "ele #phi_{sc} - #phi_{tr} vs phi, prop from vertex", nbinphi2D,phimin,phimax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiScVsPt_propVtx = new TH2F( "h_ele_dPhiScVsPt_propVtx", "ele #phi_{sc} - #phi_{tr} vs pt, prop from vertex", nbinpt2D,0.,ptmax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dEtaCl_propOut = new TH1F( "h_ele_dEtaCl_propOut", "ele #eta_{cl} - #eta_{tr}, prop from outermost",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut->Sumw2();
   h_ele_dEtaCl_propOut_eg = new TH1F( "h_ele_dEtaCl_propOut_eg", "ele #eta_{cl} - #eta_{tr}, prop from outermost, ecal driven",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_eg->Sumw2();
   h_ele_dEtaCl_propOut_barrel = new TH1F( "h_ele_dEtaCl_propOut_barrel", "ele #eta_{cl} - #eta_{tr}, prop from outermost, barrel",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_barrel->Sumw2();
   h_ele_dEtaCl_propOut_eg_barrel = new TH1F( "h_ele_dEtaCl_propOut_eg_barrel", "ele #eta_{cl} - #eta_{tr}, prop from outermost, ecal driven, barrel",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_eg_barrel->Sumw2();
   h_ele_dEtaCl_propOut_endcaps = new TH1F( "h_ele_dEtaCl_propOut_endcaps", "ele #eta_{cl} - #eta_{tr}, prop from outermost, endcaps",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_endcaps->Sumw2();
   h_ele_dEtaCl_propOut_eg_endcaps = new TH1F( "h_ele_dEtaCl_propOut_eg_endcaps", "ele #eta_{cl} - #eta_{tr}, prop from outermost, ecal driven, endcaps",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaCl_propOut_eg_endcaps->Sumw2();
   h_ele_dEtaClVsEta_propOut = new TH2F( "h_ele_dEtaClVsEta_propOut", "ele #eta_{cl} - #eta_{tr} vs eta, prop from out", nbineta2D,etamin,etamax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaClVsPhi_propOut = new TH2F( "h_ele_dEtaClVsPhi_propOut", "ele #eta_{cl} - #eta_{tr} vs phi, prop from out", nbinphi2D,phimin,phimax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaClVsPt_propOut = new TH2F( "h_ele_dEtaScVsPt_propOut", "ele #eta_{cl} - #eta_{tr} vs pt, prop from out", nbinpt2D,0.,ptmax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dPhiCl_propOut = new TH1F( "h_ele_dPhiCl_propOut", "ele #phi_{cl} - #phi_{tr}, prop from outermost",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut->Sumw2();
   h_ele_dPhiCl_propOut_eg = new TH1F( "h_ele_dPhiCl_propOut_eg", "ele #phi_{cl} - #phi_{tr}, prop from outermost, ecal driven",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_eg->Sumw2();
   h_ele_dPhiCl_propOut_barrel = new TH1F( "h_ele_dPhiCl_propOut_barrel", "ele #phi_{cl} - #phi_{tr}, prop from outermost, barrel",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_barrel->Sumw2();
   h_ele_dPhiCl_propOut_eg_barrel = new TH1F( "h_ele_dPhiCl_propOut_eg_barrel", "ele #phi_{cl} - #phi_{tr}, prop from outermost, ecal driven, barrel",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_eg_barrel->Sumw2();
   h_ele_dPhiCl_propOut_endcaps = new TH1F( "h_ele_dPhiCl_propOut_endcaps", "ele #phi_{cl} - #phi_{tr}, prop from outermost, endcaps",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_endcaps->Sumw2();
   h_ele_dPhiCl_propOut_eg_endcaps = new TH1F( "h_ele_dPhiCl_propOut_eg_endcaps", "ele #phi_{cl} - #phi_{tr}, prop from outermost, ecal driven, endcaps",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiCl_propOut_eg_endcaps->Sumw2();
   h_ele_dPhiClVsEta_propOut = new TH2F( "h_ele_dPhiClVsEta_propOut", "ele #phi_{cl} - #phi_{tr} vs eta, prop from out", nbineta2D,etamin,etamax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiClVsPhi_propOut = new TH2F( "h_ele_dPhiClVsPhi_propOut", "ele #phi_{cl} - #phi_{tr} vs phi, prop from out", nbinphi2D,phimin,phimax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiClVsPt_propOut = new TH2F( "h_ele_dPhiSClsPt_propOut", "ele #phi_{cl} - #phi_{tr} vs pt, prop from out", nbinpt2D,0.,ptmax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dEtaEleCl_propOut = new TH1F( "h_ele_dEtaEleCl_propOut", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut->Sumw2();
   h_ele_dEtaEleCl_propOut_eg = new TH1F( "h_ele_dEtaEleCl_propOut_eg", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost, ecal driven",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut_eg->Sumw2();
   h_ele_dEtaEleCl_propOut_barrel = new TH1F( "h_ele_dEtaEleCl_propOut_barrel", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost, barrel",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut_barrel->Sumw2();
   h_ele_dEtaEleCl_propOut_eg_barrel = new TH1F( "h_ele_dEtaEleCl_propOut_eg_barrel", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost, ecal driven, barrel",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut_eg_barrel->Sumw2();
   h_ele_dEtaEleCl_propOut_endcaps = new TH1F( "h_ele_dEtaEleCl_propOut_endcaps", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost, endcaps",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut_endcaps->Sumw2();
   h_ele_dEtaEleCl_propOut_eg_endcaps = new TH1F( "h_ele_dEtaEleCl_propOut_eg_endcaps", "ele #eta_{EleCl} - #eta_{tr}, prop from outermost, ecal driven, endcaps",   nbindetamatch,detamatchmin,detamatchmax);
   h_ele_dEtaEleCl_propOut_eg_endcaps->Sumw2();
   h_ele_dEtaEleClVsEta_propOut = new TH2F( "h_ele_dEtaEleClVsEta_propOut", "ele #eta_{EleCl} - #eta_{tr} vs eta, prop from out", nbineta2D,etamin,etamax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaEleClVsPhi_propOut = new TH2F( "h_ele_dEtaEleClVsPhi_propOut", "ele #eta_{EleCl} - #eta_{tr} vs phi, prop from out", nbinphi2D,phimin,phimax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dEtaEleClVsPt_propOut = new TH2F( "h_ele_dEtaScVsPt_propOut", "ele #eta_{EleCl} - #eta_{tr} vs pt, prop from out", nbinpt2D,0.,ptmax,nbindetamatch2D,detamatchmin,detamatchmax);
   h_ele_dPhiEleCl_propOut = new TH1F( "h_ele_dPhiEleCl_propOut", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut->Sumw2();
   h_ele_dPhiEleCl_propOut_eg = new TH1F( "h_ele_dPhiEleCl_propOut_eg", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost, ecal driven",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut_eg->Sumw2();
   h_ele_dPhiEleCl_propOut_barrel = new TH1F( "h_ele_dPhiEleCl_propOut_barrel", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost, barrel",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut_barrel->Sumw2();
   h_ele_dPhiEleCl_propOut_eg_barrel = new TH1F( "h_ele_dPhiEleCl_propOut_eg_barrel", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost, ecal driven, barrel",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut_eg_barrel->Sumw2();
   h_ele_dPhiEleCl_propOut_endcaps = new TH1F( "h_ele_dPhiEleCl_propOut_endcaps", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost, endcaps",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut_endcaps->Sumw2();
   h_ele_dPhiEleCl_propOut_eg_endcaps = new TH1F( "h_ele_dPhiEleCl_propOut_eg_endcaps", "ele #phi_{EleCl} - #phi_{tr}, prop from outermost, ecal driven, endcaps",   nbindphimatch,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleCl_propOut_eg_endcaps->Sumw2();
   h_ele_dPhiEleClVsEta_propOut = new TH2F( "h_ele_dPhiEleClVsEta_propOut", "ele #phi_{EleCl} - #phi_{tr} vs eta, prop from out", nbineta2D,etamin,etamax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleClVsPhi_propOut = new TH2F( "h_ele_dPhiEleClVsPhi_propOut", "ele #phi_{EleCl} - #phi_{tr} vs phi, prop from out", nbinphi2D,phimin,phimax,nbindphimatch2D,dphimatchmin,dphimatchmax);
   h_ele_dPhiEleClVsPt_propOut = new TH2F( "h_ele_dPhiSEleClsPt_propOut", "ele #phi_{EleCl} - #phi_{tr} vs pt, prop from out", nbinpt2D,0.,ptmax,nbindphimatch2D,dphimatchmin,dphimatchmax);
 
   h_ele_HoE = new TH1F("h_ele_HoE", "ele hadronic energy / em energy", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE->Sumw2();
   h_ele_HoE_eg = new TH1F("h_ele_HoE_eg", "ele hadronic energy / em energy, ecal driven", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_eg->Sumw2();
   h_ele_HoE_barrel = new TH1F("h_ele_HoE_barrel", "ele hadronic energy / em energy, barrel", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_barrel->Sumw2();
   h_ele_HoE_eg_barrel = new TH1F("h_ele_HoE_eg_barrel", "ele hadronic energy / em energy, ecal driven, barrel", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_eg_barrel->Sumw2();
   h_ele_HoE_endcaps = new TH1F("h_ele_HoE_endcaps", "ele hadronic energy / em energy, endcaps", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_endcaps->Sumw2();
   h_ele_HoE_eg_endcaps = new TH1F("h_ele_HoE_eg_endcaps", "ele hadronic energy / em energy, ecal driven, endcaps", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_eg_endcaps->Sumw2();
   h_ele_HoE_fiducial = new TH1F("h_ele_HoE_fiducial", "ele hadronic energy / em energy, fiducial region", nbinhoe, hoemin, hoemax) ;
   h_ele_HoE_fiducial->Sumw2();
   h_ele_HoEVsEta = new TH2F("h_ele_HoEVsEta", "ele hadronic energy / em energy vs eta", nbineta,etamin,etamax,nbinhoe, hoemin, hoemax) ;
   h_ele_HoEVsPhi = new TH2F("h_ele_HoEVsPhi", "ele hadronic energy / em energy vs phi", nbinphi2D,phimin,phimax,nbinhoe, hoemin, hoemax) ;
   h_ele_HoEVsE = new TH2F("h_ele_HoEVsE", "ele hadronic energy / em energy vs E", nbinp, 0.,300.,nbinhoe, hoemin, hoemax) ;
 
   h_ele_seed_dphi2_ = new TH1F("h_ele_seedDphi2", "ele seed dphi 2nd layer", 50,-0.003,+0.003) ;
   h_ele_seed_dphi2_->Sumw2();
   h_ele_seed_dphi2VsEta_ = new TH2F("h_ele_seedDphi2VsEta", "ele seed dphi 2nd layer vs eta", nbineta2D,etamin,etamax,50,-0.003,+0.003) ;
   h_ele_seed_dphi2VsPt_ = new TH2F("h_ele_seedDphi2VsPt", "ele seed dphi 2nd layer vs pt", nbinpt2D,0.,ptmax,50,-0.003,+0.003) ;
   h_ele_seed_drz2_ = new TH1F("h_ele_seedDrz2", "ele seed dr (dz) 2nd layer", 50,-0.03,+0.03) ;
   h_ele_seed_drz2_->Sumw2();
   h_ele_seed_drz2VsEta_ = new TH2F("h_ele_seedDrz2VsEta", "ele seed dr/dz 2nd layer vs eta", nbineta2D,etamin,etamax,50,-0.03,+0.03) ;
   h_ele_seed_drz2VsPt_ = new TH2F("h_ele_seedDrz2VsPt", "ele seed dr/dz 2nd layer vs pt", nbinpt2D,0.,ptmax,50,-0.03,+0.03) ;
   h_ele_seed_subdet2_ = new TH1F("h_ele_seedSubdet2", "ele seed subdet 2nd layer", 10,0.,10.) ;
   h_ele_seed_subdet2_->Sumw2();
 
   // classes
   h_ele_classes = new TH1F( "h_ele_classes", "ele classes",      20,0.0,20.);
   h_ele_classes->Sumw2();
   h_ele_eta = new TH1F( "h_ele_eta", "ele electron eta",  nbineta/2,0.0,etamax);
   h_ele_eta->Sumw2();
   h_ele_eta_golden = new TH1F( "h_ele_eta_golden", "ele electron eta golden",  nbineta/2,0.0,etamax);
   h_ele_eta_golden->Sumw2();
   h_ele_eta_bbrem = new TH1F( "h_ele_eta_bbrem", "ele electron eta bbrem",  nbineta/2,0.0,etamax);
   h_ele_eta_bbrem->Sumw2();
   h_ele_eta_narrow = new TH1F( "h_ele_eta_narrow", "ele electron eta narrow",  nbineta/2,0.0,etamax);
   h_ele_eta_narrow->Sumw2();
   h_ele_eta_shower = new TH1F( "h_ele_eta_show", "ele electron eta showering",  nbineta/2,0.0,etamax);
   h_ele_eta_shower->Sumw2();
   h_ele_PinVsPoutGolden_mode = new TH2F( "h_ele_PinVsPoutGolden_mode",      "ele track inner p vs outer p vs eta, golden, mode of GSF components" ,nbinp2D,0.,pmax,50,0.,pmax);
   h_ele_PinVsPoutShowering_mode = new TH2F( "h_ele_PinVsPoutShowering_mode",      "ele track inner p vs outer p vs eta, showering, mode of GSF components" ,nbinp2D,0.,pmax,50,0.,pmax);
   h_ele_PinVsPoutGolden_mean = new TH2F( "h_ele_PinVsPoutGolden_mean",      "ele track inner p vs outer p vs eta, golden, mean of GSF components" ,nbinp2D,0.,pmax,50,0.,pmax);
   h_ele_PinVsPoutShowering_mean = new TH2F( "h_ele_PinVsPoutShowering_mean",      "ele track inner p vs outer p vs eta, showering, mean of GSF components" ,nbinp2D,0.,pmax,50,0.,pmax);
   h_ele_PtinVsPtoutGolden_mode = new TH2F( "h_ele_PtinVsPtoutGolden_mode",      "ele track inner pt vs outer pt vs eta, golden, mode of GSF components" ,nbinpt2D,0.,ptmax,50,0.,ptmax);
   h_ele_PtinVsPtoutShowering_mode = new TH2F( "h_ele_PtinVsPtoutShowering_mode",      "ele track inner pt vs outer pt vs eta, showering, mode of GSF components" ,nbinpt2D,0.,ptmax,50,0.,ptmax);
   h_ele_PtinVsPtoutGolden_mean = new TH2F( "h_ele_PtinVsPtoutGolden_mean",      "ele track inner pt vs outer pt vs eta, golden, mean of GSF components" ,nbinpt2D,0.,ptmax,50,0.,ptmax);
   h_ele_PtinVsPtoutShowering_mean = new TH2F( "h_ele_PtinVsPtoutShowering_mean",      "ele track inner pt vs outer pt vs eta, showering, mean of GSF components" ,nbinpt2D,0.,ptmax,50,0.,ptmax);
   histSclEoEtrueGolden_barrel = new TH1F("h_scl_EoEtrue_golden_barrel","ele supercluster energy / gen energy, golden, barrel",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrueGolden_barrel->Sumw2();
   histSclEoEtrueGolden_endcaps = new TH1F("h_scl_EoEtrue_golden_endcaps","ele supercluster energy / gen energy, golden, endcaps",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrueGolden_endcaps->Sumw2();
   histSclEoEtrueShowering_barrel = new TH1F("h_scl_EoEtrue_showering_barrel","ele supercluster energy / gen energy, showering, barrel",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrueShowering_barrel->Sumw2();
   histSclEoEtrueShowering_endcaps = new TH1F("h_scl_EoEtrue_showering_endcaps","ele supercluster energy / gen energy, showering, endcaps",nbinpoptrue,poptruemin,poptruemax);
   histSclEoEtrueShowering_endcaps->Sumw2();
 
   // isolation
   h_ele_tkSumPt_dr03 = new TH1F("h_ele_tkSumPt_dr03","tk isolation sum, dR=0.3",100,0.0,20.);
   h_ele_tkSumPt_dr03->Sumw2();
   h_ele_ecalRecHitSumEt_dr03= new TH1F("h_ele_ecalRecHitSumEt_dr03","ecal isolation sum, dR=0.3",100,0.0,20.);
   h_ele_ecalRecHitSumEt_dr03->Sumw2();
   h_ele_hcalDepth1TowerSumEt_dr03= new TH1F("h_ele_hcalDepth1TowerSumEt_dr03","hcal depth1 isolation sum, dR=0.3",100,0.0,20.);
   h_ele_hcalDepth1TowerSumEt_dr03->Sumw2();
   h_ele_hcalDepth2TowerSumEt_dr03= new TH1F("h_ele_hcalDepth2TowerSumEt_dr03","hcal depth2 isolation sum, dR=0.3",100,0.0,20.);
   h_ele_hcalDepth2TowerSumEt_dr03->Sumw2();
   h_ele_tkSumPt_dr04= new TH1F("h_ele_tkSumPt_dr04","tk isolation sum, dR=0.4",100,0.0,20.);
   h_ele_tkSumPt_dr04->Sumw2();
   h_ele_ecalRecHitSumEt_dr04= new TH1F("h_ele_ecalRecHitSumEt_dr04","ecal isolation sum, dR=0.4",100,0.0,20.);
   h_ele_ecalRecHitSumEt_dr04->Sumw2();
   h_ele_hcalDepth1TowerSumEt_dr04= new TH1F("h_ele_hcalDepth1TowerSumEt_dr04","hcal depth1 isolation sum, dR=0.4",100,0.0,20.);
   h_ele_hcalDepth1TowerSumEt_dr04->Sumw2();
   h_ele_hcalDepth2TowerSumEt_dr04= new TH1F("h_ele_hcalDepth2TowerSumEt_dr04","hcal depth2 isolation sum, dR=0.4",100,0.0,20.);
   h_ele_hcalDepth2TowerSumEt_dr04->Sumw2();
 
   // fbrem
   h_ele_fbrem = new TH1F( "h_ele_fbrem","ele brem fraction, mode of GSF components",100,0.,1.);
   h_ele_fbrem->Sumw2();
   h_ele_fbrem_eg = new TH1F( "h_ele_fbrem_eg","ele brem fraction, mode of GSF components, ecal driven",100,0.,1.);
   h_ele_fbrem_eg->Sumw2();
   h_ele_fbremVsEta_mode = new TProfile( "h_ele_fbremvsEtamode","mean ele brem fraction vs eta, mode of GSF components",nbineta2D,etamin,etamax,0.,1.);
   h_ele_fbremVsEta_mean = new TProfile( "h_ele_fbremvsEtamean","mean ele brem fraction vs eta, mean of GSF components",nbineta2D,etamin,etamax,0.,1.);
 
   // e/g et pflow electrons
   h_ele_mva = new TH1F( "h_ele_mva","ele identification mva",100,-1.,1.);
   h_ele_mva->Sumw2();
   h_ele_mva_eg = new TH1F( "h_ele_mva_eg","ele identification mva, ecal driven",100,-1.,1.);
   h_ele_mva_eg->Sumw2();
   h_ele_provenance = new TH1F( "h_ele_provenance","ele provenance",5,-2.,3.);
   h_ele_provenance->Sumw2();
 
   // histos titles
   h_mcNum              -> GetXaxis()-> SetTitle("N_{gen}");
   h_mcNum              -> GetYaxis()-> SetTitle("Events");
   h_eleNum             -> GetXaxis()-> SetTitle("# gen ele");
   h_eleNum             -> GetYaxis()-> SetTitle("Events");
   h_gamNum             -> GetXaxis()-> SetTitle("N_{gen #gamma}");
   h_gamNum             -> GetYaxis()-> SetTitle("Events");
   h_simEta             -> GetXaxis()-> SetTitle("#eta");
   h_simEta             -> GetYaxis()-> SetTitle("Events");
   h_simP               -> GetXaxis()-> SetTitle("p (GeV/c)");
   h_simP               -> GetYaxis()-> SetTitle("Events");
   h_ele_foundHits      -> GetXaxis()-> SetTitle("N_{hits}");
   h_ele_foundHits      -> GetYaxis()-> SetTitle("Events");
   h_ele_foundHits_barrel      -> GetXaxis()-> SetTitle("N_{hits}");
   h_ele_foundHits_barrel      -> GetYaxis()-> SetTitle("Events");
   h_ele_foundHits_endcaps      -> GetXaxis()-> SetTitle("N_{hits}");
   h_ele_foundHits_endcaps      -> GetYaxis()-> SetTitle("Events");
   h_ele_ambiguousTracks      -> GetXaxis()-> SetTitle("N_{ambiguous tracks}");
   h_ele_ambiguousTracks      -> GetYaxis()-> SetTitle("Events");
   h_ele_lostHits       -> GetXaxis()-> SetTitle("N_{lost hits}");
   h_ele_lostHits       -> GetYaxis()-> SetTitle("Events");
   h_ele_lostHits_barrel       -> GetXaxis()-> SetTitle("N_{lost hits}");
   h_ele_lostHits_barrel       -> GetYaxis()-> SetTitle("Events");
   h_ele_lostHits_endcaps       -> GetXaxis()-> SetTitle("N_{lost hits}");
   h_ele_lostHits_endcaps       -> GetYaxis()-> SetTitle("Events");
   h_ele_chi2           -> GetXaxis()-> SetTitle("#Chi^{2}");
   h_ele_chi2           -> GetYaxis()-> SetTitle("Events");
   h_ele_chi2_barrel           -> GetXaxis()-> SetTitle("#Chi^{2}");
   h_ele_chi2_barrel           -> GetYaxis()-> SetTitle("Events");
   h_ele_chi2_endcaps           -> GetXaxis()-> SetTitle("#Chi^{2}");
   h_ele_chi2_endcaps           -> GetYaxis()-> SetTitle("Events");
   h_ele_charge         -> GetXaxis()-> SetTitle("charge");
   h_ele_charge         -> GetYaxis()-> SetTitle("Events");
   h_ele_vertexP        -> GetXaxis()-> SetTitle("p_{vertex} (GeV/c)");
   h_ele_vertexP        -> GetYaxis()-> SetTitle("Events");
   h_ele_vertexPt       -> GetXaxis()-> SetTitle("p_{T vertex} (GeV/c)");
   h_ele_vertexPt       -> GetYaxis()-> SetTitle("Events");
   h_ele_Et       -> GetXaxis()-> SetTitle("E_{T} (GeV)");
   h_ele_Et       -> GetYaxis()-> SetTitle("Events");
   h_ele_Et_all       -> GetXaxis()-> SetTitle("E_{T} (GeV)");
   h_ele_Et_all       -> GetYaxis()-> SetTitle("Events");
   h_ele_vertexEta      -> GetXaxis()-> SetTitle("#eta");
   h_ele_vertexEta      -> GetYaxis()-> SetTitle("Events");
   h_ele_vertexPhi      -> GetXaxis()-> SetTitle("#phi (rad)");
   h_ele_vertexPhi      -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_barrel        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_barrel        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_endcaps        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_endcaps        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_golden_barrel        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_golden_barrel        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_showering_barrel        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_showering_barrel        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_golden_endcaps        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_golden_endcaps        -> GetYaxis()-> SetTitle("Events");
   h_ele_PoPtrue_showering_endcaps        -> GetXaxis()-> SetTitle("P/P_{gen}");
   h_ele_PoPtrue_showering_endcaps        -> GetYaxis()-> SetTitle("Events");
   h_ele_PtoPttrue        -> GetXaxis()-> SetTitle("P_{T}/P_{T}^{gen}");
   h_ele_PtoPttrue        -> GetYaxis()-> SetTitle("Events");
   h_ele_PtoPttrue_barrel        -> GetXaxis()-> SetTitle("P_{T}/P_{T}^{gen}");
   h_ele_PtoPttrue_barrel        -> GetYaxis()-> SetTitle("Events");
   h_ele_PtoPttrue_endcaps        -> GetXaxis()-> SetTitle("P_{T}/P_{T}^{gen}");
   h_ele_PtoPttrue_endcaps        -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_barrel -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrue_barrel -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrue_endcaps -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrue_endcaps -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrueGolden_barrel -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrueGolden_barrel -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrueShowering_barrel -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrueShowering_barrel -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrueGolden_endcaps -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrueGolden_endcaps -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrueShowering_endcaps -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrueShowering_endcaps -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrue_barrel_etagap -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_barrel_etagap -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_barrel_phigap -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_barrel_phigap -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_ebeegap -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_ebeegap -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_endcaps_deegap -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_endcaps_deegap -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_endcaps_ringgap -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_endcaps_ringgap -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_barrel_new -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrue_barrel_new -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrue_endcaps_new -> GetXaxis()-> SetTitle("E/E_{gen}") ;
   histSclEoEtrue_endcaps_new -> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtrue_barrel_etagap_new -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_barrel_etagap_new -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_barrel_phigap_new -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_barrel_phigap_new -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_ebeegap_new -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_ebeegap_new -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_endcaps_deegap_new -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_endcaps_deegap_new -> GetYaxis()-> SetTitle("Events");
   histSclEoEtrue_endcaps_ringgap_new -> GetXaxis()-> SetTitle("E/E_{gen}");
   histSclEoEtrue_endcaps_ringgap_new -> GetYaxis()-> SetTitle("Events");
   histSclSigEtaEta_-> GetXaxis()-> SetTitle("#sigma_{#eta #eta}") ;
   histSclSigEtaEta_-> GetYaxis()-> SetTitle("Events") ;
   histSclSigEtaEta_barrel_-> GetXaxis()-> SetTitle("#sigma_{#eta #eta}") ;
   histSclSigEtaEta_barrel_-> GetYaxis()-> SetTitle("Events") ;
   histSclSigEtaEta_endcaps_-> GetXaxis()-> SetTitle("#sigma_{#eta #eta}") ;
   histSclSigEtaEta_endcaps_-> GetYaxis()-> SetTitle("Events") ;
   histSclSigIEtaIEta_-> GetXaxis()-> SetTitle("#sigma_{i#eta i#eta}") ;
   histSclSigIEtaIEta_-> GetYaxis()-> SetTitle("Events") ;
   histSclSigIEtaIEta_barrel_-> GetXaxis()-> SetTitle("#sigma_{i#eta i#eta}") ;
   histSclSigIEtaIEta_barrel_-> GetYaxis()-> SetTitle("Events") ;
   histSclSigIEtaIEta_endcaps_-> GetXaxis()-> SetTitle("#sigma_{i#eta i#eta}") ;
   histSclSigIEtaIEta_endcaps_-> GetYaxis()-> SetTitle("Events") ;
   histSclE1x5_-> GetXaxis()-> SetTitle("E1x5 (GeV)") ;
   histSclE1x5_-> GetYaxis()-> SetTitle("Events") ;
   histSclE1x5_barrel_-> GetXaxis()-> SetTitle("E1x5 (GeV)") ;
   histSclE1x5_barrel_-> GetYaxis()-> SetTitle("Events") ;
   histSclE1x5_endcaps_-> GetXaxis()-> SetTitle("E1x5 (GeV)") ;
   histSclE1x5_endcaps_-> GetYaxis()-> SetTitle("Events") ;
   histSclE2x5max_-> GetXaxis()-> SetTitle("E2x5 (GeV)") ;
   histSclE2x5max_-> GetYaxis()-> SetTitle("Events") ;
   histSclE2x5max_barrel_-> GetXaxis()-> SetTitle("E2x5 (GeV)") ;
   histSclE2x5max_barrel_-> GetYaxis()-> SetTitle("Events") ;
   histSclE2x5max_endcaps_-> GetXaxis()-> SetTitle("E2x5 (GeV)") ;
   histSclE2x5max_endcaps_-> GetYaxis()-> SetTitle("Events") ;
   histSclE5x5_-> GetXaxis()-> SetTitle("E5x5 (GeV)") ;
   histSclE5x5_-> GetYaxis()-> SetTitle("Events") ;
   histSclE5x5_barrel_-> GetXaxis()-> SetTitle("E5x5 (GeV)") ;
   histSclE5x5_barrel_-> GetYaxis()-> SetTitle("Events") ;
   histSclE5x5_endcaps_-> GetXaxis()-> SetTitle("E5x5 (GeV)") ;
   histSclE5x5_endcaps_-> GetYaxis()-> SetTitle("Events") ;
   histSclEoEtruePfVsEg->GetXaxis()->SetTitle("E/E_{gen} (e/g)") ;
   histSclEoEtruePfVsEg->GetYaxis()->SetTitle("E/E_{gen} (pflow)") ;
   h_ele_ChargeMnChargeTrue   -> GetXaxis()-> SetTitle("q_{rec} - q_{gen}");
   h_ele_ChargeMnChargeTrue   -> GetYaxis()-> SetTitle("Events");
   h_ele_EtaMnEtaTrue   -> GetXaxis()-> SetTitle("#eta_{rec} - #eta_{gen}");
   h_ele_EtaMnEtaTrue   -> GetYaxis()-> SetTitle("Events");
   h_ele_EtaMnEtaTrue_barrel   -> GetXaxis()-> SetTitle("#eta_{rec} - #eta_{gen}");
   h_ele_EtaMnEtaTrue_barrel   -> GetYaxis()-> SetTitle("Events");
   h_ele_EtaMnEtaTrue_endcaps   -> GetXaxis()-> SetTitle("#eta_{rec} - #eta_{gen}");
   h_ele_EtaMnEtaTrue_endcaps   -> GetYaxis()-> SetTitle("Events");
   h_ele_PhiMnPhiTrue   -> GetXaxis()-> SetTitle("#phi_{rec} - #phi_{gen} (rad)");
   h_ele_PhiMnPhiTrue   -> GetYaxis()-> SetTitle("Events");
   h_ele_PhiMnPhiTrue_barrel   -> GetXaxis()-> SetTitle("#phi_{rec} - #phi_{gen} (rad)");
   h_ele_PhiMnPhiTrue_barrel   -> GetYaxis()-> SetTitle("Events");
   h_ele_PhiMnPhiTrue_endcaps   -> GetXaxis()-> SetTitle("#phi_{rec} - #phi_{gen} (rad)");
   h_ele_PhiMnPhiTrue_endcaps   -> GetYaxis()-> SetTitle("Events");
   h_ele_PinMnPout      -> GetXaxis()-> SetTitle("P_{vertex} - P_{out} (GeV/c)");
   h_ele_PinMnPout      -> GetYaxis()-> SetTitle("Events");
   h_ele_PinMnPout_mode      -> GetXaxis()-> SetTitle("P_{vertex} - P_{out}, mode of GSF components (GeV/c)");
   h_ele_PinMnPout_mode      -> GetYaxis()-> SetTitle("Events");
   h_ele_outerP         -> GetXaxis()-> SetTitle("P_{out} (GeV/c)");
   h_ele_outerP         -> GetYaxis()-> SetTitle("Events");
   h_ele_outerP_mode         -> GetXaxis()-> SetTitle("P_{out} (GeV/c)");
   h_ele_outerP_mode         -> GetYaxis()-> SetTitle("Events");
   h_ele_outerPt        -> GetXaxis()-> SetTitle("P_{T out} (GeV/c)");
   h_ele_outerPt        -> GetYaxis()-> SetTitle("Events");
   h_ele_outerPt_mode        -> GetXaxis()-> SetTitle("P_{T out} (GeV/c)");
   h_ele_outerPt_mode        -> GetYaxis()-> SetTitle("Events");
   h_ele_EoP            -> GetXaxis()-> SetTitle("E/P_{vertex}");
   h_ele_EoP            -> GetYaxis()-> SetTitle("Events");
   h_ele_EseedOP            -> GetXaxis()-> SetTitle("E_{seed}/P_{vertex}");
   h_ele_EseedOP            -> GetYaxis()-> SetTitle("Events");
   h_ele_EoPout         -> GetXaxis()-> SetTitle("E_{seed}/P_{out}");
   h_ele_EoPout         -> GetYaxis()-> SetTitle("Events");
   h_ele_EeleOPout         -> GetXaxis()-> SetTitle("E_{ele}/P_{out}");
   h_ele_EeleOPout         -> GetYaxis()-> SetTitle("Events");
   h_ele_EoP_barrel            -> GetXaxis()-> SetTitle("E/P_{vertex}");
   h_ele_EoP_barrel            -> GetYaxis()-> SetTitle("Events");
   h_ele_EseedOP_barrel            -> GetXaxis()-> SetTitle("E_{seed}/P_{vertex}");
   h_ele_EseedOP_barrel            -> GetYaxis()-> SetTitle("Events");
   h_ele_EoPout_bar

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation