Darwin::Physics Namespace Reference

Classes
struct	Event
struct	FourVector
struct	GenEvent
struct	GenJet
struct	Jet
struct	MET
struct	PileUp
struct	RecEvent
struct	RecJet
struct	RecMET
struct	Trigger
struct	Vertex

Functions
template<bool DARWIN_TEST_EXCEPTIONS = false>
void	example02 (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
void	example03 (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
template<bool DARWIN_TEST_EXCEPTIONS = false>
void	example02 (const fs::path &input, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
void	example03 (const fs::path &input, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})

Detailed Description

Everything what concerns physics analysis directly.

Function Documentation

example02() [1/2]

void Darwin::Physics::example02	(	const fs::path &	input,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

                                      {1,0} )
{
    example02<DARWIN_TEST_EXCEPTIONS>(vector<fs::path>{input}, output, config, steering, slice);
}

example02() [2/2]

void Darwin::Physics::example02	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

Toy example to modify a n-tuple.

The template argument is only for the test of exceptions in unit tests.

Parameters

inputs	input ROOT files (n-tuples)
output	output ROOT file (n-tuple)
config	config handled with `Darwin::Tools::options`
steering	parameters obtained from explicit options
slice	number and index of slice

                                      {1,0} 
                )
{
    cout << __func__ << ' ' << slice << " start" << endl;
 
    unique_ptr<TChain> tIn = DT::GetChain(inputs);
    unique_ptr<TFile> fOut(DT_GetOutput(output));
    unique_ptr<TTree> tOut(DT_NewTree(tIn, (steering & DT::Friend) == DT::Friend));
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
 
    vector<RecJet> * recs = nullptr;
    tIn->SetBranchAddress("recs", &recs);
    if ((steering & DT::Friend) == DT::Friend)
        tOut->Branch("recs", &recs);
 
    const auto& corrections = config.get_child("corrections");
    metainfo.Set<string>("corrections", "METfilters", corrections.get<string>("METfilters"));
    metainfo.Set<string>("corrections", "hotzones",   corrections.get<string>("hotzones"  ));
 
    metainfo.Set<const char *>("variations", "JECs", "nominal");
    if (steering & DT::syst) {
        metainfo.Set<const char *>("variations", "JECs", "JESdn");
        metainfo.Set<const char *>("variations", "JECs", "JESup");
    }
 
    for (DT::Looper looper(tIn, slice); looper(); ++looper) {
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
        if constexpr (DARWIN_TEST_EXCEPTIONS)
            if (*looper == 5)
                BOOST_THROW_EXCEPTION(DE::AnomalousEvent("Here is an anomally", tIn));
 
        for (auto& rec: *recs) {
            rec.area = M_PI*pow(0.4,2);
            rec.scales = {1.1}; // nominal
            if (steering & DT::syst) {
                rec.scales.push_back(1.05); // JESdn
                rec.scales.push_back(1.15); // JESup
            }
            cout << rec << endl;
        }
 
        if (steering & DT::fill) tOut->Fill();
    }
 
    metainfo.Set<bool>("git", "complete", true);
    fOut->cd();
    tOut->Write();
 
    cout << __func__ << ' ' << slice << " end" << endl;
}

example03() [1/2]

void Darwin::Physics::example03	(	const fs::path &	input,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

                                      {1,0})
{
    example03(vector<fs::path>{input}, output, config, steering, slice);
}

example03() [2/2]

void Darwin::Physics::example03	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

Toy example to project a n-tuple.

Parameters

inputs	input ROOT files (n-tuple)
output	output ROOT file (histograms)
config	config handled with `Darwin::Tools::Options`
steering	parameters obtained from explicit options
slice	number and index of slice

                                      {1,0} 
                )
{
    cout << __func__ << ' ' << slice << " start" << endl;
 
    unique_ptr<TChain> tIn = DT::GetChain(inputs);
 
    vector<RecJet> * recs = nullptr;
    tIn->SetBranchAddress("recs", &recs);
 
    unique_ptr<TFile> fOut(DT_GetOutput(output));
    auto tOut = unique_ptr<TTree>(tIn->CloneTree(0)); // ghost tree: only there to keep meta info
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
 
    auto h = new TH1D("h", ";p_{T};N", 990, 10, 1000);
 
    // event loop
    for (DT::Looper looper(tIn, slice); looper(); ++looper) {
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
        for (const auto& rec: *recs) {
            h->Fill(rec.Pt());
            cout << rec << endl;
        }
        // here we do *NOT* fill the tree
    }
 
    metainfo.Set<bool>("git", "complete", true);
 
    tOut->Write();
    h->Write();
 
    cout << __func__ << ' ' << slice << " end" << endl;
}