testGenericSFApplier.cc File Reference

#include "Core/CommonTools/interface/GenericSFApplier.h"
#include <boost/test/included/unit_test.hpp>
#include <TFile.h>
#include <TH1D.h>
#include <filesystem>
#include <stdexcept>
#include <vector>

Include dependency graph for testGenericSFApplier.cc:

Classes
struct	HistogramFileFixture
struct	SimpleObject
struct	SimpleObjectApplier
struct	ContextApplier

Macros
#define	BOOST_TEST_MODULE   testGenericSFApplier
#define	FILE_NAME   "scaleFactors.root"
#define	HIST_PREFIX   "H"
#define	BIN_WISE_NAME   "stat"
#define	GLOBAL_NAME   "syst"

Functions
	BOOST_AUTO_TEST_CASE (SimpleObjectNoSF)
	BOOST_AUTO_TEST_CASE (Vector)
	BOOST_AUTO_TEST_CASE (SimpleObjectApplySF)
	BOOST_AUTO_TEST_CASE (SimpleObjectApplySFAndUnc)
	BOOST_AUTO_TEST_CASE (Context)

Variables
const double	BIN1_SF = 2
const double	BIN2_SF = 3
const double	BIN1_BW = 0.2
const double	BIN2_BW = 0.3
const double	BIN1_GB = 0.5
const double	BIN2_GB = 0.6

Macro Definition Documentation

BIN_WISE_NAME

#define BIN_WISE_NAME   "stat"

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   testGenericSFApplier

FILE_NAME

#define FILE_NAME   "scaleFactors.root"

GLOBAL_NAME

#define GLOBAL_NAME   "syst"

HIST_PREFIX

#define HIST_PREFIX   "H"

Function Documentation

BOOST_AUTO_TEST_CASE() [1/5]

BOOST_AUTO_TEST_CASE

(

Context

)

    {
        // This applier must not even try to open the file, so passing a dummy
        // file name must be fine
        const ContextApplier applier("/nowhere", false, false);
 
        SimpleObject obj = {2, {}};
        applier(obj, applier.expectedContext);
    }

BOOST_AUTO_TEST_CASE() [2/5]

BOOST_AUTO_TEST_CASE

(

SimpleObjectApplySF

)

    {
        // Check error condition
        BOOST_CHECK_THROW( SimpleObjectApplier("/nowhere", true, false),
                           fs::filesystem_error );
 
        HistogramFileFixture f;
        // This applier must apply the SF without doing systematics
        const SimpleObjectApplier applier(f.path, true, false);
 
        // Must only return systematics that are actually applied
        BOOST_TEST( applier.weightNames().empty() );
 
        // Selected object
        SimpleObject obj = {2, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == BIN2_SF );
        BOOST_TEST( obj.weights.at(0).i == 0 );
 
        // Selected object with existing weights
        obj = {2, {Weight{1, 0}, Weight{2, 1}}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 2 );
        BOOST_TEST( obj.weights.at(0).v == 1 * BIN2_SF );
        BOOST_TEST( obj.weights.at(0).i == 0 );
        BOOST_TEST( obj.weights.at(1).v == 2 * BIN2_SF );
        BOOST_TEST( obj.weights.at(1).i == 1 );
 
        // Selected object outside histogram bounds
        obj = {10, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == 0 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
 
        // Selected object outside histogram bounds, existing weights
        obj = {10, {Weight{1, 0}, Weight{2, 1}}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 2 );
        BOOST_TEST( obj.weights.at(0).v == 0 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
        BOOST_TEST( obj.weights.at(1).v == 0 );
        BOOST_TEST( obj.weights.at(1).i == 1 );
 
        // Object not selected
        obj = {1, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == 0 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
    }

BOOST_AUTO_TEST_CASE() [3/5]

BOOST_AUTO_TEST_CASE

(

SimpleObjectApplySFAndUnc

)

    {
        // Check error condition
        BOOST_CHECK_THROW( SimpleObjectApplier("/nowhere", true, true),
                           fs::filesystem_error );
 
        HistogramFileFixture f;
        // This applier must apply the SF and do systematics
        const SimpleObjectApplier applier(f.path, true, true);
 
        // Must only return systematics that are actually applied
        const vector<string> expected_names{
            BIN_WISE_NAME + SysUp, BIN_WISE_NAME + SysDown,
            GLOBAL_NAME + SysUp, GLOBAL_NAME + SysDown};
        BOOST_TEST( applier.weightNames() == expected_names );
 
        // Selected object
        SimpleObject obj = {2, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 5 );
        BOOST_TEST( obj.weights.at(0).v == BIN2_SF );
        BOOST_TEST( obj.weights.at(0).i == 0 );
        BOOST_TEST( obj.weights.at(1).v == BIN2_SF + BIN2_BW );
        BOOST_TEST( obj.weights.at(1).i == 2 );
        BOOST_TEST( obj.weights.at(2).v == BIN2_SF - BIN2_BW );
        BOOST_TEST( obj.weights.at(2).i == 2 );
        BOOST_TEST( obj.weights.at(3).v == BIN2_SF + BIN2_GB );
        BOOST_TEST( obj.weights.at(3).i == 0 );
        BOOST_TEST( obj.weights.at(4).v == BIN2_SF - BIN2_GB );
        BOOST_TEST( obj.weights.at(4).i == 0 );
 
        // Selected object with existing weights
        // Check that existing weights are modified as expected
        obj = {2, {Weight{1, 0}, Weight{2, 1}}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 6 );
        BOOST_TEST( obj.weights.at(0).v == 1 * BIN2_SF );
        BOOST_TEST( obj.weights.at(0).i == 0 );
        BOOST_TEST( obj.weights.at(1).v == 2 * BIN2_SF );
        BOOST_TEST( obj.weights.at(1).i == 1 );
 
        // Object not selected
        obj = {1, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == 0 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
    }

BOOST_AUTO_TEST_CASE() [4/5]

BOOST_AUTO_TEST_CASE

(

SimpleObjectNoSF

)

    {
        // This applier must not even try to open the file, so passing a dummy
        // file name must be fine
        const SimpleObjectApplier applier("/nowhere", false, false);
 
        // Must only return systematics that are actually applied
        BOOST_TEST( applier.weightNames().empty() );
 
        // Selected object
        SimpleObject obj = {2, {}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == 1 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
 
        // Selected object with existing weights
        obj = {2, {Weight{1, 0}, Weight{2, 1}}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 2 );
        BOOST_TEST( obj.weights.at(0).v == 1 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
        BOOST_TEST( obj.weights.at(1).v == 2 );
        BOOST_TEST( obj.weights.at(1).i == 1 );
 
        // Object not selected
        obj = {1, {}}; 
        applier(obj);
        BOOST_TEST( obj.weights.size() == 1 );
        BOOST_TEST( obj.weights.at(0).v == 0 );
        BOOST_TEST( obj.weights.at(0).i == 0 );
 
        // Object not selected with existing weights
        obj = {1, {Weight{1, 0}, Weight{2, 1}, Weight{3, -1}}};
        applier(obj);
        BOOST_TEST( obj.weights.size() == 3 );
        for (int i = 0; i < obj.weights.size(); ++i) {
            BOOST_TEST( obj.weights.at(i).v == 0 );
        }
    }

BOOST_AUTO_TEST_CASE() [5/5]

BOOST_AUTO_TEST_CASE

(

Vector

)

    {
        // This applier must not even try to open the file, so passing a dummy
        // file name must be fine
        const SimpleObjectApplier applier("/nowhere", false, false);
 
        // First object not selected, second selected
        vector<SimpleObject> objs = {{1, {}}, {2, {}}};
        applier(objs);
        BOOST_TEST( objs.size() == 2 );
        BOOST_TEST( objs.at(0).weights.size() == 1 );
        BOOST_TEST( objs.at(0).weights.at(0).v == 0 );
        BOOST_TEST( objs.at(0).weights.at(0).i == 0 );
        BOOST_TEST( objs.at(1).weights.size() == 1 );
        BOOST_TEST( objs.at(1).weights.at(0).v == 1 );
        BOOST_TEST( objs.at(1).weights.at(0).i == 0 );
    }

Variable Documentation

BIN1_BW

const double BIN1_BW = 0.2

BIN1_GB

const double BIN1_GB = 0.5

BIN1_SF

const double BIN1_SF = 2

BIN2_BW

const double BIN2_BW = 0.3

BIN2_GB

const double BIN2_GB = 0.6

BIN2_SF

const double BIN2_SF = 3