diff --git a/lang/femtocode/asts/statementlist.py b/lang/femtocode/asts/statementlist.py
index 2ea2fbf..b3237e9 100644
--- a/lang/femtocode/asts/statementlist.py
+++ b/lang/femtocode/asts/statementlist.py
@@ -501,7 +501,7 @@ def __hash__(self):
         return hash(("statementlist.ExplodeSize", self.column, self.explosions))
 
     def columnNames(self):
-        return [self.column] + list(self.explosions)
+        return [self.column]
 
     def inputSizes(self, statements):
         return list(self.explosions)
@@ -542,7 +542,7 @@ def __hash__(self):
         return hash(("statementlist.ExplodeData", self.column, self.schema, self.data, self.fromsize, self.explodesize, self.explosions))
 
     def columnNames(self):
-        return [self.column, self.data, self.fromsize, self.explodesize] + list(self.explosions)
+        return [self.column, self.data, self.fromsize, self.explodesize]
 
     def inputSizes(self, statements):
         for statement in statements:
@@ -631,6 +631,10 @@ def build(tree, dataset, replacements={}, refnumber=0, explosions=()):
             inputs = {ref.data: tree.schema}
         else:
             inputs = {}
+        if ref.size is not None:
+            for c in dataset.columns.values():
+                if ref.size == c.size:
+                    inputs[ref.size] = None
 
         return ref, Statements(), inputs, replacements, refnumber
 
@@ -811,7 +815,7 @@ def columns(self):
         return [r.size for n, r in self.namesToRefs if isinstance(r, Ref) and r.size is not None] + [r.data for n, r in self.namesToRefs if isinstance(r, Ref)]
 
     def columnNames(self):
-        return sum(self.namesToRefs.columnNames(), [])
+        return sum([x.columnNames() for x in self.namesToRefs.values()], [])
 
     def initialize(self):
         from femtocode.testdataset import TestDataset
diff --git a/lang/femtocode/dataset.py b/lang/femtocode/dataset.py
index b1f21a4..ce083c7 100644
--- a/lang/femtocode/dataset.py
+++ b/lang/femtocode/dataset.py
@@ -416,6 +416,13 @@ def dataset(self, name, groups=(), columns=None, schema=True):
                 for column in list(dataset.columns):
                     if column not in columns:
                         del dataset.columns[column]
+                for group in dataset.groups:
+                    todrop = []
+                    for n, seg in group.segments.items():
+                        if n not in columns:
+                            todrop.append(n)
+                    while len(todrop) > 0:
+                        del group.segments[todrop.pop()]
 
             # drop schema if not requested
             if not schema:
diff --git a/lang/femtocode/lib/standard.py b/lang/femtocode/lib/standard.py
index ec599d9..34c6f73 100644
--- a/lang/femtocode/lib/standard.py
+++ b/lang/femtocode/lib/standard.py
@@ -740,6 +740,10 @@ def buildstatements(self, call, dataset, replacements, refnumber, explosions):
 
         if reref.data in dataset.columns:
             inputs[reref.data] = reref.schema
+        if reref.size is not None:
+            for c in dataset.columns.values():
+                if reref.size == c.size:
+                    inputs[reref.size] = None
 
         return reref, statements, inputs, replacements, refnumber
 
@@ -787,6 +791,10 @@ def buildstatements(self, call, dataset, replacements, refnumber, explosions):
             inputs = {reref.data: reref.schema}
         else:
             inputs = {}
+        if reref.size is not None:
+            for c in dataset.columns.values():
+                if reref.size == c.size:
+                    inputs[reref.size] = None
 
         replacements[(typedtree.TypedTree, call.args[1].refs[0])] = replacements.get((typedtree.TypedTree, call.args[1].refs[0]), {})
         replacements[(typedtree.TypedTree, call.args[1].refs[0])][extendedExplosions] = reref
diff --git a/numpyio/femtocode/numpyio/fetch.py b/numpyio/femtocode/numpyio/fetch.py
index f7448ed..8ca0fe7 100644
--- a/numpyio/femtocode/numpyio/fetch.py
+++ b/numpyio/femtocode/numpyio/fetch.py
@@ -29,6 +29,7 @@
 from femtocode.py23 import *
 from femtocode.dataset import ColumnName
 from femtocode.dataset import sizeType
+from femtocode.execution import ExecutionFailure
 from femtocode.run.compute import DataAddress
 from femtocode.run.cache import CacheOccupant
 from femtocode.numpyio.xrootd import XRootDReader
@@ -43,8 +44,12 @@ def __init__(self, occupants, workItem):
         self.daemon = True
 
     def files(self, column):
+        out = None
         if column.issize():
-            out = self.workItem.group.segments[column.dropsize()].files
+            for n, c in self.workItem.executor.query.dataset.columns.items():
+                if c.size == column:
+                    out = self.workItem.group.segments[n].files
+                    break
         else:
             out = self.workItem.group.segments[column].files
 
@@ -53,45 +58,51 @@ def files(self, column):
         return out
 
     def run(self):
-        filesToOccupants = {}
-
-        for occupant in self.occupants:
-            for fileName in self.files(occupant.address.column):
-                if fileName not in filesToOccupants:
-                    filesToOccupants[fileName] = []
-                filesToOccupants[fileName].append(occupant)
-
-        for fileName, occupants in filesToOccupants.items():
-            protocol = urlparse(fileName).scheme
-            if protocol == "":
-                zf = zipfile.ZipFile(open(fileName, "rb"))
-            elif protocol == "root":
-                zf = zipfile.ZipFile(XRootDReader(fileName))
-            else:
-                raise NotImplementedError
-
-            for occupant in occupants:
-                stream = zf.open(str(occupant.address.column) + ".npy")
-                assert stream.read(6) == "\x93NUMPY"
-
-                version = struct.unpack("bb", stream.read(2))
-                if version[0] == 1:
-                    headerlen, = struct.unpack("<H", stream.read(2))
+        try:
+            filesToOccupants = {}
+
+            for occupant in self.occupants:
+                for fileName in self.files(occupant.address.column):
+                    if fileName not in filesToOccupants:
+                        filesToOccupants[fileName] = []
+                    filesToOccupants[fileName].append(occupant)
+
+            for fileName, occupants in filesToOccupants.items():
+                protocol = urlparse(fileName).scheme
+                if protocol == "":
+                    zf = zipfile.ZipFile(open(fileName, "rb"))
+                elif protocol == "root":
+                    zf = zipfile.ZipFile(XRootDReader(fileName))
                 else:
-                    headerlen, = struct.unpack("<I", stream.read(4))
+                    raise NotImplementedError
 
-                header = stream.read(headerlen)
-                headerdata = ast.literal_eval(header)
+                for occupant in occupants:
+                    stream = zf.open(str(occupant.address.column) + ".npy")
+                    assert stream.read(6) == "\x93NUMPY"
 
-                dtype = numpy.dtype(headerdata["descr"])
-                numBytes = reduce(lambda a, b: a * b, (dtype.itemsize,) + headerdata["shape"])
+                    version = struct.unpack("bb", stream.read(2))
+                    if version[0] == 1:
+                        headerlen, = struct.unpack("<H", stream.read(2))
+                    else:
+                        headerlen, = struct.unpack("<I", stream.read(4))
 
-                assert occupant.totalBytes == numBytes
+                    header = stream.read(headerlen)
+                    headerdata = ast.literal_eval(header)
 
-                readBytes = 0
-                while readBytes < numBytes:
-                    size = min(self.chunksize, numBytes - readBytes)
-                    readBytes += size
-                    occupant.fill(stream.read(size))
+                    dtype = numpy.dtype(headerdata["descr"])
+                    numBytes = reduce(lambda a, b: a * b, (dtype.itemsize,) + headerdata["shape"])
 
-            zf.close()
+                    assert occupant.totalBytes == numBytes
+
+                    readBytes = 0
+                    while readBytes < numBytes:
+                        size = min(self.chunksize, numBytes - readBytes)
+                        readBytes += size
+                        occupant.fill(stream.read(size))
+
+                zf.close()
+
+        except Exception as exception:
+            for occupant in self.occupants:
+                with occupant.lock:
+                    occupant.fetchfailure = ExecutionFailure(exception, sys.exc_info()[2])
diff --git a/rootio/femtocode/rootio/dataset.py b/rootio/femtocode/rootio/dataset.py
index 51201c4..e04bd9d 100644
--- a/rootio/femtocode/rootio/dataset.py
+++ b/rootio/femtocode/rootio/dataset.py
@@ -157,7 +157,7 @@ def _getBranchesForPaths(quantity, paths):
                     paths[(path, quantity.frm.tree)].append(quantity.frm.branch)
 
     @staticmethod
-    def _makeGroups(quantity, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, name=None):
+    def _makeGroups(quantity, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, name=None, sizename=None):
         if isinstance(quantity, DatasetDeclaration) or isinstance(quantity, DatasetDeclaration.Record):
             newColumns = {}
 
@@ -168,7 +168,7 @@ def _makeGroups(quantity, filesToNumEntries, fileColumnsToLengths, pathsToFiles,
                 else:
                     subname = name.rec(k)
 
-                columns, groups = ROOTDataset._makeGroups(v, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, subname)
+                columns, groups = ROOTDataset._makeGroups(v, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, subname, sizename)
 
                 for n, c in columns.items():
                     assert n not in newColumns
@@ -233,7 +233,7 @@ def _makeGroups(quantity, filesToNumEntries, fileColumnsToLengths, pathsToFiles,
             return newColumns, newGroups
 
         elif isinstance(quantity, DatasetDeclaration.Collection):
-            return ROOTDataset._makeGroups(quantity.items, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, name.coll())
+            return ROOTDataset._makeGroups(quantity.items, filesToNumEntries, fileColumnsToLengths, pathsToFiles, fileColumnsToSize, name.coll(), name.coll().size())
 
         elif isinstance(quantity, DatasetDeclaration.Primitive):
             sizeBranch = ()
@@ -247,7 +247,7 @@ def _makeGroups(quantity, filesToNumEntries, fileColumnsToLengths, pathsToFiles,
                             raise DatasetDeclaration.Error(quantity.frm.loc, "branch {0} has a counter branch in some files and not others".format(json.dumps(quantity.frm.branch)))
 
             column = ROOTColumn(name,
-                                name.size() if sizeBranch is not None else None,
+                                sizename,
                                 quantity.frm.dtype,
                                 quantity.frm.tree,
                                 quantity.frm.branch,
diff --git a/rootio/femtocode/rootio/fetch.py b/rootio/femtocode/rootio/fetch.py
index a1aa81a..cb7e428 100644
--- a/rootio/femtocode/rootio/fetch.py
+++ b/rootio/femtocode/rootio/fetch.py
@@ -14,10 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import sys
 import threading
 
 from femtocode.dataset import ColumnName
 from femtocode.dataset import sizeType
+from femtocode.execution import ExecutionFailure
 from femtocode.run.compute import DataAddress
 from femtocode.rootio._fastreader import fillarrays
 
@@ -29,8 +31,12 @@ def __init__(self, occupants, workItem):
         self.daemon = True
 
     def files(self, column):
+        out = None
         if column.issize():
-            out = self.workItem.group.segments[column.dropsize()].files
+            for n, c in self.workItem.executor.query.dataset.columns.items():
+                if c.size == column:
+                    out = self.workItem.group.segments[n].files
+                    break
         else:
             out = self.workItem.group.segments[column].files
 
@@ -39,45 +45,51 @@ def files(self, column):
         return out
 
     def run(self):
-        columnNameToArray = {}
-        filesetsToColumns = {}
-        filesetsToOccupants = {}
+        try:
+            columnNameToArray = {}
+            filesetsToColumns = {}
+            filesetsToOccupants = {}
 
-        for occupant in self.occupants:
-            column = occupant.address.column
-            columnNameToArray[column] = occupant.rawarray
+            for occupant in self.occupants:
+                column = occupant.address.column
+                columnNameToArray[column] = occupant.rawarray
 
-            filesetTree = (tuple(sorted(self.files(column))),
-                       self.workItem.executor.dataset.columns[column].tree)
+                filesetTree = (tuple(sorted(self.files(column))),
+                           self.workItem.executor.query.dataset.columns[column].tree)
 
-            if not column.issize():
-                if filesetTree not in filesetsToColumns:
-                    filesetsToColumns[filesetTree] = []
-                filesetsToColumns[filesetTree].append(column)
-
-            if filesetTree not in filesetsToOccupants:
-                filesetsToOccupants[filesetTree] = []
-            filesetsToOccupants[filesetTree].append(occupant)
-
-        for (fileset, tree), columns in filesetsToColumns.items():
-            toget = []
-            for column in columns:
                 if not column.issize():
-                    dataBranch = self.workItem.executor.dataset.columns[column].dataBranch
-                    sizeBranch = self.workItem.executor.dataset.columns[column].sizeBranch
-                    dataArray = columnNameToArray[column].view(self.workItem.executor.dataset.columns[column].dataType)
-
-                    if sizeBranch is None:
-                        toget.append((dataBranch, dataArray))
-                    else:
-                        sizeArray = columnNameToArray.get(str(column.size()))
-                        if sizeArray is not None:
-                            sizeArray = sizeArray.view(sizeType)
-
-                        toget.append((dataBranch, sizeBranch, dataArray, sizeArray))
-
-            for file in fileset:
-                fillarrays(file, tree, toget)
-
-            for occupant in filesetsToOccupants[(fileset, tree)]:
-                occupant.filledBytes = occupant.totalBytes
+                    if filesetTree not in filesetsToColumns:
+                        filesetsToColumns[filesetTree] = []
+                    filesetsToColumns[filesetTree].append(column)
+
+                if filesetTree not in filesetsToOccupants:
+                    filesetsToOccupants[filesetTree] = []
+                filesetsToOccupants[filesetTree].append(occupant)
+
+            for (fileset, tree), columns in filesetsToColumns.items():
+                toget = []
+                for column in columns:
+                    if not column.issize():
+                        dataBranch = self.workItem.executor.query.dataset.columns[column].dataBranch
+                        sizeBranch = self.workItem.executor.query.dataset.columns[column].sizeBranch
+                        dataArray = columnNameToArray[column].view(self.workItem.executor.query.dataset.columns[column].dataType)
+
+                        if sizeBranch is None:
+                            toget.append((dataBranch, dataArray))
+                        else:
+                            sizeArray = columnNameToArray.get(str(column.size()))
+                            if sizeArray is not None:
+                                sizeArray = sizeArray.view(sizeType)
+
+                            toget.append((dataBranch, sizeBranch, dataArray, sizeArray))
+
+                for file in fileset:
+                    fillarrays(file, tree, toget)
+
+                for occupant in filesetsToOccupants[(fileset, tree)]:
+                    occupant.filledBytes = occupant.totalBytes
+
+        except Exception as exception:
+            for occupant in self.occupants:
+                with occupant.lock:
+                    occupant.fetchfailure = ExecutionFailure(exception, sys.exc_info()[2])
diff --git a/rootio/tests/rootio/__init__.py b/rootio/tests/rootio/__init__.py
new file mode 100644
index 0000000..c18b0fc
--- /dev/null
+++ b/rootio/tests/rootio/__init__.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+# Copyright 2016 DIANA-HEP
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/rootio/tests/rootio/test_declare.py b/rootio/tests/rootio/test_declare.py
new file mode 100644
index 0000000..e0b0316
--- /dev/null
+++ b/rootio/tests/rootio/test_declare.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+
+# Copyright 2016 DIANA-HEP
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+import unittest
+
+import numpy
+
+from femtocode.rootio.dataset import ROOTDataset
+
+class TestDeclare(unittest.TestCase):
+    def runTest(self):
+        pass
+
+    def test_real(self):
+        declaration = """
+define:
+  MuOnia-2016-CF-23Sep2016-v1:
+    format: root
+    groupsize: 10   # 10 files per group
+    paths:
+      - root://cmseos.fnal.gov//store/data/Run2016[CF]/MuOnia/AOD/23Sep2016-v1/*/*.root
+
+  MuOnia-2016-CF-PromptReco-v2:
+    format: root
+    paths:
+      - root://cmseos.fnal.gov//store/data/Run2016C/MuOnia/AOD/PromptReco-v2/*/*.root
+      - root://cmseos.fnal.gov//store/data/Run2016F/MuOnia/AOD/PromptReco-v2/
+
+  local:
+    format: root
+    paths:
+      - /home/pivarski/storage/data/00000000-0000-0000-0000-000000000000.root
+
+name: MuOnia
+
+sources:
+  - local
+
+schema:
+
+  muons:
+    type: collection
+    items:
+      type: record
+      fields:
+        pt:
+          type: real
+          min: 0
+          max: almost(inf)
+          from:
+            tree: Events
+            branch: patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt
+            dtype: float64
+        eta:
+          type: real
+          from:
+            tree: Events
+            branch: patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta
+            dtype: float64
+        phi:
+          type: real
+          min: -pi
+          max: pi
+          from:
+            tree: Events
+            branch: patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi
+            dtype: float64
+
+  jets:
+    type: collection
+    items:
+      type: record
+      fields:
+        pt:
+          type: real
+          min: 0
+          max: almost(inf)
+          from:
+            tree: Events
+            branch: patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt
+            dtype: float64
+        eta:
+          type: real
+          from:
+            tree: Events
+            branch: patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fEta
+            dtype: float64
+        phi:
+          type: real
+          min: -pi
+          max: pi
+          from:
+            tree: Events
+            branch: patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi
+            dtype: float64
+        mass:
+          type: real
+          min: 0
+          max: almost(inf)
+          from:
+            tree: Events
+            branch: patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fM
+            dtype: float64
+"""
+
+        dataset = ROOTDataset.fromYamlString(declaration)
+
+        asjson = dataset.toJson()
+
+        self.assertEqual(asjson, {"name": "MuOnia", "numGroups": 1, "numEntries": 48131, "groups": [{"files": ["/home/pivarski/storage/data/00000000-0000-0000-0000-000000000000.root"], "segments": {"jets[]-mass": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "jets[]-pt": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "muons[]-pt": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}, "muons[]-eta": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}, "jets[]-eta": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "jets[]-phi": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "muons[]-phi": {"files": None, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}}, "numEntries": 48131, "id": 0}], "class": "femtocode.rootio.dataset.ROOTDataset", "columns": {"jets[]-mass": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fM", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-mass", "size": "jets[]@size"}, "jets[]-pt": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-pt", "size": "jets[]@size"}, "muons[]-pt": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-pt", "size": "muons[]@size"}, "muons[]-eta": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-eta", "size": "muons[]@size"}, "jets[]-eta": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-eta", "size": "jets[]@size"}, "jets[]-phi": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-phi", "size": "jets[]@size"}, "muons[]-phi": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-phi", "size": "muons[]@size"}}, "schema": {"jets": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "mass": {"max": {"almost": "inf"}, "type": "real", "min": 0}, "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}, "muons": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}}})
+
+        self.assertEqual(ROOTDataset.fromJson(asjson), dataset)
diff --git a/rootio/tests/rootio/test_fastreader.py b/rootio/tests/rootio/test_fastreader.py
new file mode 100644
index 0000000..1bde0a5
--- /dev/null
+++ b/rootio/tests/rootio/test_fastreader.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python
+
+# Copyright 2016 DIANA-HEP
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+import unittest
+
+import numpy
+
+from femtocode.rootio._fastreader import fillarrays
+
+class TestFastReader(unittest.TestCase):
+    fileName = "/home/pivarski/storage/data/00000000-0000-0000-0000-000000000000.root"
+    # fileName = "root://cmseos.fnal.gov//store/user/pivarski/femtocodetest/RunIISpring16MiniAODv2_SMS-T1tttt_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_MINIAODSIM_PUSpring16Fast_80X_mcRun2_asymptotic_2016_miniAODv2_v0-v1/00000000-0000-0000-0000-000000000000.root"
+
+    treeName = "Events"
+
+    numEvents = 48131
+    numTaus = 305544
+    numJets = 806177
+    numMuons = 132274
+    numPhotons = 139746
+    numElectrons = 120463
+    numJetAK8s = 87530
+
+    def runTest(self):
+        pass
+
+    def test_flat(self):
+        data = numpy.zeros(self.numEvents, dtype=numpy.float64)
+
+        fillarrays(self.fileName, self.treeName, [("recoBeamSpot_offlineBeamSpot__HLT.obj.position_.fCoordinates.fZ", data)])
+        print("data ({} MB) {}".format(len(data) * 8.0 / 1024**2, data))
+
+    def test_structured(self):
+        data = numpy.zeros(self.numElectrons, dtype=numpy.float64)
+        size = numpy.zeros(self.numEvents, dtype=numpy.uint64)
+
+        fillarrays(self.fileName, self.treeName, [("patElectrons_slimmedElectrons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patElectrons_slimmedElectrons__PAT.obj", data, size)])
+
+        print("data ({} MB) {}".format(len(data) * 8.0 / 1024**2, data))
+        print("size ({} MB) {}".format(len(size) * 8.0 / 1024**2, size))
+
+    def test_structured2(self):
+        data = numpy.zeros(self.numElectrons, dtype=numpy.float64)
+        size = numpy.zeros(self.numEvents, dtype=numpy.uint64)
+
+        fillarrays(self.fileName, self.treeName, [("patElectrons_slimmedElectrons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patElectrons_slimmedElectrons__PAT.obj", data, None)])
+
+        print("data ({} MB) {}".format(len(data) * 8.0 / 1024**2, data))
+
+    def test_structured3(self):
+        data = numpy.zeros(self.numJets, dtype=numpy.float64)
+        size = numpy.zeros(self.numEvents, dtype=numpy.uint64)
+
+        startTime = time.time()
+        fillarrays(self.fileName, self.treeName, [("patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patJets_slimmedJets__PAT.obj", data, size)])
+        endTime = time.time()
+
+        print("data ({} MB) {}".format(len(data) * 8.0 / 1024**2, data))
+        print("size ({} MB) {}".format(len(size) * 8.0 / 1024**2, size))
+        mb = (len(data) + len(size)) * 8.0 / 1024**2
+        sec = endTime - startTime
+        print("{} MB in {} sec at {} MB/sec".format(mb, sec, mb/sec))
+
+    def test_subdir(self):
+        # "root://cmseos.fnal.gov//store/user/pivarski/TrackResonanceNtuple.root"
+
+        mass_mumu = numpy.zeros(751919, dtype=numpy.float32)
+        startTime = time.time()
+        fillarrays("/home/pivarski/storage/data/TrackResonanceNtuple.root", "TrackResonanceNtuple/twoMuon", [("mass_mumu", mass_mumu)])
+        endTime = time.time()
+        mb = len(mass_mumu) * 4.0 / 1024**2
+        sec = endTime - startTime
+        print("mass_mumu ({} MB in {} sec at {} MB/sec) {}".format(mb, sec, mb/sec, mass_mumu))
+
+        mass_piP = numpy.zeros(1989730, dtype=numpy.float32)
+        mass_KK = numpy.zeros(1989730, dtype=numpy.float32)
+        mass_pipi = numpy.zeros(1989730, dtype=numpy.float32)
+        startTime = time.time()
+        fillarrays("/home/pivarski/storage/data/TrackResonanceNtuple.root", "TrackResonanceNtuple/twoTrack", [("mass_piP", mass_piP), ("mass_KK", mass_KK), ("mass_pipi", mass_pipi)])
+        endTime = time.time()
+        mb = (len(mass_piP) + len(mass_KK) + len(mass_pipi)) * 4.0 / 1024**2
+        sec = endTime - startTime
+        print("mass_piP ({} MB in {} sec at {} MB/sec) {}".format(mb, sec, mb/sec, mass_piP))
+
+    def test_many(self):
+        toget = []
+
+        beam_x = numpy.empty(self.numEvents, dtype=numpy.float64)
+        beam_y = numpy.empty(self.numEvents, dtype=numpy.float64)
+        beam_z = numpy.empty(self.numEvents, dtype=numpy.float64)
+        toget.append(("recoBeamSpot_offlineBeamSpot__HLT.obj.position_.fCoordinates.fX", beam_x))
+        toget.append(("recoBeamSpot_offlineBeamSpot__HLT.obj.position_.fCoordinates.fY", beam_y))
+        toget.append(("recoBeamSpot_offlineBeamSpot__HLT.obj.position_.fCoordinates.fZ", beam_z))
+
+        electron_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        electron_pt = numpy.ones(self.numElectrons, dtype=numpy.float64)
+        electron_eta = numpy.ones(self.numElectrons, dtype=numpy.float64)
+        electron_phi = numpy.ones(self.numElectrons, dtype=numpy.float64)
+        toget.append(("patElectrons_slimmedElectrons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patElectrons_slimmedElectrons__PAT.obj", electron_pt, electron_size))
+        toget.append(("patElectrons_slimmedElectrons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patElectrons_slimmedElectrons__PAT.obj", electron_eta, electron_size))
+        toget.append(("patElectrons_slimmedElectrons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patElectrons_slimmedElectrons__PAT.obj", electron_phi, electron_size))
+
+        muon_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        muon_pt = numpy.ones(self.numMuons, dtype=numpy.float64)
+        muon_eta = numpy.ones(self.numMuons, dtype=numpy.float64)
+        muon_phi = numpy.ones(self.numMuons, dtype=numpy.float64)
+        toget.append(("patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patMuons_slimmedMuons__PAT.obj", muon_pt, muon_size))
+        toget.append(("patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patMuons_slimmedMuons__PAT.obj", muon_eta, muon_size))
+        toget.append(("patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patMuons_slimmedMuons__PAT.obj", muon_phi, muon_size))
+
+        tau_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        tau_pt = numpy.ones(self.numTaus, dtype=numpy.float64)
+        tau_eta = numpy.ones(self.numTaus, dtype=numpy.float64)
+        tau_phi = numpy.ones(self.numTaus, dtype=numpy.float64)
+        toget.append(("patTaus_slimmedTaus__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patTaus_slimmedTaus__PAT.obj", tau_pt, tau_size))
+        toget.append(("patTaus_slimmedTaus__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patTaus_slimmedTaus__PAT.obj", tau_eta, tau_size))
+        toget.append(("patTaus_slimmedTaus__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patTaus_slimmedTaus__PAT.obj", tau_phi, tau_size))
+
+        photon_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        photon_pt = numpy.ones(self.numPhotons, dtype=numpy.float64)
+        photon_eta = numpy.ones(self.numPhotons, dtype=numpy.float64)
+        photon_phi = numpy.ones(self.numPhotons, dtype=numpy.float64)
+        toget.append(("patPhotons_slimmedPhotons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patPhotons_slimmedPhotons__PAT.obj", photon_pt, photon_size))
+        toget.append(("patPhotons_slimmedPhotons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patPhotons_slimmedPhotons__PAT.obj", photon_eta, photon_size))
+        toget.append(("patPhotons_slimmedPhotons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patPhotons_slimmedPhotons__PAT.obj", photon_phi, photon_size))
+
+        jet_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        jet_pt = numpy.ones(self.numJets, dtype=numpy.float64)
+        jet_eta = numpy.ones(self.numJets, dtype=numpy.float64)
+        jet_phi = numpy.ones(self.numJets, dtype=numpy.float64)
+        toget.append(("patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patJets_slimmedJets__PAT.obj", jet_pt, jet_size))
+        toget.append(("patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patJets_slimmedJets__PAT.obj", jet_eta, jet_size))
+        toget.append(("patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patJets_slimmedJets__PAT.obj", jet_phi, jet_size))
+
+        jetAK8_size = numpy.ones(self.numEvents, dtype=numpy.uint64)
+        jetAK8_pt = numpy.ones(self.numJetAK8s, dtype=numpy.float64)
+        jetAK8_eta = numpy.ones(self.numJetAK8s, dtype=numpy.float64)
+        jetAK8_phi = numpy.ones(self.numJetAK8s, dtype=numpy.float64)
+        toget.append(("patJets_slimmedJetsAK8__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "patJets_slimmedJetsAK8__PAT.obj", jetAK8_pt, jetAK8_size))
+        toget.append(("patJets_slimmedJetsAK8__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "patJets_slimmedJetsAK8__PAT.obj", jetAK8_eta, jetAK8_size))
+        toget.append(("patJets_slimmedJetsAK8__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "patJets_slimmedJetsAK8__PAT.obj", jetAK8_phi, jetAK8_size))
+
+        startTime = time.time()
+        fillarrays(self.fileName, self.treeName, toget)
+        endTime = time.time()
+
+        print("beam_x {}".format(beam_x))
+        print("beam_y {}".format(beam_y))
+        print("beam_z {}".format(beam_z))
+
+        print("electron_size {}".format(electron_size))
+        print("electron_pt {}".format(electron_pt))
+        print("electron_eta {}".format(electron_eta))
+        print("electron_phi {}".format(electron_phi))
+
+        print("muon_size {}".format(muon_size))
+        print("muon_pt {}".format(muon_pt))
+        print("muon_eta {}".format(muon_eta))
+        print("muon_phi {}".format(muon_phi))
+
+        print("tau_size {}".format(tau_size))
+        print("tau_pt {}".format(tau_pt))
+        print("tau_eta {}".format(tau_eta))
+        print("tau_phi {}".format(tau_phi))
+
+        print("photon_size {}".format(photon_size))
+        print("photon_pt {}".format(photon_pt))
+        print("photon_eta {}".format(photon_eta))
+        print("photon_phi {}".format(photon_phi))
+
+        print("jet_size {}".format(jet_size))
+        print("jet_pt {}".format(jet_pt))
+        print("jet_eta {}".format(jet_eta))
+        print("jet_phi {}".format(jet_phi))
+
+        print("jetAK8_size {}".format(jetAK8_size))
+        print("jetAK8_pt {}".format(jetAK8_pt))
+        print("jetAK8_eta {}".format(jetAK8_eta))
+        print("jetAK8_phi {}".format(jetAK8_phi))
+
+        totalMB = sum([len(beam_x), len(beam_y), len(beam_z), len(electron_size), len(electron_pt), len(electron_eta), len(electron_phi), len(muon_size), len(muon_pt), len(muon_eta), len(muon_phi), len(tau_size), len(tau_pt), len(tau_eta), len(tau_phi), len(photon_size), len(photon_pt), len(photon_eta), len(photon_phi), len(jet_size), len(jet_pt), len(jet_eta), len(jet_phi), len(jetAK8_size), len(jetAK8_pt), len(jetAK8_eta), len(jetAK8_phi)]) * 8.0 / 1024**2
+
+        print("{} MB in {} sec at {} MB/sec".format(totalMB, endTime - startTime, totalMB / (endTime - startTime)))
diff --git a/run/femtocode/run/cache.py b/run/femtocode/run/cache.py
index 9b196be..033d7dd 100644
--- a/run/femtocode/run/cache.py
+++ b/run/femtocode/run/cache.py
@@ -44,7 +44,7 @@ def __init__(self, address, totalBytes, dtype, allocate):
         self.rawarray = allocate(totalBytes)    # maybe use an alternative allocation method, maybe not
         self.needCount = 1
         self.lock = threading.Lock()            # CacheMaster and Minion both change needCount
-                                                # Fetcher sets filledBytes and CacheMaster checks it
+        self.fetchfailure = None                # Fetcher sets filledBytes and CacheMaster checks it
 
     def __repr__(self):
         return "<CacheOccupant for {0} at 0x{1:012x}>".format(self.address, id(self))
@@ -115,6 +115,16 @@ def add(self, occupant):
         self.order.append(occupant)
         self.lookup[occupant.address] = occupant
 
+    def discard(self, occupant):
+        try:
+            self.order.remove(occupant)
+        except ValueError:
+            pass
+        try:
+            del self.lookup[occupant.address]
+        except KeyError:
+            pass
+
     def extract(self, address):
         assert address in self.lookup
         occupant = None
@@ -157,7 +167,24 @@ def demoteNeedsToWants(self):
         for occupant in todemote:
             del self.need[occupant.address]
             self.want.add(occupant)
-            
+
+    def removeFailures(self):
+        toremove = []
+        for occupant in self.need.values():
+            with occupant.lock:
+                if occupant.fetchfailure is not None:
+                    toremove.append(occupant)
+        for occupant in toremove:
+            del self.need[occupant.address]
+
+        toremove = []
+        for occupant in self.want:
+            with occupant.lock:
+                if occupant.fetchfailure is not None:
+                    toremove.append(occupant)
+        for occupant in toremove:
+            self.want.discard(occupant)
+
     def howManyToEvict(self, workItem):
         required = workItem.required()
 
@@ -310,6 +337,11 @@ def run(self):
                     toremove.append(index)
                     self.outgoing.put(workItem)
                     workItem.executor.oneLoadDone(workItem.group.id)
+                else:
+                    fetchfailure = workItem.fetchfailure()
+                    if fetchfailure is not None:
+                        workItem.executor.oneFailure(fetchfailure)
+                        toremove.append(index)
             while len(toremove) > 0:
                 del self.loading[toremove.pop()]
 
diff --git a/run/femtocode/run/compute.py b/run/femtocode/run/compute.py
index 2f515c7..fb80d01 100644
--- a/run/femtocode/run/compute.py
+++ b/run/femtocode/run/compute.py
@@ -75,6 +75,14 @@ def ready(self):
         assert len(self.occupants) != 0
         return all(occupant.ready() for occupant in self.occupants)
 
+    def fetchfailure(self):
+        for occupant in self.occupants:
+            with occupant.lock:
+                fetchfailure = occupant.fetchfailure
+            if fetchfailure is not None:
+                return fetchfailure
+        return None
+
     def decrementNeed(self):
         assert len(self.occupants) != 0
         for occupant in self.occupants:
diff --git a/run/femtocode/run/standalone.py b/run/femtocode/run/standalone.py
index 18a0b03..2aca276 100644
--- a/run/femtocode/run/standalone.py
+++ b/run/femtocode/run/standalone.py
@@ -115,7 +115,7 @@ def source(self, name):
 
     def submit(self, query, ondone=None, onupdate=None, debug=False):
         # attach a more detailed Dataset to the query (same content, but with runtime details)
-        query.dataset = self.metadata.dataset(query.dataset.name, list(xrange(query.dataset.numGroups)), query.statements.columnNames(), False)
+        query.dataset = self.metadata.dataset(query.dataset.name, list(xrange(query.dataset.numGroups)), query.inputs.keys(), False)
 
         # create an executor with a reference to the FutureQueryResult we will return to the user
         query.lock = threading.Lock()
@@ -133,17 +133,23 @@ def submit(self, query, ondone=None, onupdate=None, debug=False):
     session = StandaloneSession()
     session.metadata.directory = "/home/pivarski/diana/femtocode/tests"
 
-    def callback(outputdataset):
-        print outputdataset, len(list(outputdataset))
+    # def callback(outputdataset):
+    #     print outputdataset, len(list(outputdataset))
 
-    from femtocode.lib.custom import *
-    custom = CustomLibrary()
-    custom.add(CustomFlatFunction("mysin", "math", "sin", lambda x: real))
+    # from femtocode.lib.custom import *
+    # custom = CustomLibrary()
+    # custom.add(CustomFlatFunction("mysin", "math", "sin", lambda x: real))
 
-    result = session.source("xy").define(z = "x + y").toPython(a = "z - 3", b = "z - 0.5", c = "mysin(x)").submit(libs=custom)
+    # result = session.source("xy").define(z = "x + y").toPython(a = "z - 3", b = "z - 0.5", c = "mysin(x)").submit(libs=custom)
 
-    complete = result.await()
-    print result.wallTime, result.computeTime
+    # complete = result.await()
+    # print result.wallTime, result.computeTime
 
-    for event in complete:
+    # for event in complete:
+    #     print event
+
+    pending = session.source("MuOnia").toPython(pt = "muons.map($1.pt)").submit(debug = True)
+    final = pending.await()
+    print pending.wallTime, pending.computeTime
+    for event in final:
         print event
diff --git a/tests/MuOnia.json b/tests/MuOnia.json
index d78bcb7..a534cf6 100644
--- a/tests/MuOnia.json
+++ b/tests/MuOnia.json
@@ -1 +1 @@
-{"groups": [{"files": ["/home/pivarski/storage/data/00000000-0000-0000-0000-000000000000.root"], "segments": {"jets[]-mass": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 806177}, "jets[]-pt": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 806177}, "muons[]-pt": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 132274}, "muons[]-eta": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 132274}, "jets[]-eta": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 806177}, "jets[]-phi": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 806177}, "muons[]-phi": {"files": null, "numEntries": 48131, "sizeLength": 48131, "dataLength": 132274}}, "numEntries": 48131, "id": 0}], "numEntries": 48131, "name": "MuOnia", "columns": {"jets[]-mass": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fM", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-mass", "size": "jets[]-mass@size"}, "jets[]-pt": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-pt", "size": "jets[]-pt@size"}, "muons[]-pt": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-pt", "size": "muons[]-pt@size"}, "muons[]-eta": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-eta", "size": "muons[]-eta@size"}, "jets[]-eta": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-eta", "size": "jets[]-eta@size"}, "jets[]-phi": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-phi", "size": "jets[]-phi@size"}, "muons[]-phi": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-phi", "size": "muons[]-phi@size"}}, "schema": {"jets": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "mass": {"max": {"almost": "inf"}, "type": "real", "min": 0}, "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}, "muons": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}}}
+{"name": "MuOnia", "numGroups": 1, "numEntries": 48131, "groups": [{"files": ["/home/pivarski/storage/data/00000000-0000-0000-0000-000000000000.root"], "segments": {"jets[]-mass": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "jets[]-pt": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "muons[]-pt": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}, "muons[]-eta": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}, "jets[]-eta": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "jets[]-phi": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 806177}, "muons[]-phi": {"files": null, "sizeLength": 48131, "numEntries": 48131, "dataLength": 132274}}, "numEntries": 48131, "id": 0}], "class": "femtocode.rootio.dataset.ROOTDataset", "columns": {"jets[]-mass": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fM", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-mass", "size": "jets[]@size"}, "jets[]-pt": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-pt", "size": "jets[]@size"}, "muons[]-pt": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPt", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-pt", "size": "muons[]@size"}, "muons[]-eta": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-eta", "size": "muons[]@size"}, "jets[]-eta": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fEta", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-eta", "size": "jets[]@size"}, "jets[]-phi": {"dataBranch": "patJets_slimmedJets__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patJets_slimmedJets__PAT.obj", "data": "jets[]-phi", "size": "jets[]@size"}, "muons[]-phi": {"dataBranch": "patMuons_slimmedMuons__PAT.obj.m_state.p4Polar_.fCoordinates.fPhi", "dataType": "float64", "tree": "Events", "sizeBranch": "patMuons_slimmedMuons__PAT.obj", "data": "muons[]-phi", "size": "muons[]@size"}}, "schema": {"jets": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "mass": {"max": {"almost": "inf"}, "type": "real", "min": 0}, "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}, "muons": {"items": {"fields": {"phi": {"max": 3.141592653589793, "type": "real", "min": -3.141592653589793}, "eta": "real", "pt": {"max": {"almost": "inf"}, "type": "real", "min": 0}}, "type": "record"}, "type": "collection"}}}