Event.hpp

Go to the documentation of this file.

#ifndef EVENT_HPP__
#define EVENT_HPP__

#include "cafe/EventBase.hpp"

// Global 
#include "tmb_tree/TMBGlobal.hpp"
#include "tmb_tree/TMBHistory.hpp"
#include "tmb_tree/TMBTrigger.hpp"
#include "tmb_tree/TMBEventFlags.hpp"

// Reco
#include "tmb_tree/TMBMuon.hpp"
#include "tmb_tree/TMBEMCluster.hpp"
#include "tmb_tree/TMBJet.hpp"
#include "tmb_tree/TMBMet.hpp"
#include "tmb_tree/TMBParticleJet.hpp"
#include "tmb_tree/TMBMetEx.hpp"
#include "tmb_tree/TMBTrack.hpp"
#include "tmb_tree/TMBTau.hpp"
#include "tmb_tree/TMBIsoTrack.hpp"
#include "tmb_tree/TMBPrimaryVertex.hpp"
#include "tmb_tree/TMBLeBob.hpp"
#include "tmb_tree/TMBTrackCal.hpp"
#include "tmb_tree/TMBTrackCalJet.hpp"

#include "tmb_tree/TMBCps.hpp"
#include "tmb_tree/TMBFps.hpp"

// B-Tagging
#include "tmb_tree/TMBBTag.hpp"
#include "tmb_tree/TMBBTagSLT.hpp"
#include "tmb_tree/TMBBTagJLIP.hpp"
#include "tmb_tree/TMBBTagSVT.hpp"
#include "tmb_tree/TMBBTagNN.hpp"

// Compact
#include "tmb_tree/TMBTrigBits.hpp"
#include "tmb_tree/TMBHiPt.hpp"

// MC
#include "tmb_tree/TMBMCpart.hpp"
#include "tmb_tree/TMBMCvtx.hpp"
#include "tmb_tree/TMBMCevtInfo.hpp"

// Trigger

// L1
#include "tmb_tree/TMBL1AndOr.hpp"
#include "tmb_tree/TMBL1Names.hpp"
#include "tmb_tree/TMBL2Names.hpp"
#include "tmb_tree/TMBL1Cal.hpp"
#include "tmb_tree/TMBL1CalTile.hpp"
#include "tmb_tree/TMBL1CalTower.hpp"
#include "tmb_tree/TMBL1CTT.hpp"
#include "tmb_tree/TMBL1Muon.hpp"
#include "tmb_tree/TMBL1Track.hpp"
#include "tmb_tree/TMBL1toL2CTT.hpp"

// L2 Preprocessor objects
#include "tmb_tree/TMBL2CPS.hpp"
#include "tmb_tree/TMBL2EM.hpp"
#include "tmb_tree/TMBL2FPS.hpp"
#include "tmb_tree/TMBL2Muon.hpp"
#include "tmb_tree/TMBL2Track.hpp"
#include "tmb_tree/TMBL2Jet.hpp"
#include "tmb_tree/TMBL2MEt.hpp"

// L2 Global objects
#include "tmb_tree/TMBL2GblEM.hpp"
#include "tmb_tree/TMBL2GblHt.hpp"
#include "tmb_tree/TMBL2GblInvMass.hpp"
#include "tmb_tree/TMBL2GblJet.hpp"
#include "tmb_tree/TMBL2GblMEt.hpp"
#include "tmb_tree/TMBL2GblMJt.hpp"
#include "tmb_tree/TMBL2GblMuon.hpp"
#include "tmb_tree/TMBL2GblTau.hpp"
#include "tmb_tree/TMBL2GblTrack.hpp"
#include "tmb_tree/TMBL2GblTransMass.hpp"

// L3
#include "tmb_tree/TMBL3BTagIP.hpp"
#include "tmb_tree/TMBL3CFTVtx.hpp"
#include "tmb_tree/TMBL3Ele.hpp"
#include "tmb_tree/TMBL3IPTrack.hpp"
#include "tmb_tree/TMBL3Isolation.hpp"
#include "tmb_tree/TMBL3Jet.hpp"
#include "tmb_tree/TMBL3MEt.hpp"
#include "tmb_tree/TMBL3Muon.hpp"
#include "tmb_tree/TMBL3Photon.hpp"
#include "tmb_tree/TMBL3Tau.hpp"
#include "tmb_tree/TMBL3Track.hpp"

// Detector
#include "tmb_tree/TMBCalNada.hpp"
#include "tmb_tree/TMBCellContainer.hpp"
#include "tmb_tree/TMBCps.hpp"
#include "tmb_tree/TMBCpsDigi.hpp"
#include "tmb_tree/TMBFps.hpp"
#include "tmb_tree/TMBFpsData.hpp"
#include "tmb_tree/TMBFpd.hpp"
#include "tmb_tree/TMBFPDTrack.hpp"
#include "tmb_tree/TMBTdc.hpp" 



#include "tmb_tree/TMBLum.hpp"
#include "tmb_tree/TMBLumV.hpp"

#include "tmb_tree/TMBSimCAEP.hpp"

// Weights
#include "tmb_tree/TMBHiPtWeight.hpp"
#include "cafe/EventWeight.hpp"

namespace cafe {

    class Event : public EventBase {
    public:
        Event();




        bool isMC() const;
        bool isRun2b() const;
        bool isRun2a() const {return !isRun2b();}

        const TMBGlobal *getGlobal(const Variables& vars = cafe::detail::empty) const 
        { 
            return get<TMBGlobal>("Global", vars); 
        }

        const Collection<TMBHistory> getHistory(const Variables& vars = cafe::detail::empty) const 
        { 
            return getCollection<TMBHistory>("History"); 
        }

        const TMBEventFlags *getEventFlags(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBEventFlags>("EventFlags", vars);
        }

        



        Collection<TMBMuon> getMuons(const Variables& vars = cafe::detail::empty)    const 
        { 
            return getCollection<TMBMuon>("Muon", vars); 
        }

        Collection<TMBEMCluster> getEM(const std::string& branchName, const Variables& vars = cafe::detail::empty)    const 
        { 
            return getCollection<TMBEMCluster>(branchName, vars); 
        }

        Collection<TMBEMCluster> getEMscone(const Variables& vars = cafe::detail::empty) const
        { 
            return getEM("EMscone", vars); 
        }

        Collection<TMBEMCluster> getEMcnn(const Variables& vars = cafe::detail::empty) const
        { 
            return getEM("EMcnn", vars);
        }

        Collection<TMBJet> getJets(const std::string &branchName, const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBJet>(branchName, vars);
        }

        Collection<TMBJet> getJCCA(const Variables& vars = cafe::detail::empty) const
        {
            return getJets("JCCA", vars);
        }

        Collection<TMBJet> getJCCB(const Variables& vars = cafe::detail::empty) const
        {
            return getJets("JCCB", vars);
        }

        Collection<TMBLeBob> getLeBob(const Variables& vars = cafe::detail::empty)   const 
        { 
            return getCollection<TMBLeBob>("LeBob", vars); 
        }
        const TMBLeBob* getTMBLeBob(const std::string &branchName, const Variables& vars = cafe::detail::empty) const
        {
            Collection<TMBLeBob> lebobs=getLeBob(vars);
            int nsize=lebobs.size();
            for(int i=0; i<nsize; ++i){
              if(std::string(lebobs[i].algoname())==branchName) return &lebobs[i];
            }
            return 0;
        }
        const TMBLeBob* getJCCALeBob(const Variables& vars = cafe::detail::empty) const
        {
            return getTMBLeBob("JCCA", vars);
        }

        const TMBLeBob* getJCCBLeBob(const Variables& vars = cafe::detail::empty) const
        {
            return getTMBLeBob("JCCB", vars);
        }

        Collection<TMBParticleJet> 
        getParticleJets(const std::string &branchName, const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBParticleJet>(branchName, vars);
        }
        
        Collection<TMBParticleJet> getParticlesJCCA(const Variables& vars = cafe::detail::empty) const
        {
            return getParticleJets("particlesJCCA", vars);
        }
        
        Collection<TMBParticleJet> getParticlesJCCB(const Variables& vars = cafe::detail::empty) const
        {
            return getParticleJets("particlesJCCB", vars);
        }

        Collection<TMBTrack> getTracks(const Variables& vars = cafe::detail::empty)   const 
        { 
            return getCollection<TMBTrack>("Track", vars); 
        }

        Collection<TMBIsoTrack> getIsoTracks(const Variables& vars = cafe::detail::empty)   const 
        { 
            return getCollection<TMBIsoTrack>("IsoTrack", vars); 
        }

        Collection<TMBTau> getTaus(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBTau>("Tau", vars);
        }
        
        Collection<TMBPrimaryVertex> getPrimaryVertices(const Variables& vars = cafe::detail::empty) const 
        { 
            return getCollection<TMBPrimaryVertex>("PrimaryVertex", vars); 
        }
        

        Collection<TMBPrimaryVertex> getPrimaryVertices(const std::string& type, const Variables& vars = cafe::detail::empty) const 
        { 
            return getCollection<TMBPrimaryVertex>("PrimaryVertex_" + type, vars); 
        }
        

        Collection<TMBTrackCal> getTrackCals(const Variables& vars = cafe::detail::empty) const
        {
            return  getCollection<TMBTrackCal>("TrackCal", vars);
        }

        Collection<TMBTrackCalJet> getTrackCalJCCA(const Variables& vars = cafe::detail::empty) const
        {
            return  getCollection<TMBTrackCalJet>("TrackCalJet_JCCA", vars);
        }

        Collection<TMBTrackCalJet> getTrackCalJCCB(const Variables& vars = cafe::detail::empty) const
        {
            return  getCollection<TMBTrackCalJet>("TrackCalJet_JCCB", vars);
        }

        const TMBMet  *getMet(const Variables& vars = cafe::detail::empty) const     
        { 
            return  get<TMBMet>("Met", vars); 
        }

        const TMBMetEx  *getMetEx(const Variables& vars = cafe::detail::empty) const     
        { 
            return  get<TMBMetEx>("MetEx", vars); 
        }

        Collection<TMBCps> getCPS(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBCps>("Cps", vars);
        }

        Collection<TMBFps> getFPS(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBFps>("Fps", vars);
        }

        Collection<TMBFpd> getFPD(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBFpd>("Fpd", vars);
        }





        Collection<TMBBTag> getCSIP(const std::string& jetAlgo,
                                     const std::string& qual, const Variables& vars = cafe::detail::empty)
        {
            return getCollection<TMBBTag>("BTag_" + jetAlgo + 
                                          "_CSIP_" + qual, vars);
        }
                                    

        Collection<TMBBTagSLT> getSLT(const std::string& jetAlgo,
                                      const std::string& qual, const Variables& vars = cafe::detail::empty)
        {
            return getCollection<TMBBTagSLT>("BTag_" + jetAlgo + 
                                          "_SLT_" + qual, vars);
        }
                                    

        Collection<TMBBTagJLIP> getJLIP(const std::string& jetAlgo,
                                        const std::string& qual, const Variables& vars = cafe::detail::empty)
        {
            return getCollection<TMBBTagJLIP>("BTag_" + jetAlgo + 
                                              "_JLIP_" + qual, vars);
        }

        Collection<TMBBTagSVT> getSVT(const std::string& jetAlgo,
                                      const std::string& qual, const Variables& vars = cafe::detail::empty)
        {
            return getCollection<TMBBTagSVT>("BTag_" + jetAlgo + 
                                             "_SVT_" + qual, vars);
        }

                Collection<TMBBTagNN> getNN(const std::string& jetAlgo,
                                      const std::string& qual, const Variables& vars = cafe::detail::empty)
        {
            return getCollection<TMBBTagNN>("BTag_" + jetAlgo + 
                                             "_NN_" + qual, vars);
        }




        const TMBMCevtInfo *getMCEventInfo(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBMCevtInfo>("MCevtInfo", vars);
        }

        Collection<TMBMCvtx> getMCVertices(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBMCvtx> ("MCvtx", vars);
        }
        
        Collection<TMBMCpart> getMCParticles(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBMCpart> ("MCpart", vars);
        }


        

        Collection<TMBTrigger> getTriggers(const Variables& vars = cafe::detail::empty) const
        {
            return  getCollection<TMBTrigger>("Trigger", vars);
        }


        const TMBTrigBits *getTrigBits(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBTrigBits>("TrigBits", vars);
        }

        const TMBL1AndOr *getL1AndOr(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL1AndOr>("L1AndOr", vars);
        }

        const TMBL1Names *getL1Names(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL1Names>("L1Names", vars);
        }
        
        const TMBL2Names *getL2Names(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL2Names>("L2Names", vars);
        }

        const TMBL1Cal *getL1Cal(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL1Cal>("L1Cal", vars);
        }


        Collection<TMBL1CalTile> getL1CalTiles(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL1CalTile> ("L1CalTiles", vars);
        }

        Collection<TMBL1CalTower> getL1CalTotalTowers(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL1CalTower> ("L1CalTotalTowers", vars);
        }

        Collection<TMBL1CalTower> getL1CalEMTowers(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL1CalTower> ("L1CalEMTowers", vars);
        }

        const TMBL1Muon *getL1Muon(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL1Muon>("L1Muon", vars);
        }

        const TMBL1CTT *getL1CTT(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBL1CTT>("L1CTT", vars);
        }

        Collection<TMBL1toL2CTT> getL1toL2CTT(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL1toL2CTT>("L1toL2CTT", vars);
        }

        Collection<TMBL1Track> getL1Tracks(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL1Track> ("L1Track", vars);
        }


        Collection<TMBL2CPS> getL2CPSs(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2CPS> ("L2CPS", vars);
        }

        Collection<TMBL2EM> getL2EMs(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2EM> ("L2EM", vars);
        }

        Collection<TMBL2Muon> getL2Muons(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2Muon> ("L2Muon", vars);
        }

        Collection<TMBL2Jet> getL2Jets(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2Jet> ("L2Jet", vars);
        }

        Collection<TMBL2Track> getL2STTPT(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2Track> ("STTPT", vars);
        }

        Collection<TMBL2Track> getL2STTIP(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2Track> ("STTIP", vars);
        }

        Collection<TMBL2Track> getL2CTT(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2Track> ("CTT", vars);
        }

        Collection<TMBL2GblJet> getL2GblJets(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblJet> ("L2GblJet", vars);
        }

        Collection<TMBL2GblEM> getL2GblEMs(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblEM> ("L2GblEM", vars);
        }

        Collection<TMBL2GblMuon> getL2GblMuons(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblMuon> ("L2GblMuon", vars);
        }

        Collection<TMBL2GblTrack> getL2GblTracks(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblTrack> ("L2GblTrack", vars);
        }

        Collection<TMBL2GblInvMass> getL2GblInvMass(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblInvMass> ("L2GblInvMass", vars);
        }

        Collection<TMBL2GblMJt> getL2GblMJts(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblMJt> ("L2GblMJt", vars);
        }

        Collection<TMBL2GblHt> getL2GblHts(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL2GblHt> ("L2GblHt", vars);
        }


        Collection<TMBL3BTagIP> getL3BTagIPs(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3BTagIP> ("L3BTagIP", vars);
        }

        Collection<TMBL3CFTVtx> getL3CFTVtxs(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3CFTVtx> ("L3CFTVertex", vars);
        }

        Collection<TMBL3Ele> getL3Eles(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Ele> ("L3Electron", vars);
        }

        Collection<TMBL3IPTrack> getL3IPTracks(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3IPTrack> ("L3IPTrack", vars);
        }

        Collection<TMBL3Isolation> getL3Isolations(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Isolation> ("L3Isolation", vars);
        }

        Collection<TMBL3Jet> getL3Jets(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Jet> ("L3Jet", vars);
        }

        Collection<TMBL3Muon> getL3Muons(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Muon> ("L3Muon", vars);
        }

        Collection<TMBL3Photon> getL3Photons(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Photon> ("L3Photon", vars);
        }

        Collection<TMBL3Tau> getL3Taus(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Tau> ("L3Tau", vars);
        }

        Collection<TMBL3Track> getL3Tracks(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3Track> ("L3Track", vars);
        }

        Collection<TMBL3MEt> getL3MEts(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBL3MEt> ("L3MEt", vars);
        }


        const TMBCellContainer *getCaloCells(const Variables& vars = cafe::detail::empty) const
        {
            return get<TMBCellContainer>("CaloCells", vars);
        }

        Collection<TMBLum> getLum(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBLum>("Lum", vars);
        }
        
        Collection<TMBLumV> getLumV(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBLumV>("LumV", vars);
        }

        Collection<TMBSimCAEP> getSimCAEP(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBSimCAEP>("CAEP", vars);
        }
        
        Collection<EventWeight> getEventWeights(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<EventWeight>("EventWeight", vars);
        }

        Collection<TMBHiPt> getHiPt(const Variables& vars = cafe::detail::empty) const
                {
                    return getCollection<TMBHiPt>("HiPt", vars);
                 }

        Collection<TMBFPDTrack> getFPDTrack(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBFPDTrack>("FPDTrack", vars);
        }


        Collection<TMBTdc> getTdc(const Variables& vars = cafe::detail::empty) const
        {
            return getCollection<TMBTdc>("FPDTdc", vars);
        }

    public:
        ClassDef(Event, 0);
    };

}

#endif // EVENT_HPP__

---