Meta.py

"""Helper object for configuring the LCIO output file (meta)"""

from __future__ import absolute_import, unicode_literals
import datetime
import os
import logging
import six

logging.basicConfig(format='%(levelname)s: %(message)s')
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

from DDSim.Helper.ConfigHelper import ConfigHelper

class Meta( ConfigHelper ):
  """Configuration for the LCIO output file settings"""
  def __init__( self ):
    super(Meta, self).__init__()
    self._eventParameters_EXTRA = {'help': "Event parameters to write in every event. " \
                                           "Use C/F/I ids to specify parameter type. E.g parameterName/F=0.42 to set a float parameter",
                                   'nargs': '+'}
    self.eventParameters = []
    self._runNumberOffset_EXTRA = {'help': "The run number offset to write in slcio output file. "\
                                           "E.g setting it to 42 will start counting runs from 42 instead of 0"}
    self.runNumberOffset = 0
    self._eventNumberOffset_EXTRA = {'help': "The event number offset to write in slcio output file."\
                                             " E.g setting it to 42 will start counting events from 42 instead of 0"}
    self.eventNumberOffset = 0

  def parseEventParameters(self):
    """Parse the event parameters and return 3 event parameter dictionnaries, respectively for string, int and float parameters"""
    stringParameters, intParameters, floatParameters, allParameters = {}, {}, {}, []
    for p in self.eventParameters:
      parameterAndValue = p.split( "=", 1 )
      if len(parameterAndValue) != 2:
        raise SyntaxError("ERROR: Couldn't decode event parameter '%s'" %(p))
      parameterAndType = parameterAndValue[0].split( "/", 1 )
      if len(parameterAndType) != 2:
        raise SyntaxError("ERROR: Couldn't decode event parameter '%s'" %(p))
      pname = parameterAndType[0]
      ptype = parameterAndType[1]
      pvalue = parameterAndValue[1]
      if ptype.lower() not in ["c", "f", "i"]:
        raise ValueError("ERROR: Event parameter '%s' with invalid type '%s'" %(pname, ptype))
      if pname in allParameters:
        raise RuntimeError("ERROR: Event parameter '%s' specified twice" %(pname))
      if not pvalue:
        raise RuntimeError("ERROR: Event parameter '%s' has empty value" %(pname))
      allParameters.append(pname)
      logger.info("Event parameter '%s', type '%s', value='%s'"%(pname, ptype, pvalue))
      if ptype.lower() == "c":
        stringParameters[pname] = pvalue
      elif ptype.lower() == "f":
        floatParameters[pname] = pvalue
      elif ptype.lower() == "i":
        intParameters[pname] = pvalue
    return stringParameters, intParameters, floatParameters

  @staticmethod
  def addParametersToRunHeader(sim):
    """add the parameters to the (lcio) run Header"""
    runHeader = {}
    parameters = vars(sim)
    for parName, parameter in six.iteritems(parameters):
      if isinstance( parameter, ConfigHelper ):
        options = parameter.getOptions()
        for opt,optionsDict in six.iteritems(options):
          runHeader["%s.%s"%(parName, opt)] = str(optionsDict['default'])
      else:
        runHeader[parName] = str(parameter)

    ### steeringFile content
    if sim.steeringFile and os.path.exists(sim.steeringFile) and os.path.isfile(sim.steeringFile):
      with open(sim.steeringFile) as sFile:
        runHeader["SteeringFileContent"] = sFile.read()

    ### macroFile content
    if sim.macroFile and os.path.exists(sim.macroFile) and os.path.isfile(sim.macroFile):
      with open(sim.macroFile) as mFile:
        runHeader["MacroFileContent"] = mFile.read()

    ### add command line
    if sim._argv:
      runHeader["CommandLine"] = " ".join(sim._argv)

    ### add current working directory (where we call from)
    runHeader["WorkingDirectory"] = os.getcwd()

    ### ILCSoft, LCGEo location from environment variables, names from init_ilcsoft.sh
    runHeader["ILCSoft_location"] = os.environ.get("ILCSOFT", "Unknown")
    runHeader["lcgeo_location"] = os.environ.get("lcgeo_DIR", "Unknown")

    ### add date
    runHeader["DateUTC"] = str(datetime.datetime.utcnow())+" UTC"

    ### add User
    import getpass
    runHeader["User"] = getpass.getuser()

    return runHeader