#include <SUSYBSMAnalysis/HSCP/src/HSCPTreeBuilder.cc>

Inheritance diagram for HSCPTreeBuilder:

Public Member Functions
	HSCPTreeBuilder (const edm::ParameterSet &)

	~HSCPTreeBuilder () override

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDFilter () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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 &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

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 Member Functions
void	beginJob () override

int	ClosestMuonIndex (reco::TrackRef track, std::vector< reco::MuonRef >)

void	endJob () override

bool	filter (edm::Event &, const edm::EventSetup &) override

Private Attributes
float	Calo_ecal_beta [10000]

float	Calo_ecal_beta_err [10000]

float	Calo_ecal_chi2s [10000][10]

float	Calo_ecal_crossedE [10000]

float	Calo_ecal_dEdx [10000]

unsigned int	Calo_ecal_detIds [10000][10]

float	Calo_ecal_e1OverE9s [10000][10]

float	Calo_ecal_energies [10000][10]

float	Calo_ecal_invBeta_err [10000]

int	Calo_ecal_numCrysCrossed [10000]

float	Calo_ecal_outOfTimeChi2s [10000][10]

float	Calo_ecal_outOfTimeEnergies [10000][10]

float	Calo_ecal_swissCrossKs [10000][10]

float	Calo_ecal_time [10000]

float	Calo_ecal_time_err [10000]

float	Calo_ecal_timeErrors [10000][10]

float	Calo_ecal_times [10000][10]

float	Calo_ecal_trackExitEtas [10000][10]

float	Calo_ecal_trackExitPhis [10000][10]

float	Calo_ecal_trackLengths [10000][10]

float	Event_BField

unsigned int	Event_BXCrossing

unsigned int	Event_EventNumber

unsigned int	Event_LumiSection

unsigned int	Event_Orbit

bool	Event_PhysicsDeclared

unsigned int	Event_RunNumber

unsigned int	Event_Store

bool	Event_technicalBits [64]

unsigned int	Event_Time

bool	Event_triggerHLTBits [128]

bool	Event_triggerL1Bits [192]

float	Gen_beta [10000]

float	Gen_charge [10000]

float	Gen_eta [10000]

float	Gen_mass [10000]

float	Gen_p [10000]

int	Gen_pdgId [10000]

float	Gen_phi [10000]

float	Gen_pt [10000]

float	Gen_px [10000]

float	Gen_py [10000]

float	Gen_pz [10000]

bool	Hscp_hasCalo [10000]

bool	Hscp_hasMuon [10000]

bool	Hscp_hasRpc [10000]

bool	Hscp_hasTrack [10000]

int	Hscp_type [10000]

const edm::Event *	iEvent_

const edm::EventSetup *	iSetup_

EDGetTokenT< GenParticleCollection >	m_genParticlesToken

EDGetTokenT< L1GlobalTriggerReadoutRecord >	m_gtReadoutRecordToken

EDGetTokenT< susybsm::HSCParticleCollection >	m_HSCPsToken

EDGetTokenT< reco::VertexCollection >	m_recoVertexToken

EDGetTokenT< edm::TriggerResults >	m_trToken

float	Muon_cb_fIBeta [10000]

float	Muon_cb_fIBeta_err [10000]

float	Muon_cb_IBeta [10000]

float	Muon_cb_IBeta_err [10000]

int	Muon_cb_ndof [10000]

int	Muon_charge [10000]

float	Muon_csc_fIBeta [10000]

float	Muon_csc_fIBeta_err [10000]

float	Muon_csc_IBeta [10000]

float	Muon_csc_IBeta_err [10000]

int	Muon_csc_ndof [10000]

float	Muon_dt_fIBeta [10000]

float	Muon_dt_fIBeta_err [10000]

float	Muon_dt_IBeta [10000]

float	Muon_dt_IBeta_err [10000]

int	Muon_dt_ndof [10000]

float	Muon_eta [10000]

float	Muon_p [10000]

float	Muon_phi [10000]

float	Muon_pt [10000]

bool	Muon_qualityValid [10000]

int	Muon_type [10000]

TTree *	MyTree

unsigned int	NGens

unsigned int	NHSCPs

unsigned int	NVertices

bool	reccordGenInfo

bool	reccordVertexInfo

float	Rpc_beta [10000]

edm::Service< TFileService >	tfs

int	Track_charge [10000]

float	Track_chi2 [10000]

float	Track_d0 [10000]

float	Track_dEdxD1 [10000]

unsigned int	Track_dEdxD1_NOM [10000]

float	Track_dEdxD1_NOS [10000]

float	Track_dEdxD2 [10000]

unsigned int	Track_dEdxD2_NOM [10000]

float	Track_dEdxD2_NOS [10000]

float	Track_dEdxD3 [10000]

unsigned int	Track_dEdxD3_NOM [10000]

float	Track_dEdxD3_NOS [10000]

float	Track_dEdxE1 [10000]

unsigned int	Track_dEdxE1_NOM [10000]

float	Track_dEdxE1_NOS [10000]

float	Track_dEdxE2 [10000]

unsigned int	Track_dEdxE2_NOM [10000]

float	Track_dEdxE2_NOS [10000]

float	Track_dEdxE3 [10000]

unsigned int	Track_dEdxE3_NOM [10000]

float	Track_dEdxE3_NOS [10000]

float	Track_dz [10000]

float	Track_eta [10000]

float	Track_eta_err [10000]

unsigned int	Track_ndof [10000]

unsigned int	Track_NOH [10000]

float	Track_p [10000]

float	Track_phi [10000]

float	Track_phi_err [10000]

float	Track_pt [10000]

float	Track_pt_err [10000]

int	Track_quality [10000]

float	Vertex_chi2 [1000]

bool	Vertex_isFake [1000]

float	Vertex_ndof [1000]

int	Vertex_TrackSize [1000]

float	Vertex_x [1000]

float	Vertex_x_err [1000]

float	Vertex_y [1000]

float	Vertex_y_err [1000]

float	Vertex_z [1000]

float	Vertex_z_err [1000]

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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

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

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

Detailed Description

Description: <one line="" class="" summary>="">

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

Definition at line 112 of file HSCPTreeBuilder.cc.

Constructor & Destructor Documentation

◆ HSCPTreeBuilder()

HSCPTreeBuilder::HSCPTreeBuilder ( const edm::ParameterSet & iConfig )

explicit

Definition at line 259 of file HSCPTreeBuilder.cc.

                                                                {
   m_gtReadoutRecordToken = consumes<L1GlobalTriggerReadoutRecord>(InputTag("gtDigis"));
   m_trToken = consumes<edm::TriggerResults>(InputTag("TriggerResults"));
   m_recoVertexToken = consumes<reco::VertexCollection>(InputTag("offlinePrimaryVertices"));
   m_genParticlesToken = mayConsume<GenParticleCollection>(InputTag("genParticles"));
   m_HSCPsToken = consumes<susybsm::HSCParticleCollection>(iConfig.getParameter<InputTag>("HSCParticles"));
  
   reccordVertexInfo = iConfig.getUntrackedParameter<bool>("reccordVertexInfo", true);
   reccordGenInfo = iConfig.getUntrackedParameter<bool>("reccordGenInfo", false);
  
   std::cout << "######################################################" << endl;
   std::cout << "      USE OF THE HSCPTreeBuilder is deprecated!       " << endl;
   std::cout << "better to use the HSCParticle Producer and then FWLite" << endl;
   std::cout << "######################################################" << endl;
 }

References gather_cfg::cout, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and HLT_FULL_cff::InputTag.

◆ ~HSCPTreeBuilder()

HSCPTreeBuilder::~HSCPTreeBuilder ( )

override

Definition at line 275 of file HSCPTreeBuilder.cc.

275 {}

Member Function Documentation

◆ beginJob()

void HSCPTreeBuilder::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 277 of file HSCPTreeBuilder.cc.

                                {
   TTree::SetMaxTreeSize(1000 * Long64_t(2000000000));  // authorize Trees up to 2 Terabytes
   MyTree = tfs->make<TTree>("HscpTree", "HscpTree");
  
   MyTree->Branch("Event_EventNumber", &Event_EventNumber, "Event_EventNumber/i");
   MyTree->Branch("Event_RunNumber", &Event_RunNumber, "Event_RunNumber/i");
   MyTree->Branch("Event_LumiSection", &Event_LumiSection, "Event_LumiSection/i");
   MyTree->Branch("Event_BXCrossing", &Event_BXCrossing, "Event_BXCrossing/i");
   MyTree->Branch("Event_Orbit", &Event_Orbit, "Event_Orbit/i");
   MyTree->Branch("Event_Store", &Event_Store, "Event_Store/i");
   MyTree->Branch("Event_Time", &Event_Time, "Event_Time/i");
   MyTree->Branch("Event_PhysicsDeclared", &Event_PhysicsDeclared, "Event_PhysicsDeclared/O");
   MyTree->Branch("Event_technicalBits", Event_technicalBits, "Event_technicalBits[64]/O");
   MyTree->Branch("Event_triggerL1Bits", Event_triggerL1Bits, "Event_triggerL1Bits[192]/O");
   MyTree->Branch("Event_triggerHLTBits", Event_triggerHLTBits, "Event_triggerHLTBits[128]/O");
   MyTree->Branch("Event_BField", &Event_BField, "Event_BField/F");
  
   if (reccordVertexInfo) {
     MyTree->Branch("NVertices", &NVertices, "NVertices/I");
     MyTree->Branch("Vertex_x", Vertex_x, "Vertex_x[NVertices]/F");
     MyTree->Branch("Vertex_y", Vertex_y, "Vertex_y[NVertices]/F");
     MyTree->Branch("Vertex_z", Vertex_z, "Vertex_z[NVertices]/F");
     MyTree->Branch("Vertex_x_err", Vertex_x_err, "Vertex_x_err[NVertices]/F");
     MyTree->Branch("Vertex_y_err", Vertex_y_err, "Vertex_y_err[NVertices]/F");
     MyTree->Branch("Vertex_z_err", Vertex_z_err, "Vertex_z_err[NVertices]/F");
     MyTree->Branch("Vertex_TrackSize", Vertex_TrackSize, "Vertex_TrackSize[NVertices]/I");
     MyTree->Branch("Vertex_chi2", Vertex_chi2, "Vertex_chi2[NVertices]/F");
     MyTree->Branch("Vertex_ndof", Vertex_ndof, "Vertex_ndof[NVertices]/F");
     MyTree->Branch("Vertex_isFake", Vertex_isFake, "Vertex_isFake[NVertices]/O");
   }
  
   MyTree->Branch("NHSCPs", &NHSCPs, "NHSCPs/I");
   MyTree->Branch("Hscp_hasTrack", Hscp_hasTrack, "Hscp_hasTrack[NHSCPs]/O");
   MyTree->Branch("Hscp_hasMuon", Hscp_hasMuon, "Hscp_hasMuon[NHSCPs]/O");
   MyTree->Branch("Hscp_hasRpc", Hscp_hasRpc, "Hscp_hasRpc[NHSCPs]/O");
   MyTree->Branch("Hscp_hasCalo", Hscp_hasCalo, "Hscp_hasCalo[NHSCPs]/O");
   MyTree->Branch("Hscp_type", Hscp_type, "Hscp_type[NHSCPs]/I");
   MyTree->Branch("Track_NOH", Track_NOH, "Track_NOH[NHSCPs]/I");
   MyTree->Branch("Track_p", Track_p, "Track_p[NHSCPs]/F");
   MyTree->Branch("Track_pt", Track_pt, "Track_pt[NHSCPs]/F");
   MyTree->Branch("Track_pt_err", Track_pt_err, "Track_pt_err[NHSCPs]/F");
   MyTree->Branch("Track_chi2", Track_chi2, "Track_chi2[NHSCPs]/F");
   MyTree->Branch("Track_ndof", Track_ndof, "Track_ndof[NHSCPs]/F");
   MyTree->Branch("Track_eta", Track_eta, "Track_eta[NHSCPs]/F");
   MyTree->Branch("Track_eta_err", Track_eta_err, "Track_eta_err[NHSCPs]/F");
   MyTree->Branch("Track_phi", Track_phi, "Track_phi[NHSCPs]/F");
   MyTree->Branch("Track_phi_err", Track_phi_err, "Track_phi_err[NHSCPs]/F");
   MyTree->Branch("Track_d0", Track_d0, "Track_d0[NHSCPs]/F");
   MyTree->Branch("Track_dz", Track_dz, "Track_dz[NHSCPs]/F");
   MyTree->Branch("Track_quality", Track_quality, "Track_quality[NHSCPs]/I");
   MyTree->Branch("Track_charge", Track_charge, "Track_charge[NHSCPs]/I");
   MyTree->Branch("Track_dEdxE1", Track_dEdxE1, "Track_dEdxE1[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE1_NOS", Track_dEdxE1_NOS, "Track_dEdxE1_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE1_NOM", Track_dEdxE1_NOM, "Track_dEdxE1_NOM[NHSCPs]/I");
   MyTree->Branch("Track_dEdxE2", Track_dEdxE2, "Track_dEdxE2[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE2_NOS", Track_dEdxE2_NOS, "Track_dEdxE2_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE2_NOM", Track_dEdxE2_NOM, "Track_dEdxE2_NOM[NHSCPs]/I");
   MyTree->Branch("Track_dEdxE3", Track_dEdxE3, "Track_dEdxE3[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE3_NOS", Track_dEdxE3_NOS, "Track_dEdxE3_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxE3_NOM", Track_dEdxE3_NOM, "Track_dEdxE3_NOM[NHSCPs]/I");
   MyTree->Branch("Track_dEdxD1", Track_dEdxD1, "Track_dEdxD1[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD1_NOS", Track_dEdxD1_NOS, "Track_dEdxD1_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD1_NOM", Track_dEdxD1_NOM, "Track_dEdxD1_NOM[NHSCPs]/I");
   MyTree->Branch("Track_dEdxD2", Track_dEdxD2, "Track_dEdxD2[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD2_NOS", Track_dEdxD2_NOS, "Track_dEdxD2_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD2_NOM", Track_dEdxD2_NOM, "Track_dEdxD2_NOM[NHSCPs]/I");
   MyTree->Branch("Track_dEdxD3", Track_dEdxD3, "Track_dEdxD3[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD3_NOS", Track_dEdxD3_NOS, "Track_dEdxD3_NOS[NHSCPs]/F");
   MyTree->Branch("Track_dEdxD3_NOM", Track_dEdxD3_NOM, "Track_dEdxD3_NOM[NHSCPs]/I");
   MyTree->Branch("Muon_p", Muon_p, "Muon_p[NHSCPs]/F");
   MyTree->Branch("Muon_pt", Muon_pt, "Muon_pt[NHSCPs]/F");
   MyTree->Branch("Muon_eta", Muon_eta, "Muon_eta[NHSCPs]/F");
   MyTree->Branch("Muon_phi", Muon_phi, "Muon_phi[NHSCPs]/F");
   MyTree->Branch("Muon_type", Muon_type, "Muon_type[NHSCPs]/i");
   MyTree->Branch("Muon_qualityValid", Muon_qualityValid, "Muon_qualityValid[NHSCPs]/O");
   MyTree->Branch("Muon_charge", Muon_charge, "Muon_charge[NHSCPs]/i");
   MyTree->Branch("Muon_dt_IBeta", Muon_dt_IBeta, "Muon_dt_IBeta[NHSCPs]/F");
   MyTree->Branch("Muon_dt_IBeta_err", Muon_dt_IBeta_err, "Muon_dt_IBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_dt_fIBeta", Muon_dt_fIBeta, "Muon_dt_fIBeta[NHSCPs]/F");
   MyTree->Branch("Muon_dt_fIBeta_err", Muon_dt_fIBeta_err, "Muon_dt_fIBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_dt_ndof", Muon_dt_ndof, "Muon_dt_ndof[NHSCPs]/I");
   MyTree->Branch("Muon_csc_IBeta", Muon_csc_IBeta, "Muon_csc_IBeta[NHSCPs]/F");
   MyTree->Branch("Muon_csc_IBeta_err", Muon_csc_IBeta_err, "Muon_csc_IBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_csc_fIBeta", Muon_csc_fIBeta, "Muon_csc_fIBeta[NHSCPs]/F");
   MyTree->Branch("Muon_csc_fIBeta_err", Muon_csc_fIBeta_err, "Muon_csc_fIBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_csc_ndof", Muon_csc_ndof, "Muon_csc_ndof[NHSCPs]/I");
   MyTree->Branch("Muon_cb_IBeta", Muon_cb_IBeta, "Muon_cb_IBeta[NHSCPs]/F");
   MyTree->Branch("Muon_cb_IBeta_err", Muon_cb_IBeta_err, "Muon_cb_IBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_cb_fIBeta", Muon_cb_fIBeta, "Muon_cb_fIBeta[NHSCPs]/F");
   MyTree->Branch("Muon_cb_fIBeta_err", Muon_cb_fIBeta_err, "Muon_cb_fIBeta_err[NHSCPs]/F");
   MyTree->Branch("Muon_cb_ndof", Muon_cb_ndof, "Muon_cb_ndof[NHSCPs]/I");
  
   MyTree->Branch("Rpc_beta", Rpc_beta, "Rpc_beta[NHSCPs]/F");
  
   MyTree->Branch("Calo_ecal_crossedE", Calo_ecal_crossedE, "Calo_ecal_crossedE[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_beta", Calo_ecal_beta, "Calo_ecal_beta[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_beta_err", Calo_ecal_beta_err, "Calo_ecal_beta_err[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_invBeta_err", Calo_ecal_invBeta_err, "Calo_ecal_invBeta_err[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_dEdx", Calo_ecal_dEdx, "Calo_ecal_dEdx[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_time", Calo_ecal_time, "Calo_ecal_time[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_time_err", Calo_ecal_time_err, "Calo_ecal_time_err[NHSCPs]/F");
   MyTree->Branch("Calo_ecal_numCrysCrossed", Calo_ecal_numCrysCrossed, "Calo_ecal_numCrysCrossed[NHSCPs]/I");
   MyTree->Branch("Calo_ecal_swissCrossKs", Calo_ecal_swissCrossKs, "Calo_ecal_swissCrossKs[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_e1OverE9s", Calo_ecal_e1OverE9s, "Calo_ecal_e1OverE9s[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_trackLengths", Calo_ecal_trackLengths, "Calo_ecal_trackLengths[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_trackExitEtas", Calo_ecal_trackExitEtas, "Calo_ecal_trackExitEtas[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_trackExitPhis", Calo_ecal_trackExitPhis, "Calo_ecal_trackExitPhis[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_energies", Calo_ecal_energies, "Calo_ecal_energies[NHSCPs][10]/F");
   MyTree->Branch(
       "Calo_ecal_outOfTimeEnergies", Calo_ecal_outOfTimeEnergies, "Calo_ecal_outOfTimeEnergies[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_chi2s", Calo_ecal_chi2s, "Calo_ecal_chi2s[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_outOfTimeChi2s", Calo_ecal_outOfTimeChi2s, "Calo_ecal_outOfTimeChi2s[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_times", Calo_ecal_times, "Calo_ecal_times[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_timeErrors", Calo_ecal_timeErrors, "Calo_ecal_timeErrors[NHSCPs][10]/F");
   MyTree->Branch("Calo_ecal_detIds", Calo_ecal_detIds, "Calo_ecal_detIds[NHSCPs][10]/I");
  
   if (reccordGenInfo) {
     MyTree->Branch("NGens", &NGens, "NGens/I");
     MyTree->Branch("Gen_pdgId", Gen_pdgId, "Gen_pdgId[NGens]/i");
     MyTree->Branch("Gen_charge", Gen_charge, "Gen_charge[NGens]/F");
     MyTree->Branch("Gen_p", Gen_p, "Gen_p[NGens]/F");
     MyTree->Branch("Gen_px", Gen_px, "Gen_px[NGens]/F");
     MyTree->Branch("Gen_py", Gen_py, "Gen_py[NGens]/F");
     MyTree->Branch("Gen_pz", Gen_pz, "Gen_pz[NGens]/F");
     MyTree->Branch("Gen_pt", Gen_pt, "Gen_pt[NGens]/F");
     MyTree->Branch("Gen_eta", Gen_eta, "Gen_eta[NGens]/F");
     MyTree->Branch("Gen_phi", Gen_phi, "Gen_phi[NGens]/F");
     MyTree->Branch("Gen_beta", Gen_beta, "Gen_beta[NGens]/F");
     MyTree->Branch("Gen_mass", Gen_mass, "Gen_mass[NGens]/F");
   }
 }

◆ ClosestMuonIndex()

int HSCPTreeBuilder::ClosestMuonIndex	(	reco::TrackRef	track,
		std::vector< reco::MuonRef >
	)

private

◆ endJob()

void HSCPTreeBuilder::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDFilter.

Definition at line 409 of file HSCPTreeBuilder.cc.

409 {}

◆ filter()

bool HSCPTreeBuilder::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::EDFilter.

Definition at line 411 of file HSCPTreeBuilder.cc.

                                                                           {
   bool debug = false;
   if (debug)
     cout << "I'm in HSCPTreeBuilder::analyze!" << endl;
  
   Event_EventNumber = iEvent.id().event();
   Event_RunNumber = iEvent.id().run();
   Event_LumiSection = iEvent.eventAuxiliary().luminosityBlock();
   Event_BXCrossing = iEvent.eventAuxiliary().bunchCrossing();
   Event_Orbit = iEvent.eventAuxiliary().orbitNumber();
   Event_Store = iEvent.eventAuxiliary().storeNumber();
   Event_Time = iEvent.eventAuxiliary().time().value();
  
   // BField part:
   ESHandle<MagneticField> MF;
   iSetup.get<IdealMagneticFieldRecord>().get(MF);
   const MagneticField* theMagneticField = MF.product();
   Event_BField = fabs(theMagneticField->inTesla(GlobalPoint(0, 0, 0)).z());
  
   // L1 TRIGGER part:
   edm::Handle<L1GlobalTriggerReadoutRecord> h_gtReadoutRecord;
   iEvent.getByToken(m_gtReadoutRecordToken, h_gtReadoutRecord);
   L1GtFdlWord fdlWord = h_gtReadoutRecord->gtFdlWord();
   TechnicalTriggerWord L1technical = fdlWord.gtTechnicalTriggerWord();
   Event_PhysicsDeclared = h_gtReadoutRecord->gtFdlWord().physicsDeclared();
   for (unsigned int i = 0; i < 64; ++i) {
     Event_technicalBits[i] = L1technical[i];
   }
   DecisionWord L1decision = fdlWord.gtDecisionWord();
   for (unsigned int i = 0; i < 128; ++i) {
     Event_triggerL1Bits[i] = L1decision[i];
   }
   DecisionWordExtended L1decisionE = fdlWord.gtDecisionWordExtended();
   for (unsigned int i = 0; i < 64; ++i) {
     Event_triggerL1Bits[128 + i] = L1decisionE[i];
   }
  
   // HLT TRIGGER part:
   edm::Handle<edm::TriggerResults> trh;
   iEvent.getByToken(m_trToken, trh);
   for (unsigned int i = 0; i < trh->size() && i < 128; ++i) {
     Event_triggerHLTBits[i] = trh->at(i).accept();
   }
  
   edm::Handle<reco::VertexCollection> recoVertexHandle;
   iEvent.getByToken(m_recoVertexToken, recoVertexHandle);
   reco::VertexCollection recoVertex = *recoVertexHandle;
  
   if (reccordVertexInfo) {
     NVertices = 0;
     for (unsigned int i = 0; i < recoVertex.size(); i++) {
       Vertex_x[NVertices] = recoVertex[i].x();
       Vertex_y[NVertices] = recoVertex[i].y();
       Vertex_z[NVertices] = recoVertex[i].z();
       Vertex_x_err[NVertices] = recoVertex[i].xError();
       Vertex_y_err[NVertices] = recoVertex[i].yError();
       Vertex_z_err[NVertices] = recoVertex[i].zError();
       Vertex_TrackSize[NVertices] = recoVertex[i].tracksSize();
       Vertex_chi2[NVertices] = recoVertex[i].chi2();
       Vertex_ndof[NVertices] = recoVertex[i].ndof();
       Vertex_isFake[NVertices] = recoVertex[i].isFake();
       NVertices++;
     }
   }
  
   // Source Collection
   edm::Handle<susybsm::HSCParticleCollection> HSCPCollectionHandle;
   iEvent.getByToken(m_HSCPsToken, HSCPCollectionHandle);
   susybsm::HSCParticleCollection HSCPCollection = *HSCPCollectionHandle.product();
  
   NHSCPs = 0;
   for (unsigned int i = 0; i < HSCPCollection.size(); i++) {
     susybsm::HSCParticle hscp = HSCPCollection[i];
     reco::MuonRef muon = hscp.muonRef();
     reco::TrackRef track = hscp.trackRef();
     ;
  
     Hscp_hasTrack[NHSCPs] = hscp.hasTrackRef();
     Hscp_hasMuon[NHSCPs] = hscp.hasMuonRef();
     Hscp_hasRpc[NHSCPs] = hscp.hasRpcInfo();
     Hscp_hasCalo[NHSCPs] = hscp.hasCaloInfo();
     Hscp_type[NHSCPs] = hscp.type();
  
     if (track.isNonnull() && Hscp_hasTrack[NHSCPs]) {
       Track_p[NHSCPs] = track->p();
       Track_pt[NHSCPs] = track->pt();
       Track_pt_err[NHSCPs] = track->ptError();
       Track_eta[NHSCPs] = track->eta();
       Track_eta_err[NHSCPs] = track->etaError();
       Track_phi[NHSCPs] = track->phi();
       Track_phi_err[NHSCPs] = track->phiError();
       Track_NOH[NHSCPs] = track->found();
       Track_chi2[NHSCPs] = track->chi2();
       Track_ndof[NHSCPs] = track->ndof();
       Track_d0[NHSCPs] = -1.0f * track->dxy(recoVertex[0].position());
       Track_dz[NHSCPs] = -1.0f * track->dz(recoVertex[0].position());
       Track_quality[NHSCPs] = track->qualityMask();
       Track_charge[NHSCPs] = track->charge();
       /*         Track_dEdxE1       [NHSCPs] = hscp.dedxEstimator1().dEdx();
          Track_dEdxE1_NOM   [NHSCPs] = hscp.dedxEstimator1().numberOfMeasurements();
          Track_dEdxE1_NOS   [NHSCPs] = hscp.dedxEstimator1().numberOfSaturatedMeasurements();
          Track_dEdxE2       [NHSCPs] = hscp.dedxEstimator2().dEdx();
          Track_dEdxE2_NOM   [NHSCPs] = hscp.dedxEstimator2().numberOfMeasurements();
          Track_dEdxE2_NOS   [NHSCPs] = hscp.dedxEstimator2().numberOfSaturatedMeasurements();
          Track_dEdxE3       [NHSCPs] = hscp.dedxEstimator3().dEdx();
          Track_dEdxE3_NOM   [NHSCPs] = hscp.dedxEstimator3().numberOfMeasurements();
          Track_dEdxE3_NOS   [NHSCPs] = hscp.dedxEstimator3().numberOfSaturatedMeasurements();
          Track_dEdxD1       [NHSCPs] = hscp.dedxDiscriminator1().dEdx();
          Track_dEdxD1_NOM   [NHSCPs] = hscp.dedxDiscriminator1().numberOfMeasurements();
          Track_dEdxD1_NOS   [NHSCPs] = hscp.dedxDiscriminator1().numberOfSaturatedMeasurements();
          Track_dEdxD2       [NHSCPs] = hscp.dedxDiscriminator2().dEdx();
          Track_dEdxD2_NOM   [NHSCPs] = hscp.dedxDiscriminator2().numberOfMeasurements();
          Track_dEdxD2_NOS   [NHSCPs] = hscp.dedxDiscriminator2().numberOfSaturatedMeasurements();
          Track_dEdxD3       [NHSCPs] = hscp.dedxDiscriminator3().dEdx();
          Track_dEdxD3_NOM   [NHSCPs] = hscp.dedxDiscriminator3().numberOfMeasurements();
          Track_dEdxD3_NOS   [NHSCPs] = hscp.dedxDiscriminator3().numberOfSaturatedMeasurements();
 */
     }
  
     if (muon.isNonnull() && Hscp_hasMuon[NHSCPs]) {
       Muon_p[NHSCPs] = muon->p();
       Muon_pt[NHSCPs] = muon->pt();
       Muon_eta[NHSCPs] = muon->eta();
       Muon_phi[NHSCPs] = muon->phi();
       Muon_type[NHSCPs] = muon->type();
       Muon_qualityValid[NHSCPs] = muon->isQualityValid();
       Muon_charge[NHSCPs] = muon->charge();
       /*         Muon_dt_IBeta      [NHSCPs] = hscp.muonTimeDt().inverseBeta();
          Muon_dt_IBeta_err  [NHSCPs] = hscp.muonTimeDt().inverseBetaErr();
          Muon_dt_fIBeta     [NHSCPs] = hscp.muonTimeDt().freeInverseBeta();
          Muon_dt_fIBeta_err [NHSCPs] = hscp.muonTimeDt().freeInverseBetaErr();
          Muon_dt_ndof       [NHSCPs] = hscp.muonTimeDt().nDof();
          Muon_csc_IBeta     [NHSCPs] = hscp.muonTimeCsc().inverseBeta();
          Muon_csc_IBeta_err [NHSCPs] = hscp.muonTimeCsc().inverseBetaErr();
          Muon_csc_fIBeta    [NHSCPs] = hscp.muonTimeCsc().freeInverseBeta();
          Muon_csc_fIBeta_err[NHSCPs] = hscp.muonTimeCsc().freeInverseBetaErr();
          Muon_csc_ndof      [NHSCPs] = hscp.muonTimeCsc().nDof();
          Muon_cb_IBeta      [NHSCPs] = hscp.muonTimeCombined().inverseBeta();
          Muon_cb_IBeta_err  [NHSCPs] = hscp.muonTimeCombined().inverseBetaErr();
          Muon_cb_fIBeta     [NHSCPs] = hscp.muonTimeCombined().freeInverseBeta();
          Muon_cb_fIBeta_err [NHSCPs] = hscp.muonTimeCombined().freeInverseBetaErr();
          Muon_cb_ndof       [NHSCPs] = hscp.muonTimeCombined().nDof();
 */
     }
  
     if (hscp.hasCaloInfo()) {
       //         Calo_ecal_crossedE      [NHSCPs] = hscp.calo().ecalCrossedEnergy;
       //         Calo_ecal_beta          [NHSCPs] = hscp.calo().ecalBeta;
       //         Calo_ecal_beta_err      [NHSCPs] = hscp.calo().ecalBetaError;
       //         Calo_ecal_invBeta_err   [NHSCPs] = hscp.calo().ecalInvBetaError;
       //         Calo_ecal_dEdx          [NHSCPs] = hscp.calo().ecalDeDx;
       //         Calo_ecal_time          [NHSCPs] = hscp.calo().ecalTime;
       //         Calo_ecal_time_err      [NHSCPs] = hscp.calo().ecalTimeError;
       //         Calo_ecal_numCrysCrossed[NHSCPs] = hscp.calo().ecalCrysCrossed;
       /*         for(int i=0; i < Calo_ecal_numCrysCrossed[NHSCPs] && i < MAX_ECALCRYS; ++i)
          {
            Calo_ecal_swissCrossKs     [NHSCPs][i] = hscp.calo().ecalSwissCrossKs[i];
            Calo_ecal_e1OverE9s        [NHSCPs][i] = hscp.calo().ecalE1OverE9s[i];
            Calo_ecal_trackLengths     [NHSCPs][i] = hscp.calo().ecalTrackLengths[i];
            GlobalPoint exitPosition = hscp.calo().ecalTrackExitPositions[i];
            Calo_ecal_trackExitEtas    [NHSCPs][i] = exitPosition.eta();
            Calo_ecal_trackExitPhis    [NHSCPs][i] = exitPosition.phi();
            Calo_ecal_energies         [NHSCPs][i] = hscp.calo().ecalEnergies[i];
            Calo_ecal_outOfTimeEnergies[NHSCPs][i] = hscp.calo().ecalOutOfTimeEnergies[i];
            Calo_ecal_chi2s            [NHSCPs][i] = hscp.calo().ecalChi2s[i];
            Calo_ecal_outOfTimeChi2s   [NHSCPs][i] = hscp.calo().ecalOutOfTimeChi2s[i];
            Calo_ecal_times            [NHSCPs][i] = hscp.calo().ecalTimes[i];
            Calo_ecal_timeErrors       [NHSCPs][i] = hscp.calo().ecalTimeErrors[i];
            Calo_ecal_detIds           [NHSCPs][i] = hscp.calo().ecalDetIds[i];
          }
 */
     }
  
     if (Hscp_hasRpc[NHSCPs]) {
       Rpc_beta[NHSCPs] = hscp.rpc().beta;
     }
  
     NHSCPs++;
   }
  
   if (reccordGenInfo) {
     Handle<GenParticleCollection> genParticles;
     iEvent.getByToken(m_genParticlesToken, genParticles);
     NGens = 0;
     for (unsigned int i = 0; i < genParticles->size(); i++) {
       const GenParticle& part = (*genParticles)[i];
       if (part.status() != 1)
         continue;
       if (part.pt() < 5)
         continue;
       //     if(fabs(part.pdgId())<1000000) continue;
  
       Gen_pdgId[NGens] = part.pdgId();
       Gen_charge[NGens] = part.charge();
       Gen_p[NGens] = part.p();
       Gen_px[NGens] = part.px();
       Gen_py[NGens] = part.py();
       Gen_pz[NGens] = part.pz();
       Gen_pt[NGens] = part.pt();
       Gen_eta[NGens] = part.eta();
       Gen_phi[NGens] = part.phi();
       Gen_beta[NGens] = part.p() / part.energy();
       Gen_mass[NGens] = part.mass();
       NGens++;
     }
   }
  
   MyTree->Fill();
   return true;
 }

Member Data Documentation

◆ Calo_ecal_beta

float HSCPTreeBuilder::Calo_ecal_beta[10000]

private

Definition at line 225 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_beta_err

float HSCPTreeBuilder::Calo_ecal_beta_err[10000]

private

Definition at line 226 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_chi2s

float HSCPTreeBuilder::Calo_ecal_chi2s[10000][10]

private

Definition at line 239 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_crossedE

float HSCPTreeBuilder::Calo_ecal_crossedE[10000]

private

Definition at line 224 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_dEdx

float HSCPTreeBuilder::Calo_ecal_dEdx[10000]

private

Definition at line 228 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_detIds

unsigned int HSCPTreeBuilder::Calo_ecal_detIds[10000][10]

private

Definition at line 243 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_e1OverE9s

float HSCPTreeBuilder::Calo_ecal_e1OverE9s[10000][10]

private

Definition at line 233 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_energies

float HSCPTreeBuilder::Calo_ecal_energies[10000][10]

private

Definition at line 237 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_invBeta_err

float HSCPTreeBuilder::Calo_ecal_invBeta_err[10000]

private

Definition at line 227 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_numCrysCrossed

int HSCPTreeBuilder::Calo_ecal_numCrysCrossed[10000]

private

Definition at line 231 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_outOfTimeChi2s

float HSCPTreeBuilder::Calo_ecal_outOfTimeChi2s[10000][10]

private

Definition at line 240 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_outOfTimeEnergies

float HSCPTreeBuilder::Calo_ecal_outOfTimeEnergies[10000][10]

private

Definition at line 238 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_swissCrossKs

float HSCPTreeBuilder::Calo_ecal_swissCrossKs[10000][10]

private

Definition at line 232 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_time

float HSCPTreeBuilder::Calo_ecal_time[10000]

private

Definition at line 229 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_time_err

float HSCPTreeBuilder::Calo_ecal_time_err[10000]

private

Definition at line 230 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_timeErrors

float HSCPTreeBuilder::Calo_ecal_timeErrors[10000][10]

private

Definition at line 242 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_times

float HSCPTreeBuilder::Calo_ecal_times[10000][10]

private

Definition at line 241 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_trackExitEtas

float HSCPTreeBuilder::Calo_ecal_trackExitEtas[10000][10]

private

Definition at line 235 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_trackExitPhis

float HSCPTreeBuilder::Calo_ecal_trackExitPhis[10000][10]

private

Definition at line 236 of file HSCPTreeBuilder.cc.

◆ Calo_ecal_trackLengths

float HSCPTreeBuilder::Calo_ecal_trackLengths[10000][10]

private

Definition at line 234 of file HSCPTreeBuilder.cc.

◆ Event_BField

float HSCPTreeBuilder::Event_BField

private

Definition at line 148 of file HSCPTreeBuilder.cc.

◆ Event_BXCrossing

unsigned int HSCPTreeBuilder::Event_BXCrossing

private

Definition at line 143 of file HSCPTreeBuilder.cc.

◆ Event_EventNumber

unsigned int HSCPTreeBuilder::Event_EventNumber

private

Definition at line 140 of file HSCPTreeBuilder.cc.

◆ Event_LumiSection

unsigned int HSCPTreeBuilder::Event_LumiSection

private

Definition at line 142 of file HSCPTreeBuilder.cc.

◆ Event_Orbit

unsigned int HSCPTreeBuilder::Event_Orbit

private

Definition at line 144 of file HSCPTreeBuilder.cc.

◆ Event_PhysicsDeclared

bool HSCPTreeBuilder::Event_PhysicsDeclared

private

Definition at line 147 of file HSCPTreeBuilder.cc.

◆ Event_RunNumber

unsigned int HSCPTreeBuilder::Event_RunNumber

private

Definition at line 141 of file HSCPTreeBuilder.cc.

◆ Event_Store

unsigned int HSCPTreeBuilder::Event_Store

private

Definition at line 145 of file HSCPTreeBuilder.cc.

◆ Event_technicalBits

bool HSCPTreeBuilder::Event_technicalBits[64]

private

Definition at line 139 of file HSCPTreeBuilder.cc.

◆ Event_Time

unsigned int HSCPTreeBuilder::Event_Time

private

Definition at line 146 of file HSCPTreeBuilder.cc.

◆ Event_triggerHLTBits

bool HSCPTreeBuilder::Event_triggerHLTBits[128]

private

Definition at line 138 of file HSCPTreeBuilder.cc.

◆ Event_triggerL1Bits

bool HSCPTreeBuilder::Event_triggerL1Bits[192]

private

Definition at line 137 of file HSCPTreeBuilder.cc.

◆ Gen_beta

float HSCPTreeBuilder::Gen_beta[10000]

private

Definition at line 255 of file HSCPTreeBuilder.cc.

◆ Gen_charge

float HSCPTreeBuilder::Gen_charge[10000]

private

Definition at line 247 of file HSCPTreeBuilder.cc.

◆ Gen_eta

float HSCPTreeBuilder::Gen_eta[10000]

private

Definition at line 253 of file HSCPTreeBuilder.cc.

◆ Gen_mass

float HSCPTreeBuilder::Gen_mass[10000]

private

Definition at line 256 of file HSCPTreeBuilder.cc.

◆ Gen_p

float HSCPTreeBuilder::Gen_p[10000]

private

Definition at line 248 of file HSCPTreeBuilder.cc.

◆ Gen_pdgId

int HSCPTreeBuilder::Gen_pdgId[10000]

private

Definition at line 246 of file HSCPTreeBuilder.cc.

◆ Gen_phi

float HSCPTreeBuilder::Gen_phi[10000]

private

Definition at line 254 of file HSCPTreeBuilder.cc.

◆ Gen_pt

float HSCPTreeBuilder::Gen_pt[10000]

private

Definition at line 252 of file HSCPTreeBuilder.cc.

◆ Gen_px

float HSCPTreeBuilder::Gen_px[10000]

private

Definition at line 249 of file HSCPTreeBuilder.cc.

◆ Gen_py

float HSCPTreeBuilder::Gen_py[10000]

private

Definition at line 250 of file HSCPTreeBuilder.cc.

◆ Gen_pz

float HSCPTreeBuilder::Gen_pz[10000]

private

Definition at line 251 of file HSCPTreeBuilder.cc.

◆ Hscp_hasCalo

bool HSCPTreeBuilder::Hscp_hasCalo[10000]

private

Definition at line 166 of file HSCPTreeBuilder.cc.

◆ Hscp_hasMuon

bool HSCPTreeBuilder::Hscp_hasMuon[10000]

private

Definition at line 164 of file HSCPTreeBuilder.cc.

◆ Hscp_hasRpc

bool HSCPTreeBuilder::Hscp_hasRpc[10000]

private

Definition at line 165 of file HSCPTreeBuilder.cc.

◆ Hscp_hasTrack

bool HSCPTreeBuilder::Hscp_hasTrack[10000]

private

Definition at line 163 of file HSCPTreeBuilder.cc.

◆ Hscp_type

int HSCPTreeBuilder::Hscp_type[10000]

private

Definition at line 167 of file HSCPTreeBuilder.cc.

◆ iEvent_

const edm::Event* HSCPTreeBuilder::iEvent_

private

Definition at line 124 of file HSCPTreeBuilder.cc.

◆ iSetup_

const edm::EventSetup* HSCPTreeBuilder::iSetup_

private

Definition at line 123 of file HSCPTreeBuilder.cc.

◆ m_genParticlesToken

EDGetTokenT<GenParticleCollection> HSCPTreeBuilder::m_genParticlesToken

private

Definition at line 131 of file HSCPTreeBuilder.cc.

◆ m_gtReadoutRecordToken

EDGetTokenT<L1GlobalTriggerReadoutRecord> HSCPTreeBuilder::m_gtReadoutRecordToken

private

Definition at line 128 of file HSCPTreeBuilder.cc.

◆ m_HSCPsToken

EDGetTokenT<susybsm::HSCParticleCollection> HSCPTreeBuilder::m_HSCPsToken

private

Definition at line 132 of file HSCPTreeBuilder.cc.

◆ m_recoVertexToken

EDGetTokenT<reco::VertexCollection> HSCPTreeBuilder::m_recoVertexToken

private

Definition at line 130 of file HSCPTreeBuilder.cc.

◆ m_trToken

EDGetTokenT<edm::TriggerResults> HSCPTreeBuilder::m_trToken

private

Definition at line 129 of file HSCPTreeBuilder.cc.

◆ Muon_cb_fIBeta

float HSCPTreeBuilder::Muon_cb_fIBeta[10000]

private

Definition at line 219 of file HSCPTreeBuilder.cc.

◆ Muon_cb_fIBeta_err

float HSCPTreeBuilder::Muon_cb_fIBeta_err[10000]

private

Definition at line 220 of file HSCPTreeBuilder.cc.

◆ Muon_cb_IBeta

float HSCPTreeBuilder::Muon_cb_IBeta[10000]

private

Definition at line 217 of file HSCPTreeBuilder.cc.

◆ Muon_cb_IBeta_err

float HSCPTreeBuilder::Muon_cb_IBeta_err[10000]

private

Definition at line 218 of file HSCPTreeBuilder.cc.

◆ Muon_cb_ndof

int HSCPTreeBuilder::Muon_cb_ndof[10000]

private

Definition at line 221 of file HSCPTreeBuilder.cc.

◆ Muon_charge

int HSCPTreeBuilder::Muon_charge[10000]

private

Definition at line 206 of file HSCPTreeBuilder.cc.

◆ Muon_csc_fIBeta

float HSCPTreeBuilder::Muon_csc_fIBeta[10000]

private

Definition at line 214 of file HSCPTreeBuilder.cc.

◆ Muon_csc_fIBeta_err

float HSCPTreeBuilder::Muon_csc_fIBeta_err[10000]

private

Definition at line 215 of file HSCPTreeBuilder.cc.

◆ Muon_csc_IBeta

float HSCPTreeBuilder::Muon_csc_IBeta[10000]

private

Definition at line 212 of file HSCPTreeBuilder.cc.

◆ Muon_csc_IBeta_err

float HSCPTreeBuilder::Muon_csc_IBeta_err[10000]

private

Definition at line 213 of file HSCPTreeBuilder.cc.

◆ Muon_csc_ndof

int HSCPTreeBuilder::Muon_csc_ndof[10000]

private

Definition at line 216 of file HSCPTreeBuilder.cc.

◆ Muon_dt_fIBeta

float HSCPTreeBuilder::Muon_dt_fIBeta[10000]

private

Definition at line 209 of file HSCPTreeBuilder.cc.

◆ Muon_dt_fIBeta_err

float HSCPTreeBuilder::Muon_dt_fIBeta_err[10000]

private

Definition at line 210 of file HSCPTreeBuilder.cc.

◆ Muon_dt_IBeta

float HSCPTreeBuilder::Muon_dt_IBeta[10000]

private

Definition at line 207 of file HSCPTreeBuilder.cc.

◆ Muon_dt_IBeta_err

float HSCPTreeBuilder::Muon_dt_IBeta_err[10000]

private

Definition at line 208 of file HSCPTreeBuilder.cc.

◆ Muon_dt_ndof

int HSCPTreeBuilder::Muon_dt_ndof[10000]

private

Definition at line 211 of file HSCPTreeBuilder.cc.

◆ Muon_eta

float HSCPTreeBuilder::Muon_eta[10000]

private

Definition at line 202 of file HSCPTreeBuilder.cc.

◆ Muon_p

float HSCPTreeBuilder::Muon_p[10000]

private

Definition at line 200 of file HSCPTreeBuilder.cc.

◆ Muon_phi

float HSCPTreeBuilder::Muon_phi[10000]

private

Definition at line 203 of file HSCPTreeBuilder.cc.

◆ Muon_pt

float HSCPTreeBuilder::Muon_pt[10000]

private

Definition at line 201 of file HSCPTreeBuilder.cc.

◆ Muon_qualityValid

bool HSCPTreeBuilder::Muon_qualityValid[10000]

private

Definition at line 205 of file HSCPTreeBuilder.cc.

◆ Muon_type

int HSCPTreeBuilder::Muon_type[10000]

private

Definition at line 204 of file HSCPTreeBuilder.cc.

◆ MyTree

TTree* HSCPTreeBuilder::MyTree

private

Definition at line 136 of file HSCPTreeBuilder.cc.

◆ NGens

unsigned int HSCPTreeBuilder::NGens

private

Definition at line 245 of file HSCPTreeBuilder.cc.

◆ NHSCPs

unsigned int HSCPTreeBuilder::NHSCPs

private

Definition at line 162 of file HSCPTreeBuilder.cc.

◆ NVertices

unsigned int HSCPTreeBuilder::NVertices

private

Definition at line 150 of file HSCPTreeBuilder.cc.

◆ reccordGenInfo

bool HSCPTreeBuilder::reccordGenInfo

private

Definition at line 134 of file HSCPTreeBuilder.cc.

◆ reccordVertexInfo

bool HSCPTreeBuilder::reccordVertexInfo

private

Definition at line 133 of file HSCPTreeBuilder.cc.

◆ Rpc_beta

float HSCPTreeBuilder::Rpc_beta[10000]

private

Definition at line 222 of file HSCPTreeBuilder.cc.

◆ tfs

edm::Service<TFileService> HSCPTreeBuilder::tfs

private

Definition at line 126 of file HSCPTreeBuilder.cc.

◆ Track_charge

int HSCPTreeBuilder::Track_charge[10000]

private

Definition at line 181 of file HSCPTreeBuilder.cc.

◆ Track_chi2

float HSCPTreeBuilder::Track_chi2[10000]

private

Definition at line 172 of file HSCPTreeBuilder.cc.

◆ Track_d0

float HSCPTreeBuilder::Track_d0[10000]

private

Definition at line 179 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD1

float HSCPTreeBuilder::Track_dEdxD1[10000]

private

Definition at line 191 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD1_NOM

unsigned int HSCPTreeBuilder::Track_dEdxD1_NOM[10000]

private

Definition at line 193 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD1_NOS

float HSCPTreeBuilder::Track_dEdxD1_NOS[10000]

private

Definition at line 192 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD2

float HSCPTreeBuilder::Track_dEdxD2[10000]

private

Definition at line 194 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD2_NOM

unsigned int HSCPTreeBuilder::Track_dEdxD2_NOM[10000]

private

Definition at line 196 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD2_NOS

float HSCPTreeBuilder::Track_dEdxD2_NOS[10000]

private

Definition at line 195 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD3

float HSCPTreeBuilder::Track_dEdxD3[10000]

private

Definition at line 197 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD3_NOM

unsigned int HSCPTreeBuilder::Track_dEdxD3_NOM[10000]

private

Definition at line 199 of file HSCPTreeBuilder.cc.

◆ Track_dEdxD3_NOS

float HSCPTreeBuilder::Track_dEdxD3_NOS[10000]

private

Definition at line 198 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE1

float HSCPTreeBuilder::Track_dEdxE1[10000]

private

Definition at line 182 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE1_NOM

unsigned int HSCPTreeBuilder::Track_dEdxE1_NOM[10000]

private

Definition at line 184 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE1_NOS

float HSCPTreeBuilder::Track_dEdxE1_NOS[10000]

private

Definition at line 183 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE2

float HSCPTreeBuilder::Track_dEdxE2[10000]

private

Definition at line 185 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE2_NOM

unsigned int HSCPTreeBuilder::Track_dEdxE2_NOM[10000]

private

Definition at line 187 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE2_NOS

float HSCPTreeBuilder::Track_dEdxE2_NOS[10000]

private

Definition at line 186 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE3

float HSCPTreeBuilder::Track_dEdxE3[10000]

private

Definition at line 188 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE3_NOM

unsigned int HSCPTreeBuilder::Track_dEdxE3_NOM[10000]

private

Definition at line 190 of file HSCPTreeBuilder.cc.

◆ Track_dEdxE3_NOS

float HSCPTreeBuilder::Track_dEdxE3_NOS[10000]

private

Definition at line 189 of file HSCPTreeBuilder.cc.

◆ Track_dz

float HSCPTreeBuilder::Track_dz[10000]

private

Definition at line 178 of file HSCPTreeBuilder.cc.

◆ Track_eta

float HSCPTreeBuilder::Track_eta[10000]

private

Definition at line 174 of file HSCPTreeBuilder.cc.

◆ Track_eta_err

float HSCPTreeBuilder::Track_eta_err[10000]

private

Definition at line 175 of file HSCPTreeBuilder.cc.

◆ Track_ndof

unsigned int HSCPTreeBuilder::Track_ndof[10000]

private

Definition at line 173 of file HSCPTreeBuilder.cc.

◆ Track_NOH

unsigned int HSCPTreeBuilder::Track_NOH[10000]

private

Definition at line 168 of file HSCPTreeBuilder.cc.

◆ Track_p

float HSCPTreeBuilder::Track_p[10000]

private

Definition at line 169 of file HSCPTreeBuilder.cc.

◆ Track_phi

float HSCPTreeBuilder::Track_phi[10000]

private

Definition at line 176 of file HSCPTreeBuilder.cc.

◆ Track_phi_err

float HSCPTreeBuilder::Track_phi_err[10000]

private

Definition at line 177 of file HSCPTreeBuilder.cc.

◆ Track_pt

float HSCPTreeBuilder::Track_pt[10000]

private

Definition at line 170 of file HSCPTreeBuilder.cc.

◆ Track_pt_err

float HSCPTreeBuilder::Track_pt_err[10000]

private

Definition at line 171 of file HSCPTreeBuilder.cc.

◆ Track_quality

int HSCPTreeBuilder::Track_quality[10000]

private

Definition at line 180 of file HSCPTreeBuilder.cc.

◆ Vertex_chi2

float HSCPTreeBuilder::Vertex_chi2[1000]

private

Definition at line 158 of file HSCPTreeBuilder.cc.

◆ Vertex_isFake

bool HSCPTreeBuilder::Vertex_isFake[1000]

private

Definition at line 160 of file HSCPTreeBuilder.cc.

◆ Vertex_ndof

float HSCPTreeBuilder::Vertex_ndof[1000]

private

Definition at line 159 of file HSCPTreeBuilder.cc.

◆ Vertex_TrackSize

int HSCPTreeBuilder::Vertex_TrackSize[1000]

private

Definition at line 157 of file HSCPTreeBuilder.cc.

◆ Vertex_x

float HSCPTreeBuilder::Vertex_x[1000]

private

Definition at line 151 of file HSCPTreeBuilder.cc.

◆ Vertex_x_err

float HSCPTreeBuilder::Vertex_x_err[1000]

private

Definition at line 154 of file HSCPTreeBuilder.cc.

◆ Vertex_y

float HSCPTreeBuilder::Vertex_y[1000]

private

Definition at line 152 of file HSCPTreeBuilder.cc.

◆ Vertex_y_err

float HSCPTreeBuilder::Vertex_y_err[1000]

private

Definition at line 155 of file HSCPTreeBuilder.cc.

◆ Vertex_z

float HSCPTreeBuilder::Vertex_z[1000]

private

Definition at line 153 of file HSCPTreeBuilder.cc.

◆ Vertex_z_err

float HSCPTreeBuilder::Vertex_z_err[1000]

private

Definition at line 156 of file HSCPTreeBuilder.cc.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HSCPTreeBuilder()

◆ ~HSCPTreeBuilder()

Member Function Documentation

◆ beginJob()

◆ ClosestMuonIndex()

◆ endJob()

◆ filter()

Member Data Documentation

◆ Calo_ecal_beta

◆ Calo_ecal_beta_err

◆ Calo_ecal_chi2s

◆ Calo_ecal_crossedE

◆ Calo_ecal_dEdx

◆ Calo_ecal_detIds

◆ Calo_ecal_e1OverE9s

◆ Calo_ecal_energies

◆ Calo_ecal_invBeta_err

◆ Calo_ecal_numCrysCrossed

◆ Calo_ecal_outOfTimeChi2s

◆ Calo_ecal_outOfTimeEnergies

◆ Calo_ecal_swissCrossKs

◆ Calo_ecal_time

◆ Calo_ecal_time_err

◆ Calo_ecal_timeErrors

◆ Calo_ecal_times

◆ Calo_ecal_trackExitEtas

◆ Calo_ecal_trackExitPhis

◆ Calo_ecal_trackLengths

◆ Event_BField

◆ Event_BXCrossing

◆ Event_EventNumber

◆ Event_LumiSection

◆ Event_Orbit

◆ Event_PhysicsDeclared

◆ Event_RunNumber

◆ Event_Store

◆ Event_technicalBits

◆ Event_Time

◆ Event_triggerHLTBits

◆ Event_triggerL1Bits

◆ Gen_beta

◆ Gen_charge

◆ Gen_eta

◆ Gen_mass

◆ Gen_p

◆ Gen_pdgId

◆ Gen_phi

◆ Gen_pt

◆ Gen_px

◆ Gen_py

◆ Gen_pz

◆ Hscp_hasCalo

◆ Hscp_hasMuon

◆ Hscp_hasRpc

◆ Hscp_hasTrack

◆ Hscp_type

◆ iEvent_

◆ iSetup_

◆ m_genParticlesToken

◆ m_gtReadoutRecordToken

◆ m_HSCPsToken

◆ m_recoVertexToken

◆ m_trToken

◆ Muon_cb_fIBeta

◆ Muon_cb_fIBeta_err

◆ Muon_cb_IBeta

◆ Muon_cb_IBeta_err

◆ Muon_cb_ndof

◆ Muon_charge

◆ Muon_csc_fIBeta

◆ Muon_csc_fIBeta_err

◆ Muon_csc_IBeta

◆ Muon_csc_IBeta_err

◆ Muon_csc_ndof