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/AuxElement.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_CHECK(x)

Functions
bool	successful (bool arg)
bool	successful (int arg)
bool	successful (const StatusCode &arg)
bool	allTests ()
bool	minimalTest (const std::string &type, Result &result)
bool	parallelJob (const std::string &type, const std::string &saveAs)
bool	readFromROOT ()
bool	readFromXML ()
template<class Interface = CP::IFakeBkgTool>
bool	setup (asg::AnaToolHandle< Interface > &tool, const std::string &type)
	mostly useful for athena, which will otherwise re-use the previous tool More...
template<class Interface = CP::IFakeBkgTool>
bool	eventLoop (asg::AnaToolHandle< Interface > &tool, Result &result)
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
StoreGateSvc *	store = nullptr
std::vector< std::string >	config
std::string	selection = ">=1T"
std::string	process = ">=1F[T]"
bool	readCPVariations = true
int	eventOffset = 0
int	nEvents = 48
std::string	progressFile = ""
bool	verbose = false

Macro Definition Documentation

FBT_CHECK

#define FBT_CHECK

(

x

)

Value:

  while(true) {                             \
    if(successful(x)) break;                        \
    Error("fbtTestBasics", "%s", ("failure encounted on l." + std::to_string(__LINE__)).c_str()); \
    return false;                           \
  }

Definition at line 40 of file fbtTestBasics.cxx.

Function Documentation

addEventWeight() [1/2]

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

Definition at line 259 of file fbtTestBasics.cxx.

{
  return true;
}

addEventWeight() [2/2]

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

Definition at line 242 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

(

)

Definition at line 110 of file fbtTestBasics.cxx.

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

eventLoop()

template<class Interface = CP::IFakeBkgTool>

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

Definition at line 212 of file fbtTestBasics.cxx.

{
  auto eventInfo = std::make_unique<xAOD::EventInfo>();
  auto eventAuxInfo = std::make_unique<xAOD::EventAuxInfo>();
  eventInfo->setStore(eventAuxInfo.get());
  eventInfo->auxdata<int>("flag") = 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));
  for(int i=eventOffset;i<nEvents+eventOffset;++i)
    {
      e->setP4((1 + (i%3))*1e4, 0., 0. ,0.511);
      e->auxdecor<char>("Tight") = (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 265 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 82 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 = std::make_unique<xAOD::TStore>();
  StatusCode::enableFailure();
#else
  IAppMgrUI* app = POOL::Init();
  POOL::TEvent event(POOL::TEvent::kClassAccess);
  FBT_CHECK( event.evtStore().retrieve() );
  store = event.evtStore().get();
#endif
    
  int returnCode = allTests() ? 0 : 1;
    
#ifndef XAOD_STANDALONE
  FBT_CHECK( app->finalize() );
#endif
  return returnCode;
}

minimalTest()

bool minimalTest	(	const std::string &	type,
		Result &	result
	)

Definition at line 162 of file fbtTestBasics.cxx.

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

parallelJob()

bool parallelJob	(	const std::string &	type,
		const std::string &	saveAs
	)

Definition at line 171 of file fbtTestBasics.cxx.

{
  asg::AnaToolHandle<CP::IFakeBkgTool> tool;
  FBT_CHECK( setup(tool, type) );
  Result result;
  FBT_CHECK( eventLoop(tool, result) );
  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

(

)

Definition at line 315 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

(

)

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 342 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
	)

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

Definition at line 193 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.size())
    {
      FBT_CHECK( tool.setProperty("ProgressFileName", progressFile) );
      FBT_CHECK( tool.setProperty("ProgressFileDirectory", "fakes") );
    }
  FBT_CHECK( tool.initialize() );
  return true;
    
}

successful() [1/3]

bool successful

(

bool

arg

)

Definition at line 35 of file fbtTestBasics.cxx.

{ return arg; }

successful() [2/3]

bool successful

(

const StatusCode &

arg

)

Definition at line 37 of file fbtTestBasics.cxx.

{ return arg == StatusCode::SUCCESS; }

successful() [3/3]

bool successful

(

int

arg

)

Variable Documentation

config

std::vector<std::string> config

Definition at line 72 of file fbtTestBasics.cxx.

eventOffset

int eventOffset = 0

Definition at line 76 of file fbtTestBasics.cxx.

nEvents

int nEvents = 48

Definition at line 77 of file fbtTestBasics.cxx.

process

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

Definition at line 74 of file fbtTestBasics.cxx.

progressFile

std::string progressFile = ""

Definition at line 78 of file fbtTestBasics.cxx.

readCPVariations

bool readCPVariations = true

Definition at line 75 of file fbtTestBasics.cxx.

selection

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

Definition at line 73 of file fbtTestBasics.cxx.

store

StoreGateSvc* store = nullptr

Definition at line 69 of file fbtTestBasics.cxx.

verbose

bool verbose = false

Definition at line 80 of file fbtTestBasics.cxx.