GoodRunsListSelectorTool Class Reference

This file contains the class definition for the GoodRunsListSelectorTool class. More...

#include <GoodRunsListSelectorTool.h>

Inheritance diagram for GoodRunsListSelectorTool:

Collaboration diagram for GoodRunsListSelectorTool:

Public Member Functions
virtual	~GoodRunsListSelectorTool ()
StatusCode	initialize ()
	Initialize AlgTool.
bool	passEvent (const EventIDBase &pEvent)
	called for each event by EventSelector to decide if the event should be passed
StatusCode	finalize ()
	Finalize AlgTool.
bool	passRunLB (int runNumber, int lumiBlockNr, const std::vector< std::string > &grlnameVec=std::vector< std::string >(), const std::vector< std::string > &brlnameVec=std::vector< std::string >())
	called for each event by GoodRunsListSelectorAlg to decide if the event should be passed
bool	passThisRunLB (const std::vector< std::string > &grlnameVec=std::vector< std::string >(), const std::vector< std::string > &brlnameVec=std::vector< std::string >())
	called for each event by GoodRunsListSelectorAlg to decide if the event should be passed
bool	registerGRLSelector (const std::string &name, const std::vector< std::string > &grlnameVec, const std::vector< std::string > &brlnameVec)
	register grl/brl combination
const std::map< std::string, vvPair > &	getGRLSelectorRegistry ()
	get GRL selector registry
const Root::TGRLCollection *	getGRLCollection () const
	get grl/brl collection
const Root::TGRLCollection *	getBRLCollection () const

Protected Member Functions
bool	fileExists (const char *fileName)

Protected Attributes
Gaudi::Property< std::vector< std::string > >	m_goodrunslistVec {this, "GoodRunsListVec", {}, "list of input xml files"}
Gaudi::Property< std::vector< std::string > >	m_blackrunslistVec {this,"BlackRunsListVec", {}, "list of input xml files"}
std::unique_ptr< Root::TGRLCollection >	m_grlcollection {new Root::TGRLCollection()}
std::unique_ptr< Root::TGRLCollection >	m_brlcollection {new Root::TGRLCollection()}
std::unique_ptr< Root::TGoodRunsListReader >	m_reader {new Root::TGoodRunsListReader()}
Gaudi::Property< int >	m_boolop {this,"BoolOperation",0}
Gaudi::Property< bool >	m_passthrough {this,"PassThrough",true}
Gaudi::Property< bool >	m_rejectanybrl {this,"RejectBlackRunsInEventSelector",false}
Gaudi::Property< bool >	m_eventselectormode {this,"EventSelectorMode",false}
std::map< std::string, vvPair >	m_registry

Detailed Description

This file contains the class definition for the GoodRunsListSelectorTool class.

Definition at line 30 of file GoodRunsListSelectorTool.h.

Constructor & Destructor Documentation

~GoodRunsListSelectorTool()

virtual GoodRunsListSelectorTool::~GoodRunsListSelectorTool ( )

inlinevirtual

Definition at line 36 of file GoodRunsListSelectorTool.h.

{};

Member Function Documentation

fileExists()

bool GoodRunsListSelectorTool::fileExists ( const char * fileName )

protected

stat() is able to get the file attributes, so the file obviously exists if filesize==0 assume the copying failed.

stat() is not able to get the file attributes, so the file obviously does not exist.

Definition at line 231 of file GoodRunsListSelectorTool.cxx.

{
  struct stat info;
  int ret = -1;
 
  //get the file attributes
  ret = stat(fileName, &info);
 
  if(ret == 0) {
    //if (info.st_size == 0) return false;
    //else
    return true;
  } else {
    return false;
  }
}

finalize()

StatusCode GoodRunsListSelectorTool::finalize

(

)

Finalize AlgTool.

Definition at line 223 of file GoodRunsListSelectorTool.cxx.

{
  ATH_MSG_DEBUG ("finalize() ");
  return StatusCode::SUCCESS;
}

getBRLCollection()

const Root::TGRLCollection * GoodRunsListSelectorTool::getBRLCollection ( ) const

inline

Definition at line 59 of file GoodRunsListSelectorTool.h.

{ return m_brlcollection.get(); }

getGRLCollection()

const Root::TGRLCollection * GoodRunsListSelectorTool::getGRLCollection ( ) const

inline

get grl/brl collection

Definition at line 58 of file GoodRunsListSelectorTool.h.

{ return m_grlcollection.get(); } 

getGRLSelectorRegistry()

const std::map< std::string, vvPair > & GoodRunsListSelectorTool::getGRLSelectorRegistry ( )

inline

get GRL selector registry

Definition at line 55 of file GoodRunsListSelectorTool.h.

{ return m_registry; }

initialize()

StatusCode GoodRunsListSelectorTool::initialize

(

)

Initialize AlgTool.

reset pass-through mode

warn about pass-thru mode

checking existence of goodrunslists / blocklists

start reading xml files

this merge accounts for same identical metadata, version, name, etc.

this merge accounts for same identical metadata, version, name, etc.

Definition at line 20 of file GoodRunsListSelectorTool.cxx.

{
  ATH_MSG_DEBUG ("initialize() ");
 
  Root::TMsgLogger::SetMinLevel(static_cast<Root::TMsgLevel>(msgLevel()));

  if (!m_goodrunslistVec.empty() || !m_blackrunslistVec.empty())
    m_passthrough=false;

  if (m_passthrough) ATH_MSG_WARNING ("Set to pass-through mode.");

  std::vector<std::string>::iterator itr;
  for (itr=m_goodrunslistVec.begin(); itr!=m_goodrunslistVec.end(); ++itr)  {
    std::string fname;
    if ( itr->find('/')==0 || itr->find('$')==0 || itr->find('.')==0 || itr->find(':')!=string::npos )  {
      fname = gSystem->ExpandPathName( itr->c_str() );
    }
    else {
      fname = (PathResolverFindXMLFile( *itr ));
    }
    if ( !fileExists(fname.c_str()) ) {
      ATH_MSG_ERROR ("Cannot open file : " << fname);
      return StatusCode::FAILURE;
    }
  }
  for (itr=m_blackrunslistVec.begin(); itr!=m_blackrunslistVec.end(); ++itr)  {
    std::string fname;
    if ( itr->find('/')==0 || itr->find('$')==0 || itr->find('.')==0 || itr->find(':')!=string::npos )  {
      fname = gSystem->ExpandPathName( itr->c_str() );
    }
    else {
      fname = (PathResolverFindXMLFile( *itr ));
    }
    if ( !fileExists(fname.c_str()) ) {
      ATH_MSG_ERROR ("Cannot open file : " << fname);
      return StatusCode::FAILURE;
    }
  }
  if ( !m_goodrunslistVec.empty() ) {
    m_reader->Reset();
    for (itr=m_goodrunslistVec.begin(); itr!=m_goodrunslistVec.end(); ++itr) {
      std::string fname;
      if ( itr->find('/')==0 || itr->find('$')==0 || itr->find('.')==0 || itr->find(':')!=string::npos )  {
        fname = gSystem->ExpandPathName( itr->c_str() );
      }
      else {
        fname = (PathResolverFindXMLFile( *itr ));
      }
      m_reader->AddXMLFile(fname);
    }
    m_reader->Interpret();
    *m_grlcollection = m_reader->GetMergedGRLCollection(static_cast<Root::BoolOperation>(m_boolop.value()));
  }
  if ( !m_blackrunslistVec.empty() ) {
    m_reader->Reset();
    for (itr=m_blackrunslistVec.begin(); itr!=m_blackrunslistVec.end(); ++itr) {
      std::string fname;
      if ( itr->find('/')==0 || itr->find('$')==0 || itr->find('.')==0 || itr->find(':')!=string::npos )  {
        fname = gSystem->ExpandPathName( itr->c_str() );
      }
      else {
        fname = (PathResolverFindXMLFile( *itr ));
      }
      m_reader->AddXMLFile(fname);
    }
    m_reader->Interpret();
    *m_brlcollection = m_reader->GetMergedGRLCollection(static_cast<Root::BoolOperation>(m_boolop.value()));
  }
 
  return StatusCode::SUCCESS;
}

passEvent()

bool GoodRunsListSelectorTool::passEvent

(

const EventIDBase &

pEvent

)

called for each event by EventSelector to decide if the event should be passed

now make query decision ...

decide from XML files

Definition at line 100 of file GoodRunsListSelectorTool.cxx.

{
  ATH_MSG_DEBUG ("passEvent() ");
 
  auto eventNumber = pEvent.event_number();
  int runNumber   = pEvent.run_number();
  int lumiBlockNr = pEvent.lumi_block();
  auto timeStamp   = pEvent.time_stamp();
 
  ATH_MSG_DEBUG ("passEvent() :: run number = " << runNumber <<
                 " ; event number = " << eventNumber <<
                 " ; lumiblock number = " << lumiBlockNr <<
                 " ; timestamp = " << timeStamp
                );

  bool pass(false);
  if (m_passthrough) {
    ATH_MSG_DEBUG ("passEvent() :: Pass through mode.");
    pass = true;
  }
  else {
    pass = this->passRunLB(runNumber,lumiBlockNr);
  }
 
  return pass;
}

passRunLB()

bool GoodRunsListSelectorTool::passRunLB	(	int	runNumber,
		int	lumiBlockNr,
		const std::vector< std::string > &	grlnameVec = std::vector<std::string>(),
		const std::vector< std::string > &	brlnameVec = std::vector<std::string>() )

called for each event by GoodRunsListSelectorAlg to decide if the event should be passed

pass through

decision based on merged blackrunslist

decision based on specific blackrunlists

decision based on specific goodrunlists

decision based on merged goodrunslist

Definition at line 165 of file GoodRunsListSelectorTool.cxx.

{
  ATH_MSG_DEBUG ("passRunLB() ");

  if (m_passthrough) {
    ATH_MSG_DEBUG ("passRunLB() :: Pass through mode.");
    return true;
  }

  if ( m_rejectanybrl && m_eventselectormode ) {
    if ( m_brlcollection->HasRunLumiBlock(runNumber,lumiBlockNr) ) {
      ATH_MSG_DEBUG ("passRunLB() :: Event rejected by (_any_ of) merged black runs list.");
      return false;
    }
  } else if (!brlnameVec.empty()) {
    bool reject(false);
    std::vector<Root::TGoodRunsList>::const_iterator brlitr;
    for (unsigned int i=0; i<brlnameVec.size() && !reject; ++i) {
      brlitr = m_brlcollection->find(brlnameVec[i]);
      if (brlitr!=m_brlcollection->end())
        reject = brlitr->HasRunLumiBlock(runNumber,lumiBlockNr);
    }
    if (reject) {
      ATH_MSG_DEBUG ("passRunLB() :: Event rejected by specific black runs list.");
      return false;
    }
  }

  if (!grlnameVec.empty()) {
    bool pass(false);
    std::vector<Root::TGoodRunsList>::const_iterator grlitr;
    for (unsigned int i=0; i<grlnameVec.size() && !pass; ++i) {
      grlitr = m_grlcollection->find(grlnameVec[i]);
      if (grlitr!=m_grlcollection->end())
        pass = grlitr->HasRunLumiBlock(runNumber,lumiBlockNr);
    }
    if (pass) {
      ATH_MSG_DEBUG ("passRunLB() :: Event accepted by specific good runs list.");
      return true;
    }
  } else if (m_grlcollection->HasRunLumiBlock(runNumber,lumiBlockNr)) {
    ATH_MSG_DEBUG ("passRunLB() :: Event accepted by (_any_ of) merged good runs list.");
    return true;
  }
 
  ATH_MSG_DEBUG ("passRunLB() :: Event rejected, not in (any) good runs list.");
  return false;
}

passThisRunLB()

bool GoodRunsListSelectorTool::passThisRunLB	(	const std::vector< std::string > &	grlnameVec = std::vector<std::string>(),
		const std::vector< std::string > &	brlnameVec = std::vector<std::string>() )

called for each event by GoodRunsListSelectorAlg to decide if the event should be passed

now make query decision ...

decide from XML files

Definition at line 131 of file GoodRunsListSelectorTool.cxx.

{
  ATH_MSG_DEBUG ("passThisRunLB() ");
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  int eventNumber = ctx.eventID().event_number();
  int runNumber   = ctx.eventID().run_number();
  int lumiBlockNr = ctx.eventID().lumi_block();
  int timeStamp   = ctx.eventID().time_stamp();
 
  ATH_MSG_DEBUG ("passThisRunLB() :: run number = " << runNumber <<
                 " ; event number = " << eventNumber <<
                 " ; lumiblock number = " << lumiBlockNr <<
                 " ; timestamp = " << timeStamp
                );

  bool pass(false);
  if (m_passthrough) {
    ATH_MSG_DEBUG ("passThisRunLB() :: Pass through mode.");
    pass = true;
  }
  else {
    pass = this->passRunLB(runNumber,lumiBlockNr,grlnameVec,brlnameVec);
  }
 
  return pass;
}

registerGRLSelector()

bool GoodRunsListSelectorTool::registerGRLSelector	(	const std::string &	name,
		const std::vector< std::string > &	grlnameVec,
		const std::vector< std::string > &	brlnameVec )

register grl/brl combination

check if brl names are really known

check if grl names are really known

Definition at line 253 of file GoodRunsListSelectorTool.cxx.

{
  if (m_registry.find(name)!=m_registry.end()) {
    ATH_MSG_WARNING ("registerGRLSelector() :: GRL selector with name <" << name << "> already registered. Return false.");
    return false;
  }

  if (!brlnameVec.empty()) {
    std::vector<Root::TGoodRunsList>::const_iterator brlitr;
    for (unsigned int i=0; i<brlnameVec.size(); ++i) {
      brlitr = m_brlcollection->find(brlnameVec[i]);
      if (brlitr==m_brlcollection->end()) {
        ATH_MSG_ERROR ("registerGRLSelector() :: requested BRL object with name <" << brlnameVec[i] << "> not found. Have you provided an object name from the BRL xml-file(s)?");
        return false;
      }
    }
  }

  if (!grlnameVec.empty()) {
    std::vector<Root::TGoodRunsList>::const_iterator grlitr;
    for (unsigned int i=0; i<grlnameVec.size(); ++i) {
      grlitr = m_grlcollection->find(grlnameVec[i]);
      if (grlitr==m_grlcollection->end()) {
        ATH_MSG_ERROR ("registerGRLSelector() :: requested GRL object with name <" << grlnameVec[i] << "> not found. Have you provided an object name from the GRL xml-file(s)?");
        return false;
      }
    }
  }
 
  ATH_MSG_DEBUG ("registerGRLSelector() :: GRL selector with name <" << name << "> registered.");
  m_registry[name] = vvPair(grlnameVec,brlnameVec);
  return true;
}

Member Data Documentation

m_blackrunslistVec

Gaudi::Property<std::vector<std::string> > GoodRunsListSelectorTool::m_blackrunslistVec {this,"BlackRunsListVec", {}, "list of input xml files"}

protected

Definition at line 66 of file GoodRunsListSelectorTool.h.

{this,"BlackRunsListVec", {}, "list of input xml files"}; 

m_boolop

Gaudi::Property<int> GoodRunsListSelectorTool::m_boolop {this,"BoolOperation",0}

protected

Definition at line 74 of file GoodRunsListSelectorTool.h.

{this,"BoolOperation",0};

m_brlcollection

std::unique_ptr<Root::TGRLCollection> GoodRunsListSelectorTool::m_brlcollection {new Root::TGRLCollection()}

protected

Definition at line 70 of file GoodRunsListSelectorTool.h.

{new Root::TGRLCollection()};

m_eventselectormode

Gaudi::Property<bool> GoodRunsListSelectorTool::m_eventselectormode {this,"EventSelectorMode",false}

protected

Definition at line 77 of file GoodRunsListSelectorTool.h.

{this,"EventSelectorMode",false};

m_goodrunslistVec

Gaudi::Property<std::vector<std::string> > GoodRunsListSelectorTool::m_goodrunslistVec {this, "GoodRunsListVec", {}, "list of input xml files"}

protected

Definition at line 65 of file GoodRunsListSelectorTool.h.

{this, "GoodRunsListVec", {}, "list of input xml files"};

m_grlcollection

std::unique_ptr<Root::TGRLCollection> GoodRunsListSelectorTool::m_grlcollection {new Root::TGRLCollection()}

protected

Definition at line 69 of file GoodRunsListSelectorTool.h.

{new Root::TGRLCollection()};

m_passthrough

Gaudi::Property<bool> GoodRunsListSelectorTool::m_passthrough {this,"PassThrough",true}

protected

Definition at line 75 of file GoodRunsListSelectorTool.h.

{this,"PassThrough",true};

m_reader

std::unique_ptr<Root::TGoodRunsListReader> GoodRunsListSelectorTool::m_reader {new Root::TGoodRunsListReader()}

protected

Definition at line 72 of file GoodRunsListSelectorTool.h.

{new Root::TGoodRunsListReader()};

m_registry

std::map< std::string, vvPair > GoodRunsListSelectorTool::m_registry

protected

Definition at line 79 of file GoodRunsListSelectorTool.h.

m_rejectanybrl

Gaudi::Property<bool> GoodRunsListSelectorTool::m_rejectanybrl {this,"RejectBlackRunsInEventSelector",false}

protected

Definition at line 76 of file GoodRunsListSelectorTool.h.

{this,"RejectBlackRunsInEventSelector",false};

---

The documentation for this class was generated from the following files:

• GoodRunsListSelectorTool.h
• GoodRunsListSelectorTool.cxx