AAH Class Reference

#include <AthAnalysisHelper.h>

Inheritance diagram for AAH:

Collaboration diagram for AAH:

Static Public Member Functions
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const int &value, bool override=true)
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const double &value, bool override=true)
static StatusCode	setProperty (const GaudiHandleBase &toolHandle, const std::string &property, const std::string &value, bool override=true)
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: ... usual joboptions ... theApp.setup() #triggers population of property catalogue import ROOT ROOT.AAH.setProperty( "ToolSvc.MyTool" , "Property" , str(value) )
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
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.
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
template<typename W>
static StatusCode	setProperty (IAlgorithm *alg, const std::string &property, const W &value)
	setProperty on an alg, even when initialized
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
static IAppMgrUI *	initGaudi (const char *options="")
	initGaudi method starts the gaudi ApplicationMgr ready for working with all the components
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()
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 W>
static W *	createTool (const std::string &typeAndName, INamedInterface *parent=0)
	Create a tool using the gaudi factory methods.
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
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() ... ROOT.AAH.retrieveMetadata("/Folder","key",evt.inputMetaStore())
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.
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
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)'
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.
static void	dumpProperties (const std::string &client="")
static void	dumpProperties (const SG::AuxElement &ae)
static void	dumpProperties (const IProperty &component)
	Dump the properties of an IProperty.
template<typename T>
static void	dumpProperties (const GaudiHandle< T > &handle)
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.
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.
static TFile *	getOutputFile (const std::string &streamName)

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

Detailed Description

Definition at line 396 of file AthAnalysisHelper.h.

Member Function Documentation

addPropertyToCatalogue()

template<typename W>

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

inlinestaticinherited

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

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

inlinestaticinherited

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>

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

inlinestaticinherited

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]

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

inlinestaticinherited

Definition at line 225 of file AthAnalysisHelper.h.

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

dumpJobOptionProperties()

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

staticinherited

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>

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

inlinestaticinherited

Definition at line 382 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 )

staticinherited

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]

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

inlinestaticinherited

Definition at line 374 of file AthAnalysisHelper.h.

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

dumpProperties() [4/4]

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

inlinestaticinherited

Definition at line 363 of file AthAnalysisHelper.h.

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

getOutputFile()

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

staticinherited

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(const auto& attrib : Gaudi::Utils::AttribStringParser(output.substr(output.find(' ')+1))) {
      std::string 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 )

staticinherited

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 = "" )

staticinherited

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 )

staticinherited

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]

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

inlinestaticinherited

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]

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

inlinestaticinherited

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>

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

inlinestaticinherited

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>

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

inlinestaticinherited

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

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

inlinestaticinherited

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>

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

inlinestaticinherited

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 {
    const coral::Attribute& attr = attrlist->second[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(...) {
    return StatusCode::FAILURE;
      }
   
      return StatusCode::SUCCESS;
   }

setProperty() [1/11]

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

inlinestatic

Definition at line 403 of file AthAnalysisHelper.h.

  { return AthAnalysisHelper::setProperty (toolHandle, property, value, override); }

setProperty() [2/11]

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() [3/11]

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() [4/11]

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

inlinestatic

Definition at line 401 of file AthAnalysisHelper.h.

  { return AthAnalysisHelper::setProperty (toolHandle, property, value, override); }

setProperty() [5/11]

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

inlinestatic

Definition at line 405 of file AthAnalysisHelper.h.

  { return AthAnalysisHelper::setProperty (toolHandle, property, value, override); }

setProperty() [6/11]

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

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() [7/11]

template<typename T, typename W>

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() [8/11]

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() [9/11]

template<typename W>

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() [10/11]

template<typename W>

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() [11/11]

template<typename W>

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]

bool AthAnalysisHelper::toolExists ( const GaudiHandleBase & toolHandle )

inlinestaticinherited

Definition at line 246 of file AthAnalysisHelper.h.

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

toolExists() [2/2]

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

staticinherited

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]

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

inlinestaticinherited

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]

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

inlinestaticinherited

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>

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

inlinestaticinherited

Definition at line 162 of file AthAnalysisHelper.h.

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

Member Data Documentation

UNDEFINED

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

staticinherited

Definition at line 42 of file AthAnalysisHelper.h.

---

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

• AthAnalysisHelper.h