fbtTestBasics.cxx File Reference

#include <fstream>
#include <map>
#include <memory>
#include <getopt.h>
#include <TSystem.h>
#include <TError.h>
#include <TFile.h>
#include <TH1F.h>
#include "POOLRootAccess/TEvent.h"
#include "AsgTools/AnaToolHandle.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODEventInfo/EventAuxInfo.h"
#include "xAODEgamma/Electron.h"
#include "xAODMuon/Muon.h"
#include "AthContainers/Accessor.h"
#include "AsgMessaging/MessageCheck.h"
#include "AsgAnalysisInterfaces/IFakeBkgTool.h"
#include "AsgAnalysisInterfaces/ILinearFakeBkgTool.h"

Go to the source code of this file.

Classes
struct	Result

Macros
#define	FBT_CHECK1(x, FAIL)
#define	FBT_CHECK(x)   FBT_CHECK1(x, false)

Typedefs
using	Store_t = StoreGateSvc *

Functions
bool	successful (bool arg)
bool	successful (const StatusCode &arg)
bool	allTests (Store_t &store)
bool	minimalTest (const std::string &type, const std::vector< std::string > &config, Store_t &store, Result &result)
bool	parallelJob (const std::string &type, const std::vector< std::string > &config, Store_t &store, const std::string &saveAs, int nEvents, int eventOffset)
bool	readFromROOT (std::vector< std::string > &config)
bool	readFromXML (std::vector< std::string > &config)
template<class Interface = CP::IFakeBkgTool>
bool	setup (asg::AnaToolHandle< Interface > &tool, const std::string &type, const std::vector< std::string > &config, const std::string &progressFile)
	mostly useful for athena, which will otherwise re-use the previous tool More...
template<class Interface = CP::IFakeBkgTool>
bool	eventLoop (asg::AnaToolHandle< Interface > &tool, Store_t &store, Result &result, int nEvents, int eventOffset=0)
bool	addEventWeight (asg::AnaToolHandle< CP::ILinearFakeBkgTool > &tool, Result &result)
bool	addEventWeight (asg::AnaToolHandle< CP::IFakeBkgTool > &tool, Result &result)
template<class Interface = CP::IFakeBkgTool>
bool	fillResult (asg::AnaToolHandle< Interface > &tool, Result &result)
int	main (int argc, char *argv[])

Variables
const std::string	selection = ">=1T"
const std::string	process = ">=1F[T]"
const bool	readCPVariations = true
const int	nEvents = 48
std::atomic< bool >	verbose = false

Macro Definition Documentation

FBT_CHECK

#define FBT_CHECK

(

x

)

FBT_CHECK1(x, false)

Definition at line 47 of file fbtTestBasics.cxx.

FBT_CHECK1

#define FBT_CHECK1	(		x,
			FAIL
	)

Value:

  do {                                                                  \
    if(!successful(x)) {                                                \
      Error("fbtTestBasics", "failure encounted on l.%d", __LINE__);    \
      return FAIL;                          \
    }                                                                   \
  } while(false)

Definition at line 40 of file fbtTestBasics.cxx.

Typedef Documentation

Store_t

using Store_t = StoreGateSvc*

Definition at line 59 of file fbtTestBasics.cxx.

Function Documentation

addEventWeight() [1/2]

bool addEventWeight	(	asg::AnaToolHandle< CP::IFakeBkgTool > &	tool,
		Result &	result
	)

Definition at line 253 of file fbtTestBasics.cxx.

{
  return true;
}

addEventWeight() [2/2]

bool addEventWeight	(	asg::AnaToolHandle< CP::ILinearFakeBkgTool > &	tool,
		Result &	result
	)

Definition at line 236 of file fbtTestBasics.cxx.

{
  FBT_CHECK( tool->applySystematicVariation({}) );
  float y;
  FBT_CHECK( tool->getEventWeight(y, selection, process) );
  result.value += y;
  result.statUp = sqrt(pow(result.statUp, 2) + y*y);
  result.statDown = sqrt(pow(result.statDown, 2) + y*y);
  for(auto& sysvar : tool->affectingSystematics())
    {
      FBT_CHECK( tool->applySystematicVariation({sysvar}) );
      FBT_CHECK( tool->getEventWeight(y, selection, process) );
      result.variations[sysvar] += y;
    }
  return true;
}

allTests()

bool allTests

(

Store_t &

store

)

Definition at line 109 of file fbtTestBasics.cxx.

{
  std::vector<std::string> config;
  Result result0, result1, result2, result3, result4, result5;
    
  if(verbose) std::cout <<"\nWill do minimal test with CP::ApplyFakeFactor\n";
  FBT_CHECK( readFromROOT(config) );
  FBT_CHECK( minimalTest("CP::ApplyFakeFactor", config, store, result0) );
    
  if(verbose) std::cout <<"\nWill do minimal test with CP::AsymptMatrixTool\n";
  FBT_CHECK( minimalTest("CP::AsymptMatrixTool", config, store, result1) );
    
  if(verbose) std::cout <<"\nWill do minimal test with CP::LhoodMM_tools\n";
  FBT_CHECK( minimalTest("CP::LhoodMM_tools", config, store, result2) );
    
  if(verbose) std::cout <<"\nWill test loading efficiencies from XML\n";
  FBT_CHECK( readFromXML(config) );
  FBT_CHECK( minimalTest("CP::AsymptMatrixTool", config, store, result3) );
  FBT_CHECK( readFromROOT(config) );
  FBT_CHECK( result1 == result3 );
    
  if(verbose) std::cout <<"\nWill test getEventWeight()\n";
  {
    asg::AnaToolHandle<CP::ILinearFakeBkgTool> tool;
    FBT_CHECK( setup(tool, "CP::AsymptMatrixTool", config) );
    FBT_CHECK( eventLoop(tool, store, result4, nEvents) );
    if(verbose) result3.Print();
  }
  FBT_CHECK( result1 == result4 );
    
  if(verbose) std::cout <<"\nWill test parallel jobs and merging\n";
  FBT_CHECK( parallelJob("CP::LhoodMM_tools", config, store, "fbt_job1.root", 16, 0) );
  FBT_CHECK( parallelJob("CP::LhoodMM_tools", config, store, "fbt_job2.root", 16, 16) );
  FBT_CHECK( parallelJob("CP::LhoodMM_tools", config, store, "fbt_job3.root", 16, 32) );
  FBT_CHECK( gSystem->Exec("hadd -f fbt_merged.root fbt_job*.root") == 0 );
  {
    asg::AnaToolHandle<CP::IFakeBkgTool> tool;
    FBT_CHECK( setup(tool, "CP::LhoodMM_tools", config, "fbt_merged.root") );
    FBT_CHECK( fillResult(tool, result5) );
  }
  FBT_CHECK(result2 == result5 );
    
  return true;
}

eventLoop()

template<class Interface = CP::IFakeBkgTool>

bool eventLoop	(	asg::AnaToolHandle< Interface > &	tool,
		Store_t &	store,
		Result &	result,
		int	nEvents,
		int	eventOffset = 0
	)

Definition at line 204 of file fbtTestBasics.cxx.

{
  auto eventInfo = std::make_unique<xAOD::EventInfo>();
  auto eventAuxInfo = std::make_unique<xAOD::EventAuxInfo>();
  eventInfo->setStore(eventAuxInfo.get());
  static const SG::Accessor<int> flagAcc("flag");
  flagAcc(*eventInfo) = 1;
  FBT_CHECK( store->record(std::move(eventInfo), "EventInfo") );
  FBT_CHECK( store->record(std::move(eventAuxInfo), "EventInfoAux.") );
 
  xAOD::IParticleContainer particles(SG::VIEW_ELEMENTS);
  auto e = std::make_unique<xAOD::Electron>();
  e->makePrivateStore();
  e->setCharge(1);
  particles.push_back(static_cast<xAOD::IParticle*>(&*e));
  static const SG::Accessor<char> TightAcc("Tight");
  for(int i=eventOffset;i<nEvents+eventOffset;++i)
    {
      e->setP4((1 + (i%3))*1e4, 0., 0. ,0.511);
      TightAcc(*e) = (i%4)? 0 : 1;
      FBT_CHECK( tool->addEvent(particles) );
      FBT_CHECK( addEventWeight(tool, result) );
    }
    
#ifdef XAOD_STANDALONE
  store->clear();
#else
  FBT_CHECK( store->clearStore(true) );
#endif
  return true;
}

fillResult()

template<class Interface = CP::IFakeBkgTool>

bool fillResult	(	asg::AnaToolHandle< Interface > &	tool,
		Result &	result
	)

Definition at line 259 of file fbtTestBasics.cxx.

{
  result.variations.clear();
  FBT_CHECK( tool->getTotalYield(result.value, result.statUp, result.statDown) );
  if(readCPVariations)
    {
      for(auto& sysvar : tool->affectingSystematics())
        {
      FBT_CHECK( tool->applySystematicVariation({sysvar}) );
      float unused;
      FBT_CHECK( tool->getTotalYield(result.variations[sysvar], unused, unused) );
        }
    }
  if(verbose) result.Print();
  return true;
}

main()

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

Definition at line 81 of file fbtTestBasics.cxx.

{
  for(int i=1;i<argc;++i)
    {
      std::string option = argv[i];
      if(option=="-v" || option=="--verbose") verbose = true;
    }
 
#ifdef XAOD_STANDALONE
  xAOD::Init("fbtTestBasics").ignore();
  xAOD::TEvent event(xAOD::TEvent::kClassAccess);
  Store_t store = std::make_unique<xAOD::TStore>();
  StatusCode::enableFailure();
#else
  IAppMgrUI* app = POOL::Init();
  POOL::TEvent event(POOL::TEvent::kClassAccess);
  FBT_CHECK1( event.evtStore().retrieve(), 1 );
  Store_t store = event.evtStore().get();
#endif
    
  int returnCode = allTests(store) ? 0 : 1;
    
#ifndef XAOD_STANDALONE
  FBT_CHECK1( app->finalize(), 1 );
#endif
  return returnCode;
}

minimalTest()

bool minimalTest	(	const std::string &	type,
		const std::vector< std::string > &	config,
		Store_t &	store,
		Result &	result
	)

Definition at line 154 of file fbtTestBasics.cxx.

{
  asg::AnaToolHandle<CP::IFakeBkgTool> tool;
  FBT_CHECK( setup(tool, type, config) );
  FBT_CHECK( eventLoop(tool, store, result, nEvents) );
  FBT_CHECK( fillResult(tool, result) );
  return true;
}

parallelJob()

bool parallelJob	(	const std::string &	type,
		const std::vector< std::string > &	config,
		Store_t &	store,
		const std::string &	saveAs,
		int	nEvents,
		int	eventOffset
	)

Definition at line 163 of file fbtTestBasics.cxx.

{
  asg::AnaToolHandle<CP::IFakeBkgTool> tool;
  FBT_CHECK( setup(tool, type, config) );
  Result result;
  FBT_CHECK( eventLoop(tool, store, result, nEvents, eventOffset) );
  std::unique_ptr<TFile> f(TFile::Open(saveAs.c_str(), "RECREATE"));
  FBT_CHECK( !!f );
  FBT_CHECK( tool->saveProgress(f->mkdir("fakes")) );
  f->Close();
  if(verbose)
    {
      float value, up, down;
      FBT_CHECK( tool->getTotalYield(value, up, down) );
      std::cout << "Parallel job stored intermediate yield " << value << " +" << up << " -" << down << std::endl;
    }
  return true;
}

readFromROOT()

bool readFromROOT

(

std::vector< std::string > &

config

)

Definition at line 309 of file fbtTestBasics.cxx.

{
  config.clear();
  config.emplace_back("fbt_efficiencies.root");
  TH1D hElFake("FakeEfficiency_el_pt","FakeEfficiency", 1, 10., 100.);
  hElFake.SetBinContent(1, 0.05);
  hElFake.SetBinError(1, 0.01);
  TH1D hMuFake("FakeEfficiency_mu_pt","FakeEfficiency", 1, 10., 100.);
  hMuFake.SetBinContent(1, 0.15);
  hMuFake.SetBinError(1, 0.032);
  TH1D hElReal("RealEfficiency_el_pt","RealEfficiency", 1, 10., 100.);
  hElReal.SetBinContent(1, 0.90);
  hElReal.SetBinError(1, 0.01);
  TH1D hMuReal("RealEfficiency_mu_pt","RealEfficiency", 1, 10., 100.);
  hMuReal.SetBinContent(1, 0.95);
  hMuReal.SetBinError(1, 0.01);
  std::unique_ptr<TFile> f(TFile::Open(config.back().c_str(), "RECREATE"));
  FBT_CHECK( !!f );
  f->cd();
  hElFake.Write();
  hElReal.Write();
  hMuFake.Write();
  hMuReal.Write();
  f->Close();
  return true;
}

readFromXML()

bool readFromXML

(

std::vector< std::string > &

config

)

note: the declarations must be placed in the "good" order, otherwise the definitions of the SystematicVariations will be different than those obtained with readFromROOT()

Definition at line 336 of file fbtTestBasics.cxx.

{
  config.clear();
  config.emplace_back("fbt_efficiencies.xml");
  std::ofstream out(config.back().c_str(), std::ios_base::out);
  FBT_CHECK( out.is_open() );
  out << "<efficiencies>\n";
  out << "<param type=\"int\" level=\"event\"> flag </param>\n";
  out << "<electron type=\"fake-efficiency\" input=\"central-value\" stat=\"per-bin\" >\n\t<bin flag=\"1\">\n 0.05 +- 0.01 (stat) </bin>\n</electron>\n";
  out << "<electron type=\"real-efficiency\" input=\"central-value\" stat=\"global\" >\n\t<bin flag=\"1\">\n 0.90 +- 0.01 (stat) </bin>\n</electron>\n";
  out << "<muon type=\"fake-efficiency\" input=\"central-value\" stat=\"per-bin\" >\n\t<bin flag=\"1\">\n 0.15 +- 0.032 (stat) </bin>\n</muon>\n";
  out << "<muon type=\"real-efficiency\" input=\"central-value\" stat=\"global\" >\n\t<bin flag=\"1\">\n 0.95 +- 0.01 (stat) </bin>\n</muon>\n";
  out << "</efficiencies>\n";
  out.close();
  return true;
}

setup()

template<class Interface = CP::IFakeBkgTool>

bool setup	(	asg::AnaToolHandle< Interface > &	tool,
		const std::string &	type,
		const std::vector< std::string > &	config,
		const std::string &	progressFile = ""
	)

mostly useful for athena, which will otherwise re-use the previous tool

Definition at line 185 of file fbtTestBasics.cxx.

{
  tool = asg::AnaToolHandle<Interface>(type + "/FBT" + std::to_string(++instance));
  FBT_CHECK( tool.setProperty("InputFiles", config) );
  FBT_CHECK( tool.setProperty("EnergyUnit", "GeV") );
  FBT_CHECK( tool.setProperty("ConvertWhenMissing", true) );
  FBT_CHECK( tool.setProperty("Selection", selection) );
  FBT_CHECK( tool.setProperty("Process", process) );
  if(!progressFile.empty())
    {
      FBT_CHECK( tool.setProperty("ProgressFileName", progressFile) );
      FBT_CHECK( tool.setProperty("ProgressFileDirectory", "fakes") );
    }
  FBT_CHECK( tool.initialize() );
  return true;
    
}

successful() [1/2]

bool successful

(

bool

arg

)

Definition at line 36 of file fbtTestBasics.cxx.

{ return arg; }

successful() [2/2]

bool successful

(

const StatusCode &

arg

)

Definition at line 37 of file fbtTestBasics.cxx.

{ return arg.isSuccess(); }

Variable Documentation

nEvents

const int nEvents = 48

Definition at line 77 of file fbtTestBasics.cxx.

process

const std::string process = ">=1F[T]"

Definition at line 75 of file fbtTestBasics.cxx.

readCPVariations

const bool readCPVariations = true

Definition at line 76 of file fbtTestBasics.cxx.

selection

const std::string selection = ">=1T"

Definition at line 74 of file fbtTestBasics.cxx.

verbose

std::atomic<bool> verbose = false

Definition at line 79 of file fbtTestBasics.cxx.