SusyNtuple/SusyNtTools.h

#ifndef SusyNtuple_SusyNtTools_h
#define SusyNtuple_SusyNtTools_h

// std
#include <iostream>

// SusyNtuple
#include "SusyNtuple/SusyDefs.h"
#include "SusyNtuple/AnalysisType.h"
#include "SusyNtuple/SusyNt.h"
#include "SusyNtuple/SusyNtObject.h"
#include "SusyNtuple/MCWeighter.h"
#include "SusyNtuple/JetSelector.h"
#include "SusyNtuple/MuonSelector.h"
#include "SusyNtuple/ElectronSelector.h"
#include "SusyNtuple/OverlapTools.h"
#include "SusyNtuple/TauSelector.h"
#include "SusyNtuple/TauId.h"
#include "SusyNtuple/TriggerTools.h"

// SUSYTools
#include "SUSYTools/SUSYCrossSection.h"

using namespace Susy;
using namespace NtSys;

class SusyNtTools {
public:

    SusyNtTools();
    virtual ~SusyNtTools();

    void setSFOSRemoval(AnalysisType A);
    bool doSFOSRemoval() { return m_doSFOS; }
    void removeSFOSPairs(ElectronVector& baseElectrons, MuonVector& baseMuons);
    
    void setAnaType(AnalysisType A, bool verbose = false);
    AnalysisType getAnaType() { return m_anaType; }


    bool initTriggerTool(const std::string &anyInputFilename);

    //
    // Methods to return the tools
    //
    ElectronSelector&   electronSelector()   { return *m_electronSelector; }
    MuonSelector&       muonSelector()       { return *m_muonSelector; }
    TauSelector&        tauSelector()        { return *m_tauSelector; }
    JetSelector&        jetSelector()        { return *m_jetSelector; }
    OverlapTools&       overlapTool()        { return *m_overlapTool; }
    TriggerTools&       triggerTool()        { return m_triggerTool; }

    //
    // Methods to perform event selection
    //
    bool passGRL(int flags);
    bool passLarErr(int flags);
    bool passTileErr(int flags);
    bool passTTC(int flags);
    bool passGoodVtx(int flags);
    bool passBadMuon(const MuonVector* preMuons) { return SusyNtTools::passBadMuon(*preMuons); }
    bool passBadMuon(const MuonVector& preMuons);
    bool passCosmicMuon(const MuonVector* baseMuons) { return SusyNtTools::passCosmicMuon(*baseMuons); }
    bool passCosmicMuon(const MuonVector& baseMuons);
    bool passJetCleaning(const JetVector* preJets) { return SusyNtTools::passJetCleaning(*preJets); }
    bool passJetCleaning(const JetVector& preJets);

    //
    // Methods to grab objects based on systematic shift desired
    //

    ElectronVector getPreElectrons(Susy::SusyNtObject* susyNt, SusyNtSys sys);
    MuonVector     getPreMuons(Susy::SusyNtObject* susyNt, SusyNtSys sys);
    TauVector      getPreTaus(Susy::SusyNtObject* susyNt, SusyNtSys sys);
    JetVector      getPreJets(Susy::SusyNtObject* susyNt, SusyNtSys sys);

    ElectronVector getBaselineElectrons(const ElectronVector& preElectrons);
    MuonVector     getBaselineMuons(const MuonVector& preMuons);
    TauVector      getBaselineTaus(const TauVector& preTaus);
    JetVector      getBaselineJets(const JetVector& preJets);

    void getPreObjects(Susy::SusyNtObject* susyNt, SusyNtSys sys,
                                                   ElectronVector& preElectrons,
                                                   MuonVector& preMuons,
                                                   JetVector& preJets,
                                                   TauVector& preTaus);

    void getBaselineObjects(const ElectronVector& preElectrons, const MuonVector& preMuons, const JetVector& preJets, const TauVector& preTaus,
                            ElectronVector& baseElectrons, MuonVector& baseMuons, JetVector& baseJets, TauVector& baseTaus);
    void getSignalObjects(const ElectronVector& baseElectrons, const MuonVector& baseMuons, const JetVector& baseJets, const TauVector& baseTaus,
                            ElectronVector& signalElectrons, MuonVector& signalMuons, JetVector& signalJets, TauVector& signalTaus, TauId& sigTauId);


    ElectronVector getSignalElectrons(const ElectronVector& baseElecs);
    MuonVector     getSignalMuons(const MuonVector& baseMuons);
    PhotonVector   getSignalPhotons(Susy::SusyNtObject* susyNt);
    TauVector      getSignalTaus(const TauVector& baseTaus);
    JetVector      getSignalJets(const JetVector& baseJets);

    bool isSignal(const Susy::Lepton* l);
    bool isSignal(const Susy::Electron* e);
    bool isSignal(const Susy::Muon* m);
    bool isSignal(const Susy::Tau* tau);

    void buildLeptons(LeptonVector &lep, const ElectronVector& ele, const MuonVector& muo);

    Susy::Met* getMet(Susy::SusyNtObject* susyNt, SusyNtSys sys);
    Susy::TrackMet* getTrackMet(Susy::SusyNtObject* susyNt, SusyNtSys sys);

    //
    // Methods to get useful quantities for event, leptons, or jets
    //

    // B jets
    int numBJets(const JetVector& jets);
    bool hasBJet(const JetVector& jets);
    JetVector getBJets(const JetVector& jets);


    int numberOfCLJets(const JetVector& jets);
    int numberOfCBJets(const JetVector& jets);
    int numberOfFJets(const JetVector& jets);

    // Methods to grab obect SF

    float bTagSF(const JetVector& jets);
   
    float leptonEffSF(const LeptonVector& leps);
 
    float leptonEffSF(const Lepton* lep) { return leptonEffSF(*lep); }
    float leptonEffSF(const Lepton& lep);

    float leptonEffSFError(const Lepton* lep, const NtSys::SusyNtSys sys) { return leptonEffSFError(*lep, sys); }
    float leptonEffSFError(const Lepton& lep, const NtSys::SusyNtSys sys);

    //
    // Object printing
    //

    template<class T> void dumpObjects(const std::vector<T>& objects)
    {
        for (unsigned int i = 0; i < objects.size(); i++) {
            std::cout << i << " ";
            objects[i].print();
        }
    }
    template<class T> void dumpObjects(const std::vector<T*>& objects)
    {
        for (unsigned int i = 0; i < objects.size(); i++) {
            std::cout << i << " ";
            objects[i]->print();
        }
    }

    // \todo make these datamembers protected
    // Object Selectors and Tools
    ElectronSelector* m_electronSelector; 
    MuonSelector* m_muonSelector;         
    TauSelector*  m_tauSelector;          
    JetSelector* m_jetSelector;           
    OverlapTools* m_overlapTool;          
    TriggerTools m_triggerTool;  

protected:

    AnalysisType m_anaType;    
    bool m_doSFOS;             
};

#endif