AthAnalysisHelper.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// AthAnalysisHelper.h 
// Header file for class AthAnalysisHelper
// Methods that are useful for athena-based analysis will go here
// Author: W.Buttinger<will@cern.ch>
 
#ifndef ATHANALYSISBASECOMPS_ATHANALYSISHELPER_H
#define ATHANALYSISBASECOMPS_ATHANALYSISHELPER_H 1
 
#include "StoreGate/StoreGateSvc.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "Gaudi/Interfaces/IOptionsSvc.h"
#include "GaudiKernel/IToolSvc.h"
 
#include "IOVDbDataModel/IOVMetaDataContainer.h"
 
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/Algorithm.h"
 
#include "AthContainers/AuxElement.h"
 
#include "GaudiKernel/IAppMgrUI.h"
 
 
#include "GaudiKernel/ToolHandle.h"
 
#include <type_traits>
#include "TFile.h"
 
class AthAnalysisHelper { //thought about being a namespace but went for static methods instead, in case I want private data members in future
 
public:
    AthAnalysisHelper(); //need a constructor to link the dictionary library with the implementation library
 
   static const std::string UNDEFINED;  //used in getProperty
   
   static IAppMgrUI* initGaudi(const char* options = "");
 
   
   template<typename W> static StatusCode addPropertyToCatalogue( const std::string& name , const std::string& property, const W& value, bool override=true) {
     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;
   }
   
 
   //alias for above
   template<typename W> static StatusCode setProperty( const std::string& name , const std::string& property, const W& value, bool override=true) {
    return addPropertyToCatalogue(name,property,value,override);
   }
   
   static StatusCode setProperty( const std::string& name , const std::string& property, const std::string& value, bool override=true) { 
    return addPropertyToCatalogue( name, property, value, override );
   } //set a property for a client in the catalogue
 
 
 
  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) {
      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);
   }
   
   static StatusCode setProperty(const GaudiHandleBase& toolHandle, const std::string& property, const GaudiHandleBase& value, bool override=true) {
      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 );
   }
   static StatusCode setProperty(const GaudiHandleBase& toolHandle, const std::string& property, const GaudiHandleArrayBase& value, bool override=true) {
      return setProperty( toolHandle, property, value.typesAndNames(), override );
   }
 
   template<typename W> static StatusCode setProperty(IAlgTool* tool, const std::string& property, const W& value) {
      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);
   }
 
   template<typename W> static StatusCode setProperty(IAlgorithm* alg, const std::string& property, const W& value) {
     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);
   }
 
  template<typename T> static std::string toString(const T& value) { return Gaudi::Utils::toString( value ); }
  static std::string toString(const std::string& value) { return value; } //gaudi's toString puts extra quote marks around things like "['b']" .. should probably stop that..
  static std::string toString(const char* value) { return value; } //gaudi's toString puts extra quote marks around things like "['b']" .. should probably stop that..
 
 
   template<typename T, typename W> static StatusCode setProperty(const ServiceHandle<T>& serviceHandle, const std::string& property, const W& value) {
      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);
   }
 
   template<typename W> static W* createTool(const std::string& typeAndName, INamedInterface* parent = 0) {
      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;
   }
   static IAlgTool* createTool(const std::string& typeAndName, INamedInterface* parent = 0) {
     return createTool<IAlgTool>(typeAndName,parent);
   }
 
 
   //equivalent method for creating an algorithm ... always returns an IAlgorithm though, so not templated
   static IAlgorithm* createAlgorithm(const std::string& typeAndName) {
      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;
   }
   
   
   static bool toolExists( const std::string& fullName );
   static bool toolExists(const GaudiHandleBase& toolHandle) { return toolExists( toolHandle.parentName() + "." + toolHandle.name() ); }
 
  
  static std::string retrieveMetadata(const std::string& folder, const std::string& key, const ServiceHandle<StoreGateSvc>& inputMetaStore) {
    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;
  }
  static std::string retrieveMetadata(const std::string& folder, const std::string& key, ServiceHandle<StoreGateSvc>& inputMetaStore) {
    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;
  }
 
 
   template<typename T> static StatusCode retrieveMetadata(const std::string& folder, const std::string& key, T& out) {
      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;
   }
   
   
   
  template<typename T> static StatusCode retrieveMetadata(const std::string& folder, const std::string& key, T& out, const ServiceHandle<StoreGateSvc>& inputMetaStore) {
      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;
   }
 
  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) {
      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;
   }
 
  template<typename T> static StatusCode retrieveMetadata(const std::string& folder, const std::string& key, T& out, const IOVTime& time, int channel=-1) {
      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;
   }
 
 
   static void dumpJobOptionProperties(const std::string& client="");
   inline static void dumpProperties(const std::string& client="") { dumpJobOptionProperties(client); } //list properties of client present in catalogue
 
   static std::string getProperty(const std::string& client, const std::string& property); //get property of client present in catalogue, or return AAH::UNDEFINED
 
 
   static void printAuxElement(const SG::AuxElement& ae);
   static void dumpProperties(const SG::AuxElement& ae) { printAuxElement(ae); } //list properties of an xAOD object
 
 
   //these aren't necessarily the same as what is in the JobOptionsSvc
  static void dumpProperties(const IProperty& component); //list properties of an existing component (may not match what is in the catalogue)
    
 
   template<typename T> static void dumpProperties(const GaudiHandle<T>& handle) {
    if(!handle.isSet()) {std::cout << "Please retrieve handle before dumping properties" << std::endl; return;}
    return dumpProperties(dynamic_cast<const IProperty&>(*handle));
  }
 
 
 
  //Obtain TFile pointer to THistSvc's output file with the given streamName
  static TFile* getOutputFile(const std::string& streamName);
 
 
}; //AthAnalysisHelper class
 
 
class AAH : public AthAnalysisHelper {
  
};
 
 
 
#endif