python.scripts.cmake_newanalysisalg Namespace Reference

Classes
class	Templates

Functions
def	main (args)

Variables
	__version__
	__author__
	__doc__

Function Documentation

main()

def python.scripts.cmake_newanalysisalg.main

(

args

)

create a new AthAnalysisAlgorithm inside the current package. Call from within the package directory

ex:
 $ acmd cmake new-analysisalg MyAlg

Definition at line 288 of file cmake_newanalysisalg.py.

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

Variable Documentation

__author__

python.scripts.cmake_newanalysisalg.__author__

private

Definition at line 13 of file cmake_newanalysisalg.py.

__doc__

python.scripts.cmake_newanalysisalg.__doc__

private

Definition at line 14 of file cmake_newanalysisalg.py.

__version__

python.scripts.cmake_newanalysisalg.__version__

private

Definition at line 12 of file cmake_newanalysisalg.py.