Merge remaining Muon Collider changes from fork

.github/workflows/linux.yml

@@ -29,7 +29,11 @@ jobs:
             ..
           make -k
           make install
-          ctest --output-on-failure
+          if [[ ${{ matrix.LCG }} =~ LCG_97 ]]; then
+              ctest --output-on-failure -E t_anajob_py
+          else
+              ctest --output-on-failure
+          fi
           echo "::group::Test downstream build"
           cd -
           export CMAKE_PREFIX_PATH=$PWD/install:$CMAKE_PREFIX_PATH

CMakeLists.txt

@@ -83,9 +83,21 @@ IF( INSTALL_JAR )
 ENDIF()
 
 
+# ROOT
+OPTION( BUILD_ROOTDICT "Set to ON to build ROOT dictionary" ON )
+IF( BUILD_ROOTDICT )
+    FIND_PACKAGE( ROOT 6.04 REQUIRED ) # look for ROOT versions >= 5.27.06
+    INCLUDE(${ROOT_USE_FILE})
+ENDIF()
+
+
 # install python stuff (for out-of-source-build)
 INSTALL( DIRECTORY "${PROJECT_SOURCE_DIR}/src/python/" DESTINATION python )
 INSTALL( DIRECTORY "${PROJECT_SOURCE_DIR}/examples/python/" DESTINATION python/examples )
+# install executable python utilities
+IF( BUILD_ROOTDICT )
+  INSTALL( PROGRAMS "${PROJECT_SOURCE_DIR}/examples/python/anajob.py" TYPE BIN RENAME anajob.py )
+ENDIF()
 
 
 # JAVA (needed to generate c++ headers)
@@ -98,14 +110,6 @@ if( INSTALL_JAR OR LCIO_GENERATE_HEADERS)
 endif()
 
 
-# ROOT
-OPTION( BUILD_ROOTDICT "Set to ON to build ROOT dictionary" OFF )
-IF( BUILD_ROOTDICT )
-    FIND_PACKAGE( ROOT 6.04 REQUIRED ) # look for ROOT versions >= 5.27.06
-    INCLUDE(${ROOT_USE_FILE})
-ENDIF()
-
-
 # DCAP
 #OPTION( LCIO_DCAP "Set to ON to build LCIO with dcap (dCache) support" OFF )
 #MESSAGE( STATUS "LCIO_DCAP = ${LCIO_DCAP}" )

examples/python/anajob.py

@@ -1,125 +1,173 @@
-'''
-Created on May 19, 2013
-
-Re-implementation of anajob.cc
-Illustrates looping over events, run headers and collections, as well as some string formatting.
-
-@author: Christian Grefe, CERN
-'''
-from __future__ import absolute_import, unicode_literals
-from __future__ import print_function
-import sys
-
-def formatVecValues( vec ):
-    ''' Helper method to transform the content of a vector into a string '''
-    if len( vec ) == 0:
-        return ' [empty]'
-    string = ''
-    for val in vec:
-        string += '%s, ' % ( val )
-    return string
-
-def printParameters( parameters ):
-    from ROOT import vector
-    ''' Helper method to print the content of an LCParameters object '''
-    keyVec = vector( 'string' )()
-    for intKey in parameters.getIntKeys( keyVec ):
-        intVec = vector( 'int' )()
-        parameters.getIntVals( intKey, intVec )
-        print(' parameter %s [int]: %s' % (intKey, formatVecValues(intVec)))
+#!/usr/bin/env python3
+"""
+Concise printout of the LCIO file contents
+Re-implemented using python3 functions
+
+@author: Nazar Bartosik, INFN Torino
+"""
+
+from pyLCIO import IOIMPL
+from ROOT import vector
+
+
+def formatVecValues(vec):
+    """Helper method to transform the content of a vector into a string"""
+    if len(vec) == 0:
+        return " [empty]"
+    return f"[{', '.join([str(v) for v in vec])}]"
+
+
+def printParameters(parameters):
+    """Helper method to print the content of an LCParameters object"""
+    keyVec = vector("string")()
+    for intKey in parameters.getIntKeys(keyVec):
+        intVec = vector("int")()
+        parameters.getIntVals(intKey, intVec)
+        print(f"- {intKey} [int]: formatVecValues(intVec)")
     keyVec.clear()
-    for floatKey in parameters.getFloatKeys( keyVec ):
-        floatVec = vector( 'float' )()
-        parameters.getFloatVals( floatKey, floatVec )
-        print(' parameter %s [float]: %s' % (floatKey, formatVecValues(floatVec)))
+    for floatKey in parameters.getFloatKeys(keyVec):
+        floatVec = vector("float")()
+        parameters.getFloatVals(floatKey, floatVec)
+        print(f"- {floatKey} [float]: formatVecValues(floatVec)")
     keyVec.clear()
-    for stringKey in parameters.getStringKeys( keyVec ):
-        stringVec = vector( 'string' )()
-        parameters.getStringVals( stringKey, stringVec )
-        print(' parameter %s [string]: %s' % (stringKey, formatVecValues(stringVec)))
-
-def dumpEvent( event ):
-    ''' Helper method to print information on all collections in an LCEvent'''
-    # the event
-    print('///////////////////////////////////')
-    print('EVENT:', event.getEventNumber())
-    print('RUN:', event.getRunNumber())
-    print('DETECTOR:', event.getDetectorName())
-    print('COLLECTIONS: (see below)')
-    print('///////////////////////////////////\n')
-
-    print('---------------------------------------------------------------------------')
-    print('{0:30}{1:25}{2:20}'.format('COLLECTION NAME', 'COLLECTION TYPE', 'NUMBER OF ELEMENTS'))
-    print('===========================================================================')
-
+    for doubleKey in parameters.getDoubleKeys(keyVec):
+        doubleVec = vector("double")()
+        parameters.getDoubleVals(doubleKey, doubleVec)
+        print(f"- {doubleKey} [double]: formatVecValues(doubleVec)")
+    keyVec.clear()
+    for stringKey in parameters.getStringKeys(keyVec):
+        stringVec = vector("string")()
+        parameters.getStringVals(stringKey, stringVec)
+        print(f"- {stringKey} [string]: formatVecValues(stringVec)")
+
+
+def dumpEvent(event):
+    """Helper method to print information on all collections in an LCEvent"""
+    print(
+        f"RUN: {event.getRunNumber():<9d}  EVENT: {event.getEventNumber():<10d}  DETECTOR: {event.getDetectorName()}"
+    )
+    print("---------------------------------------------------------------------------")
+    print(
+        "{0:35}{1:27}{2:13}".format(
+            "COLLECTION NAME", "COLLECTION TYPE", "# OF ELEMENTS"
+        )
+    )
+    print("===========================================================================")
+
     for collectionName, collection in event:
-        print('{0:30}{1:25}{2:9}'.format(collectionName, collection.getTypeName(), collection.getNumberOfElements()))
+        print(
+            f"{str(collectionName):35}{collection.getTypeName():27}{collection.getNumberOfElements():>13}"
+        )
+
+    print(
+        "---------------------------------------------------------------------------\n\n"
+    )
 
-    print('---------------------------------------------------------------------------\n\n')
 
-def dumpRunHeader( run ):
-    ''' Helper method to print information on a LCRunHeader'''
-    print('  Run : %d - %s:  %s' % (run.getRunNumber(), run.getDetectorName(), run.getDescription()))
-    printParameters( run.parameters() )
-    print(' --------------------------------------------------------------- ')
+def dumpRunHeader(run):
+    """Helper method to print information on a LCRunHeader"""
 
-def anajob( fileNames ):
-    from ROOT import vector
-    ''' Method to loop over all events of the given slcio files and print
-        information about all collections'''
+    print(
+        f"Run : {run.getRunNumber()} - {run.getDetectorName()}:  {run.getDescription()}"
+    )
+    printParameters(run.parameters())
+    print("")
+
+
+def analyze_file(
+    file_name, print_headers=False, max_events=None, run_nr=None, event_nr=None
+):
+    """Loop over all events of the given LCIO file and list the stored collections"""
 
-    from pyLCIO import IOIMPL
     reader = IOIMPL.LCFactory.getInstance().createLCReader()
-
-    # first loop over all files: open them and print the total number of runs and events
-    fileNameVec = vector( 'string' )()
-    print('anajob: will open and read from files:')
-    for fileName in fileNames:
-        fileNameVec.push_back( fileName )
-        reader.open( fileName )
-        print('     %s     [ number of runs: %d, number of events: %d ]\n' %
-              (fileName, reader.getNumberOfRuns(), reader.getNumberOfEvents()))
-        reader.close()
-
-    # second loop: print information on all run headers
-    # this time we open all files in one stream by passing them as a std::vector<std::string>
-    reader.open( fileNameVec )
-    runHeader = reader.readNextRunHeader()
-    while runHeader:
-        dumpRunHeader( runHeader )
+    reader.open(file_name)
+
+    print(f"Reading from file: {file_name}")
+    print(
+        f"# of runs: {reader.getNumberOfRuns()}   # of events: {reader.getNumberOfEvents()}\n"
+    )
+
+    if print_headers:
         runHeader = reader.readNextRunHeader()
-    print('')
-    reader.close()
-
-    print(' will reopen and read from files:')
-    for fileName in fileNames:
-        print('     %s' % (fileName))
-
-    # final loop: print information on all events
-    reader.open( fileNameVec )
-    nEvents = 0
+        while runHeader:
+            dumpRunHeader(runHeader)
+            runHeader = reader.readNextRunHeader()
+        print()
+
+    n_events_read = 0
+    # Print the contents of each event
+    reader.open(file_name)
     for event in reader:
-        # use the c++ method or the one defined above for printing
-        # from pyLCIO import UTIL
+        if max_events is not None and n_events_read >= max_events:
+            break
+        n_events_read += 1
+        if run_nr is None and event_nr is not None:
+            if event_nr != n_events_read:
+                continue
+            if event_nr > n_events_read:
+                break
+        elif run_nr is not None:
+            if run_nr != event.getRunNumber():
+                continue
+            if event_nr is not None and event_nr != event.getEventNumber():
+                continue
         # UTIL.LCTOOLS.dumpEvent( event )
-        dumpEvent( event )
-        nEvents += 1
+        # Using the custom dump function with more compact formatting
+        dumpEvent(event)
     reader.close()
-
-    print('  %s events read from files:' % (nEvents))
-    for fileName in fileNames:
-        print('     %s' % (fileName))
-
-def usage():
-    ''' Helper method to inform about the usage of this script '''
-    print('usage: python anajob.py <input-file1> [[input-file2],...]')
-
-if __name__ == '__main__':
-    # check the command line parameters
-    if len( sys.argv ) < 2 or sys.argv[1] in ['-h', '--help']:
-        usage()
-        sys.exit( 1 )
-
-    # pass all arguments except for the first one as file names
-    anajob( sys.argv[1:] )
-    sys.exit( 0 )
+    return n_events_read
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Prints summary of the LCIO file contents"
+    )
+    parser.add_argument("files", metavar="FILE", help="Input file(s)", nargs="+")
+    parser.add_argument(
+        "-e",
+        "--event",
+        metavar="NUMBER",
+        help="Event number to print",
+        type=int,
+        default=None,
+    )
+    parser.add_argument(
+        "-r",
+        "--run",
+        metavar="NUMBER",
+        help="Run number to print",
+        type=int,
+        default=None,
+    )
+    parser.add_argument(
+        "-m",
+        "--max_events",
+        metavar="N",
+        help="Maximum number of events to print",
+        type=int,
+        default=None,
+    )
+    parser.add_argument(
+        "-v", "--verbose", help="Print run headers", action="store_true"
+    )
+    args = parser.parse_args()
+
+    print(f"Analyzing {len(args.files)} file(s)")
+
+    n_events_read = 0
+    for file_name in args.files:
+        max_events = (
+            None if args.max_events is None else args.max_events - n_events_read
+        )
+        n_events_read += analyze_file(
+            file_name,
+            print_headers=args.verbose,
+            max_events=max_events,
+            run_nr=args.run,
+            event_nr=args.event,
+        )
+        if args.max_events is not None and n_events_read >= args.max_events:
+            break
+    print(f"\nFinished reading {n_events_read} event(s)")

tests/CMakeLists.txt

@@ -175,6 +175,11 @@ IF( BUILD_ROOTDICT )
       DEPENDS t_root_writeEventTree
       )
 
+    ADD_TEST( t_anajob_py ${SH} "${LCIO_ENV_INIT}" "python3 ${PROJECT_SOURCE_DIR}/examples/python/anajob.py c_rec.slcio")
+    set_tests_properties( t_anajob_py
+      PROPERTIES DEPENDS t_c_rec_c_sim
+    )
+
 ENDIF()