MuonTriggerSFRootCoreTest.cxx File Reference

#include <string>
#include <TFile.h>
#include <TError.h>
#include <TStopwatch.h>
#include <TString.h>
#include "xAODEventInfo/EventInfo.h"
#include "xAODMuon/MuonContainer.h"
#include "MuonEfficiencyCorrections/MuonTriggerScaleFactors.h"
#include "PATInterfaces/ISystematicsTool.h"
#include "PATInterfaces/SystematicsUtil.h"

Go to the source code of this file.

Classes
class	MuonTriggerSFTester

Macros
#define	CHECK_CPSys(Arg)

Functions
CP::CorrectionCode	getThreshold (Int_t &threshold, const std::string &trigger)
int	main (int argc, char *argv[])

Variables
static const std::vector< std::string >	qualities { "HighPt", "Tight", "Medium", "Loose", "LowPt" }
static const std::vector< std::string >	binnings { "coarse", "fine" }
static const std::vector< std::string >	types { "data", "mc" }

Macro Definition Documentation

CHECK_CPSys

#define CHECK_CPSys

(

Arg

)

Value:

    if (Arg.isFailure()){                                              \
        Warning(#Arg,"Unsupported systematic (in line %i) ",__LINE__); \
    }

Definition at line 38 of file MuonTriggerSFRootCoreTest.cxx.

#define CHECK_CPSys(Arg) \
    if (Arg.isFailure()){                                              \
        Warning(#Arg,"Unsupported systematic (in line %i) ",__LINE__); \
    }      

Function Documentation

getThreshold()

CP::CorrectionCode getThreshold	(	Int_t &	threshold,
		const std::string &	trigger )

Definition at line 48 of file MuonTriggerSFRootCoreTest.cxx.

                                                                          {
    std::size_t index = trigger.find("HLT_mu");
    if (index != std::string::npos) {
        std::string rawNumber = trigger.substr(index + 6);
        if (!rawNumber.empty() && isdigit(rawNumber[0])) {
            std::stringstream(rawNumber) >> threshold;
            if (threshold < 10) threshold = 10000;
            else threshold = (threshold + 1) * 1000;
            return CP::CorrectionCode::Ok;
        }
    }
    return CP::CorrectionCode::Error;
}

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 317 of file MuonTriggerSFRootCoreTest.cxx.

                                 {
 
    const char* APP_NAME = argv[0];
    CP::CorrectionCode::enableFailure();
    // Read the config provided by the user
    const char* xAODFileName = "";
    std::string customInputFolder = "";
    std::string customFileName = "";
    const char* nrOfEntries = "";
    std::string trigger = "";
    int year = -1;
    std::string period = "";
    for (int i = 1; i < argc - 1; i++) {
        std::string arg = std::string(argv[i]);
        if (arg == "-x") {
            xAODFileName = argv[i + 1];
        }
        else if (arg == "-d")
            customInputFolder = argv[i + 1];
        else if (arg == "-f")
            customFileName = argv[i + 1];
        else if (arg == "-e")
            nrOfEntries = argv[i + 1];
        else if (arg == "-t")
            trigger = argv[i + 1];
    else if (arg == "-y")
      year = atoi(argv[i + 1]);
    else if (arg == "-p")
            period = argv[i + 1];
    }
    
    bool error = false;
    if (xAODFileName[0] == '\0') {
        Error(APP_NAME, "xAOD file name missing!");
        error = true;
    }
    if (trigger == "") {
        Error(APP_NAME, "trigger missing!");
        error = true;
    }
    if (error) {
        Error(APP_NAME, "  Usage: %s -x [xAOD file name] -y [year] -p [period] -t [trigger] -d [custom input folder] -f [custom file name] -e [number of events to process]", APP_NAME);
        return 1;
    }
 
    RETURN_CHECK(APP_NAME, xAOD::Init(APP_NAME));
 
    Info(APP_NAME, "Opening file: %s", xAODFileName);
    std::unique_ptr<TFile> ifile(TFile::Open(xAODFileName, "READ"));
    if (!ifile.get()) {
        Error(APP_NAME, " Unable to load xAOD input file");
        return 1;
    }
 
    xAOD::TEvent event;
    RETURN_CHECK(APP_NAME, event.readFrom(ifile.get(), xAOD::TEvent::kClassAccess));
    Info(APP_NAME, "Number of events in the file: %i",  static_cast<int>(event.getEntries()));
 
    // Decide how many events to run over:
    int nrOfEntriesToRunOver = 1000;//event.getEntries();
    if (!std::string(nrOfEntries).empty()) {
        int e = atoll(nrOfEntries);
        if (e < nrOfEntriesToRunOver) {
            nrOfEntriesToRunOver = e;
        }
    }
 
    
    MuonTriggerSFTester sfChecker(APP_NAME, trigger);
    sfChecker.initialiseTools(customFileName, customInputFolder, year, period);
    for(Long64_t entry = 0; entry < nrOfEntriesToRunOver; entry++) {
        // Tell the object which entry to look at:
        event.getEntry(entry);
    sfChecker.processEvent(event, year, period);
 
    }
    
    Info(APP_NAME, "%i events successfully processed, %i warnings, %i errors detected.", nrOfEntriesToRunOver, sfChecker.m_warningsCount, sfChecker.m_errorsCount);
    return 0;
}

Variable Documentation

binnings

const std::vector<std::string> binnings { "coarse", "fine" }

static

Definition at line 44 of file MuonTriggerSFRootCoreTest.cxx.

{ "coarse", "fine" };

qualities

const std::vector<std::string> qualities { "HighPt", "Tight", "Medium", "Loose", "LowPt" }

static

Definition at line 43 of file MuonTriggerSFRootCoreTest.cxx.

{ "HighPt", "Tight", "Medium", "Loose", "LowPt" };

types

const std::vector<std::string> types { "data", "mc" }

static

Definition at line 45 of file MuonTriggerSFRootCoreTest.cxx.

{ "data", "mc" };