vector._methods module

vector._methods module#

class vector._methods.Azimuthal#

Bases: Coordinates

property elements: tuple[Any, Any]#

Azimuthal coordinates as a tuple.

Each coordinate may be a scalar, a NumPy array, an Awkward Array, etc., but they are not vectors.

class vector._methods.AzimuthalRhoPhi#

Bases: Azimuthal

rho#

The \(\rho\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

phi#

The \(\phi\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

phi: Any#

rho: Any#

class vector._methods.AzimuthalXY#

Bases: Azimuthal

x#

The \(x\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

y#

The \(y\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

x: Any#

y: Any#

class vector._methods.Coordinates#: Bases: object

class vector._methods.Longitudinal#

Bases: Coordinates

property elements: tuple[Any]#

Longitudinal coordinates as a tuple.

Each coordinate may be a scalar, a NumPy array, an Awkward Array, etc., but they are not vectors.

class vector._methods.LongitudinalEta#

Bases: Longitudinal

eta#

The \(\eta\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

eta: Any#

class vector._methods.LongitudinalTheta#

Bases: Longitudinal

theta#

The \(\theta\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

theta: Any#

class vector._methods.LongitudinalZ#

Bases: Longitudinal

z#

The \(z\) coordinate(s).

Type:: scalar, np.ndarray, ak.Array, etc.

z: Any#

class vector._methods.Lorentz#

Bases: Spatial, VectorProtocolLorentz

add(other: VectorProtocol) → VectorProtocol#

Sum of self and other.

This method is equivalent to the + operator.

property beta: Any#: The speed(s) of the Lorentz vector or array of vectors, in which lightlike vectors have beta == 1.

boost(booster: VectorProtocolSpatial | VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors using the 3D or 4D booster.

If booster is 3D, it is interpreted as a velocity (in which lightlike velocities have mag == 1) and vector._methods.VectorProtocolLorentz.boost_beta3() is called.

If booster is 4D, it is interpreted as a Lorentz vector and vector._methods.VectorProtocolLorentz.boost_p4() is called.

Note that v.boost(v) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost(-v), since that negates the time component of v as well.

To boost to the center-of-mass frame of a vector v, use vector._methods.VectorProtocolLorentz.boostCM_of(). For instance, v.boostCM_of(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of(booster: VectorProtocolSpatial | VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 3D or 4D booster.

If booster is 3D, it is interpreted as a velocity (in which lightlike velocities have mag == 1) and vector._methods.VectorProtocolLorentz.boostCM_of_beta3() is called.

If booster is 4D, it is interpreted as a Lorentz vector and vector._methods.VectorProtocolLorentz.boostCM_of_p4() is called.

Note that v.boostCM_of(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of_beta3(beta3: VectorProtocolSpatial) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 3D velocity or array of velocity vectors beta3.

Note that v.boostCM_of_beta3(v.to_beta3()) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostCM_of_p4(p4: VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors to the center-of-mass (CM) frame of the 4D vector or array of vectors p4.

This function is equivalent to but more numerically stable than

boostCM_of_beta3(p4.to_beta3())

Note that v.boostCM_of_p4(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boostX(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(x\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-x\) direction.

boostY(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(y\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-y\) direction.

boostZ(beta: Any | None = None, gamma: Any | None = None) → SameVectorType#

Boosts the vector or array of vectors in the \(z\) direction by a speed beta (in which lightlike boosts have beta == 1) or time dilation/length contraction factor gamma.

Either beta xor gamma must be specified, not both or neither.

If beta or gamma is negative, it is taken as a boost in the \(-z\) direction.

boost_beta3(beta3: VectorProtocolSpatial) → SameVectorType#

Boosts the vector or array of vectors in a direction and magnitude given by the 3D velocity or array of velocity vectors beta3.

Note that v.boost_beta3(v.to_beta3()) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost_beta3((-v).to_beta3()), since that negates the time component of v as well. On the other hand, v.boost_beta3(-(v.to_beta3())) would boost to the center-of-mass frame.

However, there’s a function for that: vector._methods.VectorProtocolLorentz.boostCM_of_beta3() is explicit about boosting to a center-of-mass (CM) frame and it handles the negative sign for you: v.boostCM_of_beta3(v.to_beta3()) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

boost_p4(p4: VectorProtocolLorentz) → SameVectorType#

Boosts the vector or array of vectors in a direction and magnitude given by the 4D vector or array of vectors p4.

This function is equivalent to but more numerically stable than

boost_beta3(p4.to_beta3())

where vector._methods.VectorProtocolLorentz.to_beta3() converts a 4D Lorentz vector into a 3D velocity (in which lightlike velocities have mag == 1).

Note that v.boost_p4(v) does not boost into the center-of-mass (CM) frame of v; it boosts away from its CM frame. Neither does v.boost_p4(-v), since that negates the time component of v as well.

To boost to the center-of-mass frame of a vector v, use vector._methods.VectorProtocolLorentz.boostCM_of_p4(). For instance, v.boostCM_of_p4(v) is guaranteed to have spatial components close to zero and a temporal component close to v.tau.

deltaRapidityPhi(other: VectorProtocolLorentz) → Any#

Sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and the difference in vector._methods.VectorProtocolLorentz.rapidity of the two vectors:

\[\Delta R_{\mbox{rapidity}} = \sqrt{\Delta\phi^2 + \Delta \mbox{rapidity}^2}\]

deltaRapidityPhi2(other: VectorProtocolLorentz) → Any#

Square of the sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and the difference in vector._methods.VectorProtocolLorentz.rapidity of the two vectors:

\[\Delta R_{\mbox{rapidity}} = \Delta\phi^2 + \Delta \mbox{rapidity}^2\]

dot(other: VectorProtocol) → Any#

Vector dot product of self with other.

This method is equivalent to the @ operator.

equal(other: VectorProtocol) → Any#

Returns True if self is exactly equal to other (possibly for arrays of vectors), False otherwise.

This method is equivalent to the == operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property gamma: Any#: The time dilation/length contraction factor(s) of the Lorentz vector or array of vectors: \(t/\tau\).

is_lightlike(tolerance: Any = 1e-05) → Any#

Returns True if the vector or a vector in the array is pointing in a lightlike direction, t**2 == mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

the default tolerance for vector._methods.VectorProtocolLorentz.is_timelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_spacelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_lightlike() is 1e-5

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

is_spacelike(tolerance: Any = 0) → Any#

Returns True if the vector or a vector in the array is pointing in a spacelike direction, t**2 < mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

the default tolerance for vector._methods.VectorProtocolLorentz.is_timelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_spacelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_lightlike() is 1e-5

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

is_timelike(tolerance: Any = 0) → Any#

Returns True if the vector or a vector in the array is pointing in a timelike direction, t**2 > mag**2, False otherwise.

The tolerance is in units of t and mag. Note that

the default tolerance for vector._methods.VectorProtocolLorentz.is_timelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_spacelike() is 0
the default tolerance for vector._methods.VectorProtocolLorentz.is_lightlike() is 1e-5

If you want to use these methods to divide space-time into non-overlapping regions (the light-cone), use the same tolerance for each.

isclose(other: VectorProtocol, rtol: Any = 1e-05, atol: Any = 1e-08, equal_nan: Any = False) → Any#

Returns True if self is approximately equal to other (possibly for arrays of vectors), False otherwise.

The relative tolerance (rtol) and absolute tolerance (atol) are interpreted as in np.isclose:

close_enough = abs(self - other) <= atol + rtol * abs(other)

property neg2D: SameVectorType#: Returns vector(s) with the 2D part negated, not affecting any longitudinal or temporal parts.

property neg3D: SameVectorType#: Returns vector(s) with the 3D part negated, not affecting any longitudinal or temporal parts.

property neg4D: SameVectorType#: Same as multiplying by -1.

not_equal(other: VectorProtocol) → Any#

Returns False if self is exactly equal to other (possibly for arrays of vectors), True otherwise.

This method is equivalent to the != operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property rapidity: Any#

The rapidity relative to the longitudinal axis of the Lorentz vector or array of vectors.

0.5 * log((t + z) / (t - z))

scale(factor: Any) → SameVectorType#

Returns vector(s) scaled by a factor, changing the length(s) but not the direction(s).

This method is equivalent to the * operator.

scale2D(factor: Any) → SameVectorType#: Returns vector(s) with the 2D part scaled by a factor, not affecting any longitudinal or temporal parts.

scale3D(factor: Any) → SameVectorType#: Returns vector(s) with the 3D part scaled by a factor, not affecting any longitudinal or temporal parts.

scale4D(factor: Any) → SameVectorType#: Same as scale.

subtract(other: VectorProtocol) → VectorProtocol#

Difference of self minus other.

This method is equivalent to the - operator.

property t: Any#

The Cartesian \(t\) (time) coordinate of the vector or every vector in the array.

If \(t\) is derived from \(\tau\), it is not allowed to be NaN.

t = sqrt(max(copysign(tau**2, tau) + mag**2, 0))

property t2: Any#

The Cartesian \(t\) (time) coordinate squared of the vector or every vector in the array.

If \(t^2\) is derived from \(\tau\), it is not allowed to be negative.

t2 = max(copysign(tau**2, tau) + mag**2, 0)

property tau: Any#

The Lorentz magnitude \(\tau\) (proper time) of the vector or every vector in the array.

If \(\tau\) is derived from \(t\), spacelike vectors are represented by negative proper times.

tau = copysign(sqrt(abs(t**2 - mag**2)), t**2 - mag**2)

property tau2: Any#

The Lorentz magnitude \(\tau\) (proper time) squared of the vector or every vector in the array.

tau2 = t**2 - mag**2

to_beta3() → VectorProtocolSpatial#: Converts the 4D Lorentz vector or array of vectors into a 3D velocity vector or array of vectors, in which lightlike velocities have mag == 1.

transform4D(obj: TransformProtocol4D) → SameVectorType#

Arbitrarily transforms the vector(s) by

obj["xx"] obj["xy"] obj["xz"] obj["xt"]
obj["yx"] obj["yy"] obj["yz"] obj["yt"]
obj["zx"] obj["zy"] obj["zz"] obj["zt"]
obj["tx"] obj["ty"] obj["tz"] obj["tt"]

There is no restriction on the type of obj; it just has to provide those components (which can be arrays if the vectors are in an array).

unit() → SameVectorType#: Returns vector(s) normalized to unit length, which is rho == 1 for 2D vectors, mag == 1 for 3D vectors, and tau == 1 for 4D vectors.

class vector._methods.LorentzMomentum#

Bases: SpatialMomentum, MomentumProtocolLorentz

property E: Any#: Momentum-synonyor vector._methods.VectorProtocolLorentz.t.

property E2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorent2.

property Et: Any#: Transverse energy of the four-momentum vector or array of vectors: \(E_T = E \sin\theta\).

property Et2: Any#: Transverse energy squared of the four-momentum vector or array of vectors: \(E_T^2 = E^2 \sin^2\theta\).

property M: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property M2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property Mt: Any#: Transverse mass of the four-momentum vector or array of vectors: \(M_T = \sqrt{t^2 - z^2}\).

property Mt2: Any#: Transverse mass squared of the four-momentum vector or array of vectors: \(M_T^2 = t^2 - z^2\).

property e: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

property e2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t2.

property energy: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

property energy2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t2.

property et: Any#: Transverse energy of the four-momentum vector or array of vectors: \(E_T = E \sin\theta\).

property et2: Any#: Transverse energy squared of the four-momentum vector or array of vectors: \(E_T^2 = E^2 \sin^2\theta\).

property m: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property m2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property mass: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property mass2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property mt: Any#: Transverse mass of the four-momentum vector or array of vectors: \(M_T = \sqrt{t^2 - z^2}\).

property mt2: Any#: Transverse mass squared of the four-momentum vector or array of vectors: \(M_T^2 = t^2 - z^2\).

property transverse_energy: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Et.

property transverse_energy2: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Et2.

property transverse_mass: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Mt.

property transverse_mass2: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Mt2.

class vector._methods.Momentum#: Bases: object

class vector._methods.MomentumProtocolLorentz#

Bases: VectorProtocolLorentz, MomentumProtocolSpatial

property E: Any#: Momentum-synonyor vector._methods.VectorProtocolLorentz.t.

property E2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorent2.

property Et: Any#: Transverse energy of the four-momentum vector or array of vectors: \(E_T = E \sin\theta\).

property Et2: Any#: Transverse energy squared of the four-momentum vector or array of vectors: \(E_T^2 = E^2 \sin^2\theta\).

property M: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property M2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property Mt: Any#: Transverse mass of the four-momentum vector or array of vectors: \(M_T = \sqrt{t^2 - z^2}\).

property Mt2: Any#: Transverse mass squared of the four-momentum vector or array of vectors: \(M_T^2 = t^2 - z^2\).

property e: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

property e2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t2.

property energy: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

property energy2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.t2.

property et: Any#: Transverse energy of the four-momentum vector or array of vectors: \(E_T = E \sin\theta\).

property et2: Any#: Transverse energy squared of the four-momentum vector or array of vectors: \(E_T^2 = E^2 \sin^2\theta\).

property m: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property m2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property mass: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property mass2: Any#: Momentum-synonym for vector._methods.VectorProtocolLorentz.tau2.

property mt: Any#: Transverse mass of the four-momentum vector or array of vectors: \(M_T = \sqrt{t^2 - z^2}\).

property mt2: Any#: Transverse mass squared of the four-momentum vector or array of vectors: \(M_T^2 = t^2 - z^2\).

property transverse_energy: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Et.

property transverse_energy2: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Et2.

property transverse_mass: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Mt.

property transverse_mass2: Any#: Synonym for vector._methods.MomentumProtocolLorentz.Mt2.

class vector._methods.MomentumProtocolPlanar#

Bases: VectorProtocolPlanar

property pt: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.rho.

property pt2: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.rho2.

property px: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.x.

property py: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.y.

class vector._methods.MomentumProtocolSpatial#

Bases: VectorProtocolSpatial, MomentumProtocolPlanar

property p: Any#: Momentum-synonym for vector._methods.VectorProtocolSpatial.mag.

property p2: Any#: Momentum-synonym for vector._methods.VectorProtocolSpatial.mag2.

property pseudorapidity: Any#: Momentum-synonym for vector._methods.VectorProtocolSpatial.eta.

property pz: Any#: Momentum-synonym for vector._methods.VectorProtocolSpatial.z.

class vector._methods.Planar#

Bases: VectorProtocolPlanar

add(other: VectorProtocol) → VectorProtocol#

Sum of self and other.

This method is equivalent to the + operator.

deltaphi(other: VectorProtocol) → Any#: Signed difference in \(\phi\) of self minus other (in radians).

dot(other: VectorProtocol) → Any#

Vector dot product of self with other.

This method is equivalent to the @ operator.

equal(other: VectorProtocol) → Any#

Returns True if self is exactly equal to other (possibly for arrays of vectors), False otherwise.

This method is equivalent to the == operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

is_antiparallel(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in opposite directions (i.e. dot product is nearly -abs(self) * abs(other)).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

is_parallel(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in the same direction (i.e. not “antiparallel”; dot product is nearly abs(self) * abs(other)).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

is_perpendicular(other: VectorProtocol, tolerance: Any = 1e-05) → Any#

Returns True if self and other are pointing in perpendicular directions (i.e. dot product is nearly 0).

The tolerance is measured in units of \(\cos(\Delta\alpha)\) where \(\Delta\alpha\) is self.deltaangle(other).

isclose(other: VectorProtocol, rtol: Any = 1e-05, atol: Any = 1e-08, equal_nan: Any = False) → Any#

Returns True if self is approximately equal to other (possibly for arrays of vectors), False otherwise.

The relative tolerance (rtol) and absolute tolerance (atol) are interpreted as in np.isclose:

close_enough = abs(self - other) <= atol + rtol * abs(other)

property neg2D: SameVectorType#: Returns vector(s) with the 2D part negated, not affecting any longitudinal or temporal parts.

not_equal(other: VectorProtocol) → Any#

Returns False if self is exactly equal to other (possibly for arrays of vectors), True otherwise.

This method is equivalent to the != operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property phi: Any#: The polar \(\phi\) coordinate of the vector or every vector in the array (in radians, always between \(-\pi\) and \(\pi\)).

property rho: Any#

The polar \(\rho\) coordinate of the vector or every vector in the array.

This is also the magnitude of the 2D azimuthal part of the vector (not including any longitudinal or temporal parts).

property rho2: Any#: The polar \(\rho\) coordinate squared of the vector or every vector in the array.

rotateZ(angle: Any) → SameVectorType#

Rotates the vector(s) by a given angle (in radians) around the longitudinal axis.

Note that the angle can be an array with the same length as the vectors, if the vectors are in an array.

scale(factor: Any) → SameVectorType#

Returns vector(s) scaled by a factor, changing the length(s) but not the direction(s).

This method is equivalent to the * operator.

scale2D(factor: Any) → SameVectorType#: Returns vector(s) with the 2D part scaled by a factor, not affecting any longitudinal or temporal parts.

subtract(other: VectorProtocol) → VectorProtocol#

Difference of self minus other.

This method is equivalent to the - operator.

transform2D(obj: TransformProtocol2D) → SameVectorType#

Arbitrarily transforms the vector(s) by

obj["xx"] obj["xy"]
obj["yx"] obj["yy"]

leaving any longitudinal or temporal coordinates unchanged. There is no restriction on the type of obj; it just has to provide those components (which can be arrays if the vectors are in an array).

unit() → SameVectorType#: Returns vector(s) normalized to unit length, which is rho == 1 for 2D vectors, mag == 1 for 3D vectors, and tau == 1 for 4D vectors.

property x: Any#: The Cartesian \(x\) coordinate of the vector or every vector in the array.

property y: Any#: The Cartesian \(y\) coordinate of the vector or every vector in the array.

class vector._methods.PlanarMomentum#

Bases: Momentum, MomentumProtocolPlanar

property pt: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.rho.

property pt2: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.rho2.

property px: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.x.

property py: Any#: Momentum-synonym for vector._methods.VectorProtocolPlanar.y.

class vector._methods.Spatial#

Bases: Planar, VectorProtocolSpatial

add(other: VectorProtocol) → VectorProtocol#

Sum of self and other.

This method is equivalent to the + operator.

property costheta: Any#: The \(\cos\theta\) coordinate of the vector or every vector in the array (has the same sign as \(z\)).

property cottheta: Any#: The \(\cot\theta\) coordinate of the vector or every vector in the array (has the same sign as \(z\)).

cross(other: VectorProtocolSpatial) → VectorProtocolSpatial#

The 3D cross-product of self with other.

Even if self or other is 4D, the resulting vector(s) is/are 3D.

deltaR(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and vector._methods.VectorProtocolSpatial.deltaeta():

\[\Delta R = \sqrt{\Delta\phi^2 + \Delta\eta^2}\]

deltaR2(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#

Square of the sum in quadrature of vector._methods.VectorProtocolPlanar.deltaphi() and vector._methods.VectorProtocolSpatial.deltaeta():

\[\Delta R^2 = \Delta\phi^2 + \Delta\eta^2\]

deltaangle(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#: Angle in 3D space between self and other, which is always positive, between \(0\) and \(\pi\).

deltaeta(other: VectorProtocolSpatial | VectorProtocolLorentz) → Any#: Signed difference in \(\eta\) of self minus other.

dot(other: VectorProtocol) → Any#

Vector dot product of self with other.

This method is equivalent to the @ operator.

equal(other: VectorProtocol) → Any#

Returns True if self is exactly equal to other (possibly for arrays of vectors), False otherwise.

This method is equivalent to the == operator.

Typically, you’ll want to check vector._methods.VectorProtocol.isclose() to allow for numerical errors.

property eta: Any#: The pseudorapidity \(\eta\) coordinate of the vector or every vector in the array (in radians, always between \(0\) (\(+z\)) and \(\pi\) (\(-z\))).