vector.backends.object module

Defines behaviors for Object vectors. New vectors created with the respective classes

vector.VectorObject2D(...)
vector.VectorObject3D(...)

will have these behaviors built in (and will pass them to any derived objects).

The class methods can also be used to construct object type vectors -

vec = vector.VectorObject2D.from_xy(1, 2)

Additionally, object type vectors can also be constructed using -

vector.obj(...)

function.

class vector.backends.object.AzimuthalObject

Bases: CoordinatesObject, Azimuthal

Azimuthal class for the Object backend.

class vector.backends.object.AzimuthalObjectRhoPhi(rho: float, phi: float)

Bases: AzimuthalObject, AzimuthalRhoPhi, TupleRhoPhi

Class for the rho and phi (azimuthal) coordinates of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float, float]

Azimuthal coordinates (rho and phi) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.VectorObject2D(rho=1, phi=2)
>>> az = v.azimuthal
>>> az.elements
(1, 2)

class vector.backends.object.AzimuthalObjectXY(x: float, y: float)

Bases: AzimuthalObject, AzimuthalXY, TupleXY

Class for the x and y (azimuthal) coordinates of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float, float]

Azimuthal coordinates (x and y) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.VectorObject2D(x=1, y=2)
>>> az = v.azimuthal
>>> az.elements
(1, 2)

class vector.backends.object.CoordinatesObject

Bases: object

Coordinates class for the Object backend.

class vector.backends.object.LongitudinalObject

Bases: CoordinatesObject, Longitudinal

Longitudinal class for the Object backend.

class vector.backends.object.LongitudinalObjectEta(eta: float)

Bases: LongitudinalObject, LongitudinalEta, TupleEta

Class for the eta (longitudinal) coordinate of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float]

Longitudinal coordinates (theta) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.obj(rho=1, phi=2, eta=3)
>>> lc = v.longitudinal
>>> lc.elements
(3,)

class vector.backends.object.LongitudinalObjectTheta(theta: float)

Bases: LongitudinalObject, LongitudinalTheta, TupleTheta

Class for the theta (longitudinal) coordinate of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float]

Longitudinal coordinates (theta) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.obj(rho=1, phi=2, theta=3)
>>> lc = v.longitudinal
>>> lc.elements
(3,)

class vector.backends.object.LongitudinalObjectZ(z: float)

Bases: LongitudinalObject, LongitudinalZ, TupleZ

Class for the z (longitudinal) coordinate of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float]

Longitudinal coordinates (z) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.obj(rho=1, phi=2, z=3)
>>> lc = v.longitudinal
>>> lc.elements
(3,)

class vector.backends.object.MomentumObject2D(*, x: float, y: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, z: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, pz: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, theta: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, eta: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject2D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject2D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject2D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject2D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject2D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject2D(__azumthal: Azimuthal)

class vector.backends.object.MomentumObject2D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.MomentumObject2D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: PlanarMomentum, VectorObject2D

Two dimensional momentum vector class for the object backend.

Examples

>>> import vector
>>> vec = vector.MomentumObject2D(px=1, py=2)
>>> vec.px, vec.py
(1, 2)
>>> vec = vector.MomentumObject2D(pt=1, phi=2)
>>> vec.pt, vec.phi
(1, 2)
>>> vec = vector.MomentumObject2D(azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2))
>>> vec.px, vec.py
(1, 2)

The vector.obj() function can also be used to construct 2D momentum object type vectors.

For two dimensional vector objects, see vector.backends.object.VectorObject2D.

GenericClass

alias of VectorObject2D

MomentumClass

alias of MomentumObject2D

ProjectionClass2D

alias of MomentumObject2D

ProjectionClass3D

alias of MomentumObject3D

ProjectionClass4D

alias of MomentumObject4D

azimuthal: AzimuthalObject

property pt: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.rho.

property px: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.x.

property py: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.y.

class vector.backends.object.MomentumObject3D(*, x: float, y: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, z: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, pz: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, theta: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, eta: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject3D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject3D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject3D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject3D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject3D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject3D(__azumthal: Azimuthal)

class vector.backends.object.MomentumObject3D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.MomentumObject3D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: SpatialMomentum, VectorObject3D

Three dimensional momentum vector class for the object backend.

Examples

>>> import vector
>>> vec = vector.MomentumObject3D(px=1, py=2, pz=3)
>>> vec.px, vec.py, vec.pz
(1, 2, 3)
>>> vec = vector.MomentumObject3D(pt=1, phi=2, pz=3)
>>> vec.pt, vec.phi, vec.pz
(1, 2, 3)
>>> vec = vector.MomentumObject3D(
...     azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2),
...     longitudinal=vector.backends.object.LongitudinalObjectTheta(3)
... )
>>> vec.x, vec.y, vec.theta
(1, 2, 3)

The vector.obj() function can also be used to construct 3D momentum object type vectors.

For three dimensional vector objects, see vector.backends.object.VectorObject3D.

GenericClass

alias of VectorObject3D

MomentumClass

alias of MomentumObject3D

ProjectionClass2D

alias of MomentumObject2D

ProjectionClass3D

alias of MomentumObject3D

ProjectionClass4D

alias of MomentumObject4D

azimuthal: AzimuthalObject

longitudinal: LongitudinalObject

property pt: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.rho.

property px: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.x.

property py: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.y.

property pz: float

Momentum-synonym for vector._methods.VectorProtocolSpatial.z.

class vector.backends.object.MomentumObject4D(*, x: float, y: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, z: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, pz: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, theta: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, eta: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.MomentumObject4D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.MomentumObject4D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.MomentumObject4D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.MomentumObject4D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.MomentumObject4D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.MomentumObject4D(__azumthal: Azimuthal)

class vector.backends.object.MomentumObject4D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.MomentumObject4D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: LorentzMomentum, VectorObject4D

Four dimensional momentum vector class for the object backend.

Examples

>>> import vector
>>> vec = vector.MomentumObject4D(px=1, py=2, pz=3, t=4)
>>> vec.px, vec.py, vec.pz, vec.t
(1, 2, 3, 4)
>>> vec = vector.MomentumObject4D(pt=1, phi=2, pz=3, M=4)
>>> vec.pt, vec.phi, vec.pz, vec.M
(1, 2, 3, 4)
>>> vec = vector.MomentumObject4D(
...     azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2),
...     longitudinal=vector.backends.object.LongitudinalObjectTheta(3),
...     temporal=vector.backends.object.TemporalObjectTau(4)
... )
>>> vec.x, vec.y, vec.theta, vec.tau
(1, 2, 3, 4)

The vector.obj() function can also be used to construct 4D momentum object type vectors.

For four dimensional vector objects, see vector.backends.object.VectorObject4D.

property E: float

Momentum-synonyor vector._methods.VectorProtocolLorentz.t.

GenericClass

alias of VectorObject4D

property M: float

Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

MomentumClass

alias of MomentumObject4D

ProjectionClass2D

alias of MomentumObject2D

ProjectionClass3D

alias of MomentumObject3D

ProjectionClass4D

alias of MomentumObject4D

azimuthal: AzimuthalObject

property e: float

Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

property energy: float

Momentum-synonym for vector._methods.VectorProtocolLorentz.t.

longitudinal: LongitudinalObject

property m: float

Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property mass: float

Momentum-synonym for vector._methods.VectorProtocolLorentz.tau.

property pt: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.rho.

property px: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.x.

property py: float

Momentum-synonym for vector._methods.VectorProtocolPlanar.y.

property pz: float

Momentum-synonym for vector._methods.VectorProtocolSpatial.z.

temporal: TemporalObject

class vector.backends.object.TemporalObject

Bases: CoordinatesObject, Temporal

Temporal class for the Object backend.

class vector.backends.object.TemporalObjectT(t: float)

Bases: TemporalObject, TemporalT, TupleT

Class for the t (temporal) coordinate of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float]

Temporal coordinates (t) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.obj(rho=1, phi=2, theta=3, t=4)
>>> tc = v.temporal
>>> tc.elements
(4,)

class vector.backends.object.TemporalObjectTau(tau: float)

Bases: TemporalObject, TemporalTau, TupleTau

Class for the tau (temporal) coordinate of Object backend. Use the elements property to retrieve the coordinates.

property elements: tuple[float]

Temporal coordinates (tau) as a tuple. Each coordinate is a scalar and not a vector.

Examples

>>> import vector
>>> v = vector.obj(rho=1, phi=2, theta=3, tau=4)
>>> tc = v.temporal
>>> tc.elements
(4,)

class vector.backends.object.TupleEta(eta: float)

Bases: NamedTuple

eta coordinate as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('eta',)

classmethod _make(iterable)

Make a new TupleEta object from a sequence or iterable

_replace(**kwds)

Return a new TupleEta object replacing specified fields with new values

eta: float

Alias for field number 0

class vector.backends.object.TupleRhoPhi(rho: float, phi: float)

Bases: NamedTuple

rho and phi coordinates as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('rho', 'phi')

classmethod _make(iterable)

Make a new TupleRhoPhi object from a sequence or iterable

_replace(**kwds)

Return a new TupleRhoPhi object replacing specified fields with new values

phi: float

Alias for field number 1

rho: float

Alias for field number 0

class vector.backends.object.TupleT(t: float)

Bases: NamedTuple

t coordinate as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('t',)

classmethod _make(iterable)

Make a new TupleT object from a sequence or iterable

_replace(**kwds)

Return a new TupleT object replacing specified fields with new values

t: float

Alias for field number 0

class vector.backends.object.TupleTau(tau: float)

Bases: NamedTuple

tau coordinate as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('tau',)

classmethod _make(iterable)

Make a new TupleTau object from a sequence or iterable

_replace(**kwds)

Return a new TupleTau object replacing specified fields with new values

tau: float

Alias for field number 0

class vector.backends.object.TupleTheta(theta: float)

Bases: NamedTuple

theta coordinates as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('theta',)

classmethod _make(iterable)

Make a new TupleTheta object from a sequence or iterable

_replace(**kwds)

Return a new TupleTheta object replacing specified fields with new values

theta: float

Alias for field number 0

class vector.backends.object.TupleXY(x: float, y: float)

Bases: NamedTuple

x and y coordinates as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('x', 'y')

classmethod _make(iterable)

Make a new TupleXY object from a sequence or iterable

_replace(**kwds)

Return a new TupleXY object replacing specified fields with new values

x: float

Alias for field number 0

y: float

Alias for field number 1

class vector.backends.object.TupleZ(z: float)

Bases: NamedTuple

z coordinate as a NamedTuple.

_asdict()

Return a new dict which maps field names to their values.

_field_defaults = {}

_fields = ('z',)

classmethod _make(iterable)

Make a new TupleZ object from a sequence or iterable

_replace(**kwds)

Return a new TupleZ object replacing specified fields with new values

z: float

Alias for field number 0

class vector.backends.object.VectorObject(*, x: float, y: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float)

class vector.backends.object.VectorObject(*, px: float, py: float)

class vector.backends.object.VectorObject(*, x: float, py: float)

class vector.backends.object.VectorObject(*, px: float, y: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, z: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, pz: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, theta: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, eta: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject(__azumthal: Azimuthal)

class vector.backends.object.VectorObject(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.VectorObject(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: Vector

Mixin class for Object vectors.

lib = <module 'numpy' from '/home/docs/checkouts/readthedocs.org/user_builds/vector/envs/latest/lib/python3.12/site-packages/numpy/__init__.py'>

class vector.backends.object.VectorObject2D(*, x: float, y: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, z: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, pz: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, theta: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, eta: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject2D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject2D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject2D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject2D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject2D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject2D(__azumthal: Azimuthal)

class vector.backends.object.VectorObject2D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.VectorObject2D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: VectorObject, Planar, Vector2D

Two dimensional vector class for the object backend.

Examples

>>> import vector
>>> vec = vector.VectorObject2D(x=1, y=2)
>>> vec.x, vec.y
(1, 2)
>>> vec = vector.VectorObject2D(rho=1, phi=2)
>>> vec.rho, vec.phi
(1, 2)
>>> vec = vector.VectorObject2D(azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2))
>>> vec.x, vec.y
(1, 2)

The following class methods can also be used to construct 2D object type vectors -

• VectorObject2D.from_xy()

• VectorObject2D.from_rhophi()

Additionally, the vector.obj() function can also be used to construct 2D object type vectors.

For two dimensional momentum vector objects, see vector.backends.object.MomentumObject2D.

GenericClass

alias of VectorObject2D

MomentumClass

alias of MomentumObject2D

ProjectionClass2D

alias of VectorObject2D

ProjectionClass3D

alias of VectorObject3D

ProjectionClass4D

alias of VectorObject4D

_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any

Wraps the raw result of a compute function as a scalar or a vector.

Parameters:

• result – Value or tuple of values from a compute function.

• returns – Signature from a dispatch_map.

• num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

azimuthal: AzimuthalObject

classmethod from_rhophi(rho: float, phi: float) → VectorObject2D

Constructs a VectorObject2D from polar coordinates.

Use vector.backends.object.MomentumObject2D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject2D.from_rhophi(1, 2)
>>> vec
VectorObject2D(rho=1, phi=2)

classmethod from_xy(x: float, y: float) → VectorObject2D

Constructs a VectorObject2D from Cartesian coordinates.

Use vector.backends.object.MomentumObject2D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject2D.from_xy(1, 2)
>>> vec
VectorObject2D(x=1, y=2)

property phi: float

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

property rho: float

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 x: float

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

property y: float

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

class vector.backends.object.VectorObject3D(*, x: float, y: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, z: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, pz: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, theta: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, eta: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject3D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject3D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject3D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject3D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject3D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject3D(__azumthal: Azimuthal)

class vector.backends.object.VectorObject3D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.VectorObject3D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: VectorObject, Spatial, Vector3D

Three dimensional vector class for the object backend. Use the class methods -

Examples

>>> import vector
>>> vec = vector.VectorObject3D(x=1, y=2, z=3)
>>> vec.x, vec.y, vec.z
(1, 2, 3)
>>> vec = vector.VectorObject3D(rho=1, phi=2, eta=3)
>>> vec.rho, vec.phi, vec.eta
(1, 2, 3)
>>> vec = vector.VectorObject3D(
...     azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2),
...     longitudinal=vector.backends.object.LongitudinalObjectTheta(3)
... )
>>> vec.x, vec.y, vec.theta
(1, 2, 3)

The following class methods can also be used to construct 3D object type vectors -

• VectorObject3D.from_xyz()

• VectorObject3D.from_xytheta()

• VectorObject3D.from_xyeta()

• VectorObject3D.from_rhophiz()

• VectorObject3D.from_rhophitheta()

• VectorObject3D.from_rhophieta()

Additionally, the vector.obj() function can also be used to construct 3D object type vectors.

For three dimensional momentum vector objects, see vector.backends.object.MomentumObject3D.

GenericClass

alias of VectorObject3D

MomentumClass

alias of MomentumObject3D

ProjectionClass2D

alias of VectorObject2D

ProjectionClass3D

alias of VectorObject3D

ProjectionClass4D

alias of VectorObject4D

_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any

Wraps the raw result of a compute function as a scalar or a vector.

Parameters:

• result – Value or tuple of values from a compute function.

• returns – Signature from a dispatch_map.

• num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

azimuthal: AzimuthalObject

property eta: float

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

classmethod from_rhophieta(rho: float, phi: float, eta: float) → VectorObject3D

Constructs a VectorObject3D from polar azimuthal coordinates and a pseudorapidity \(\eta\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_rhophieta(1, 1, 1)
>>> vec
VectorObject3D(rho=1, phi=1, eta=1)

classmethod from_rhophitheta(rho: float, phi: float, theta: float) → VectorObject3D

Constructs a VectorObject3D from polar azimuthal coordinates and a polar angle \(\theta\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_rhophitheta(1, 1, 1)
>>> vec
VectorObject3D(rho=1, phi=1, theta=1)

classmethod from_rhophiz(rho: float, phi: float, z: float) → VectorObject3D

Constructs a VectorObject3D from polar azimuthal coordinates and a Cartesian longitudinal coordinate \(z\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_rhophiz(1, 1, 1)
>>> vec
VectorObject3D(rho=1, phi=1, z=1)

classmethod from_xyeta(x: float, y: float, eta: float) → VectorObject3D

Constructs a VectorObject3D from Cartesian coordinates and a pseudorapidity \(\eta\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_xyeta(1, 1, 1)
>>> vec
VectorObject3D(x=1, y=1, eta=1)

classmethod from_xytheta(x: float, y: float, theta: float) → VectorObject3D

Constructs a VectorObject3D from Cartesian azimuthal coordinates and a polar angle \(\theta\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_xytheta(1, 1, 1)
>>> vec
VectorObject3D(x=1, y=1, theta=1)

classmethod from_xyz(x: float, y: float, z: float) → VectorObject3D

Constructs a VectorObject3D from Cartesian coordinates.

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject3D.from_xyz(1, 1, 1)
>>> vec
VectorObject3D(x=1, y=1, z=1)

longitudinal: LongitudinalObject

property phi: float

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

property rho: float

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 theta: float

The spherical \(\theta\) coordinate (polar angle) of the vector or every vector in the array (in radians, always between \(0\) (\(+z\)) and \(\pi\) (\(-z\))).

property x: float

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

property y: float

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

property z: float

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

class vector.backends.object.VectorObject4D(*, x: float, y: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, z: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, pz: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, theta: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, eta: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, z: float, t: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, pz: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, theta: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, eta: float, t: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, ptau: float, phi: float, z: float, tau: float)

class vector.backends.object.VectorObject4D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, pE: float, phi: float, z: float, E: float)

class vector.backends.object.VectorObject4D(*, pE: float, phi: float, pz: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, pE: float, phi: float, theta: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, pE: float, phi: float, eta: float, E: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, pe: float, phi: float, z: float, e: float)

class vector.backends.object.VectorObject4D(*, pe: float, phi: float, pz: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, pe: float, phi: float, theta: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, pe: float, phi: float, eta: float, e: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, z: float, energy: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, pz: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, theta: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, eta: float, energy: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, pM: float, phi: float, z: float, M: float)

class vector.backends.object.VectorObject4D(*, pM: float, phi: float, pz: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, pM: float, phi: float, theta: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, pM: float, phi: float, eta: float, M: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, pm: float, phi: float, z: float, m: float)

class vector.backends.object.VectorObject4D(*, pm: float, phi: float, pz: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, pm: float, phi: float, theta: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, pm: float, phi: float, eta: float, m: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, z: float, mass: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, pz: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, theta: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(*, x: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, y: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(*, px: float, py: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(*, rho: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(*, pt: float, phi: float, eta: float, mass: float)

class vector.backends.object.VectorObject4D(__azumthal: Azimuthal)

class vector.backends.object.VectorObject4D(__azumthal: Azimuthal, __longitudinal: Longitudinal)

class vector.backends.object.VectorObject4D(__azumthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

Bases: VectorObject, Lorentz, Vector4D

Four dimensional vector class for the object backend. Use the class methods -

Examples

>>> import vector
>>> vec = vector.VectorObject4D(x=1, y=2, z=3, t=4)
>>> vec.x, vec.y, vec.z, vec.t
(1, 2, 3, 4)
>>> vec = vector.VectorObject4D(rho=1, phi=2, eta=3, tau=4)
>>> vec.rho, vec.phi, vec.eta, vec.tau
(1, 2, 3, 4)
>>> vec = vector.VectorObject4D(
...     azimuthal=vector.backends.object.AzimuthalObjectXY(1, 2),
...     longitudinal=vector.backends.object.LongitudinalObjectTheta(3),
...     temporal=vector.backends.object.TemporalObjectTau(4)
... )
>>> vec.x, vec.y, vec.theta, vec.tau
(1, 2, 3, 4)

The following class methods can also be used to construct 4D object type vectors -

• VectorObject4D.from_xyzt()

• VectorObject4D.from_xythetat()

• VectorObject4D.from_xyetat()

• VectorObject4D.from_rhophizt()

• VectorObject4D.from_rhophithetat()

• VectorObject4D.from_rhophietat()

• VectorObject4D.from_xyztau()

• VectorObject4D.from_xythetatau()

• VectorObject4D.from_xyetatau()

• VectorObject4D.from_rhophiztau()

• VectorObject4D.from_rhophithetatau()

• VectorObject4D.from_rhophietatau()

Additionally, the vector.obj() function can also be used to construct 4D object type vectors.

For four dimensional momentum vector objects, see vector.backends.object.MomentumObject4D.

GenericClass

alias of VectorObject4D

MomentumClass

alias of MomentumObject4D

ProjectionClass2D

alias of VectorObject2D

ProjectionClass3D

alias of VectorObject3D

ProjectionClass4D

alias of VectorObject4D

_wrap_result(cls: Any, result: Any, returns: Any, num_vecargs: Any) → Any

Wraps the raw result of a compute function as a scalar or a vector.

Parameters:

• result – Value or tuple of values from a compute function.

• returns – Signature from a dispatch_map.

• num_vecargs (int) – Number of vector arguments in the function that would be treated on an equal footing (i.e. add has two, but rotate_axis has only one: the axis is secondary).

azimuthal: AzimuthalObject

property eta: float

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

classmethod from_rhophietat(rho: float, phi: float, eta: float, t: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a pseudorapidity \(\eta\), and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophietat(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, eta=1, t=1)

classmethod from_rhophietatau(rho: float, phi: float, eta: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a pseudorapidity \(\eta\), and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophietatau(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, eta=1, tau=1)

classmethod from_rhophithetat(rho: float, phi: float, theta: float, t: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a polar angle \(\theta\), and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophithetat(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, theta=1, t=1)

classmethod from_rhophithetatau(rho: float, phi: float, theta: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a polar angle \(\theta\), and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophithetatau(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, theta=1, tau=1)

classmethod from_rhophizt(rho: float, phi: float, z: float, t: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a Cartesian longitudinal coordinate \(z\), and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophizt(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, z=1, t=1)

classmethod from_rhophiztau(rho: float, phi: float, z: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from polar azimuthal coordinates, a Cartesian longitudinal coordinate \(z\), and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_rhophiztau(1, 1, 1, 1)
>>> vec
VectorObject4D(rho=1, phi=1, z=1, tau=1)

classmethod from_xyetat(x: float, y: float, eta: float, t: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian coordinates, a pseudorapidity \(\eta\), and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xyetat(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, eta=1, t=1)

classmethod from_xyetatau(x: float, y: float, eta: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian coordinates, a pseudorapidity \(\eta\), and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xyetatau(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, eta=1, tau=1)

classmethod from_xythetat(x: float, y: float, theta: float, t: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian azimuthal coordinates, a polar angle \(\theta\), and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xythetat(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, theta=1, t=1)

classmethod from_xythetatau(x: float, y: float, theta: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian azimuthal coordinates, a polar angle \(\theta\), and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xythetatau(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, theta=1, tau=1)

classmethod from_xyzt(x: float, y: float, z: float, t: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian coordinates and a time coordinate \(t\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xyzt(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, z=1, t=1)

classmethod from_xyztau(x: float, y: float, z: float, tau: float) → VectorObject4D

Constructs a VectorObject3D from Cartesian coordinates and a proper time coordinate \(\tau\).

Use vector.backends.object.MomentumObject3D to construct a vector with momentum properties and methods.

Examples

>>> import vector
>>> vec = vector.VectorObject4D.from_xyztau(1, 1, 1, 1)
>>> vec
VectorObject4D(x=1, y=1, z=1, tau=1)

longitudinal: LongitudinalObject

property phi: float

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

property rho: float

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 t: float

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 tau: float

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)

temporal: TemporalObject

property theta: float

The spherical \(\theta\) coordinate (polar angle) of the vector or every vector in the array (in radians, always between \(0\) (\(+z\)) and \(\pi\) (\(-z\))).

property x: float

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

property y: float

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

property z: float

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

vector.backends.object._gather_coordinates(planar_class: type[VectorObject2D], spatial_class: type[VectorObject3D], lorentz_class: type[VectorObject4D], coordinates: dict[str, Any]) → Any

Helper function for vector.backends.object.obj().

Constructs and returns a 2D, 3D, or 4D VectorObject or MomentumObject with the provided coordinates (dictionary), planar (VectorObject2D or MomentumObject2D), spatial (VectorObject3D or MomentumObject3D), and lorentz (VectorObject4D or MomentumObject4D) classes.

vector.backends.object._is_type_safe(coordinates: dict[str, Any]) → bool

vector.backends.object._replace_data(obj: Any, result: Any) → Any

vector.backends.object.obj(*, x: float, y: float) → VectorObject2D

vector.backends.object.obj(*, x: float, py: float) → MomentumObject2D

vector.backends.object.obj(*, px: float, y: float) → MomentumObject2D

vector.backends.object.obj(*, px: float, py: float) → MomentumObject2D

vector.backends.object.obj(*, rho: float, phi: float) → VectorObject2D

vector.backends.object.obj(*, pt: float, phi: float) → MomentumObject2D

vector.backends.object.obj(*, x: float, y: float, z: float) → VectorObject3D

vector.backends.object.obj(*, x: float, y: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, x: float, py: float, z: float) → MomentumObject3D

vector.backends.object.obj(*, x: float, py: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, y: float, z: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, y: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, py: float, z: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, py: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, rho: float, phi: float, z: float) → VectorObject3D

vector.backends.object.obj(*, rho: float, phi: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, pt: float, phi: float, z: float) → MomentumObject3D

vector.backends.object.obj(*, pt: float, phi: float, pz: float) → MomentumObject3D

vector.backends.object.obj(*, x: float, y: float, theta: float) → VectorObject3D

vector.backends.object.obj(*, x: float, py: float, theta: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, y: float, theta: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, py: float, theta: float) → MomentumObject3D

vector.backends.object.obj(*, rho: float, phi: float, theta: float) → VectorObject3D

vector.backends.object.obj(*, pt: float, phi: float, theta: float) → MomentumObject3D

vector.backends.object.obj(*, x: float, y: float, eta: float) → VectorObject3D

vector.backends.object.obj(*, x: float, py: float, eta: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, y: float, eta: float) → MomentumObject3D

vector.backends.object.obj(*, px: float, py: float, eta: float) → MomentumObject3D

vector.backends.object.obj(*, rho: float, phi: float, eta: float) → VectorObject3D

vector.backends.object.obj(*, pt: float, phi: float, eta: float) → MomentumObject3D

vector.backends.object.obj(*, x: float, y: float, z: float, t: float) → VectorObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, t: float) → VectorObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, z: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, pz: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, t: float) → VectorObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, t: float) → VectorObject4D

vector.backends.object.obj(*, pt: float, phi: float, theta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, t: float) → VectorObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, t: float) → VectorObject4D

vector.backends.object.obj(*, pt: float, phi: float, eta: float, t: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, ptau: float, phi: float, z: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, ptau: float, phi: float, pz: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, ptau: float, phi: float, theta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, tau: float) → VectorObject4D

vector.backends.object.obj(*, ptau: float, phi: float, eta: float, tau: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, pE: float, phi: float, z: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, pE: float, phi: float, pz: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, pE: float, phi: float, theta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, pE: float, phi: float, eta: float, E: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, pe: float, phi: float, z: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, pe: float, phi: float, pz: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, pe: float, phi: float, theta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, pe: float, phi: float, eta: float, e: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, z: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, pz: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, theta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, eta: float, energy: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, pM: float, phi: float, z: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, pM: float, phi: float, pz: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, pM: float, phi: float, theta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, pM: float, phi: float, eta: float, M: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, pm: float, phi: float, z: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, pm: float, phi: float, pz: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, pm: float, phi: float, theta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, pm: float, phi: float, eta: float, m: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, z: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, pz: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, theta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, y: float, eta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, x: float, py: float, eta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, y: float, eta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, px: float, py: float, eta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, rho: float, phi: float, eta: float, mass: float) → MomentumObject4D

vector.backends.object.obj(*, pt: float, phi: float, eta: float, mass: float) → MomentumObject4D

Constructs a single Object type vector, whose type is determined by the keyword-only arguments to this function.

Allowed combinations are:

• (2D) x, y

• (2D) rho, phi

• (3D) x, y, z

• (3D) x, y, theta

• (3D) x, y, eta

• (3D) rho, phi, z

• (3D) rho, phi, theta

• (3D) rho, phi, eta

• (4D) x, y, z, t

• (4D) x, y, z, tau`

• (4D) x, y, theta, t`

• (4D) x, y, theta, tau`

• (4D) x, y, eta, t`

• (4D) x, y, eta, tau`

• (4D) rho, phi, z, t`

• (4D) rho, phi, z, tau`

• (4D) rho, phi, theta, t`

• (4D) rho, phi, theta, tau`

• (4D) rho, phi, eta, t`

• (4D) rho, phi, eta, tau`

in which

• px may be substituted for x

• py may be substituted for y

• pt may be substituted for rho

• pz may be substituted for z

• E may be substituted for t

• e may be substituted for t

• energy may be substituted for t

• M may be substituted for tau

• m may be substituted for tau

• mass may be substituted for tau

to make the vector a momentum vector.

Alternatively, the vector.backends.object.VectorObject2D, vector.backends.object.VectorObject3D, and vector.backends.object.VectorObject4D classes (with momentum subclasses) have explicit constructors:

• vector.backends.object.VectorObject2D.from_xy()

• vector.backends.object.VectorObject2D.from_rhophi()

• vector.backends.object.VectorObject3D.from_xyz()

• vector.backends.object.VectorObject3D.from_xytheta()

• vector.backends.object.VectorObject3D.from_xyeta()

• vector.backends.object.VectorObject3D.from_rhophiz()

• vector.backends.object.VectorObject3D.from_rhophitheta()

• vector.backends.object.VectorObject3D.from_rhophieta()

• vector.backends.object.VectorObject4D.from_xyzt()

• vector.backends.object.VectorObject4D.from_xyztau()

• vector.backends.object.VectorObject4D.from_xythetat()

• vector.backends.object.VectorObject4D.from_xythetatau()

• vector.backends.object.VectorObject4D.from_xyetat()

• vector.backends.object.VectorObject4D.from_xyetatau()

• vector.backends.object.VectorObject4D.from_rhophizt()

• vector.backends.object.VectorObject4D.from_rhophiztau()

• vector.backends.object.VectorObject4D.from_rhophithetat()

• vector.backends.object.VectorObject4D.from_rhophithetatau()

• vector.backends.object.VectorObject4D.from_rhophietat()

• vector.backends.object.VectorObject4D.from_rhophietatau()