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)

Functions
bool	successful (bool arg)
bool	successful (int arg)
bool	successful (const StatusCode &arg)
bool allTests	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options. More...
bool minimalTest	ATLAS_NOT_THREAD_SAFE (const std::string &type, Result &result)
bool parallelJob	ATLAS_NOT_THREAD_SAFE (const std::string &type, const std::string &saveAs)
template<class Interface = CP::IFakeBkgTool>
bool setup	ATLAS_NOT_THREAD_SAFE (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	ATLAS_NOT_THREAD_SAFE (asg::AnaToolHandle< Interface > &tool, Result &result)
bool addEventWeight	ATLAS_NOT_THREAD_SAFE (asg::AnaToolHandle< CP::ILinearFakeBkgTool > &tool, Result &result)
bool addEventWeight	ATLAS_NOT_THREAD_SAFE (asg::AnaToolHandle< CP::IFakeBkgTool > &tool, Result &result)
template<class Interface = CP::IFakeBkgTool>
bool fillResult	ATLAS_NOT_THREAD_SAFE (asg::AnaToolHandle< Interface > &tool, Result &result)
int main	ATLAS_NOT_THREAD_SAFE (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

)

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.

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/9]

bool allTests ATLAS_NOT_THREAD_SAFE ( )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

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 112 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;
}

ATLAS_NOT_THREAD_SAFE() [2/9]

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

Definition at line 263 of file fbtTestBasics.cxx.

{
  return true;
}

ATLAS_NOT_THREAD_SAFE() [3/9]

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

Definition at line 246 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;
}

ATLAS_NOT_THREAD_SAFE() [4/9]

template<class Interface = CP::IFakeBkgTool>

bool setup ATLAS_NOT_THREAD_SAFE	(	asg::AnaToolHandle< Interface > &	tool,
		const std::string &	type
	)

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

Definition at line 195 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;
    
}

ATLAS_NOT_THREAD_SAFE() [5/9]

template<class Interface = CP::IFakeBkgTool>

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

Definition at line 214 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;
}

ATLAS_NOT_THREAD_SAFE() [6/9]

template<class Interface = CP::IFakeBkgTool>

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

Definition at line 269 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;
}

ATLAS_NOT_THREAD_SAFE() [7/9]

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

Definition at line 173 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;
}

ATLAS_NOT_THREAD_SAFE() [8/9]

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

Definition at line 164 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;
}

ATLAS_NOT_THREAD_SAFE() [9/9]

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

Definition at line 84 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_CHECK1( event.evtStore().retrieve(), 1 );
  store = event.evtStore().get();
#endif
    
  int returnCode = allTests() ? 0 : 1;
    
#ifndef XAOD_STANDALONE
  FBT_CHECK1( app->finalize(), 1 );
#endif
  return returnCode;
}

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 74 of file fbtTestBasics.cxx.

eventOffset

int eventOffset = 0

Definition at line 78 of file fbtTestBasics.cxx.

nEvents

int nEvents = 48

Definition at line 79 of file fbtTestBasics.cxx.

process

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

Definition at line 76 of file fbtTestBasics.cxx.

progressFile

std::string progressFile = ""

Definition at line 80 of file fbtTestBasics.cxx.

readCPVariations

bool readCPVariations = true

Definition at line 77 of file fbtTestBasics.cxx.

selection

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

Definition at line 75 of file fbtTestBasics.cxx.

store

StoreGateSvc* store = nullptr

Definition at line 71 of file fbtTestBasics.cxx.

verbose

bool verbose = false

Definition at line 82 of file fbtTestBasics.cxx.