def root2array(filenames,
treename=None,
branches=None,
selection=None,
start=None,
stop=None,
step=None,
include_weight=False,
weight_name='weight'):
"""Convert trees in ROOT files into a numpy structured array.
Refer to the type conversion table :ref:`here <conversion_table>`.
Parameters
----------
filenames : str or list
ROOT file name pattern or list of patterns. Wildcarding is supported by
Python globbing.
treename : str, optional (default=None)
Name of the tree to convert (optional if each file contains exactly one
tree).
branches : list of str, optional (default=None)
List of branch names to include as columns of the array. If None or
empty then include all branches than can be converted in the first
tree. If branches contains duplicate branches, only the first one is
used.
selection : str, optional (default=None)
Only include entries fulfilling this condition.
start, stop, step: int, optional (default=None)
The meaning of the ``start``, ``stop`` and ``step`` parameters is the
same as for Python slices. If a range is supplied (by setting some of
the ``start``, ``stop`` or ``step`` parameters), only the entries in
that range and fulfilling the ``selection`` condition (if defined) are
used.
include_weight : bool, optional (default=False)
Include a column containing the tree weight.
weight_name : str, optional (default='weight')
The field name for the weight column if ``include_weight=True``.
Examples
--------
Read all branches from the tree named ``mytree`` in ``a.root``
Remember that ``mytree`` is optional if ``a.root`` has one tree::
root2array('a.root', 'mytree')
Read all branches starting from entry 5 and include 10 entries or up to the
end of the file::
root2array('a.root', 'mytree', start=5, stop=11)
Read all branches in reverse order::
root2array('a.root', 'mytree', step=-1)
Read every second entry::
root2array('a.root', 'mytree', step=2)
Read all branches from the tree named ``mytree`` in ``a*.root``::
root2array('a*.root', 'mytree')
Read all branches from the tree named ``mytree`` in ``a*.root`` and
``b*.root``::
root2array(['a*.root', 'b*.root'], 'mytree')
Read branch ``x`` and ``y`` from the tree named ``mytree`` in ``a.root``::
root2array('a.root', 'mytree', ['x', 'y'])
Notes
-----
Due to the way TChain works, if the trees specified in the input files have
different structures, only the branch in the first tree will be
automatically extracted. You can work around this by either reordering the
input file or specifying the branches manually.
"""
filenames = _glob(filenames)
if not filenames:
raise ValueError("specify at least one filename")
if treename is None:
trees = list_trees(filenames[0])
if len(trees) > 1:
raise ValueError(
"treename must be specified if the file "
"contains more than one tree")
elif not trees:
raise IOError(
"no trees present in {0}".format(filenames[0]))
else:
treename = trees[0]
return _librootnumpy.root2array_fromFname(
filenames, treename, branches,
selection,
start, stop, step,
include_weight,
weight_name)
def root2array(filenames,
treename=None,
branches=None,
selection=None,
start=None,
stop=None,
step=None,
include_weight=False,
weight_name='weight'):
"""Convert trees in ROOT files into a numpy structured array.
Refer to the type conversion table :ref:`here <conversion_table>`.
Parameters
----------
filenames : str or list
ROOT file name pattern or list of patterns. Wildcarding is
supported by Python globbing.
treename : str, optional (default=None)
Name of the tree to convert (optional if each file contains exactly one
tree).
branches : list of str, optional (default=None)
List of branch names to include as columns of the array.
If None or empty then include all branches than can be converted in the
first tree.
If branches contains duplicate branches, only the first one is used.
selection : str, optional (default=None)
Only include entries fulfilling this condition.
start, stop, step: int, optional (default=None)
The meaning of the ``start``, ``stop`` and ``step``
parameters is the same as for Python slices.
If a range is supplied (by setting some of the
``start``, ``stop`` or ``step`` parameters), only the entries in that
range and fulfilling the ``selection`` condition (if defined) are used.
include_weight : bool, optional (default=False)
Include a column containing the tree weight.
weight_name : str, optional (default='weight')
The field name for the weight column if ``include_weight=True``.
Examples
--------
Read all branches from the tree named ``mytree`` in ``a.root``
Remember that ``mytree`` is optional if ``a.root`` has one tree::
root2array('a.root', 'mytree')
Read all branches starting from entry 5 and include 10 entries or up to the
end of the file::
root2array('a.root', 'mytree', start=5, stop=11)
Read all branches in reverse order::
root2array('a.root', 'mytree', step=-1)
Read every second entry::
root2array('a.root', 'mytree', step=2)
Read all branches from the tree named ``mytree`` in ``a*.root``::
root2array('a*.root', 'mytree')
Read all branches from the tree named ``mytree`` in ``a*.root`` and
``b*.root``::
root2array(['a*.root', 'b*.root'], 'mytree')
Read branch ``x`` and ``y`` from the tree named ``mytree`` in ``a.root``::
root2array('a.root', 'mytree', ['x', 'y'])
Notes
-----
Due to the way TChain works, if the trees specified in the input files have
different structures, only the branch in the first tree will be
automatically extracted. You can work around this by either reordering the
input file or specifying the branches manually.
"""
filenames = _glob(filenames)
if not filenames:
raise ValueError("specify at least one filename")
if treename is None:
trees = list_trees(filenames[0])
if len(trees) > 1:
raise ValueError(
"treename must be specified if the file "
"contains more than one tree")
elif not trees:
raise IOError(
"no trees present in {0}".format(filenames[0]))
else:
treename = trees[0]
return _librootnumpy.root2array_fromFname(
filenames, treename, branches,
selection,
start, stop, step,
include_weight,
weight_name)
def root2array(filenames,
treename=None,
branches=None,
entries=None,
offset=0,
selection=None):
"""
Convert trees in ROOT files into a numpy structured array.
Refer to the type conversion table :ref:`here <conversion_table>`.
Parameters
----------
filenames : str or list
ROOT file name pattern or list of patterns. Wildcarding is
supported by Python globbing.
treename : str, optional (default=None)
Name of the tree to convert (optional if each file contains exactly one
tree).
branches : list of str, optional (default=None)
List of branch names to include as columns of the array.
If None or empty then include all branches than can be converted in the
first tree.
If branches contains duplicate branches, only the first one is used.
entries : int, optional (default=None)
Maximum number of entries that will be converted from the chained
trees. If None then convert all entries. If a selection is applied then
fewer entries may be converted.
offset : int, optional (default=0):
Offset from the beginning of the chained trees where conversion will
begin.
selection : str, optional (default=None)
Only include entries passing a cut expression.
Examples
--------
Read all branches from the tree named ``mytree`` in ``a.root``
Remember that ``mytree`` is optional if ``a.root`` has one tree::
root2array('a.root', 'mytree')
Read all branches starting from entry 5 and include 10 entries or up to the
end of the file::
root2array('a.root', 'mytree', entries=10, offset=5)
Read all branches from the tree named ``mytree`` in ``a*.root``::
root2array('a*.root', 'mytree')
Read all branches from the tree named ``mytree`` in ``a*.root`` and
``b*.root``::
root2array(['a*.root', 'b*.root'], 'mytree')
Read branch ``x`` and ``y`` from the tree named ``mytree`` in ``a.root``::
root2array('a.root', 'mytree', ['x', 'y'])
Notes
-----
Due to the way TChain works, if the trees specified in the input files have
different structures, only the branch in the first tree will be
automatically extracted. You can work around this by either reordering the
input file or specifying the branches manually.
"""
matched_filenames = []
if isinstance(filenames, basestring):
matched_filenames = glob(filenames)
else:
for fn in filenames:
tmp = glob(fn)
if len(tmp) == 0:
raise IOError('%s does not match any readable file.' % fn)
matched_filenames.extend(tmp)
if len(matched_filenames) == 0:
raise IOError('pattern given does not match any file %s' % filenames)
if treename is None:
trees = list_trees(matched_filenames[0])
if len(trees) != 1:
raise ValueError('treename needs to be specified if the file '
'contains more than one tree. Your choices are:'
+ str(trees))
else:
treename = trees[0]
return _librootnumpy.root2array_fromFname(
matched_filenames, treename, branches, entries, offset, selection)
def root2array(fnames, treename=None, branches=None, N=None, offset=0):
"""
convert tree *treename* in root files specified in *fnames* to
numpy structured array. Type conversion table
is given :ref:`here <conversion_table>`
Arguments:
*fnames*: Root file name pattern. Wildcard is also supported by
Python glob (not ROOT semi-broken wildcard)
fnames can be string or list of string.
*treename*: name of tree to convert to numpy array.
This is optional if the file contains exactly 1 tree.
*branches(optional)*: list of string for branch name to be
extracted from tree.
* If branches is not specified or is None or is empty,
all from the first treebranches are extracted
* If branches contains duplicate branches, only the first one is used.
*N(optional)*: maximum number of data that it should load
useful for testing out stuff
*offset(optional)*: start index (first one is 0)
**Example**
::
# read all branches from tree named mytree from a.root
# remember that 'mytree' is optional if a.root has 1 tree
root2array('a.root', 'mytree')
::
#read all branches starting from record 5 for 10 records
#or the end of file.
root2array('a.root', 'mytree',offset=5,N=10)
::
# read all branches from tree named mytree from a*.root
root2array('a*.root', 'mytree')
::
# read all branches from tree named mytree from a*.root and b*.root
root2array(['a*.root', 'b*.root'], 'mytree')
::
#read branch x and y from tree named mytree from a.root
root2array('a.root', 'mytree', ['x', 'y'])
.. note::
Due to
the way TChain works, if the trees specified
in the input files have different structures, only the
branch in the first tree will be automatically extracted.
You can work around this by either reordering the input
file or specifying the branches manually.
"""
filenames = []
if isinstance(fnames, basestring):
filenames = glob(fnames)
else:
for fn in fnames:
tmp = glob(fn)
if len(tmp) == 0:
raise IOError('%s does not match any readable file.' % tmp)
filenames.extend(tmp)
if len(filenames)==0:
raise IOError('pattern given does not match any file')
if treename is None:
trees = list_trees(filenames[0])
if len(trees) != 1:
raise ValueError('treename needs to be specified if the file '
'contains more than one tree. Your choices are:'
+ str(trees))
else:
treename = trees[0]
return _librootnumpy.root2array_fromFname(
filenames, treename, branches, N, offset)
def root2array(fnames, treename=None, branches=None, N=None, offset=0):
"""
convert tree *treename* in root files specified in *fnames* to
numpy structured array. Type conversion table
is given :ref:`here <conversion_table>`
Arguments:
*fnames*: Root file name pattern. Wildcard is also supported by
Python glob (not ROOT semi-broken wildcard)
fnames can be string or list of string.
*treename*: name of tree to convert to numpy array.
This is optional if the file contains exactly 1 tree.
*branches(optional)*: list of string for branch name to be
extracted from tree.
* If branches is not specified or is None or is empty,
all from the first treebranches are extracted
* If branches contains duplicate branches, only the first one is used.
*N(optional)*: maximum number of data that it should load
useful for testing out stuff
*offset(optional)*: start index (first one is 0)
**Example**
::
# read all branches from tree named mytree from a.root
# remember that 'mytree' is optional if a.root has 1 tree
root2array('a.root', 'mytree')
::
#read all branches starting from record 5 for 10 records
#or the end of file.
root2array('a.root', 'mytree',offset=5,N=10)
::
# read all branches from tree named mytree from a*.root
root2array('a*.root', 'mytree')
::
# read all branches from tree named mytree from a*.root and b*.root
root2array(['a*.root', 'b*.root'], 'mytree')
::
#read branch x and y from tree named mytree from a.root
root2array('a.root', 'mytree', ['x', 'y'])
.. note::
Due to
the way TChain works, if the trees specified
in the input files have different structures, only the
branch in the first tree will be automatically extracted.
You can work around this by either reordering the input
file or specifying the branches manually.
"""
filenames = []
if isinstance(fnames, basestring):
filenames = glob(fnames)
else:
for fn in fnames:
tmp = glob(fn)
if len(tmp) == 0:
raise IOError('%s does not match any readable file.' % tmp)
filenames.extend(tmp)
if len(filenames) == 0:
raise IOError('pattern given does not match any file')
if treename is None:
trees = list_trees(filenames[0])
if len(trees) != 1:
raise ValueError('treename needs to be specified if the file '
'contains more than one tree. Your choices are:' +
str(trees))
else:
treename = trees[0]
return _librootnumpy.root2array_fromFname(filenames, treename, branches, N,
offset)