diff --git a/tests/test_vector.py b/tests/test_vector.py index 56cfd66..838de19 100644 --- a/tests/test_vector.py +++ b/tests/test_vector.py @@ -66,7 +66,7 @@ def test_vector2_array(self): self.assertEqual(a.tolist(), [TVector2(0, 0), TVector2(0, 1), TVector2(0, 2), TVector2(0, 3), TVector2(0, 4), TVector2(0, 5), TVector2(0, 6), TVector2(0, 7), TVector2(0, 8), TVector2(0, 9)]) self.assertEqual(a[5], TVector2(0, 5)) self.assertEqual(a.y.tolist(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) - self.assertEqual(a.mag2().tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) + self.assertEqual(a.mag2.tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) self.assertEqual((a + TVector2(1000, 2000))[5], TVector2(1000, 2005)) self.assertEqual((a + TVector2(1000, 2000) == TVector2Array(numpy.full(10, 1000), numpy.arange(2000, 2010))).tolist(), [True, True, True, True, True, True, True, True, True, True]) self.assertEqual((a**2).tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) @@ -110,7 +110,7 @@ def test_vector3_array(self): self.assertEqual(a.tolist(), [TVector3(0, 0, 0), TVector3(0, 1, 0), TVector3(0, 2, 0), TVector3(0, 3, 0), TVector3(0, 4, 0), TVector3(0, 5, 0), TVector3(0, 6, 0), TVector3(0, 7, 0), TVector3(0, 8, 0), TVector3(0, 9, 0)]) self.assertEqual(a[5], TVector3(0, 5, 0)) self.assertEqual(a.y.tolist(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) - self.assertEqual(a.mag2().tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) + self.assertEqual(a.mag2.tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) self.assertEqual((a + TVector3(1000, 2000, 0))[5], TVector3(1000, 2005, 0)) self.assertEqual((a + TVector3(1000, 2000, 0) == TVector3Array(numpy.full(10, 1000), numpy.arange(2000, 2010), numpy.zeros(10))).tolist(), [True, True, True, True, True, True, True, True, True, True]) self.assertEqual((a**2).tolist(), [0.0, 1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0]) @@ -154,7 +154,7 @@ def test_lorentzvector_array(self): self.assertEqual(a.tolist(), [TLorentzVector(0, 0, 0, 0), TLorentzVector(0, 1, 0, 0), TLorentzVector(0, 2, 0, 0), TLorentzVector(0, 3, 0, 0), TLorentzVector(0, 4, 0, 0), TLorentzVector(0, 5, 0, 0), TLorentzVector(0, 6, 0, 0), TLorentzVector(0, 7, 0, 0), TLorentzVector(0, 8, 0, 0), TLorentzVector(0, 9, 0, 0)]) self.assertEqual(a[5], TLorentzVector(0, 5, 0, 0)) self.assertEqual(a.y.tolist(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) - self.assertEqual(a.mag2().tolist(), [0.0, -1.0, -4.0, -9.0, -16.0, -25.0, -36.0, -49.0, -64.0, -81.0]) + self.assertEqual(a.mag2.tolist(), [0.0, -1.0, -4.0, -9.0, -16.0, -25.0, -36.0, -49.0, -64.0, -81.0]) self.assertEqual((a + TLorentzVector(1000, 2000, 0, 0))[5], TLorentzVector(1000, 2005, 0, 0)) self.assertEqual((a + TLorentzVector(1000, 2000, 0, 0) == TLorentzVectorArray(numpy.full(10, 1000), numpy.arange(2000, 2010), numpy.zeros(10), numpy.zeros(10))).tolist(), [True, True, True, True, True, True, True, True, True, True]) self.assertEqual((a**2).tolist(), [0.0, -1.0, -4.0, -9.0, -16.0, -25.0, -36.0, -49.0, -64.0, -81.0]) diff --git a/uproot_methods/classes/TLorentzVector.py b/uproot_methods/classes/TLorentzVector.py index 0260d07..05eb8f2 100644 --- a/uproot_methods/classes/TLorentzVector.py +++ b/uproot_methods/classes/TLorentzVector.py @@ -51,68 +51,84 @@ def dot(self, other): out = out - self.z*other.z return out + @property def energy(self): return self.t + @property def p(self): - return self.vect.mag() + return self.p3.mag + @property def p2(self): - return self.vect.mag2() + return self.p3.mag2 + @property def perp2(self): - return self.vect.rho2() + return self.p3.rho2 + @property def perp(self): - return self.vect.rho() + return self.p3.rho + @property def pt2(self): - return self.vect.rho2() + return self.p3.rho2 + @property def pt(self): - return self.vect.rho() + return self.p3.rho + @property def Et(self): - return self.energy() * self.pt() / self.p() + return self.energy * self.pt / self.p + @property def mag2(self): return self.dot(self) + @property def mass2(self): - return self.mag2() + return self.mag2 + @property def mass(self): - return self.mag() + return self.mag + @property def mt2(self): - return self.energy()**2 - self.z**2 + return self.energy**2 - self.z**2 + @property def phi(self): - return self.vect.phi() + return self.p3.phi + @property def theta(self): - return self.vect.theta() + return self.p3.theta + @property def cottheta(self): - return self.vect.cottheta() + return self.p3.cottheta + @property def beta(self): - return self.p() / self.energy() + return self.p / self.energy def delta_phi(self, other): - return (self.phi() - other.phi() + math.pi) % (2*math.pi) - math.pi + return (self.phi - other.phi + math.pi) % (2*math.pi) - math.pi def delta_r2(self, other): - return (self.eta() - other.eta())**2 + self.delta_phi(other)**2 + return (self.eta - other.eta)**2 + self.delta_phi(other)**2 def _rotate_axis(self, axis, angle): if not isinstance(axis, uproot_methods.classes.TVector3.Common): raise TypeError("axis must be an (array of) TVector3") - vect = self.vect._rotate_axis(axis, angle) - return vect, self.t + p3 = self.p3._rotate_axis(axis, angle) + return p3, self.t def _rotate_euler(self, phi, theta, psi): - return self.vect._rotate_euler(phi, theta, psi), self.t + return self.p3._rotate_euler(phi, theta, psi), self.t def rotatex(self, angle): return self.rotate_axis(TVector3(1.0, 0.0, 0.0), angle) @@ -124,10 +140,10 @@ def rotatez(self, angle): return self.rotate_axis(TVector3(0.0, 0.0, 1.0), angle) def isspacelike(self, tolerance=1e-10): - return self.mag2() < -tolerance + return self.mag2 < -tolerance def istimelike(self, tolerance=1e-10): - return self.mag2() > tolerance + return self.mag2 > tolerance def __lt__(self, other): raise TypeError("Lorentz vectors have no natural ordering") @@ -147,7 +163,7 @@ def _initObjectArray(self, table): self.content.rowname = "TLorentzVector" @property - def vect(self): + def p3(self): out = self.empty_like(generator=lambda row: uproot_methods.classes.TVector3.TVector3(row["fX"], row["fY"], row["fZ"])) if isinstance(self, awkward.JaggedArray): out.__class__ = type("JaggedArray", (awkward.JaggedArray, uproot_methods.classes.TVector3.ArrayMethods), {}) @@ -174,24 +190,30 @@ def z(self): def t(self): return self["fE"] + @property def mag(self): - return awkward.util.numpy.sqrt(self.mag2()) + return awkward.util.numpy.sqrt(self.mag2) + @property def mt(self): - mt2 = self.mt2() + mt2 = self.mt2 sign = awkward.util.numpy.sign(mt2) return awkward.util.numpy.sqrt(awkward.util.numpy.absolute(mt2)) * sign + @property def eta(self): - return -awkward.util.numpy.log((1.0 - awkward.util.numpy.cos(self.theta())) / (1.0 + awkward.util.numpy.cos(self.theta()))) / 2.0 + return -awkward.util.numpy.log((1.0 - awkward.util.numpy.cos(self.theta)) / (1.0 + awkward.util.numpy.cos(self.theta))) / 2.0 + @property def rapidity(self): return awkward.util.numpy.log((self.t + self.z) / (self.t - self.z)) / 2.0 + @property def unit(self): - return self / awkward.util.numpy.sqrt(self.mag()) + return self / awkward.util.numpy.sqrt(self.mag) - def boost_vector(self): + @property + def boostp3(self): out = self.empty_like(generator=lambda row: uproot_methods.classes.TVector3.TVector3(row["fX"], row["fY"], row["fZ"])) if isinstance(self, awkward.JaggedArray): out.__class__ = type("JaggedArray", (awkward.JaggedArray, uproot_methods.classes.TVector3.ArrayMethods), {}) @@ -202,19 +224,19 @@ def boost_vector(self): out["fZ"] = self.z / self.t return out - def boost(self, vect): - if not isinstance(vect, (uproot_methods.classes.TVector3.ArrayMethods, uproot_methods.classes.TVector3.Methods)): - raise TypeError("boost vect must be an (array of) TVector3") + def boost(self, p3): + if not isinstance(p3, (uproot_methods.classes.TVector3.ArrayMethods, uproot_methods.classes.TVector3.Methods)): + raise TypeError("boost p3 must be an (array of) TVector3") - b2 = vect.mag2() + b2 = p3.mag2 gamma = (1 - b2)**(-0.5) gamma2 = awkward.util.numpy.zeros(b2.shape, dtype=awkward.util.numpy.float64) mask = (b2 != 0) gamma2[mask] = (gamma[mask] - 1) / b2[mask] del mask - bp = self.vect.dot(vect) - v = self.vect + gamma2*bp*vect + gamma*vect*self.t + bp = self.p3.dot(p3) + v = self.p3 + gamma2*bp*p3 + gamma*p3*self.t out = self.empty_like() out["fX"] = v.x out["fY"] = v.y @@ -222,36 +244,37 @@ def boost(self, vect): out["fE"] = gamma*(self.t + bp) return out + @property def gamma(self): - out = self.beta() + out = self.beta mask = (out < 1) & (out > -1) out[mask] = (1 - out[mask]**2)**(-0.5) out[~mask] = awkward.util.numpy.inf return out - def delta_r(self): - return awkward.util.numpy.sqrt(self.delta_r2()) + def delta_r(self, other): + return awkward.util.numpy.sqrt(self.delta_r2(other)) def rotate_axis(self, axis, angle): - vect, t = self._rotate_axis(axis, angle) + p3, t = self._rotate_axis(axis, angle) out = self.empty_like() - out["fX"] = vect.x - out["fY"] = vect.y - out["fZ"] = vect.z + out["fX"] = p3.x + out["fY"] = p3.y + out["fZ"] = p3.z out["fE"] = t return out def rotate_euler(self, phi=0, theta=0, psi=0): - vect, t = self._rotate_euler(phi, theta, psi) + p3, t = self._rotate_euler(phi, theta, psi) out = self.empty_like() - out["fX"] = vect.x - out["fY"] = vect.y - out["fZ"] = vect.z + out["fX"] = p3.x + out["fY"] = p3.y + out["fZ"] = p3.z out["fE"] = t return out def islightlike(self, tolerance=1e-10): - return awkward.util.numpy.absolute(self.mag2()) < tolerance + return awkward.util.numpy.absolute(self.mag2) < tolerance def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): if method != "__call__": @@ -276,12 +299,12 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): elif ufunc is awkward.util.numpy.power and len(inputs) >= 2 and isinstance(inputs[1], (numbers.Number, awkward.util.numpy.number)): if inputs[1] == 2: - return self.mag2() + return self.mag2 else: - return self.mag2()**(0.5*inputs[1]) + return self.mag2**(0.5*inputs[1]) elif ufunc is awkward.util.numpy.absolute: - return self.mag() + return self.mag else: return awkward.ObjectArray.__array_ufunc__(self, ufunc, method, *inputs, **kwargs) @@ -290,7 +313,7 @@ class Methods(Common, uproot_methods.base.ROOTMethods): _arraymethods = ArrayMethods @property - def vect(self): + def p3(self): return self._fP @property @@ -337,63 +360,70 @@ def _vector(self, operator, vector, reverse=False): def _unary(self, operator): return TLorentzVector(operator(self.x), operator(self.y), operator(self.z), operator(self.t)) + @property def mag(self): - return math.sqrt(self.mag2()) + return math.sqrt(self.mag2) + @property def mt(self): - out = self.mt2() + out = self.mt2 if out >= 0: return math.sqrt(out) else: return -math.sqrt(out) + @property def eta(self): - return -math.log((1.0 - math.cos(self.theta())) / (1.0 + math.cos(self.theta())))/2.0 + return -math.log((1.0 - math.cos(self.theta)) / (1.0 + math.cos(self.theta)))/2.0 + @property def rapidity(self): return math.log((self.t + self.z) / (self.t - self.z)) / 2.0 + @property def unit(self): - return self / math.sqrt(self.mag()) + return self / math.sqrt(self.mag) - def boost_vector(self): + @property + def boostp3(self): return uproot_methods.classes.TVector3.TVector3(self.x/self.t, self.y/self.t, self.z/self.t) - def boost(self, vect): - if not isinstance(vect, uproot_methods.classes.TVector3.Methods): - raise TypeError("boost vect must be a TVector3") + def boost(self, p3): + if not isinstance(p3, uproot_methods.classes.TVector3.Methods): + raise TypeError("boost p3 must be a TVector3") - b2 = vect.mag2() + b2 = p3.mag2 gamma = (1.0 - b2)**(-0.5) if b2 != 0: gamma2 = (gamma - 1.0) / b2 else: gamma2 = 0.0 - bp = self.vect.dot(vect) - v = self.vect + gamma2*bp*vect + gamma*vect*self.t + bp = self.p3.dot(p3) + v = self.p3 + gamma2*bp*p3 + gamma*p3*self.t return self.__class__(v.x, v.y, v.z, gamma*(self.t + bp)) + @property def gamma(self): - out = self.beta() + out = self.beta if -1 < out < 1: return (1 - out**2)**(-0.5) else: return float("inf") - def delta_r(self): - return math.sqrt(self.delta_r2()) + def delta_r(self, other): + return math.sqrt(self.delta_r2(other)) def rotate_axis(self, axis, angle): - vect, t = self._rotate_axis(axis, angle) - return self.__class__(vect.x, vect.y, vect.z, t) + p3, t = self._rotate_axis(axis, angle) + return self.__class__(p3.x, p3.y, p3.z, t) def rotate_euler(self, phi=0, theta=0, psi=0): - vect, t = self._rotate_euler(phi, theta, psi) - return self.__class__(vect.x, vect.y, vect.z, t) + p3, t = self._rotate_euler(phi, theta, psi) + return self.__class__(p3.x, p3.y, p3.z, t) def islightlike(self, tolerance=1e-10): - return abs(self.mag2()) < tolerance + return abs(self.mag2) < tolerance def __add__(self, other): return self._vector(operator.add, other) @@ -446,9 +476,9 @@ def __rdivmod__(self, other): def __pow__(self, other): if isinstance(other, (numbers.Number, awkward.util.numpy.number)): if other == 2: - return self.mag2() + return self.mag2 else: - return self.mag2()**(0.5*other) + return self.mag2**(0.5*other) else: self._scalar(operator.pow, other) @@ -491,7 +521,7 @@ def __pos__(self): return self._unary(operator.pos) def __abs__(self): - return self.mag() + return self.mag def __invert__(self): return self._unary(operator.invert) @@ -518,21 +548,21 @@ def origin_like(cls, array): return cls.origin(array.shape, array.dtype) @classmethod - def from_vect(cls, vect, t): + def from_p3(cls, p3, t): out = cls.__new__(cls) - out["fX"] = vect.x - out["fY"] = vect.y - out["fZ"] = vect.z + out["fX"] = p3.x + out["fY"] = p3.y + out["fZ"] = p3.z out["fE"] = t return out @classmethod def from_spherical(cls, r, theta, phi, t): - return cls.from_vect(uproot_methods.classes.TVector3.TVector3Array.from_spherical(r, theta, phi), t) + return cls.from_p3(uproot_methods.classes.TVector3.TVector3Array.from_spherical(r, theta, phi), t) @classmethod def from_cylindrical(cls, rho, phi, z, t): - return cls.from_vect(uproot_methods.classes.TVector3.TVector3Array.from_cylindrical(rho, phi, z), t) + return cls.from_p3(uproot_methods.classes.TVector3.TVector3Array.from_cylindrical(rho, phi, z), t) @classmethod def from_xyzm(cls, x, y, z, m): @@ -550,8 +580,8 @@ def from_ptetaphim(cls, pt, eta, phi, mass): x = pt * awkward.util.numpy.cos(phi), y = pt * awkward.util.numpy.sin(phi), z = pt * awkward.util.numpy.sinh(eta) - vect = uproot_methods.classes.TVector3.TVector3Array(x, y, z) - return cls.from_vect(vect, awkward.util.numpy.sqrt(x*x + y*y + z*z + m*m*awkward.util.numpy.sign(m))) + p3 = uproot_methods.classes.TVector3.TVector3Array(x, y, z) + return cls.from_p3(p3, awkward.util.numpy.sqrt(x*x + y*y + z*z + m*m*awkward.util.numpy.sign(m))) @property def x(self): @@ -603,19 +633,19 @@ def origin(cls): return cls(0.0, 0.0, 0.0, 0.0) @classmethod - def from_vect(cls, vect, t): + def from_p3(cls, p3, t): out = cls.__new__(cls) - out._fP = vect + out._fP = p3 out._fE = t return out @classmethod def from_spherical(cls, r, theta, phi, t): - return cls.from_vect(uproot_methods.classes.TVector3.Methods.from_spherical(r, theta, phi), t) + return cls.from_p3(uproot_methods.classes.TVector3.Methods.from_spherical(r, theta, phi), t) @classmethod def from_cylindrical(cls, rho, phi, z, t): - return cls.from_vect(uproot_methods.classes.TVector3.Methods.from_cylindrical(rho, phi, z), t) + return cls.from_p3(uproot_methods.classes.TVector3.Methods.from_cylindrical(rho, phi, z), t) @classmethod def from_xyzm(cls, x, y, z, m): diff --git a/uproot_methods/classes/TVector2.py b/uproot_methods/classes/TVector2.py index 75ec5dc..6531c55 100644 --- a/uproot_methods/classes/TVector2.py +++ b/uproot_methods/classes/TVector2.py @@ -80,12 +80,12 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): elif ufunc is awkward.util.numpy.power and len(inputs) >= 2 and isinstance(inputs[1], (numbers.Number, awkward.util.numpy.number)): if inputs[1] == 2: - return self.mag2() + return self.mag2 else: - return self.mag2()**(0.5*inputs[1]) + return self.mag2**(0.5*inputs[1]) elif ufunc is awkward.util.numpy.absolute: - return self.mag() + return self.mag else: return awkward.ObjectArray.__array_ufunc__(self, ufunc, method, *inputs, **kwargs) diff --git a/uproot_methods/classes/TVector3.py b/uproot_methods/classes/TVector3.py index 9b2f414..1cdc93e 100644 --- a/uproot_methods/classes/TVector3.py +++ b/uproot_methods/classes/TVector3.py @@ -49,13 +49,14 @@ def _cross(self, other): self.z*other.x - self.x*other.z, self.x*other.y - self.y*other.x) + @property def cottheta(self): - out = self.rho() + out = self.rho out /= self.z return out def _rotate_axis(self, axis, angle): - u = axis.unit() + u = axis.unit c = awkward.util.numpy.cos(angle) s = awkward.util.numpy.sin(angle) c1 = 1 - c @@ -129,8 +130,9 @@ def cross(self, other): out["fZ"] = z return out + @property def theta(self): - return awkward.util.numpy.arctan2(self.rho(), self.z) + return awkward.util.numpy.arctan2(self.rho, self.z) def rotate_axis(self, axis, angle): x, y, z = self._rotate_axis(axis, angle) @@ -170,12 +172,12 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): elif ufunc is awkward.util.numpy.power and len(inputs) >= 2 and isinstance(inputs[1], (numbers.Number, awkward.util.numpy.number)): if inputs[1] == 2: - return self.mag2() + return self.mag2 else: - return self.mag2()**(0.5*inputs[1]) + return self.mag2**(0.5*inputs[1]) elif ufunc is awkward.util.numpy.absolute: - return self.mag() + return self.mag else: return awkward.ObjectArray.__array_ufunc__(self, ufunc, method, *inputs, **kwargs) @@ -227,8 +229,9 @@ def cross(self, other): x, y, z = self._cross(other) return self.TVector3(x, y, z) + @property def theta(self): - return math.atan2(self.rho(), self.z) + return math.atan2(self.rho, self.z) def rotate_axis(self, axis, angle): x, y, z = self._rotate_axis(axis, angle) diff --git a/uproot_methods/common/TVector.py b/uproot_methods/common/TVector.py index 84ed160..162335a 100644 --- a/uproot_methods/common/TVector.py +++ b/uproot_methods/common/TVector.py @@ -36,19 +36,22 @@ import awkward.util class Common(object): + @property def mag2(self): return self.dot(self) + @property def mag(self): - return awkward.util.numpy.sqrt(self.mag2()) + return awkward.util.numpy.sqrt(self.mag2) + @property def rho2(self): out = self.x*self.x out = out + self.y*self.y return out def delta_phi(self, other): - return (self.phi() - other.phi() + math.pi) % (2*math.pi) - math.pi + return (self.phi - other.phi + math.pi) % (2*math.pi) - math.pi def isparallel(self, other, tolerance=1e-10): return 1 - self.cosdelta(other) < tolerance @@ -72,18 +75,21 @@ def __ge__(self, other): raise TypeError("spatial vectors have no natural ordering") class ArrayMethods(Common): + @property def unit(self): - return self / self.mag() + return self / self.mag + @property def rho(self): - out = self.rho2() + out = self.rho2 return awkward.util.numpy.sqrt(out) + @property def phi(self): return awkward.util.numpy.arctan2(self.y, self.x) def cosdelta(self, other): - denom = self.mag2() * other.mag2() + denom = self.mag2 * other.mag2 mask = (denom > 0) denom = denom[mask] denom[:] = awkward.util.numpy.sqrt(denom) @@ -99,8 +105,8 @@ def cosdelta(self, other): def angle(self, other, normal=None, degrees=False): out = awkward.util.numpy.arccos(self.cosdelta(other)) if normal is not None: - a = self.unit() - b = other.unit() + a = self.unit + b = other.unit out = out * awkward.util.numpy.sign(normal.dot(a.cross(b))) if degrees: out = awkward.util.numpy.multiply(out, 180.0/awkward.util.numpy.pi) @@ -129,18 +135,21 @@ def isperpendicular(self, other, tolerance=1e-10): return out class Methods(Common): + @property def unit(self): - return self / self.mag() + return self / self.mag + @property def rho(self): - return math.sqrt(self.rho2()) + return math.sqrt(self.rho2) + @property def phi(self): return math.atan2(self.y, self.x) def cosdelta(self, other): - m1 = self.mag2() - m2 = other.mag2() + m1 = self.mag2 + m2 = other.mag2 if m1 == 0 or m2 == 0: return 1.0 r = self.dot(other) / math.sqrt(m1 * m2) @@ -211,9 +220,9 @@ def __rdivmod__(self, other): def __pow__(self, other): if isinstance(other, (numbers.Number, awkward.util.numpy.number)): if other == 2: - return self.mag2() + return self.mag2 else: - return self.mag2()**(0.5*other) + return self.mag2**(0.5*other) else: self._scalar(operator.pow, other) @@ -256,7 +265,7 @@ def __pos__(self): return self._unary(operator.pos) def __abs__(self): - return self.mag() + return self.mag def __invert__(self): return self._unary(operator.invert) diff --git a/uproot_methods/version.py b/uproot_methods/version.py index 6979236..464b2e4 100644 --- a/uproot_methods/version.py +++ b/uproot_methods/version.py @@ -30,7 +30,7 @@ import re -__version__ = "0.0.9" +__version__ = "0.1.0" version = __version__ version_info = tuple(re.split(r"[-\.]", __version__))