Making vector objects

A vector object represents a single vector, rather than an array of vectors. Lists of vector objects are slower to compute and have more memory overhead than arrays of vectors, unless those computations are performed in Numba-compiled functions.

To create a vector object, use the vector.obj function with appropriate arguments for 2D/3D/4D and geometric versus momentum.

General constructor

vector.obj(*, x: float, y: float) → VectorObject2D

vector.obj(*, x: float, py: float) → MomentumObject2D

vector.obj(*, px: float, y: float) → MomentumObject2D

vector.obj(*, px: float, py: float) → MomentumObject2D

vector.obj(*, rho: float, phi: float) → VectorObject2D

vector.obj(*, pt: float, phi: float) → MomentumObject2D

vector.obj(*, x: float, y: float, z: float) → VectorObject3D

vector.obj(*, x: float, y: float, pz: float) → MomentumObject3D

vector.obj(*, x: float, py: float, z: float) → MomentumObject3D

vector.obj(*, x: float, py: float, pz: float) → MomentumObject3D

vector.obj(*, px: float, y: float, z: float) → MomentumObject3D

vector.obj(*, px: float, y: float, pz: float) → MomentumObject3D

vector.obj(*, px: float, py: float, z: float) → MomentumObject3D

vector.obj(*, px: float, py: float, pz: float) → MomentumObject3D

vector.obj(*, rho: float, phi: float, z: float) → VectorObject3D

vector.obj(*, rho: float, phi: float, pz: float) → MomentumObject3D

vector.obj(*, pt: float, phi: float, z: float) → MomentumObject3D

vector.obj(*, pt: float, phi: float, pz: float) → MomentumObject3D

vector.obj(*, x: float, y: float, theta: float) → VectorObject3D

vector.obj(*, x: float, py: float, theta: float) → MomentumObject3D

vector.obj(*, px: float, y: float, theta: float) → MomentumObject3D

vector.obj(*, px: float, py: float, theta: float) → MomentumObject3D

vector.obj(*, rho: float, phi: float, theta: float) → VectorObject3D

vector.obj(*, pt: float, phi: float, theta: float) → MomentumObject3D

vector.obj(*, x: float, y: float, eta: float) → VectorObject3D

vector.obj(*, x: float, py: float, eta: float) → MomentumObject3D

vector.obj(*, px: float, y: float, eta: float) → MomentumObject3D

vector.obj(*, px: float, py: float, eta: float) → MomentumObject3D

vector.obj(*, rho: float, phi: float, eta: float) → VectorObject3D

vector.obj(*, pt: float, phi: float, eta: float) → MomentumObject3D

vector.obj(*, x: float, y: float, z: float, t: float) → VectorObject4D

vector.obj(*, x: float, y: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, t: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, t: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, t: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, t: float) → VectorObject4D

vector.obj(*, rho: float, phi: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, z: float, t: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, pz: float, t: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, t: float) → VectorObject4D

vector.obj(*, x: float, py: float, theta: float, t: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, t: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, t: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, t: float) → VectorObject4D

vector.obj(*, pt: float, phi: float, theta: float, t: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, t: float) → VectorObject4D

vector.obj(*, x: float, py: float, eta: float, t: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, t: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, t: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, t: float) → VectorObject4D

vector.obj(*, pt: float, phi: float, eta: float, t: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, tau: float) → VectorObject4D

vector.obj(*, x: float, y: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, tau: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, tau: float) → VectorObject4D

vector.obj(*, rho: float, phi: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, ptau: float, phi: float, z: float, tau: float) → MomentumObject4D

vector.obj(*, ptau: float, phi: float, pz: float, tau: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, tau: float) → VectorObject4D

vector.obj(*, x: float, py: float, theta: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, tau: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, tau: float) → VectorObject4D

vector.obj(*, ptau: float, phi: float, theta: float, tau: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, tau: float) → VectorObject4D

vector.obj(*, x: float, py: float, eta: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, tau: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, tau: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, tau: float) → VectorObject4D

vector.obj(*, ptau: float, phi: float, eta: float, tau: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, E: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, E: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, E: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, E: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, E: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, pE: float, phi: float, z: float, E: float) → MomentumObject4D

vector.obj(*, pE: float, phi: float, pz: float, E: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, pE: float, phi: float, theta: float, E: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, pE: float, phi: float, eta: float, E: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, e: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, e: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, e: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, e: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, e: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, pe: float, phi: float, z: float, e: float) → MomentumObject4D

vector.obj(*, pe: float, phi: float, pz: float, e: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, pe: float, phi: float, theta: float, e: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, pe: float, phi: float, eta: float, e: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, z: float, energy: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, pz: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, theta: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, eta: float, energy: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, M: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, M: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, M: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, M: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, M: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, pM: float, phi: float, z: float, M: float) → MomentumObject4D

vector.obj(*, pM: float, phi: float, pz: float, M: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, pM: float, phi: float, theta: float, M: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, pM: float, phi: float, eta: float, M: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, m: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, m: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, m: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, m: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, m: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, pm: float, phi: float, z: float, m: float) → MomentumObject4D

vector.obj(*, pm: float, phi: float, pz: float, m: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, pm: float, phi: float, theta: float, m: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, pm: float, phi: float, eta: float, m: float) → MomentumObject4D

vector.obj(*, x: float, y: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, y: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, py: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, py: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, y: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, y: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, py: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, py: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, z: float, mass: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, pz: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, y: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, py: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, y: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, py: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, pt: float, phi: float, theta: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, y: float, eta: float, mass: float) → MomentumObject4D

vector.obj(*, x: float, py: float, eta: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, y: float, eta: float, mass: float) → MomentumObject4D

vector.obj(*, px: float, py: float, eta: float, mass: float) → MomentumObject4D

vector.obj(*, rho: float, phi: float, eta: float, mass: float) → MomentumObject4D

vector.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.VectorObject2D, vector.VectorObject3D, and vector.VectorObject4D classes (with momentum subclasses) have explicit constructors:

• vector.VectorObject2D.from_xy()

• vector.VectorObject2D.from_rhophi()

• vector.VectorObject3D.from_xyz()

• vector.VectorObject3D.from_xytheta()

• vector.VectorObject3D.from_xyeta()

• vector.VectorObject3D.from_rhophiz()

• vector.VectorObject3D.from_rhophitheta()

• vector.VectorObject3D.from_rhophieta()

• vector.VectorObject4D.from_xyzt()

• vector.VectorObject4D.from_xyztau()

• vector.VectorObject4D.from_xythetat()

• vector.VectorObject4D.from_xythetatau()

• vector.VectorObject4D.from_xyetat()

• vector.VectorObject4D.from_xyetatau()

• vector.VectorObject4D.from_rhophizt()

• vector.VectorObject4D.from_rhophiztau()

• vector.VectorObject4D.from_rhophithetat()

• vector.VectorObject4D.from_rhophithetatau()

• vector.VectorObject4D.from_rhophietat()

• vector.VectorObject4D.from_rhophietatau()

2D constructors

class vector.VectorObject2D(*, x: float, y: float)

class vector.VectorObject2D(*, rho: float, phi: float)

class vector.VectorObject2D(*, x: float, y: float, z: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float)

class vector.VectorObject2D(*, px: float, py: float)

class vector.VectorObject2D(*, x: float, py: float)

class vector.VectorObject2D(*, px: float, y: float)

class vector.VectorObject2D(*, pt: float, phi: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float)

class vector.VectorObject2D(*, x: float, py: float, z: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float)

class vector.VectorObject2D(*, px: float, y: float, z: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float)

class vector.VectorObject2D(*, px: float, py: float, z: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float)

class vector.VectorObject2D(*, pt: float, phi: float, z: float)

class vector.VectorObject2D(*, pt: float, phi: float, pz: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float)

class vector.VectorObject2D(*, pt: float, phi: float, theta: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float)

class vector.VectorObject2D(*, pt: float, phi: float, eta: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, t: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, t: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, t: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, t: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, t: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, t: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, t: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, t: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorObject2D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorObject2D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, t: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, t: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, t: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, t: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorObject2D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, t: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, t: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, t: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, t: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorObject2D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, tau: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, tau: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, tau: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, tau: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorObject2D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorObject2D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorObject2D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorObject2D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, E: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, E: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, E: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, E: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, E: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, E: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, E: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, E: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorObject2D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorObject2D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, E: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, E: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, E: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, E: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorObject2D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, E: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, E: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, E: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, E: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorObject2D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, e: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, e: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, e: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, e: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, e: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, e: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, e: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, e: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorObject2D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorObject2D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, e: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, e: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, e: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, e: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorObject2D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, e: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, e: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, e: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, e: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorObject2D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, energy: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, energy: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, energy: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, energy: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorObject2D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorObject2D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorObject2D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorObject2D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, M: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, M: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, M: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, M: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, M: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, M: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, M: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, M: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorObject2D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorObject2D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, M: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, M: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, M: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, M: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorObject2D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, M: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, M: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, M: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, M: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorObject2D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, m: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, m: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, m: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, m: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, m: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, m: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, m: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, m: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorObject2D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorObject2D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, m: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, m: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, m: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, m: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorObject2D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, m: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, m: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, m: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, m: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorObject2D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorObject2D(*, x: float, y: float, z: float, mass: float)

class vector.VectorObject2D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorObject2D(*, x: float, py: float, z: float, mass: float)

class vector.VectorObject2D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorObject2D(*, px: float, y: float, z: float, mass: float)

class vector.VectorObject2D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorObject2D(*, px: float, py: float, z: float, mass: float)

class vector.VectorObject2D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorObject2D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorObject2D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorObject2D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorObject2D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorObject2D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorObject2D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorObject2D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorObject2D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorObject2D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorObject2D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorObject2D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorObject2D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorObject2D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorObject2D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorObject2D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorObject2D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorObject2D(__azimuthal: Azimuthal)

class vector.VectorObject2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorObject2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class vector.MomentumObject2D(__azimuthal: Azimuthal)

class vector.MomentumObject2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumObject2D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)

3D constructors

class vector.VectorObject3D(*, x: float, y: float)

class vector.VectorObject3D(*, rho: float, phi: float)

class vector.VectorObject3D(*, x: float, y: float, z: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float)

class vector.VectorObject3D(*, px: float, py: float)

class vector.VectorObject3D(*, x: float, py: float)

class vector.VectorObject3D(*, px: float, y: float)

class vector.VectorObject3D(*, pt: float, phi: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float)

class vector.VectorObject3D(*, x: float, py: float, z: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float)

class vector.VectorObject3D(*, px: float, y: float, z: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float)

class vector.VectorObject3D(*, px: float, py: float, z: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float)

class vector.VectorObject3D(*, pt: float, phi: float, z: float)

class vector.VectorObject3D(*, pt: float, phi: float, pz: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float)

class vector.VectorObject3D(*, pt: float, phi: float, theta: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float)

class vector.VectorObject3D(*, pt: float, phi: float, eta: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, t: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, t: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, t: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, t: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, t: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, t: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, t: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, t: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorObject3D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorObject3D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, t: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, t: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, t: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, t: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorObject3D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, t: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, t: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, t: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, t: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorObject3D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, tau: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, tau: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, tau: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, tau: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorObject3D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorObject3D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorObject3D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorObject3D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, E: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, E: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, E: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, E: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, E: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, E: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, E: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, E: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorObject3D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorObject3D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, E: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, E: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, E: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, E: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorObject3D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, E: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, E: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, E: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, E: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorObject3D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, e: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, e: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, e: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, e: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, e: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, e: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, e: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, e: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorObject3D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorObject3D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, e: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, e: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, e: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, e: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorObject3D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, e: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, e: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, e: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, e: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorObject3D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, energy: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, energy: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, energy: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, energy: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorObject3D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorObject3D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorObject3D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorObject3D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, M: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, M: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, M: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, M: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, M: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, M: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, M: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, M: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorObject3D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorObject3D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, M: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, M: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, M: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, M: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorObject3D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, M: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, M: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, M: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, M: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorObject3D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, m: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, m: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, m: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, m: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, m: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, m: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, m: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, m: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorObject3D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorObject3D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, m: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, m: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, m: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, m: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorObject3D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, m: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, m: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, m: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, m: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorObject3D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorObject3D(*, x: float, y: float, z: float, mass: float)

class vector.VectorObject3D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorObject3D(*, x: float, py: float, z: float, mass: float)

class vector.VectorObject3D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorObject3D(*, px: float, y: float, z: float, mass: float)

class vector.VectorObject3D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorObject3D(*, px: float, py: float, z: float, mass: float)

class vector.VectorObject3D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorObject3D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorObject3D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorObject3D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorObject3D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorObject3D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorObject3D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorObject3D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorObject3D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorObject3D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorObject3D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorObject3D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorObject3D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorObject3D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorObject3D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorObject3D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorObject3D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorObject3D(__azimuthal: Azimuthal)

class vector.VectorObject3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorObject3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class vector.MomentumObject3D(__azimuthal: Azimuthal)

class vector.MomentumObject3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumObject3D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)

4D constructors

class vector.VectorObject4D(*, x: float, y: float)

class vector.VectorObject4D(*, rho: float, phi: float)

class vector.VectorObject4D(*, x: float, y: float, z: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float)

class vector.VectorObject4D(*, px: float, py: float)

class vector.VectorObject4D(*, x: float, py: float)

class vector.VectorObject4D(*, px: float, y: float)

class vector.VectorObject4D(*, pt: float, phi: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float)

class vector.VectorObject4D(*, x: float, py: float, z: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float)

class vector.VectorObject4D(*, px: float, y: float, z: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float)

class vector.VectorObject4D(*, px: float, py: float, z: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float)

class vector.VectorObject4D(*, pt: float, phi: float, z: float)

class vector.VectorObject4D(*, pt: float, phi: float, pz: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float)

class vector.VectorObject4D(*, pt: float, phi: float, theta: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float)

class vector.VectorObject4D(*, pt: float, phi: float, eta: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, t: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, t: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, t: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, t: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, t: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, t: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, t: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, t: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, t: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, t: float)

class vector.VectorObject4D(*, pt: float, phi: float, z: float, t: float)

class vector.VectorObject4D(*, pt: float, phi: float, pz: float, t: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, t: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, t: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, t: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, t: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, t: float)

class vector.VectorObject4D(*, pt: float, phi: float, theta: float, t: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, t: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, t: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, t: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, t: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, t: float)

class vector.VectorObject4D(*, pt: float, phi: float, eta: float, t: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, tau: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, tau: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, tau: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, tau: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, tau: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, tau: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, tau: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, tau: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, tau: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, tau: float)

class vector.VectorObject4D(*, ptau: float, phi: float, z: float, tau: float)

class vector.VectorObject4D(*, ptau: float, phi: float, pz: float, tau: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, tau: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, tau: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, tau: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, tau: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, tau: float)

class vector.VectorObject4D(*, ptau: float, phi: float, theta: float, tau: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, tau: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, tau: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, tau: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, tau: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, tau: float)

class vector.VectorObject4D(*, ptau: float, phi: float, eta: float, tau: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, E: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, E: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, E: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, E: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, E: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, E: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, E: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, E: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, E: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, E: float)

class vector.VectorObject4D(*, pE: float, phi: float, z: float, E: float)

class vector.VectorObject4D(*, pE: float, phi: float, pz: float, E: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, E: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, E: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, E: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, E: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, E: float)

class vector.VectorObject4D(*, pE: float, phi: float, theta: float, E: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, E: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, E: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, E: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, E: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, E: float)

class vector.VectorObject4D(*, pE: float, phi: float, eta: float, E: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, e: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, e: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, e: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, e: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, e: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, e: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, e: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, e: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, e: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, e: float)

class vector.VectorObject4D(*, pe: float, phi: float, z: float, e: float)

class vector.VectorObject4D(*, pe: float, phi: float, pz: float, e: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, e: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, e: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, e: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, e: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, e: float)

class vector.VectorObject4D(*, pe: float, phi: float, theta: float, e: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, e: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, e: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, e: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, e: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, e: float)

class vector.VectorObject4D(*, pe: float, phi: float, eta: float, e: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, energy: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, energy: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, energy: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, energy: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, energy: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, energy: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, energy: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, energy: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, energy: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, energy: float)

class vector.VectorObject4D(*, pt: float, phi: float, z: float, energy: float)

class vector.VectorObject4D(*, pt: float, phi: float, pz: float, energy: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, energy: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, energy: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, energy: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, energy: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, energy: float)

class vector.VectorObject4D(*, pt: float, phi: float, theta: float, energy: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, energy: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, energy: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, energy: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, energy: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, energy: float)

class vector.VectorObject4D(*, pt: float, phi: float, eta: float, energy: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, M: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, M: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, M: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, M: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, M: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, M: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, M: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, M: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, M: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, M: float)

class vector.VectorObject4D(*, pM: float, phi: float, z: float, M: float)

class vector.VectorObject4D(*, pM: float, phi: float, pz: float, M: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, M: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, M: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, M: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, M: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, M: float)

class vector.VectorObject4D(*, pM: float, phi: float, theta: float, M: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, M: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, M: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, M: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, M: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, M: float)

class vector.VectorObject4D(*, pM: float, phi: float, eta: float, M: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, m: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, m: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, m: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, m: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, m: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, m: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, m: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, m: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, m: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, m: float)

class vector.VectorObject4D(*, pm: float, phi: float, z: float, m: float)

class vector.VectorObject4D(*, pm: float, phi: float, pz: float, m: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, m: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, m: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, m: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, m: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, m: float)

class vector.VectorObject4D(*, pm: float, phi: float, theta: float, m: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, m: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, m: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, m: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, m: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, m: float)

class vector.VectorObject4D(*, pm: float, phi: float, eta: float, m: float)

class vector.VectorObject4D(*, x: float, y: float, z: float, mass: float)

class vector.VectorObject4D(*, x: float, y: float, pz: float, mass: float)

class vector.VectorObject4D(*, x: float, py: float, z: float, mass: float)

class vector.VectorObject4D(*, x: float, py: float, pz: float, mass: float)

class vector.VectorObject4D(*, px: float, y: float, z: float, mass: float)

class vector.VectorObject4D(*, px: float, y: float, pz: float, mass: float)

class vector.VectorObject4D(*, px: float, py: float, z: float, mass: float)

class vector.VectorObject4D(*, px: float, py: float, pz: float, mass: float)

class vector.VectorObject4D(*, rho: float, phi: float, z: float, mass: float)

class vector.VectorObject4D(*, rho: float, phi: float, pz: float, mass: float)

class vector.VectorObject4D(*, pt: float, phi: float, z: float, mass: float)

class vector.VectorObject4D(*, pt: float, phi: float, pz: float, mass: float)

class vector.VectorObject4D(*, x: float, y: float, theta: float, mass: float)

class vector.VectorObject4D(*, x: float, py: float, theta: float, mass: float)

class vector.VectorObject4D(*, px: float, y: float, theta: float, mass: float)

class vector.VectorObject4D(*, px: float, py: float, theta: float, mass: float)

class vector.VectorObject4D(*, rho: float, phi: float, theta: float, mass: float)

class vector.VectorObject4D(*, pt: float, phi: float, theta: float, mass: float)

class vector.VectorObject4D(*, x: float, y: float, eta: float, mass: float)

class vector.VectorObject4D(*, x: float, py: float, eta: float, mass: float)

class vector.VectorObject4D(*, px: float, y: float, eta: float, mass: float)

class vector.VectorObject4D(*, px: float, py: float, eta: float, mass: float)

class vector.VectorObject4D(*, rho: float, phi: float, eta: float, mass: float)

class vector.VectorObject4D(*, pt: float, phi: float, eta: float, mass: float)

class vector.VectorObject4D(__azimuthal: Azimuthal)

class vector.VectorObject4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.VectorObject4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class vector.MomentumObject4D(__azimuthal: Azimuthal)

class vector.MomentumObject4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal)

class vector.MomentumObject4D(__azimuthal: Azimuthal, __longitudinal: Longitudinal, __temporal: Temporal)

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.

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)