python.Helpers Namespace Reference

Classes
class	ShutUp

Functions
	MakexAODDataFrame (inputs)
	separateSources (filenames)
	Separate the source and header files based on their names.
	dictionaryHeaders (filenames)
	Find the headers needed for dictionary generation.
	dictionaryClasses (filenames)
	Function collecting the class names to create a dictionary for.
	writeLinkDefFile (filename, classnames, headers=[])
	Function writing a LinkDef file.
	makeRootCorePackageSkeleton (directory, name)
	Create the directory structure for a RootCore package.
	makeSFramePackageSkeleton (directory, name)
	Create an SFrame package skeleton.
	ROOTSetup (batch=False)
	release_metadata ()
str	get_release_setup (Logger logger, no_setup=False)
None	list_changed_packages (Logger logger, no_setup=False)
List[str]	warnings_count (Path file_name)

Function Documentation

dictionaryClasses()

python.Helpers.dictionaryClasses

(

filenames

)

Function collecting the class names to create a dictionary for.

This function can parse all headers of the generated sources to collect the class names for which a CINT dictionary should be generated.

Parameters

filenames

Header file names (as returned by dictionaryHeaders(...))

Returns

A list with the class names

Definition at line 80 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def dictionaryClasses( filenames ):
 
    # Create a logger object first of all:
    from AthenaCommon.Logging import logging
    logger = logging.getLogger( "dictionaryClasses" )
 
    # Extract the class names from the header files:
    classnames = [ "D3PDReader::VarHandleBase",
                   "D3PDReader::VarProxyBase",
                   "D3PDReader::VariableStats",
                   "D3PDReader::D3PDReadStats",
                   "map<TString,D3PDReader::VariableStats>",
                   "pair<TString,D3PDReader::VariableStats>",
                   "map<TString,D3PDReader::VarHandleBase*>",
                   "pair<TString,D3PDReader::VarHandleBase*>",
                   "D3PDReader::UserD3PDObjectElement",
                   "D3PDReader::UserD3PDObject" ]
    for header in filenames:
        # Open the header file:
        hfile = open( header, "rU" )
        if not hfile:
            logger.error( "Couldn't open header file: %s", hfile )
            return 255
        for line in hfile:
            import re
            m1 = re.match( r".*ClassDef\‍( (\w+), 0 \‍)", line )
            m2 = re.match( ".*(VarHandle< .* >).*", line )
            m3 = re.match( ".*(VarProxy< .* >).*", line )
            if m1:
                if not ( "D3PDReader::" + m1.group( 1 ) ) in classnames:
                    logger.verbose( "Found class: " + m1.group( 1 ) )
                    classnames += [ "D3PDReader::" + m1.group( 1 ) ]
                    pass
                continue
            if m2:
                if m2.group( 1 ) == "VarHandle< T >": continue
                if not ( "D3PDReader::" + m2.group( 1 ) ) in classnames:
                    logger.verbose( "Found class: " + m2.group( 1 ) )
                    classnames += [ "D3PDReader::" + m2.group( 1 ) ]
                    pass
                continue
            if m3:
                if m3.group( 1 ) == "VarProxy< T >": continue
                if not ( "D3PDReader::" + m3.group( 1 ) ) in classnames:
                    logger.verbose( "Found class: " + m3.group( 1 ) )
                    classnames += [ "D3PDReader::" + m3.group( 1 ) ]
                    pass
                continue
            pass
        pass
 
    # Now "clean up" these class names a little, so that ROOT would
    # like them better:
    import re
    finalnames = []
    for cname in classnames:
        # First, let's remove all mentions of the std namespace:
        cname = re.sub( r"std::", "", cname )
        # Now remove all the whitespaces:
        cname = re.sub( r"\s", "", cname )
        # Remove the allocator class names:
        cname = re.sub( r",allocator<\w*>", "", cname )
        cname = re.sub( r",allocator<\w*<\w*>>", "", cname )
        cname = re.sub( r",allocator<\w*<\w*<\w*>>>", "", cname )
        # Make sure whitespaces are re-inserted into the unsigned primitive
        # names:
        cname = re.sub( r"unsigned", "unsigned ", cname )
        # Also take care of adding back the needed whitespace before the
        # "long" modifier. But don't add a whitespace after the last long in
        # the name. For instance, "longlong" should become "long long" and not
        # "long long ".
        cname = re.sub( r"long(?!>)", "long ", cname )
        # Finally, make sure that there is a space between the > operators:
        while cname != re.sub( r">>", "> >", cname ):
            cname = re.sub( r">>", "> >", cname )
            pass
        finalnames += [ cname ]
        pass
 
    return finalnames
 

dictionaryHeaders()

python.Helpers.dictionaryHeaders

(

filenames

)

Find the headers needed for dictionary generation.

This function can be used to find the headers from the specified file names that should be given to rootcint for dictionary generation.

Parameters

filenames

A list of file names

Returns

A list of header file names that should be given to rootcint

Definition at line 48 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def dictionaryHeaders( filenames ):
 
    # Loop over the file names, and collect the "dictionary headers":
    header_files = []
    for file in filenames:
        # Skip the lingering linkdef and dictionary files:
        if file.lower().find( "linkdef" ) != -1 or file.lower().find( "dict" ) != -1:
            continue
        # Skip the D3PDReader template classes:
        if ( file.find( "VarHandle.h" ) != -1 or
             file.find( "VarHandle.icc" ) != -1 or
             file.find( "VarProxy.h" ) != -1 or
             file.find( "VarProxy.icc" ) != -1 ):
            continue
        # Find the header files:
        if file.endswith( ".h" ):
            header_files += [ file ]
            pass
        pass
 
    # Return the final list:
    return header_files
 

get_release_setup()

str python.Helpers.get_release_setup	(	Logger	logger,
			no_setup = False )

Get release setup.

Definition at line 9 of file Tools/WorkflowTestRunner/python/Helpers.py.

def get_release_setup(logger: Logger, no_setup=False) -> str:
    """Get release setup."""
    if no_setup:
        logger.info("No release information is available when a release is not set-up.\n")
        return ""
 
    current_nightly = environ["AtlasBuildStamp"]
    release_base = environ["AtlasBuildBranch"]
    release_head = environ["AtlasVersion"]
    platform = environ["LCG_PLATFORM"]
    project = environ["AtlasProject"]
    builds_dir_search_str = f"/cvmfs/atlas-nightlies.cern.ch/repo/sw/{release_base}_{project}_{platform}/[!latest_]*/{project}/{release_head}"
    # finds all directories matching above search pattern, and sorts by modification time
    # suggest to use latest opt over dbg
    sorted_list = sorted(glob(builds_dir_search_str), key=path.getmtime)
    latest_nightly = ""
    for folder in reversed(sorted_list):
        if not glob(f"{folder}/../../{release_base}__{project}*-opt*.log"):
            continue
        latest_nightly = folder.split("/")[-3]
        break
 
    if current_nightly != latest_nightly:
        logger.info(f"Please be aware that you are not testing your tags in the latest available nightly, which is {latest_nightly}")
 
    setup = "%s,%s,%s,Athena" % (release_base, platform.replace("-", ","), current_nightly)
 
    logger.info(f"Your tags will be tested in environment {setup}")
 
    return setup
 
 

list_changed_packages()

None python.Helpers.list_changed_packages	(	Logger	logger,
			no_setup = False )

List packages that have changed.

Definition at line 41 of file Tools/WorkflowTestRunner/python/Helpers.py.

def list_changed_packages(logger: Logger, no_setup=False) -> None:
    """List packages that have changed."""
    if no_setup:
        logger.info("The list of changed packages is not available when the relase is not set-up.\n")
        return
 
    if "WorkDir_DIR" in environ:
        logger.info("Changed packages in your build to be tested:\n")
        file_path = Path(environ["WorkDir_DIR"])
        fname = file_path / "packages.txt"
        with fname.open() as fp:
            lines = fp.readlines()
            last_line = lines[-1].strip() if lines else None
            for line in lines:
                line = line.strip()
                if "#" not in line:
                    if line == last_line:
                        logger.info(f"{line}\n")
                    else:
                        logger.info(line)
    else:
        logger.warning("A release area with locally installed packages has not been setup.")
        logger.warning("quit by executing <CONTROL-C> if this is not your intention, and")
        logger.warning("source <YOUR_CMake_BUILD_AREA>/setup.sh")
        logger.warning("to pickup locally built packages in your environment.\n")
    pass
 
 

makeRootCorePackageSkeleton()

python.Helpers.makeRootCorePackageSkeleton	(		directory,
			name )

Create the directory structure for a RootCore package.

This function can be used to create the directory structure for a RootCore package.

Parameters

directory	The directory where the package is to be created
name	The name for the RootCore package

Returns

0 in case of success, something else in case of failure

Definition at line 279 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def makeRootCorePackageSkeleton( directory, name ):
 
    # Create a logger object first of all:
    from AthenaCommon.Logging import logging
    logger = logging.getLogger( "makeRootCorePackageSkeleton" )
 
    # Check whether the output directory exists:
    import os.path
    if not os.path.exists( directory ):
        logger.error( "The output directory (%s) doesn't exist!", directory )
        return 255
 
    # Check that the package's directory doesn't exist yet:
    if os.path.exists( directory + "/" + name ):
        logger.error( "The directory for the package (%s/%s) already exists!", directory, name )
        return 255
 
    # Create the directory structure:
    import os
    os.mkdir( directory + "/" + name, 0o755 )
    os.mkdir( directory + "/" + name + "/" + name, 0o755 )
    os.mkdir( directory + "/" + name + "/Root", 0o755 )
    os.mkdir( directory + "/" + name + "/cmt", 0o755 )
 
    # Create the RootCore Makefile:
    makefile = open( directory + "/" + name + "/cmt/Makefile.RootCore", "w" )
    makefile.write( "# $Id: Helpers.py 600807 2014-06-08 15:26:51Z krasznaa $\n\n" )
    makefile.write( "PACKAGE          = %s\n" % name )
    makefile.write( "PACKAGE_PRELOAD  = Tree\n" )
    makefile.write( "# Add the option -DACTIVATE_BRANCHES if your analysis framework\n" )
    makefile.write( "# disables all branches by default.\n" )
    makefile.write( "# Remove the COLLECT_D3PD_READING_STATISTICS option to gain a bit\n" )
    makefile.write( "# of performance...\n" )
    makefile.write( "PACKAGE_CXXFLAGS = -DCOLLECT_D3PD_READING_STATISTICS\n" )
    makefile.write( "PACKAGE_LDFLAGS  =\n" )
    makefile.write( "PACKAGE_DEP      =\n" )
    makefile.write( "PACKAGE_PEDANTIC = 1\n" )
    makefile.write( "PACKAGE_NOOPT    = dict\n\n" )
    makefile.write( "include $(ROOTCOREDIR)/Makefile-common\n" )
    makefile.close()
 
    # Create the RootCore requirements file:
    requirements = open( directory + "/" + name + "/cmt/requirements", "w" )
    requirements.write( "package %s\n\n" % name )
    requirements.write( "use AtlasPolicy  AtlasPolicy-*\n" )
    requirements.write( "use AtlasROOT    AtlasROOT-*    External\n\n" )
    requirements.write( "library %s ../Root/*.cxx\n" % name )
    requirements.write( "apply_pattern installed_library\n\n" )
    requirements.write( "apply_pattern have_root_headers root_headers=\"*.h " \
                        "../Root/LinkDef.h\" headers_lib=%s\n" % name )
    requirements.close()
 
    # Signal that the function was successful:
    return 0
 

makeSFramePackageSkeleton()

python.Helpers.makeSFramePackageSkeleton	(		directory,
			name )

Create an SFrame package skeleton.

This function can be used to create the directory structure for an SFrame package. It does as similar job as SFrame's sframe_new_package.sh script.

Parameters

directory	The directory where the package is to be created
name	The name for the SFrame package

Returns

0 in case of success, something else in case of failure

Definition at line 345 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def makeSFramePackageSkeleton( directory, name ):
 
    # Create a logger object first of all:
    from AthenaCommon.Logging import logging
    logger = logging.getLogger( "makeSFramePackageSkeleton" )
 
    # Check whether the output directory exists:
    import os.path
    if not os.path.exists( directory ):
        logger.error( "The output directory (%s) doesn't exist!", directory )
        return 255
 
    # Check that the package's directory doesn't exist yet:
    if os.path.exists( directory + "/" + name ):
        logger.error( "The directory for the package (%s/%s) already exists!", directory, name )
        return 255
 
    # Create the directory structure:
    import os
    os.mkdir( directory + "/" + name, 0o755 )
    os.mkdir( directory + "/" + name + "/include", 0o755 )
    os.mkdir( directory + "/" + name + "/src", 0o755 )
    os.mkdir( directory + "/" + name + "/proof", 0o755 )
 
    # Create the SFrame Makefile:
    makefile = open( directory + "/" + name + "/Makefile", "w" )
    makefile.write( "# $Id: Helpers.py 600807 2014-06-08 15:26:51Z krasznaa $\n\n" )
    makefile.write( "# Package information\n" )
    makefile.write( "LIBRARY = %s\n" % name )
    makefile.write( "OBJDIR  = obj\n" )
    makefile.write( "DEPDIR  = $(OBJDIR)/dep\n" )
    makefile.write( "SRCDIR  = src\n" )
    makefile.write( "INCDIR  = include\n\n" )
    makefile.write( "# Enable collecting D3PD reading statistics\n" )
    makefile.write( "INCLUDES += -DCOLLECT_D3PD_READING_STATISTICS\n\n" )
    makefile.write( "# Include the generic compilation rules\n" )
    makefile.write( "include $(SFRAME_DIR)/Makefile.common\n" )
    makefile.close()
 
    # Create the PROOF related files:
    setup = open( directory + "/" + name + "/proof/SETUP.C", "w" )
    setup.write( "// $Id: Helpers.py 600807 2014-06-08 15:26:51Z krasznaa $\n\n" )
    setup.write( "int SETUP() {\n\n" )
    setup.write( "   if( gSystem->Load( \"libTree\" ) == -1 ) return -1;\n" )
    setup.write( "   if( gSystem->Load( \"lib%s\" ) == -1 ) return -1;\n\n" % name )
    setup.write( "   return 0;\n" )
    setup.write( "}\n" )
    setup.close()
    # Notice that BUILD.sh has to be executable:
    build = open( directory + "/" + name + "/proof/BUILD.sh", "w" )
    build.write( "# $Id: Helpers.py 600807 2014-06-08 15:26:51Z krasznaa $\n\n" )
    build.write( "if [ \"$1\" = \"clean\" ]; then\n" )
    build.write( "   make distclean\n" )
    build.write( "   exit 0\n" )
    build.write( "fi\n\n" )
    build.write( "make default\n" )
    build.close()
    os.chmod( directory + "/" + name + "/proof/BUILD.sh", 0o755 )
 
    # Signal that the function was successful:
    return 0

MakexAODDataFrame()

python.Helpers.MakexAODDataFrame

(

inputs

)

Helper function creating a ROOT::RDataFrame object reading xAOD files

The function returns an instance of ROOT::RDataFrame that uses
xAOD::RDataSource for reading its inputs.

Keyword arguments:
  inputs -- A single string, or a list of string selecting the input file(s)
            Note that the string(s) may contain wildcards and environment
            variables as well.

Definition at line 6 of file Control/xAODDataSource/python/Helpers.py.

def MakexAODDataFrame( inputs ):
    """Helper function creating a ROOT::RDataFrame object reading xAOD files
 
    The function returns an instance of ROOT::RDataFrame that uses
    xAOD::RDataSource for reading its inputs.
 
    Keyword arguments:
      inputs -- A single string, or a list of string selecting the input file(s)
                Note that the string(s) may contain wildcards and environment
                variables as well.
    """
 
    # Make sure that the dictionary is loaded.
    ROOT.xAOD.ROOT6_xAODDataSource_WorkAround_Dummy()
 
    # Use the C++ function for the heavy lifting.
    return ROOT.xAOD.MakeDataFrame( inputs )

release_metadata()

python.Helpers.release_metadata

(

)

Returns information about the current release based on ReleaseData

Definition at line 129 of file Tools/PyUtils/python/Helpers.py.

def release_metadata():
   """Returns information about the current release based on ReleaseData"""
 
   import configparser
   d = {
      'project name': '?',
      'release': '?',
      'base release': '?',
      'nightly release': '?',
      'nightly name': '?',
      'date': '?',
      'platform': '?',
      }
 
   for cmake_path in os.environ['CMAKE_PREFIX_PATH'].split(os.pathsep):
      release_data = os.path.join(cmake_path, 'ReleaseData')
      if os.path.exists(release_data):
         d1=d
         cfg = configparser.ConfigParser()
         try:
            cfg.read( release_data )
            if cfg.has_section( 'release_metadata' ):
               d1.update( dict( cfg.items( 'release_metadata' ) ) )
               d1['platform'] = os.getenv( '%s_PLATFORM' % d1['project name'],
                                           '?' )
               release = d1['release'].split('.')
               base_release = d1['base release'].split('.')
               if len(release)>=3 or len(base_release)>=3:
                  return d1
         except Exception:
            pass
   return d

ROOTSetup()

python.Helpers.ROOTSetup

(

batch = False

)

At this point this function just makes sure the ROOT batch mode is set
correctly when someone imports ROOT

Definition at line 18 of file Tools/PyUtils/python/Helpers.py.

def ROOTSetup(batch=False):
   """
   At this point this function just makes sure the ROOT batch mode is set
   correctly when someone imports ROOT
   """
   from AthenaCommon.Logging import log
   import builtins as builtin_mod
   oldimporthook = builtin_mod.__import__
   batch_mode = bool(batch)
 
   def root6_importhook(name, globals={}, locals={}, fromlist=[], level=0):
       nonlocal batch_mode
       isroot = False
       bm = batch_mode
       if name=='ROOT' or (name[0:4]=='ROOT' and name!='ROOT.pythonization'):
          isroot = True
          batch_mode = None  # only set it on first ROOT import
 
       m = oldimporthook(name, globals, locals, fromlist, level)
 
       if m and isroot:
          log.debug('Python import module=%s, fromlist=%s', name, fromlist)
          if bm is not None:
             log.debug('Setting ROOT batch mode to %s', bm)
             m.gROOT.SetBatch(bm)
 
       return m
 
   builtin_mod.__import__ = root6_importhook
 
 

separateSources()

python.Helpers.separateSources

(

filenames

)

Separate the source and header files based on their names.

This function can be used to separate a list of file names into header and source files just based on their names.

Parameters

filename

A simple list of the names of all the files

Returns

The a <code>(headers,sources)</code> pair of file name lists

Definition at line 17 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def separateSources( filenames ):
 
    # Loop over the file names, and create the header and source lists:
    header_files = []
    source_files = []
    for file in filenames:
        # Skip the lingering linkdef and dictionary files:
        if file.lower().find( "linkdef" ) != -1 or file.lower().find( "dict" ) != -1:
            continue
        # Find the header files:
        if file.endswith( ".h" ) or file.endswith( ".icc" ):
            header_files += [ file ]
            pass
        # Find the source files:
        if file.endswith( ".cxx" ) or file.endswith( ".cpp" ) or file.endswith( ".C" ):
            source_files += [ file ]
            pass
        pass
 
    # Return the result:
    return ( header_files, source_files )
 

warnings_count()

List[str] python.Helpers.warnings_count

(

Path

file_name

)

Run a WARNING helper function.

Definition at line 69 of file Tools/WorkflowTestRunner/python/Helpers.py.

def warnings_count(file_name: Path) -> List[str]:
    """Run a WARNING helper function."""
    warnings = []
    with file_name.open() as file:
        for line in file:
            if "WARNING" in line and "| WARNING |" not in line:
                warnings.append(line)
    return warnings

writeLinkDefFile()

python.Helpers.writeLinkDefFile	(		filename,
			classnames,
			headers = [] )

Function writing a LinkDef file.

This function can be used to generate a LinkDef file based on the class names for which a dictionary needs to be generated.

Parameters

filename	The name of the output LinkDef file
classname	A list of the class names to generate a dictionary for
headers	Header file names that are to be included

Returns

0 in case of success, something else in case of failure

Definition at line 172 of file PhysicsAnalysis/D3PDMaker/D3PDMakerReader/python/Helpers.py.

def writeLinkDefFile( filename, classnames, headers = [] ):
 
    # Create a logger object first of all:
    from AthenaCommon.Logging import logging
    logger = logging.getLogger( "writeLinkDefFile" )
 
    # Open the linkdef file:
    linkdef = open( filename, "w" )
    if not linkdef:
        logger.error( "Couldn't open %s for writing!", filename )
        return 255
    else:
        logger.info( "Writing linkdef file to: %s", filename )
        pass
 
    # Write the file's header:
    linkdef.write( "// Dear emacs, this is -*- c++ -*-\n" )
    linkdef.write( "// $Id: Helpers.py 600807 2014-06-08 15:26:51Z krasznaa $\n" )
    linkdef.write( "#ifndef D3PDREADER_LINKDEF_H\n" )
    linkdef.write( "#define D3PDREADER_LINKDEF_H\n\n" )
 
    # Write the required includes:
    for header in headers:
        linkdef.write( "#include \"%s\"\n" % header )
        pass
 
    # Write the rest of the constant part:
    linkdef.write( "\n#ifdef __CINT__\n\n" )
    linkdef.write( "#pragma link off all globals;\n" )
    linkdef.write( "#pragma link off all classes;\n" )
    linkdef.write( "#pragma link off all functions;\n\n" )
    linkdef.write( "#pragma link C++ nestedclass;\n\n" )
 
    # Write which files to generate a dictionary for:
    for classname in classnames:
        linkdef.write( "#pragma link C++ class %s+;\n" % classname )
        pass
 
    # Write which template functions to generate a dictionary for:
    linkdef.write( "\n" )
    linkdef.write( "// You can disable the remaining lines if you don't\n" )
    linkdef.write( "// plan to use the library in CINT or PyROOT.\n" )
    functions = [ "D3PDReader::UserD3PDObject::DeclareVariable<bool>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<short>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<unsigned short>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<int>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<unsigned int>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<long long>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<unsigned long long>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<float>",
                  "D3PDReader::UserD3PDObject::DeclareVariable<double>",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<short>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<unsigned short>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<int>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<unsigned int>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<long long>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<unsigned long long>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<float>* >",
#                  "D3PDReader::UserD3PDObject::DeclareVariable<vector<double>* >",
                  "D3PDReader::UserD3PDObject::Variable<bool>",
                  "D3PDReader::UserD3PDObject::Variable<short>",
                  "D3PDReader::UserD3PDObject::Variable<unsigned short>",
                  "D3PDReader::UserD3PDObject::Variable<int>",
                  "D3PDReader::UserD3PDObject::Variable<unsigned int>",
                  "D3PDReader::UserD3PDObject::Variable<long long>",
                  "D3PDReader::UserD3PDObject::Variable<unsigned long long>",
                  "D3PDReader::UserD3PDObject::Variable<float>",
                  "D3PDReader::UserD3PDObject::Variable<double>",
#                  "D3PDReader::UserD3PDObject::Variable<vector<short>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<unsigned short>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<int>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<unsigned int>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<long long>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<unsigned long long>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<float>* >",
#                  "D3PDReader::UserD3PDObject::Variable<vector<double>* >",
                  "D3PDReader::UserD3PDObjectElement::Variable<short>",
                  "D3PDReader::UserD3PDObjectElement::Variable<unsigned short>",
                  "D3PDReader::UserD3PDObjectElement::Variable<int>",
                  "D3PDReader::UserD3PDObjectElement::Variable<unsigned int>",
                  "D3PDReader::UserD3PDObjectElement::Variable<long long>",
                  "D3PDReader::UserD3PDObjectElement::Variable<unsigned long long>",
                  "D3PDReader::UserD3PDObjectElement::Variable<float>",
                  "D3PDReader::UserD3PDObjectElement::Variable<double>" ]
    for function in functions:
        linkdef.write( "#pragma link C++ function %s;\n" % function )
        pass
 
    # Close the file:
    linkdef.write( "\n" )
    linkdef.write( "#endif // __CINT__\n" )
    linkdef.write( "#endif // D3PDREADER_LINKDEF_H\n" )
    linkdef.close()
 
    # Signal that the function was successful:
    return 0