AthAnalysisHelper Class Reference

#include <AthAnalysisHelper.h>

Inheritance diagram for AthAnalysisHelper:

Collaboration diagram for AthAnalysisHelper:

Public Member Functions
	AthAnalysisHelper ()

Static Public Member Functions
static IAppMgrUI *	initGaudi (const char *options="")
	initGaudi method starts the gaudi ApplicationMgr ready for working with all the components More...
template<typename W >
static StatusCode	addPropertyToCatalogue (const std::string &name, const std::string &property, const W &value, bool override=true)
	helper method for adding a property to the JobOptionsSvc to list all the properties in the catalogue, do: AthAnalysisHelper::dumpJobOptionProperties() More...
template<typename W >
static StatusCode	setProperty (const std::string &name, const std::string &property, const W &value, bool override=true)
static StatusCode	setProperty (const std::string &name, const std::string &property, const std::string &value, bool override=true)
	non-template method, for use in joboptions current usage would be: ... More...
template<class W , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase,W>::value && !std::is_base_of<GaudiHandleArrayBase,W>::value>::type>
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const W &value, bool override=true)
	helper method for setting a property on a tool before retrieving it uses the toolhandle to work out what to register the joboptionsvc Usage examples: ToolHandle<IMyTool> tool("MyTool/toolName"); CHECK( AthAnalysisHelper::setProperty( tool, "IntegerProperty", 5) ); CHECK( AthAnalysisHelper::setProperty( tool, "StringProperty", "hello") ); CHECK( AthAnalysisHelper::setProperty( tool, "StringArrayProperty", std::vector<std::string>({"a","b","c"}) ) ); CHECK( AthAnalysisHelper::setProperty( tool, "PublicToolHandleProperty", anotherToolHandle) ); CHECK( AthAnalysisHelper::setProperty( tool, "PrivateToolHandleName.SubToolIntegerProperty", 4) ); The last example assumes the 'MyTool' class has declared a ToolHandle("SubTool/PrivateToolHandleName",this) and 'SubTool' class has an integer property called 'SubToolIntegerProperty' declared More...
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const GaudiHandleBase &value, bool override=true)
	Partial template specialization for ToolHandles and ToolHandleArrays ... strips parent name from tool name, for setting private handles on. More...
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const GaudiHandleArrayBase &value, bool override=true)
template<typename W >
static StatusCode	setProperty (IAlgTool *tool, const std::string &property, const W &value)
	setProperty on any tool, even when initialized More...
template<typename W >
static StatusCode	setProperty (IAlgorithm *alg, const std::string &property, const W &value)
	setProperty on an alg, even when initialized More...
template<typename T >
static std::string	toString (const T &value)
static std::string	toString (const std::string &value)
static std::string	toString (const char *value)
template<typename T , typename W >
static StatusCode	setProperty (const ServiceHandle< T > &serviceHandle, const std::string &property, const W &value)
	setProperty for services ... will allow setProperty on already-existing services More...
template<typename W >
static W *	createTool (const std::string &typeAndName, INamedInterface *parent=0)
	Create a tool using the gaudi factory methods. More...
static IAlgTool *	createTool (const std::string &typeAndName, INamedInterface *parent=0)
static IAlgorithm *	createAlgorithm (const std::string &typeAndName)
static bool	toolExists (const std::string &fullName)
	check if tool already exists. FullName = Parent.Name More...
static bool	toolExists (const GaudiHandleBase &toolHandle)
static std::string	retrieveMetadata (const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
	method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT.POOL.TEvent() ... More...
static std::string	retrieveMetadata (const std::string &folder, const std::string &key, ServiceHandle< StoreGateSvc > &inputMetaStore)
template<typename T >
static StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out)
	retrieve metadata from the input metadata storegate. More...
template<typename T >
static StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out, const ServiceHandle< StoreGateSvc > &inputMetaStore)
	implemenation where you pass it a particular store instead More...
template<typename T >
static StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out, const ServiceHandle< StoreGateSvc > &inputMetaStore, const IOVTime &time, int channel=-1)
	retrieve metadata, for a specified IOVTime and a specific channel, unless the channel is -1, in which case we take the first available channel channels have to be unsigned int, so can use -1 to signal 'take whatever first channel is (it isn't always 0)' More...
template<typename T >
static StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out, const IOVTime &time, int channel=-1)
static void	dumpJobOptionProperties (const std::string &client="")
	Dump the properties from joboptionsvc of clients with names beginning with given string. More...
static void	dumpProperties (const std::string &client="")
static std::string	getProperty (const std::string &client, const std::string &property)
	Check catalogue for property of specified client returns AAH::UNDEFINED in case of no property value available (i.e. More...
static void	printAuxElement (const SG::AuxElement &ae)
	Print the aux variables of an xAOD object (aux element) An alternative to this method is the 'xAOD::dump' method. More...
static void	dumpProperties (const SG::AuxElement &ae)
static void	dumpProperties (const IProperty &component)
	Dump the properties of an IProperty. More...
template<typename T >
static void	dumpProperties (const GaudiHandle< T > &handle)
static TFile *	getOutputFile (const std::string &streamName)

Static Public Attributes
static const std::string	UNDEFINED = "__UNDEFINED__"

Detailed Description

Definition at line 37 of file AthAnalysisHelper.h.

Constructor & Destructor Documentation

AthAnalysisHelper()

AthAnalysisHelper::AthAnalysisHelper

(

)

Definition at line 18 of file AthAnalysisHelper.cxx.

{ } 

Member Function Documentation

addPropertyToCatalogue()

template<typename W >

static StatusCode AthAnalysisHelper::addPropertyToCatalogue ( const std::string &  name, const std::string &  property, const W &  value, bool  override = true  )

inlinestatic

helper method for adding a property to the JobOptionsSvc to list all the properties in the catalogue, do: AthAnalysisHelper::dumpJobOptionProperties()

Definition at line 50 of file AthAnalysisHelper.h.

                                                                                                                                                         {
     ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AthAnalysisHelper");
     if(joSvc.retrieve().isFailure()) return StatusCode::FAILURE;
     if(!override) {
      //check if property already defined. If so, then print a warning and return failure
      std::string pValue = getProperty( name, property );
      if( pValue != UNDEFINED) {
        std::cout << "WARNING: " << name << "." << property << " already defined as " << pValue << " ... ignoring " <<  Gaudi::Utils::toString ( value ) << std::endl;
        return StatusCode::FAILURE;
      }
     }
 
     if constexpr (std::is_convertible<W, std::string>::value) {
       // If value is already convertible to a string, don't use toString().
       // Otherwise, toString() will add quotes around the string,
       // which confuses things further on.
       // (These quotes used to be removed by the old 
       // IJobOptionsSvc::addPropertyToCatalogue interface, but IOptionsSvc::set
       // doesn't do that.)
       joSvc->set( name+"."+property , std::string (value) );
     }
     else {
       joSvc->set( name+"."+property , Gaudi::Utils::toString ( value ) );
     }
     return StatusCode::SUCCESS;
   }

createAlgorithm()

static IAlgorithm* AthAnalysisHelper::createAlgorithm ( const std::string &  typeAndName )

inlinestatic

Definition at line 231 of file AthAnalysisHelper.h.

                                                                    {
      std::string type = typeAndName; std::string name = typeAndName;
      std::string::size_type pos = type.find('/');
      if(pos!=std::string::npos) {
        type.resize (pos);
        name = name.substr(pos+1,name.length());
      }
      IAlgorithm* out = Algorithm::Factory::create(type,name,Gaudi::svcLocator()).release();
      out->addRef(); //important to increment the reference count so that Gaudi Garbage collection wont delete alg ahead of time 
      return out;
   }

createTool() [1/2]

template<typename W >

static W* AthAnalysisHelper::createTool ( const std::string &  typeAndName, INamedInterface *  parent = 0  )

inlinestatic

Create a tool using the gaudi factory methods.

This creates tools that wont be known to the ToolSvc User is responsible for deleting the tool Parent is optional, allows your created tool to inherit OutputLevel properties from the parent If not parent specified, the ToolSvc will be used as the parent Please Note: The preferred method of creating tools is with a ToolHandle Usage: IMyTool* tool = AthAnalysisHelper::createTool<IMyTool>("ToolType/ToolName"); CHECK( AthAnalysisHelper::setProperty( tool, "Property", value ) ); CHECK( tool->initialize() ); Preferred: ToolHandle<IMyTool> tool("ToolType/ToolName"); CHECK( AthAnalysisHelper::setProperty( tool, "Property", value ) ); CHECK( tool.retrieve() );

Definition at line 204 of file AthAnalysisHelper.h.

                                                                                                        {
      std::string type = typeAndName; std::string name = typeAndName;
      std::string::size_type pos = type.find('/');
      if(pos!=std::string::npos) {
        type.resize (pos);
        name = name.substr(pos+1,name.length());
      }
      if(parent==0) {
    //use ToolSvc as parent
    parent = Gaudi::svcLocator()->service( "ToolSvc" );
      }
      IAlgTool *algtool = AlgTool::Factory::create(type,type,name,parent).release();
      algtool->addRef(); //important to increment the reference count so that Gaudi Garbage collection wont delete alg ahead of time 
      W* out = dynamic_cast<W*>(algtool);
      if(!out) {
         std::cout << "ERROR: Tool of type " << type << " does not implement the interface " << System::typeinfoName(typeid(W)) << std::endl;
         delete algtool;
         return 0; 
      }
      return out;
   }

createTool() [2/2]

static IAlgTool* AthAnalysisHelper::createTool ( const std::string &  typeAndName, INamedInterface *  parent = 0  )

inlinestatic

Definition at line 225 of file AthAnalysisHelper.h.

                                                                                          {
     return createTool<IAlgTool>(typeAndName,parent);
   }

dumpJobOptionProperties()

void AthAnalysisHelper::dumpJobOptionProperties ( const std::string &  client = "" )

static

Dump the properties from joboptionsvc of clients with names beginning with given string.

If string is blank, will print all clients Example usage: athena -i myJobOptions.py athena> theApp.setup() athena> import ROOT athena> ROOT.AAH.dumpJobOptionProperties() This will display all the joboption properties declared at the start of your job

Definition at line 54 of file AthAnalysisHelper.cxx.

                                                                       {
   ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AthAnalysisHelper");
   if(joSvc.retrieve().isFailure()) return;
   for(const auto& [name,value] : joSvc->items()) {
     if(name.find(client)!=0) continue; //must start with client
     std::cout << name << " = " << value << std::endl;
   }
}

dumpProperties() [1/4]

template<typename T >

static void AthAnalysisHelper::dumpProperties ( const GaudiHandle< T > &  handle )

inlinestatic

Definition at line 386 of file AthAnalysisHelper.h.

                                                                                 {
    if(!handle.isSet()) {std::cout << "Please retrieve handle before dumping properties" << std::endl; return;}
    return dumpProperties(dynamic_cast<const IProperty&>(*handle));
  }

dumpProperties() [2/4]

void AthAnalysisHelper::dumpProperties ( const IProperty &  component )

static

Dump the properties of an IProperty.

Definition at line 98 of file AthAnalysisHelper.cxx.

                                                                 {
  for(auto p : component.getProperties()) {
    std::cout << p->name() << " = " << p->toString() << std::endl;
  }
}

dumpProperties() [3/4]

static void AthAnalysisHelper::dumpProperties ( const SG::AuxElement &  ae )

inlinestatic

Definition at line 378 of file AthAnalysisHelper.h.

{ printAuxElement(ae); } //list properties of an xAOD object

dumpProperties() [4/4]

static void AthAnalysisHelper::dumpProperties ( const std::string &  client = "" )

inlinestatic

Definition at line 367 of file AthAnalysisHelper.h.

{ dumpJobOptionProperties(client); } //list properties of client present in catalogue

getOutputFile()

TFile * AthAnalysisHelper::getOutputFile ( const std::string &  streamName )

static

Definition at line 105 of file AthAnalysisHelper.cxx.

                                                                   {
  ServiceHandle<IProperty> histSvc("THistSvc","");
  auto& prop = histSvc->getProperty("Output");
 
  std::vector<std::string> outputs;
  if( Gaudi::Parsers::parse(outputs,prop.toString()).isFailure() ) {
    return nullptr;
  }
 
  //extract the DATAFILE part of the string
  std::string fileName="";
  for(std::string& output : outputs) {
    if( output.substr(0,output.find(' '))!=streamName ) continue;
 
    //got here .. means we found the stream ...
    for(auto attrib : Gaudi::Utils::AttribStringParser(output.substr(output.find(' ')+1))) {
      auto TAG = attrib.tag;
      std::transform(TAG.begin(), TAG.end(), TAG.begin(), [](unsigned char c){ return std::toupper(c); });
 
      if(TAG=="FILE" || TAG=="DATAFILE") {
    fileName = attrib.value;
    break;
      }
 
    }
    if(fileName.length()) {
      return static_cast<TFile*>(gROOT->GetListOfFiles()->FindObject(fileName.c_str()));
    }
 
  }
  return 0;
 
}

getProperty()

std::string AthAnalysisHelper::getProperty ( const std::string &  client, const std::string &  property  )

static

Check catalogue for property of specified client returns AAH::UNDEFINED in case of no property value available (i.e.

component will take the default property value) otherwise returns the property value in its string representation

Definition at line 63 of file AthAnalysisHelper.cxx.

                                                                                           {
   ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc","AthAnalysisHelper");
   if(joSvc.retrieve().isFailure()) return UNDEFINED;
   return joSvc->get(client+"."+property, UNDEFINED);
}

initGaudi()

IAppMgrUI * AthAnalysisHelper::initGaudi ( const char *  options = "" )

static

initGaudi method starts the gaudi ApplicationMgr ready for working with all the components

Definition at line 21 of file AthAnalysisHelper.cxx.

                                                           {
    IAppMgrUI* theApp = Gaudi::createApplicationMgr();
    //check if already configured 
    if(theApp->FSMState() != Gaudi::StateMachine::OFFLINE) return theApp;
    //set the joboptions 
    SmartIF<IProperty> propMgr(theApp);
    if(strlen(options)) {
      if (propMgr->setProperty("JobOptionsPath",options).isFailure()) return nullptr;
    } else {
      //no joboptions given
      if (propMgr->setProperty( "JobOptionsType", "NONE" ).isFailure()) return nullptr;
    }
    //using this instead of the default EventLoopMgr means some services (e.g. EventSelector) are not created, which is good! :-)
    if (propMgr->setProperty("EventLoop","MinimalEventLoopMgr").isFailure()) return nullptr;
 
    //configure and return
    if (theApp->configure().isFailure()) return nullptr;
    propMgr->setProperty("OutputLevel","3").ignore(); //INFO
    if (theApp->initialize().isFailure()) return nullptr;
    return theApp;
}

printAuxElement()

void AthAnalysisHelper::printAuxElement ( const SG::AuxElement &  ae )

static

Print the aux variables of an xAOD object (aux element) An alternative to this method is the 'xAOD::dump' method.

Definition at line 69 of file AthAnalysisHelper.cxx.

                                                              {
   const SG::auxid_set_t& auxids = ae.getAuxIDs();
   SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
   for( SG::auxid_t aux : auxids) {
      std::string name = reg.getName( aux );
      std::cout << "    " << name << " = ";
      const std::type_info& typeinfo = *reg.getType(aux);
#define PRINT_AE( TYPE ) \
      if(typeinfo==typeid(TYPE)) {         \
        SG::ConstAccessor<TYPE> acc (aux);                              \
        if (acc.isAvailable(ae)) std::cout << acc(ae) << " (" << #TYPE << ")" << std::endl; \
      }
 
      PRINT_AE( bool )
      else PRINT_AE(uint)
      else PRINT_AE(int)
      else PRINT_AE(float)
      else PRINT_AE(double)
      else PRINT_AE(unsigned char)
      else PRINT_AE(char)
      else PRINT_AE(short)
      else PRINT_AE(unsigned short)
      else PRINT_AE(unsigned long long)
      else std::cout << " (" << System::typeinfoName( typeinfo ) << ")" << std::endl;
      
#undef PRINT_AE
   }
}

retrieveMetadata() [1/6]

static std::string AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, const ServiceHandle< StoreGateSvc > &  inputMetaStore  )

inlinestatic

method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT.POOL.TEvent() ...

ROOT.AAH.retrieveMetadata("/Folder","key",evt.inputMetaStore())

Definition at line 254 of file AthAnalysisHelper.h.

                                                                                                                                      {
    std::string out("");
    StatusCode result = retrieveMetadata(folder,key,out,inputMetaStore);
    if(result.isFailure()) { std::cout << "ERROR: Could not retrieve IOVMetadata with folder " << folder << " and key " << key << std::endl; }
    return out;
  }

retrieveMetadata() [2/6]

static std::string AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, ServiceHandle< StoreGateSvc > &  inputMetaStore  )

inlinestatic

Definition at line 260 of file AthAnalysisHelper.h.

                                                                                                                                {
    std::string out("");
    StatusCode result = retrieveMetadata(folder,key,out,inputMetaStore);
    if(result.isFailure()) { std::cout << "ERROR: Could not retrieve IOVMetadata with folder " << folder << " and key " << key << std::endl; }
    return out;
  }

retrieveMetadata() [3/6]

template<typename T >

static StatusCode AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out  )

inlinestatic

retrieve metadata from the input metadata storegate.

Use 'meta-reader' to see the 'folder' and 'key' values available always takes the first CondAttrListCollection (aka IOV) and the first channel number present in that IOV

Definition at line 270 of file AthAnalysisHelper.h.

                                                                                                                  {
      ServiceHandle<StoreGateSvc> inputMetaStore("StoreGateSvc/InputMetaDataStore", "AthAnalysisHelper");
      if(inputMetaStore.retrieve().isFailure()) return StatusCode::FAILURE; //must remember to release
      StatusCode result = retrieveMetadata(folder,key,out,inputMetaStore);
      if(inputMetaStore.release().isFailure()) return StatusCode::FAILURE;
      return result;
   }

retrieveMetadata() [4/6]

template<typename T >

static StatusCode AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out, const IOVTime &  time, int  channel = -1  )

inlinestatic

Definition at line 350 of file AthAnalysisHelper.h.

                                                                                                                                                      {
      ServiceHandle<StoreGateSvc> inputMetaStore("StoreGateSvc/InputMetaDataStore", "AthAnalysisHelper");
      if(inputMetaStore.retrieve().isFailure()) return StatusCode::FAILURE; //must remember to release
      StatusCode result = retrieveMetadata(folder,key,out,inputMetaStore,time,channel);
      if(inputMetaStore.release().isFailure()) return StatusCode::FAILURE;
      return result;
   }

retrieveMetadata() [5/6]

template<typename T >

static StatusCode AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out, const ServiceHandle< StoreGateSvc > &  inputMetaStore  )

inlinestatic

implemenation where you pass it a particular store instead

Definition at line 281 of file AthAnalysisHelper.h.

                                                                                                                                                                    {
      const IOVMetaDataContainer* cont = 0;
      if( inputMetaStore->retrieve(cont,folder).isFailure()) return StatusCode::FAILURE;
   
      //payload is a collection of condattrlistcollections
      //only look a the first one, assuming it exists, and within that only look at the first channel;
      if(cont->payloadContainer()->size()>0 && cont->payloadContainer()->at(0)->size()>0) {
         //just try to retrieve the requested key from the attributelist - we will let it throw the coral::AttributeListException (inherits from std::exception) if it fails
         //if the typeName is std::string, we will try to use the gaudi parsers to parse it
         //otherwise we try to do a straight assignment 
     try {
       const coral::Attribute& attr = cont->payloadContainer()->at(0)->attributeList(cont->payloadContainer()->at(0)->chanNum(0))[key];
     
       if(attr.specification().typeName()=="string") {
         if(Gaudi::Parsers::parse(out,attr.data<std::string>()).isFailure()) return StatusCode::FAILURE;
       } else { //do a straight conversion, and just hope its ok (FIXME: should probably do a check of typeid(T) vs typeName)
         out = attr.data<T>();
       }
     } catch(...) {
       //anything that goes wrong is taken to be a failure
       return StatusCode::FAILURE;
     }
   
         return StatusCode::SUCCESS;
      }
      return StatusCode::FAILURE;
   }

retrieveMetadata() [6/6]

template<typename T >

static StatusCode AthAnalysisHelper::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out, const ServiceHandle< StoreGateSvc > &  inputMetaStore, const IOVTime &  time, int  channel = -1  )

inlinestatic

retrieve metadata, for a specified IOVTime and a specific channel, unless the channel is -1, in which case we take the first available channel channels have to be unsigned int, so can use -1 to signal 'take whatever first channel is (it isn't always 0)'

Definition at line 311 of file AthAnalysisHelper.h.

                                                                                                                                                                                                         {
      const IOVMetaDataContainer* cont = 0;
      if( inputMetaStore->retrieve(cont,folder).isFailure()) return StatusCode::FAILURE;
   
      //payload is a collection of condattrlistcollections
      //have to find first one that the time lies in
      auto cond = cont->payloadContainer()->find(time);
      if(cond == cont->payloadContainer()->end()) { return StatusCode::FAILURE; }
 
      //get the first channel number, if required 
      if(channel<0) channel = (*cond)->chanNum(0);
 
      //get the channel pair.. checks if it exists...
      auto attrlist = (*cond)->chanAttrListPair(channel);
      if(attrlist == (*cond)->end()) { return StatusCode::FAILURE; }
      
      
      //just try to retrieve the requested key from the attributelist - we will let it throw the coral::AttributeListException (inherits from std::exception) if it fails
      //if the typeName is std::string, we will try to use the gaudi parsers to parse it
      //otherwise we try to do a straight assignment 
      try {
        // cppcheck-suppress danglingTempReference; false positive
    const coral::Attribute& attr = attrlist->second[key];
        // cppcheck-suppress danglingTempReference; false positive
    if(attr.specification().typeName()=="string") {
          // cppcheck-suppress danglingTempReference; false positive
      if(Gaudi::Parsers::parse(out,attr.data<std::string>()).isFailure()) return StatusCode::FAILURE;
    } else { //do a straight conversion, and just hope its ok (FIXME: should probably do a check of typeid(T) vs typeName)
          // cppcheck-suppress danglingTempReference; false positive
      out = attr.data<T>();
    }
      }
      catch(...) {
    return StatusCode::FAILURE;
      }
   
      return StatusCode::SUCCESS;
   }

setProperty() [1/8]

static StatusCode AthAnalysisHelper::setProperty ( const GaudiHandleBase &  toolHandle, const std::string &  property, const GaudiHandleArrayBase &  value, bool  override = true  )

inlinestatic

Definition at line 138 of file AthAnalysisHelper.h.

                                                                                                                                                      {
      return setProperty( toolHandle, property, value.typesAndNames(), override );
   }

setProperty() [2/8]

static StatusCode AthAnalysisHelper::setProperty ( const GaudiHandleBase &  toolHandle, const std::string &  property, const GaudiHandleBase &  value, bool  override = true  )

inlinestatic

Partial template specialization for ToolHandles and ToolHandleArrays ... strips parent name from tool name, for setting private handles on.

Definition at line 131 of file AthAnalysisHelper.h.

                                                                                                                                                 {
      std::string subToolName(value.name());
      size_t start_pos = subToolName.find(toolHandle.name()+".");
      if(start_pos!=std::string::npos) { subToolName.replace( start_pos, toolHandle.name().length()+1, "" ); }
      std::string typeAndName = value.type(); if(!subToolName.empty()) typeAndName += "/"+subToolName;
      return setProperty( toolHandle, property, typeAndName, override );
   }

setProperty() [3/8]

template<class W , typename = typename std::enable_if<!std::is_base_of<GaudiHandleBase,W>::value && !std::is_base_of<GaudiHandleArrayBase,W>::value>::type>

static StatusCode AthAnalysisHelper::setProperty ( const GaudiHandleBase &  toolHandle, const std::string &  property, const W &  value, bool  override = true  )

inlinestatic

helper method for setting a property on a tool before retrieving it uses the toolhandle to work out what to register the joboptionsvc Usage examples: ToolHandle<IMyTool> tool("MyTool/toolName"); CHECK( AthAnalysisHelper::setProperty( tool, "IntegerProperty", 5) ); CHECK( AthAnalysisHelper::setProperty( tool, "StringProperty", "hello") ); CHECK( AthAnalysisHelper::setProperty( tool, "StringArrayProperty", std::vector<std::string>({"a","b","c"}) ) ); CHECK( AthAnalysisHelper::setProperty( tool, "PublicToolHandleProperty", anotherToolHandle) ); CHECK( AthAnalysisHelper::setProperty( tool, "PrivateToolHandleName.SubToolIntegerProperty", 4) ); The last example assumes the 'MyTool' class has declared a ToolHandle("SubTool/PrivateToolHandleName",this) and 'SubTool' class has an integer property called 'SubToolIntegerProperty' declared

Definition at line 108 of file AthAnalysisHelper.h.

                                                                                                                                   {
      if(toolHandle.empty()) {
          std::cout << "ERROR: Empty toolHandle passed to AthAnalysisHelper::setProperty" << std::endl;
          return StatusCode::FAILURE;
      }
      std::string fullName = toolHandle.parentName() + "." + toolHandle.name();
      std::string thePropertyName(property);
      //if the property contains any "." then strip the last bit as the property name
      std::string::size_type dotLocation = thePropertyName.find_last_of('.');
      if(dotLocation != std::string::npos) {
         fullName += "." + thePropertyName.substr(0,dotLocation);
         thePropertyName = thePropertyName.substr(dotLocation+1,thePropertyName.length()-dotLocation);
      }
      //check if the tool already exists, if so then we are too late!!
      if( toolExists( fullName ) ) {
        std::cout << "ERROR: Cannot setProperty on a tool that is already initialized" << std::endl;
        return StatusCode::FAILURE;
      }
      //tool not existing, ok so add property to catalogue
      return addPropertyToCatalogue(fullName, thePropertyName, value, override);
   }

setProperty() [4/8]

template<typename T , typename W >

static StatusCode AthAnalysisHelper::setProperty ( const ServiceHandle< T > &  serviceHandle, const std::string &  property, const W &  value  )

inlinestatic

setProperty for services ... will allow setProperty on already-existing services

Definition at line 168 of file AthAnalysisHelper.h.

                                                                                                                                                    {
      if(serviceHandle.isSet()) {
         return dynamic_cast<Service&>(*serviceHandle).setProperty(property,toString ( value ));
      }
      std::string fullName = serviceHandle.name();
      std::string thePropertyName(property);
      //if the property contains any "." then strip the last bit as the property name
      std::string::size_type dotLocation = thePropertyName.find_last_of('.');
      if(dotLocation != std::string::npos) {
         fullName += "." + thePropertyName.substr(0,dotLocation);
         thePropertyName = thePropertyName.substr(dotLocation+1,thePropertyName.length()-dotLocation);
      }
 
      //check if the service already exists
      if(Gaudi::svcLocator()->existsService(serviceHandle.name())) {
         //set property on the service directly
         return dynamic_cast<Service&>(*serviceHandle).setProperty(property,toString ( value ));
      } 
 
      //service not existing, ok so add property to catalogue
      return addPropertyToCatalogue(fullName, thePropertyName, value);
   }

setProperty() [5/8]

static StatusCode AthAnalysisHelper::setProperty ( const std::string &  name, const std::string &  property, const std::string &  value, bool  override = true  )

inlinestatic

non-template method, for use in joboptions current usage would be: ...

usual joboptions ... theApp.setup() #triggers population of property catalogue import ROOT ROOT.AAH.setProperty( "ToolSvc.MyTool" , "Property" , str(value) )

Definition at line 89 of file AthAnalysisHelper.h.

                                                                                                                                 { 
    return addPropertyToCatalogue( name, property, value, override );
   } //set a property for a client in the catalogue

setProperty() [6/8]

template<typename W >

static StatusCode AthAnalysisHelper::setProperty ( const std::string &  name, const std::string &  property, const W &  value, bool  override = true  )

inlinestatic

Definition at line 79 of file AthAnalysisHelper.h.

                                                                                                                                              {
    return addPropertyToCatalogue(name,property,value,override);
   }

setProperty() [7/8]

template<typename W >

static StatusCode AthAnalysisHelper::setProperty ( IAlgorithm *  alg, const std::string &  property, const W &  value  )

inlinestatic

setProperty on an alg, even when initialized

Definition at line 153 of file AthAnalysisHelper.h.

                                                                                                                  {
     Gaudi::Algorithm* theAlg = dynamic_cast<Gaudi::Algorithm*>(alg);
      if(!theAlg) {
         std::cout << "ERROR: alg is not an Algorithm. Cannot AthAnalysisHelper::setProperty on it" << std::endl;
         return StatusCode::FAILURE;
      }
      return theAlg->setProperty(property, value);
   }

setProperty() [8/8]

template<typename W >

static StatusCode AthAnalysisHelper::setProperty ( IAlgTool *  tool, const std::string &  property, const W &  value  )

inlinestatic

setProperty on any tool, even when initialized

Definition at line 143 of file AthAnalysisHelper.h.

                                                                                                                 {
      AlgTool* algtool = dynamic_cast<AlgTool*>(tool);
      if(!algtool) {
         std::cout << "ERROR: Tool is not an algtool. Cannot AthAnalysisHelper::setProperty on it" << std::endl;
         return StatusCode::FAILURE;
      }
      return algtool->setProperty(property, value);
   }

toolExists() [1/2]

static bool AthAnalysisHelper::toolExists ( const GaudiHandleBase &  toolHandle )

inlinestatic

Definition at line 246 of file AthAnalysisHelper.h.

{ return toolExists( toolHandle.parentName() + "." + toolHandle.name() ); }

toolExists() [2/2]

bool AthAnalysisHelper::toolExists ( const std::string &  fullName )

static

check if tool already exists. FullName = Parent.Name

Definition at line 43 of file AthAnalysisHelper.cxx.

                                                              {
  ServiceHandle<IToolSvc> toolSvc("ToolSvc","AthAnalysisHelper");
  if(toolSvc.retrieve().isFailure()) return false;
  auto existingTools = toolSvc->getInstances();
  for(auto& toolName : existingTools) {
    if(fullName==toolName) { toolSvc.release().ignore(); return true; }
  }
  toolSvc.release().ignore();
  return false;
}

toString() [1/3]

static std::string AthAnalysisHelper::toString ( const char *  value )

inlinestatic

Definition at line 164 of file AthAnalysisHelper.h.

{ return value; } //gaudi's toString puts extra quote marks around things like "['b']" .. should probably stop that..

toString() [2/3]

static std::string AthAnalysisHelper::toString ( const std::string &  value )

inlinestatic

Definition at line 163 of file AthAnalysisHelper.h.

{ return value; } //gaudi's toString puts extra quote marks around things like "['b']" .. should probably stop that..

toString() [3/3]

template<typename T >

static std::string AthAnalysisHelper::toString ( const T &  value )

inlinestatic

Definition at line 162 of file AthAnalysisHelper.h.

{ return Gaudi::Utils::toString( value ); }

Member Data Documentation

UNDEFINED

const std::string AthAnalysisHelper::UNDEFINED = "__UNDEFINED__"

static

Definition at line 42 of file AthAnalysisHelper.h.

---

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

• AthAnalysisHelper.h
• AthAnalysisHelper.cxx