python.RootUtils.RootFileDumper Class Reference

Inheritance diagram for python.RootUtils.RootFileDumper:

Collaboration diagram for python.RootUtils.RootFileDumper:

Public Types
typedef HLT::TypeInformation::for_each_type_c< typenameEDMLIST::map, my_functor, my_result<>, my_arg< HLT::TypeInformation::get_cont, CONTAINER > >::type	result

Public Member Functions
	__init__ (self, fname, tree_name=None)
	dump (self, tree_name, itr_entries, leaves=None, retvecs=False, sortleaves=True)

Public Attributes
bool	allgood = True
	root_file = ROOT.TFile.Open(fname)
	obj_name = name
	obj = ROOT.RNTupleReader.Open(obj)
	tree = self.obj

Protected Member Functions
	_dump (self, obj, itr_entries, leaves=None, retvecs=False, sortleaves=True)
	_tree_dump (self, tree, itr_entries, leaves=None, retvecs=False, sortleaves=True)
	_reader_dump (self, reader, itr_entries, leaves=None, retvecs=False, sortleaves=True)

Protected Attributes
list	_trees = []

Private Member Functions
	__init_obj (self, obj_name)

Detailed Description

A helper class to dump in more or less human readable form the content of
any TTree.

Definition at line 211 of file RootUtils.py.

Member Typedef Documentation

result

typedef HLT::TypeInformation::for_each_type_c<typenameEDMLIST::map,my_functor,my_result<>,my_arg<HLT::TypeInformation::get_cont,CONTAINER>>::type master_search< typenameEDMLIST::map, HLT::TypeInformation::get_cont, CONTAINER >::result

inherited

Definition at line 90 of file EDM_MasterSearch.h.

Constructor & Destructor Documentation

__init__()

python.RootUtils.RootFileDumper.__init__	(		self,
			fname,
			tree_name = None )

Definition at line 217 of file RootUtils.py.

    def __init__(self, fname, tree_name=None):
        object.__init__(self)
 
        ROOT = import_root()
 
        # remember if an error or problem occurred during the dump
        self.allgood = True
        
        self.root_file = ROOT.TFile.Open(fname)
        if (self.root_file is None or
            not isinstance(self.root_file, ROOT.TFile) or
            not self.root_file.IsOpen()):
            raise IOError('could not open [%s]'% fname)
 
        self.__init_obj(tree_name)
 
        if 0:
            self._trees = []
            keys = [k.GetName() for k in self.root_file.GetListOfKeys()]
            for k in keys:
                o = self.root_file.Get(k)
                if isinstance(o, ROOT.TTree):
                    self._trees.append(k)
                    pass
 
        return
 

Member Function Documentation

__init_obj()

python.RootUtils.RootFileDumper.__init_obj ( self, obj_name )

private

Definition at line 244 of file RootUtils.py.

    def __init_obj(self, obj_name):
 
        ROOT = import_root()
        from PyUtils.PoolFile import PoolOpts
        TTreeNames = PoolOpts.TTreeNames
        RNTupleNames = PoolOpts.RNTupleNames
 
        if obj_name is None:
            for name, klass in ((TTreeNames.EventData, ROOT.TTree), (RNTupleNames.EventData, ROOT.RNTuple)):
                if (obj := self.root_file.Get(name)) and isinstance(obj, klass):
                    self.obj_name = name
                    break
            else:
                raise AttributeError('No TTree named %r or RNTuple named %r in file %r' %
                                     (TTreeNames.EventData, RNTupleNames.EventData,
                                      self.root_file.GetName()))
        else:
            if (not (obj := self.root_file.Get(obj_name)) or
                not isinstance(obj, ROOT.TTree) and not isinstance(obj, ROOT.RNTuple)):
                raise AttributeError('No TTree or RNTuple named %r in file %r' %
                                     (obj_name, self.root_file.GetName()))
            self.obj_name = obj_name
 
        if isinstance(obj, ROOT.RNTuple):
            try:
                self.obj = ROOT.RNTupleReader.Open(obj)
            except AttributeError:
                self.obj = ROOT.Experimental.RNTupleReader.Open(obj)
        elif isinstance(obj, ROOT.TTree):
            self.obj = obj
            # in case it is used somewhere
            self.tree = self.obj
 

_dump()

python.RootUtils.RootFileDumper._dump ( self, obj, itr_entries, leaves = None, retvecs = False, sortleaves = True )

protected

Definition at line 277 of file RootUtils.py.

    def _dump(self, obj, itr_entries, leaves=None, retvecs=False, sortleaves=True):
        ROOT = import_root()
        try:
            RNTupleReader = ROOT.RNTupleReader
        except AttributeError:
            RNTupleReader = ROOT.Experimental.RNTupleReader
        if isinstance(obj, ROOT.TTree):
            yield from self._tree_dump(obj, itr_entries, leaves, retvecs, sortleaves)
        elif isinstance(obj, RNTupleReader):
            yield from self._reader_dump(obj, itr_entries, leaves, retvecs, sortleaves)
        else:
            raise NotImplementedError("'_dump' not implemented for object of class=%r" %
                                      (obj.__class__.__name__,))
 

_reader_dump()

python.RootUtils.RootFileDumper._reader_dump ( self, reader, itr_entries, leaves = None, retvecs = False, sortleaves = True )

protected

Definition at line 408 of file RootUtils.py.

    def _reader_dump(self, reader, itr_entries, leaves=None, retvecs=False, sortleaves=True):
 
        ROOT = import_root()
        import AthenaPython.PyAthena as PyAthena
        _pythonize = PyAthena.RootUtils.PyROOTInspector.pyroot_inspect2
 
        ntuple_name = self.obj_name
        nentries = reader.GetNEntries()
        from operator import methodcaller
        if leaves is not None:
            leaves = sorted(leaves)
        else:
            leaves = sorted(map(methodcaller('GetFieldName'), reader.GetDescriptor().GetTopLevelFields()))
 
        # handle itr_entries
        if isinstance(itr_entries, str):
            if ':' in itr_entries:
                def toint(s):
                    if s == '':
                        return None
                    try:
                        return int(s)
                    except ValueError:
                        return s
                from itertools import islice
                itr_entries = islice(range(nentries),
                                     *map(toint, itr_entries.split(':')))
            elif ('range' in itr_entries or
                  ',' in itr_entries):
                itr_entries = eval(itr_entries)
            else:
                try:
                    _n = int(itr_entries)
                    itr_entries = range(_n)
                except ValueError:
                    print ("** err ** invalid 'itr_entries' argument. will iterate over all entries.")
                    itr_entries = range(nentries)
        elif isinstance(itr_entries, list):
            itr_entries = itr_entries
        else:
            itr_entries = range(itr_entries)
 
        list_ = list
        map_ = map
        str_ = str
        isinstance_ = isinstance
 
        try:
            from ROOT import RException
        except ImportError:
            from ROOT.Experimental import RException
 
        try:
            entry = reader.CreateEntry()
        except AttributeError:
            entry = reader.GetModel().CreateEntry()
 
        for ientry in itr_entries:
            try:
                reader.LoadEntry(ientry, entry)
            except RException as err:
                from traceback import format_exception
                import sys
                print("Exception reading entry=%05i of ntuple %r\n%s" %
                      (ientry, ntuple_name, "".join(format_exception(err))), file=sys.stderr)
                self.allgood = False
                continue
 
            for br_name in leaves:
                py_name = [br_name]
                token = entry.GetToken(br_name)
                typeName = entry.GetTypeName(token)
                # Make sure dictionaries are completely loaded before
                # trying to fetch it from ROOT.  Otherwise we can run
                # into cling parse failures due to it synthesizing
                # incorrect forward declarations.
                # See ATEAM-1000.
                getattr(ROOT, typeName)
                val = entry[token]
                if val is not None:
                    try:
                        vals = _pythonize(val, py_name, True, retvecs)
                    except Exception as err:
                        print("**err** for branch [%s] val=%s (type=%s)" %
                              (br_name, val, type(val)))
                        self.allgood = False
                        print(err)
                    if sortleaves:
                        viter = sorted(vals, key = lambda x: '.'.join(s for s in x[0] if isinstance_(s, str_)))
                    else:
                        viter = vals
                    for o in viter:
                        n = list_(map_(str_, o[0]))
                        v = o[1]
                        yield ntuple_name, ientry, n, v
 
 

_tree_dump()

python.RootUtils.RootFileDumper._tree_dump ( self, tree, itr_entries, leaves = None, retvecs = False, sortleaves = True )

protected

Definition at line 297 of file RootUtils.py.

    def _tree_dump(self, tree, itr_entries, leaves=None, retvecs=False, sortleaves=True):
 
        ROOT = import_root()
        import AthenaPython.PyAthena as PyAthena
        _pythonize = PyAthena.RootUtils.PyROOTInspector.pyroot_inspect2
 
        tree_name = self.obj_name
        nentries = tree.GetEntries()
        if leaves is not None:
            leaves = [str(b).rstrip('\0') for b in leaves]
            leaves.sort()
        else:
            leaves = sorted([b.GetName().rstrip('\0') for b in tree.GetListOfBranches()])
        
        # handle itr_entries
        if isinstance(itr_entries, str):
            if ':' in itr_entries:
                def toint(s):
                    if s == '':
                        return None
                    try:
                        return int(s)
                    except ValueError:
                        return s
                from itertools import islice
                itr_entries = islice(range(nentries),
                                     *map(toint, itr_entries.split(':')))
            elif ('range' in itr_entries or
                  ',' in itr_entries):
                itr_entries = eval(itr_entries)
            else:
                try:
                    _n = int(itr_entries)
                    itr_entries = range(_n)
                except ValueError:
                    print ("** err ** invalid 'itr_entries' argument. will iterate over all entries.")
                    itr_entries = range(nentries)
        elif isinstance(itr_entries, list):
            itr_entries = itr_entries
        else:
            itr_entries = range(itr_entries)
                
        list_ = list
        map_ = map
        str_ = str
        isinstance_ = isinstance
 
        for ientry in itr_entries:
            hdr = ":: entry [%05i]..." % (ientry,)
            #print (hdr)
            #print (hdr, file=self.fout)
            err = tree.LoadTree(ientry)
            if err < 0:
                print ("**err** loading tree for entry",ientry)
                self.allgood = False
                break
 
            nbytes = tree.GetEntry(ientry)
            if nbytes <= 0:
                print ("**err** reading entry [%s] of tree [%s]" % (ientry, tree_name))
                hdr = ":: entry [%05i]... [ERR]" % (ientry,)
                print (hdr)
                self.allgood = False
                continue
 
            for br_name in leaves:
                hdr = "::  branch [%s]..." % (br_name,)
                #print (hdr)
                #tree.GetBranch(br_name).GetEntry(ientry)
                _vals = list()
 
                br = tree.GetBranch (br_name)
                if br.GetClassName() != '':
                    # Make sure dictionaries are completely loaded before
                    # trying to fetch it from ROOT.  Otherwise we can run
                    # into cling parse failures due to it synthesizing
                    # incorrect forward declarations.
                    # See ATEAM-1000.
                    getattr (ROOT, br.GetClassName())
                    val = getattr(tree, br_name)
                    _vals += [ ([br_name], val) ]
                else:
                    for l in br.GetListOfLeaves():
                        if (br.GetNleaves() == 1 and (br_name == l.GetName() or
                                                      br_name.endswith('.' + l.GetName()))):
                            _vals += [ ([br_name], _getLeaf (l)) ]
                        else:
                            _vals += [ ([br_name, l.GetName()], _getLeaf (l)) ]
                for py_name, val in _vals:
                    if val is None: continue
                    try:
                        vals = _pythonize(val, py_name, True, retvecs)
                    except Exception as err:
                        print ("**err** for branch [%s] val=%s (type=%s)" % (
                            br_name, val, type(val),
                            ))
                        self.allgood = False
                        print (err)
                    if sortleaves:
                        viter = sorted(vals, key = lambda x: '.'.join(s for s in x[0] if isinstance_(s, str_)))
                    else:
                        viter = vals
                    for o in viter:
                        n = list_(map_(str_, o[0]))
                        v = o[1]
                        yield tree_name, ientry, n, v
 
                pass # loop over branch names
            pass # loop over entries

dump()

python.RootUtils.RootFileDumper.dump	(		self,
			tree_name,
			itr_entries,
			leaves = None,
			retvecs = False,
			sortleaves = True )

Definition at line 291 of file RootUtils.py.

    def dump(self, tree_name, itr_entries, leaves=None, retvecs=False, sortleaves=True):
        if (tree_name is None and getattr(self, "obj_name", None) is None or
            tree_name is not None and getattr(self, "obj_name", None) != tree_name):
                self.__init_obj(tree_name)
        yield from self._dump(self.obj, itr_entries, leaves, retvecs, sortleaves)
 

Member Data Documentation

_trees

list python.RootUtils.RootFileDumper._trees = []

protected

Definition at line 234 of file RootUtils.py.

allgood

bool python.RootUtils.RootFileDumper.allgood = True

Definition at line 223 of file RootUtils.py.

obj

python.RootUtils.RootFileDumper.obj = ROOT.RNTupleReader.Open(obj)

Definition at line 269 of file RootUtils.py.

obj_name

python.RootUtils.RootFileDumper.obj_name = name

Definition at line 254 of file RootUtils.py.

root_file

python.RootUtils.RootFileDumper.root_file = ROOT.TFile.Open(fname)

Definition at line 225 of file RootUtils.py.

tree

python.RootUtils.RootFileDumper.tree = self.obj

Definition at line 275 of file RootUtils.py.

---

The documentation for this class was generated from the following file:

• RootUtils.py