cmake_newanalysisalg.py

Go to the documentation of this file.

# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
# @file PyUtils.scripts.cmt_newanalysisalg
# @purpose streamline and ease the creation of new athena algs
# @author Will Buttinger
# @date February 2017
 
#Note - this code could use a serious rewrite, I just hacked it together to get something working
 
from __future__ import with_statement
 
__version__ = "$Revision: 795362 $"
__author__ = "Will Buttinger"
__doc__ = "streamline and ease the creation of new AthAnalysisAlgorithm"
 
 
import os
import textwrap
import subprocess
import PyUtils.acmdlib as acmdlib
 
class Templates:
    jobo_template = """\
#Skeleton joboption for a simple analysis job
 
#---- Minimal job options -----
 
jps.AthenaCommonFlags.AccessMode = "ClassAccess"              #Choose from TreeAccess,BranchAccess,ClassAccess,AthenaAccess,POOLAccess
#jps.AthenaCommonFlags.TreeName = "MyTree"                    #when using TreeAccess, must specify the input tree name
 
jps.AthenaCommonFlags.HistOutputs = ["MYSTREAM:myfile.root"]  #register output files like this. MYSTREAM is used in the code
 
athAlgSeq += CfgMgr.%(klass)s()                               #adds an instance of your alg to the main alg sequence
 
 
#---- Options you could specify on command line -----
#jps.AthenaCommonFlags.EvtMax=-1                          #set on command-line with: --evtMax=-1
#jps.AthenaCommonFlags.SkipEvents=0                       #set on command-line with: --skipEvents=0
#jps.AthenaCommonFlags.FilesInput = ["%(inFile)s"]        #set on command-line with: --filesInput=...
 
 
include("AthAnalysisBaseComps/SuppressLogging.py")              #Optional include to suppress as much athena output as possible. Keep at bottom of joboptions so that it doesn't suppress the logging of the things you have configured above
 
"""
 
    script_template = """\
#!/usr/bin/env python
 
# Run this application/script like this:
# run%(klass)s.py --filesInput file.root --evtMax 100
# See --help for more arguments and flag options
 
from AthenaConfiguration.AllConfigFlags import initConfigFlags
flags = initConfigFlags()
flags._parser = flags.getArgumentParser(description=\"\"\"My Demo Application\"\"\") # an argparse.ArgumentParser
flags.parser().add_argument('--accessMode',default="POOLAccess",               # can add arguments to the parser as usual
                            choices={"POOLAccess","ClassAccess"},help="Input file reading mode (ClassAccess can be faster but is less supported)")
# changes to default flag values (done before fillFromArgs so appears in the --help flag system
flags.Exec.PrintAlgsSequence = True # displays algsequence at start of job
 
 
args = flags.fillFromArgs() # parse command line arguments
flags.lock() # lock the flags
 
 
# configure main services and input file reading
from AthenaConfiguration.MainServicesConfig import MainServicesCfg
from AthenaConfiguration.Enums import Format
cfg = MainServicesCfg(flags)
if flags.Input.Format is Format.BS:
    # read RAW (bytestream)
    from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
    cfg.merge(ByteStreamReadCfg(flags))
else:
    # reading POOL, use argument to decide which read mode
    if flags.args().accessMode == "POOLAccess":
        from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
        cfg.merge(PoolReadCfg(flags))
    else:
        from AthenaRootComps.xAODEventSelectorConfig import xAODReadCfg,xAODAccessMode
        cfg.merge(xAODReadCfg(flags, AccessMode = xAODAccessMode.CLASS_ACCESS))
 
# configure output ROOT files from Output.HISTOutputs flag (should be of form: "STREAMNAME:file.root")
from AthenaConfiguration.ComponentFactory import CompFactory
if flags.Output.HISTFileName != "":
    outputs = []
    for file in (flags.Output.HISTFileName if type(flags.Output.HISTFileName)==list else flags.Output.HISTFileName.split(",")):
        streamName = file.split(":")[0] if ":" in file else "ANALYSIS"
        fileName = file.split(":")[1] if ":" in file else file
        outputs += ["{} DATAFILE='{}' OPT='RECREATE'".format(streamName,fileName)]
    cfg.addService(CompFactory.THistSvc(Output = outputs))
 
# add our algorithm
cfg.addEventAlgo(CompFactory.%(klass)s(),sequenceName="AthAlgSeq")
 
 
# final cfg tweaks before launching:
cfg.getService("AthenaEventLoopMgr").IntervalInSeconds = 5 # enable processing rate reporting every 5s
# suppress logging from some core services that we usually don't care about hearing from
cfg.getService("MessageSvc").setWarning += ["ClassIDSvc","PoolSvc","AthDictLoaderSvc","AthenaPoolAddressProviderSvc",
                                            "ProxyProviderSvc","DBReplicaSvc","MetaDataSvc","MetaDataStore","AthenaPoolCnvSvc",
                                            "TagMetaDataStore","EventSelector","CoreDumpSvc","AthMasterSeq","EventPersistencySvc",
                                            "ActiveStoreSvc","AthOutSeq","AthRegSeq","FPEAuditor"]
 
# run the job
if cfg.run().isFailure():
    import sys
    sys.exit(1)
"""
 
    alg_hdr_template = """\
#ifndef %(guard)s
#define %(guard)s 1
 
#include "AthAnalysisBaseComps/AthAnalysisAlgorithm.h"
 
//Example ROOT Includes
//#include "TTree.h"
//#include "TH1D.h"
 
%(namespace_begin)s
 
class %(klass)s: public ::AthAnalysisAlgorithm { 
 public: 
  %(klass)s( const std::string& name, ISvcLocator* pSvcLocator );
  virtual ~%(klass)s(); 
 
  ///uncomment and implement methods as required
 
                                        //IS EXECUTED:
  virtual StatusCode  initialize();     //once, before any input is loaded
  virtual StatusCode  beginInputFile(); //start of each input file, only metadata loaded
  //virtual StatusCode  firstExecute();   //once, after first eventdata is loaded (not per file)
  virtual StatusCode  execute();        //per event
  //virtual StatusCode  endInputFile();   //end of each input file
  //virtual StatusCode  metaDataStop();   //when outputMetaStore is populated by MetaDataTools
  virtual StatusCode  finalize();       //once, after all events processed
  
 
  ///Other useful methods provided by base class are:
  ///evtStore()        : ServiceHandle to main event data storegate
  ///inputMetaStore()  : ServiceHandle to input metadata storegate
  ///outputMetaStore() : ServiceHandle to output metadata storegate
  ///histSvc()         : ServiceHandle to output ROOT service (writing TObjects)
  ///currentFile()     : TFile* to the currently open input file
  ///retrieveMetadata(...): See twiki.cern.ch/twiki/bin/view/AtlasProtected/AthAnalysisBase#ReadingMetaDataInCpp
 
 
 private: 
 
   //Example algorithm property, see constructor for declaration:
   //int m_nProperty = 0;
 
   //Example histogram, see initialize method for registration to output histSvc
   //TH1D* m_myHist = 0;
   //TTree* m_myTree = 0;
 
}; 
%(namespace_end)s
#endif //> !%(guard)s
"""
 
    alg_cxx_template = """\
// %(pkg)s includes
#include "%(namespace_klass)s.h"
 
//#include "xAODEventInfo/EventInfo.h"
 
 
%(namespace_begin)s
 
%(klass)s::%(klass)s( const std::string& name, ISvcLocator* pSvcLocator ) : AthAnalysisAlgorithm( name, pSvcLocator ){
 
  //declareProperty( "Property", m_nProperty = 0, "My Example Integer Property" ); //example property declaration
 
}
 
 
%(klass)s::~%(klass)s() {}
 
 
StatusCode %(klass)s::initialize() {
  ATH_MSG_INFO ("Initializing " << name() << "...");
  //
  //This is called once, before the start of the event loop
  //Retrieves of tools you have configured in the joboptions go here
  //
 
  //HERE IS AN EXAMPLE
  //We will create a histogram and a ttree and register them to the histsvc
  //Remember to configure the histsvc stream in the joboptions
  //
  //m_myHist = new TH1D("myHist","myHist",100,0,100);
  //CHECK( histSvc()->regHist("/MYSTREAM/myHist", m_myHist) ); //registers histogram to output stream
  //m_myTree = new TTree("myTree","myTree");
  //CHECK( histSvc()->regTree("/MYSTREAM/SubDirectory/myTree", m_myTree) ); //registers tree to output stream inside a sub-directory
 
 
  return StatusCode::SUCCESS;
}
 
StatusCode %(klass)s::finalize() {
  ATH_MSG_INFO ("Finalizing " << name() << "...");
  //
  //Things that happen once at the end of the event loop go here
  //
 
 
  return StatusCode::SUCCESS;
}
 
StatusCode %(klass)s::execute() {  
  ATH_MSG_DEBUG ("Executing " << name() << "...");
  setFilterPassed(false); //optional: start with algorithm not passed
 
 
 
  //
  //Your main analysis code goes here
  //If you will use this algorithm to perform event skimming, you
  //should ensure the setFilterPassed method is called
  //If never called, the algorithm is assumed to have 'passed' by default
  //
 
 
  //HERE IS AN EXAMPLE
  //const xAOD::EventInfo* ei = 0;
  //CHECK( evtStore()->retrieve( ei , "EventInfo" ) );
  //ATH_MSG_INFO("eventNumber=" << ei->eventNumber() );
  //m_myHist->Fill( ei->averageInteractionsPerCrossing() ); //fill mu into histogram
 
 
  setFilterPassed(true); //if got here, assume that means algorithm passed
  return StatusCode::SUCCESS;
}
 
StatusCode %(klass)s::beginInputFile() { 
  //
  //This method is called at the start of each input file, even if
  //the input file contains no events. Accumulate metadata information here
  //
 
  //example of retrieval of CutBookkeepers: (remember you will need to include the necessary header files and use statements in requirements file)
  // const xAOD::CutBookkeeperContainer* bks = 0;
  // CHECK( inputMetaStore()->retrieve(bks, "CutBookkeepers") );
 
  //example of IOVMetaData retrieval (see https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/AthAnalysisBase#How_to_access_file_metadata_in_C)
  //float beamEnergy(0); CHECK( retrieveMetadata("/TagInfo","beam_energy",beamEnergy) );
  //std::vector<float> bunchPattern; CHECK( retrieveMetadata("/Digitiation/Parameters","BeamIntensityPattern",bunchPattern) );
 
 
 
  return StatusCode::SUCCESS;
}
 
%(namespace_end)s
"""
    testxml_template = """\
   <TEST name="%(namespace_klass)s" type="athena" suite="ASGTests">
      <options_atn>%(pkg)s/%(namespace_klass)sJobOptions.py</options_atn>
      <timelimit>5</timelimit>
      <author> PLEASE ENTER A NAME </author>
      <mailto> PLEASEENTER@cern.ch </mailto>
      <expectations>
         <errorMessage> Athena exited abnormally </errorMessage>
         <errorMessage>FAILURE (ERROR)</errorMessage>
         <returnValue>0</returnValue>
      </expectations>
   </TEST>
"""
 
 
 
@acmdlib.command(
    name='cmake.new-analysisalg'
    )
@acmdlib.argument(
    'algname',
    help="name of the new alg"
    )
@acmdlib.argument(
    '--newJobo',
    action='store_true',
    default=False,
    help='Create a skeleton joboption for execution of the new algorithm'
    )
 
def main(args):
    """create a new AthAnalysisAlgorithm inside the current package. Call from within the package directory
 
    ex:
     $ acmd cmake new-analysisalg MyAlg
    """
    sc = 0
    
    full_alg_name = args.algname
 
    #determine the package from the cwd 
    cwd = os.getcwd()
    #check that src dir exists and CMakeLists.txt exists (i.e. this is a package)
    if not os.path.isdir(cwd+"/src") or not os.path.isfile(cwd+"/CMakeLists.txt"):
        print("ERROR you must call new-analysisalg from within the package you want to add the algorithm to")
        return -1
   
   
    full_pkg_name = os.path.basename(cwd)
    print(textwrap.dedent("""\
    ::: create alg [%(full_alg_name)s] in pkg [%(full_pkg_name)s]""" %locals()))
 
    
    #first we must check that CMakeLists.txt file has the AthAnalysisBaseComps dependency in it
    foundBaseComps=False
    hasxAODEventInfo=False
    hasAtlasROOT=False
    hasAsgTools=False
    lastUse=0 
    lineCount=0
    hasLibraryLine=False
    hasComponentLine=False
    for line in open('CMakeLists.txt'):
        lineCount +=1 
        if "atlas_add_library" in line: hasLibraryLine=True
        if "atlas_add_component" in line: hasComponentLine=True
 
#GOT THIS FAR WITH EDITING
 
        
        
 
    
    #following code borrowed from gen_klass
    hdr = Templates.alg_hdr_template
    cxx = Templates.alg_cxx_template
    
    namespace_klass = full_alg_name.replace('::','__')
    namespace_begin,namespace_end = "",""
    namespace = ""
    if full_alg_name.count("::")>0:
        namespace    = full_alg_name.split("::")[0]
        full_alg_name = full_alg_name.split("::")[1]
        namespace_begin = "namespace %s {" % namespace
        namespace_end   = "} //> end namespace %s" % namespace
        pass
 
    guard = "%s_%s_H" % (full_pkg_name.upper(), namespace_klass.upper())
 
    d = dict( pkg=full_pkg_name,
              klass=full_alg_name,
              guard=guard,
              namespace_begin=namespace_begin,
              namespace_end=namespace_end,namespace_klass=namespace_klass,namespace=namespace
              )
    fname = os.path.splitext("src/%s"%namespace_klass)[0]
    #first check doesn't exist 
    if os.path.isfile(fname+'.h'):
       print(":::  ERROR %s.h already exists" % fname)
       return -1
    print(":::  INFO Creating %s.h" % fname)
    o_hdr = open(fname+'.h', 'w')
    o_hdr.writelines(hdr%d)
    o_hdr.flush()
    o_hdr.close()
 
    if os.path.isfile(fname+'.cxx'):
       print(":::  ERROR %s.cxx already exists" % fname)
       return -1
    print(":::  INFO Creating %s.cxx" % fname)
    o_cxx = open(fname+'.cxx', 'w')
    o_cxx.writelines(cxx%d)
    o_cxx.flush()
    o_cxx.close()
 
 
    #now add the algorithm to the _entries.cxx file in the components folder 
    #first check they exist
    if not os.path.exists("src/components"): os.mkdir("src/components") 
    if not os.path.isfile("src/components/%s_entries.cxx"%full_pkg_name):
       print(":::  INFO Creating src/components/%s_entries.cxx"%full_pkg_name)
       loadFile = open("src/components/%s_entries.cxx"%full_pkg_name,'w')
       if len(namespace_begin)>0:
          d["namespace"] = args.algname.split("::")[0]
          loadFile.writelines("""
#include "../%(namespace_klass)s.h"
DECLARE_COMPONENT(%(namespace)s::%(klass)s )
"""%d)
       else:
          loadFile.writelines("""
#include "../%(namespace_klass)s.h"
DECLARE_COMPONENT( %(klass)s )
"""%d)
       loadFile.flush()
       loadFile.close()
    else:
       #first check algorithm not already in _entries file 
       inFile=False
       for line in open("src/components/%s_entries.cxx"%full_pkg_name):
          if len(namespace_begin)==0 and "DECLARE_COMPONENT" in line and  d["klass"] in line: inFile=True
          if len(namespace_begin)>0 and "DECLARE_COMPONENT" in line and d["klass"] in line and d["namespace"]: inFile=True
          
       if not inFile:
         print(":::  INFO Adding %s to src/components/%s_entries.cxx"% (args.algname,full_pkg_name))
         nextAdd=True
         with open("src/components/%s_entries.cxx"%full_pkg_name, "a") as f:
              if len(namespace_begin)>0:
                  f.write("""  DECLARE_COMPONENT(%(namespace)s::%(klass)s );"""%d)
              else:
                  f.write("""  DECLARE_COMPONENT( %(klass)s );"""%d)
   
   
    if args.newJobo:
      #make the joboptions file too
      full_jobo_name = namespace_klass + "JobOptions"
      full_script_name = "run" + namespace_klass
      full_alg_name = namespace_klass
   
      print(textwrap.dedent("""\
      ::: create jobo [%(full_jobo_name)s] and script [%(full_script_name)s] for alg [%(full_alg_name)s]""" %locals()))
   
      #following code borrowed from gen_klass
      jobo = Templates.jobo_template
   
      e = dict( klass=full_alg_name,
               inFile=os.environ['ASG_TEST_FILE_MC'],
               )
      fname = 'share/%s.py' % full_jobo_name
      #first check doesn't exist 
      if os.path.isfile(fname):
         print(":::  WARNING %s already exists .. will not overwrite" % fname)
      else:
         o_hdr = open(fname, 'w')
         o_hdr.writelines(jobo%e)
         o_hdr.flush()
         o_hdr.close()
 
    scripto = Templates.script_template
 
    e = dict( klass=full_alg_name,
              inFile=os.environ['ASG_TEST_FILE_MC'],
              )
    fname = 'scripts/%s.py' % full_script_name
    #first check doesn't exist
    if os.path.isfile(fname):
        print(":::  WARNING %s already exists .. will not overwrite" % fname)
    else:
        o_hdr = open(fname, 'w')
        o_hdr.writelines(scripto%e)
        o_hdr.flush()
        o_hdr.close()
        os.chmod(fname, 0o755)
 
    #need to reconfigure cmake so it knows about the new files
    #rely on the WorkDir_DIR env var for this
    workDir = os.environ.get("WorkDir_DIR")
    if workDir is None:
        print("::: ERROR No WorkDir_DIR env var, did you forget to source the setup.sh script?")
        print("::: ERROR Please do this and reconfigure cmake manually!")
    else:
        print(":::  INFO Reconfiguring cmake %s/../." % workDir)
        res = subprocess.getstatusoutput('cmake %s/../.' % workDir)
        if res[0]!=0:
            print(":::  WARNING reconfigure unsuccessful. Please reconfigure manually!")
        
 
    print(":::  INFO Please ensure your CMakeLists.txt file has ")
    print(":::       atlas_add_component( %s src/component/*.cxx ... )" % full_pkg_name)
    print(":::  INFO and necessary dependencies declared ")
    print(":::  INFO Minimum dependency is: Control/AthAnalysisBaseComps")