InDetTrackSelectionToolTester.cxx File Reference

#include <memory>
#include <cstdlib>
#include <TFile.h>
#include <TError.h>
#include <TH2F.h>
#include "InDetTrackSelectionTool/InDetTrackSelectionTool.h"
#include "xAODTracking/TrackingPrimitives.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/VertexContainer.h"

Include dependency graph for InDetTrackSelectionToolTester.cxx:

Go to the source code of this file.

Classes
struct	HistFamily
class	unique_ptr< T >
	STL class. More...

Macros
#define	CHECK(ARG)
#define	HIST_INIT(NAME, AXIS_LABEL, AXIS_N, AXIS_XL, AXIS_XH)

Typedefs
using	TrkSelTool = InDet::InDetTrackSelectionTool

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

Macro Definition Documentation

CHECK

#define CHECK

(

ARG

)

Value:

do {ASG_CHECK_SA( APP_NAME, ARG );} while (false)

HIST_INIT

#define HIST_INIT	(		NAME,
			AXIS_LABEL,
			AXIS_N,
			AXIS_XL,
			AXIS_XH )

Value:

  do{                                   \
    h_##NAME = new TH2F(#NAME, #NAME ";#eta;" AXIS_LABEL, 50,-2.5,2.5,  \
            AXIS_N, AXIS_XL, AXIS_XH);          \
  } while (false)

Typedef Documentation

TrkSelTool

using TrkSelTool = InDet::InDetTrackSelectionTool

Definition at line 31 of file InDetTrackSelectionToolTester.cxx.

Function Documentation

main()

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

Definition at line 69 of file InDetTrackSelectionToolTester.cxx.

                                   {
 
   // The application's name:
   const char* APP_NAME = argv[ 0 ];
#define CHECK( ARG ) do {ASG_CHECK_SA( APP_NAME, ARG );} while (false)
 
   string fileName;
   // Check if we received a file name:
   if( argc < 2 ) {
     fileName = getenv("ROOTCORE_TEST_FILE");
     if (fileName.empty()) {
       Error( APP_NAME, "No file name received!" );
       Error( APP_NAME, "  Usage: %s [xAOD file name]", APP_NAME );
       return 1;
     }
   } else {
     fileName = argv[ 1 ];
   }
 
   // fail on an unchecked StatusCode
   StatusCode::enableFailure();
 
   // Initialise the application:
   CHECK( static_cast<StatusCode>(xAOD::Init( APP_NAME )) );
 
   // Open the input file:
   Info( APP_NAME, "Opening file: %s", fileName.data() );
   unique_ptr< TFile > ifile( TFile::Open( fileName.data(), "READ" ) );
   StatusCode gotFile = ifile.get()!=nullptr ? StatusCode::SUCCESS : StatusCode::FAILURE;
   CHECK( gotFile );
 
   // Create a TEvent object:
   xAOD::TEvent event( static_cast<TFile*>(nullptr), xAOD::TEvent::kClassAccess );
   CHECK( static_cast<StatusCode>(event.readFrom( ifile.get() )) );
   Info( APP_NAME, "Number of events in the file: %llu", event.getEntries() );
 
   // Decide how many events to run over:
   Long64_t entries = event.getEntries();
   if( argc > 2 ) {
      const Long64_t e = atoll( argv[ 2 ] );
      if( e < entries ) {
         entries = e;
      }
   }
 
   unique_ptr< TFile > outFile(new TFile("IDTrackSelectionToolTestOut.root", "RECREATE"));
   Info( APP_NAME, "Creating output file %s", outFile->GetName() );
 
   const vector<string> cutNames = {"NoCut", "Loose", "LoosePrimary", "TightPrimary", "LooseMuon", "LooseElectron", "MinBias", "HILoose", "HITight", "HILooseOptimized", "HITightOptimized"}; // these are names of pre-defined selections
   const vector<string> otherCutNames = {"IP", "IPSigma", "IPSignificance"}; // other configurations we will define manually
   std::map<string, unique_ptr<TrkSelTool> > selToolMap;
   std::map<string, unique_ptr<HistFamily> > histFamilyMap;
   for (const auto& cut : cutNames) {
     selToolMap[cut] = unique_ptr<TrkSelTool>(new TrkSelTool( (cut+"TrackSelection") ));
     CHECK( selToolMap[cut]->setProperty( "CutLevel", cut) );
     CHECK( selToolMap[cut]->initialize() );
     histFamilyMap[cut] = unique_ptr<HistFamily>(new HistFamily(cut));
   }
   selToolMap["IP"] = unique_ptr<TrkSelTool>(new TrkSelTool("IPTrackSelection"));
   CHECK( selToolMap["IP"]->setProperty( "maxD0", 1.5 ) );
   CHECK( selToolMap["IP"]->setProperty( "maxZ0SinTheta", 1.5 ) );
   CHECK( selToolMap["IP"]->initialize() );
   histFamilyMap["IP"] = unique_ptr<HistFamily>(new HistFamily("IP"));
   selToolMap["IPSigma"] = unique_ptr<TrkSelTool>(new TrkSelTool("IPSigmaTrackSelection"));
   CHECK( selToolMap["IPSigma"]->setProperty( "maxSigmaD0", 1.5 ) );
   CHECK( selToolMap["IPSigma"]->setProperty( "maxSigmaZ0SinTheta", 1.5 ) );
   CHECK( selToolMap["IPSigma"]->initialize() );
   histFamilyMap["IPSigma"] = unique_ptr<HistFamily>(new HistFamily("IPSigma"));
   selToolMap["IPSignificance"] = unique_ptr<TrkSelTool>(new TrkSelTool("IPSignificanceTrackSelection"));
   CHECK( selToolMap["IPSignificance"]->setProperty( "maxD0overSigmaD0", 3.0 ) );
   CHECK( selToolMap["IPSignificance"]->setProperty( "maxZ0SinThetaoverSigmaZ0SinTheta", 3.0 ) );
   CHECK( selToolMap["IPSignificance"]->initialize() );
   histFamilyMap["IPSignificance"] = unique_ptr<HistFamily>(new HistFamily("IPSignificance"));
 
   // Loop over the events:
   for( Long64_t entry = 0; entry < entries; ++entry ) {
     
     // Tell the object which entry to look at:
     CHECK( !event.getEntry( entry ) );
          
     // Get the InDetTrackParticles from the event:
     const xAOD::TrackParticleContainer* tracks = nullptr;
     CHECK( static_cast<StatusCode>(event.retrieve( tracks, "InDetTrackParticles" )) );
     
     const xAOD::VertexContainer* vertices = nullptr;
     CHECK( static_cast<StatusCode>(event.retrieve( vertices, "PrimaryVertices" )) );
     const auto it_pv = std::find_if(vertices->cbegin(), vertices->cend(),
                     [](const xAOD::Vertex* vtx)
                     {return vtx->vertexType() == xAOD::VxType::PriVtx;});
     const xAOD::Vertex* primaryVertex = (it_pv == vertices->cend()) ? nullptr : *it_pv;
     if (primaryVertex == nullptr) Warning( APP_NAME, "No primary vertex found." );
 
     for( const xAOD::TrackParticle* track : *tracks ) {
       if (track == nullptr) {
     Error( APP_NAME, "Null pointer to track!" );
     continue;
       }
       for (const auto& cut : cutNames) {
     if (selToolMap[cut]->accept(*track, primaryVertex)) histFamilyMap[cut]->fill(*track, primaryVertex);
       }
       for (const auto& cut : otherCutNames) {
     if (selToolMap[cut]->accept(*track, primaryVertex)) histFamilyMap[cut]->fill(*track, primaryVertex);   
       }
       
     } // end loop over tracks
     
   } // end loop over events
   
   for (const auto& selTool : selToolMap) CHECK( selTool.second->finalize() );
 
   // draw histogram
   outFile->Write();
 
   // Return gracefully:
   return 0;
}