rootloader 1.2.3__tar.gz → 1.2.4__tar.gz

{rootloader-1.2.3 → rootloader-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootloader
-Version: 1.2.3
+Version: 1.2.4
 Summary: Read simple root files into memory
 Project-URL: Homepage, https://github.com/ucn-triumf/rootloader
 Project-URL: Bug Tracker, https://github.com/ucn-triumf/rootloader/issues

{rootloader-1.2.3 → rootloader-1.2.4}/rootloader/ttree.py

@@ -11,6 +11,50 @@ import os
 import ROOT
 ROOT.EnableImplicitMT()
 
+# pre-compile stats functions to avoid memory creep during JIT compilations
+cpp_code = """
+Double_t RDF_min_d(ROOT::RDataFrame df, string col){
+    return df.Min<Double_t>(col).GetValue();
+}
+
+Double_t RDF_max_d(ROOT::RDataFrame df, string col){
+    return df.Max<Double_t>(col).GetValue();
+}
+
+Double_t RDF_mean_d(ROOT::RDataFrame df, string col){
+    return df.Mean<Double_t>(col).GetValue();
+}
+
+Double_t RDF_std_d(ROOT::RDataFrame df, string col){
+    return df.StdDev<Double_t>(col).GetValue();
+}
+
+Double_t RDF_sum_d(ROOT::RDataFrame df, string col){
+    return df.Sum<Double_t>(col).GetValue();
+}
+
+Int_t RDF_min_i(ROOT::RDataFrame df, string col){
+    return df.Min<Int_t>(col).GetValue();
+}
+
+Int_t RDF_max_i(ROOT::RDataFrame df, string col){
+    return df.Max<Int_t>(col).GetValue();
+}
+
+Int_t RDF_mean_i(ROOT::RDataFrame df, string col){
+    return df.Mean<Int_t>(col).GetValue();
+}
+
+Int_t RDF_std_i(ROOT::RDataFrame df, string col){
+    return df.StdDev<Int_t>(col).GetValue();
+}
+
+Int_t RDF_sum_i(ROOT::RDataFrame df, string col){
+    return df.Sum<Int_t>(col).GetValue();
+}
+"""
+ROOT.gInterpreter.Declare(cpp_code)
+
 class ttree(object):
     """Extract ROOT.TTree with lazy operation. Looks like a dataframe in most ways
 
@@ -63,9 +107,6 @@ class ttree(object):
         for filt in self._filters:
             self._rdf = self._rdf.Filter(filt, filt)
 
-        # track stats
-        self._stats = {}
-
     def __dir__(self):
         superdir = [d for d in super().__dir__() if d[0] != '_']
         return sorted(self._columns) + superdir
@@ -86,7 +127,6 @@ class ttree(object):
         h._columns = self._columns
         h._index = self._index
         h._filters = self._filters
-        h._stats = self._stats
         h.name = self.name
 
         # get list of keys
@@ -271,7 +311,6 @@ class ttree(object):
         if inplace:
             self._rdf = self._rdf.Filter(expression, expression)
             self._filters.append(expression)
-            self._stats = {}
         else:
             new = ttree(self)
             new.set_filter(expression, inplace=True)
@@ -335,44 +374,28 @@ class ttree(object):
         return _ttree_indexed(self)
     @property
     def size(self):
-        try:
-            return self._stats['size']
-        except KeyError:
-            self._stats['size'] = self._rdf.Count().GetValue()
-            return self.size
+        return self._rdf.Count().GetValue()
 
     # STATS ================================
-    def _get_stats(self, col):
-        try:
-            return self._stats[col]
-        except KeyError:
-            self._stats[col] = self._rdf.Stats(col).GetValue()
-            return self._stats[col]
-
-    def min(self):
-        vals = [self._get_stats(col).GetMin() for col in self._columns]
-        if len(vals) == 1:  return vals[0]
+    def _getstat(self, fnname):
+
+        double_fn = getattr(ROOT, f'RDF_{fnname}_d')
+        int_fn = getattr(ROOT, f'RDF_{fnname}_i')
+
+        vals = []
+        for col in self._columns:
+            dtype = self._rdf.GetColumnType(col)
+            if dtype == 'Double_t':
+                vals.append(double_fn(self._rdf, col))
+            elif dtype == 'Int_t':
+                vals.append(int_fn(self._rdf, col))
         return pd.Series(vals, index=self._columns)
 
-    def max(self):
-        vals = [self._get_stats(col).GetMax() for col in self._columns]
-        if len(vals) == 1:  return vals[0]
-        return pd.Series(vals, index=self._columns)
-
-    def mean(self):
-        vals = [self._get_stats(col).GetMean() for col in self._columns]
-        if len(vals) == 1:  return vals[0]
-        return pd.Series(vals, index=self._columns)
-
-    def rms(self):
-        vals = [self._get_stats(col).GetRMS() for col in self._columns]
-        if len(vals) == 1:  return vals[0]
-        return pd.Series(vals, index=self._columns)
-
-    def std(self):
-        vals = [self._rdf.StdDev(col).GetValue() for col in self._columns]
-        if len(vals) == 1:  return vals[0]
-        return pd.Series(vals, index=self._columns)
+    def min(self):  return self._getstat('min')
+    def max(self):  return self._getstat('max')
+    def mean(self): return self._getstat('mean')
+    def sum(self):  return self._getstat('sum')
+    def std(self):  return self._getstat('std')
 
 # ttree but slice on time
 class _ttree_indexed(object):

rootloader-1.2.4/rootloader/version.py

@@ -0,0 +1 @@
+__version__ = '1.2.4'

rootloader-1.2.3/rootloader/version.py

@@ -1 +0,0 @@
-__version__ = '1.2.3'