#include "TFourVectorComplex.h"

TFourVectorComplex

class description - header file - source file

class TFourVectorComplex: public TThreeVectorComplex

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
public:
TFourVectorComplex()
TFourVectorComplex(const Float_t* array)
TFourVectorComplex(const Double_t* array)
TFourVectorComplex(const Complex_t* array)
TFourVectorComplex(const TFourVectorComplex& another)
TFourVectorComplex(const TFourVectorReal& another)
TFourVectorComplex(const Complex_t& t, const TThreeVectorComplex& another)
TFourVectorComplex(const Complex_t& t, const Complex_t& x, const Complex_t& y, const Complex_t& z)
virtual~TFourVectorComplex()
TFourVectorComplex&Boost(const TLorentzBoost& boostOp)
TFourVectorComplex&Boost(const TUnitVector& bhat, const Double_t beta)
TFourVectorComplex&Boost(const Double_t betaX, const Double_t betaY, const Double_t betaZ)
static TClass*Class()
TFourVectorComplex&Conj()
TThreeVectorComplex&TThreeVectorComplex::Cross(const TThreeVectorComplex& other)
TThreeVectorComplex&TThreeVectorComplex::Cross(const TThreeVectorComplex& va, const TThreeVectorComplex& vb)
Double_tDistanceTo(const Float_t* array) const
Double_tDistanceTo(const Double_t* array) const
Double_tDistanceTo(const Complex_t* array) const
Double_tDistanceTo(const TFourVectorComplex& vec2) const
Double_tDistanceTo(const Complex_t t, const Complex_t x, const Complex_t y, const Complex_t z) const
Complex_tTThreeVectorComplex::Dot(const TThreeVectorComplex& other)
voidTThreeVectorComplex::GetCartesian(Complex_t* array) const
voidTThreeVectorComplex::GetCartesian(Complex_t& x, Complex_t& y, Complex_t& z) const
voidGetCoord(Complex_t* array) const
voidGetCoord(Complex_t& t, Complex_t& x, Complex_t& y, Complex_t& z) const
TFourVectorRealImagPart() const
Double_tInvariant() const
Double_tInvariantSqr() const
virtual TClass*IsA() const
Double_tTThreeVectorComplex::Length() const
Double_tTThreeVectorComplex::LengthSqr() const
TThreeVectorComplex&TThreeVectorComplex::Normalize(const Double_t length)
Bool_toperator!=(const TFourVectorComplex& other) const
TFourVectorComplex&operator*=(const Complex_t& factor)
TFourVectorComplex&operator+=(const TFourVectorReal& source)
TFourVectorComplex&operator+=(const TFourVectorComplex& source)
TFourVectorComplex&operator+=(const Float_t* array)
TFourVectorComplex&operator+=(const Double_t* array)
TFourVectorComplex&operator+=(const Complex_t* array)
TFourVectorComplexoperator-() const
TFourVectorComplex&operator-=(const TFourVectorReal& source)
TFourVectorComplex&operator-=(const TFourVectorComplex& source)
TFourVectorComplex&operator-=(const Float_t* array)
TFourVectorComplex&operator-=(const Double_t* array)
TFourVectorComplex&operator-=(const Complex_t* array)
TFourVectorComplex&operator/=(const Complex_t& factor)
TFourVectorComplex&operator=(const TFourVectorReal& source)
TFourVectorComplex&operator=(const TFourVectorComplex& source)
TFourVectorComplex&operator=(const Float_t* array)
TFourVectorComplex&operator=(const Double_t* array)
TFourVectorComplex&operator=(const Complex_t* array)
Bool_toperator==(const TFourVectorComplex& other) const
Complex_t&operator[](const Int_t index) const
voidPrint(Option_t* option = "")
TFourVectorRealRealPart() const
Double_tResolution() const
TThreeVectorComplex&TThreeVectorComplex::Rotate(const TThreeRotation& rotOp)
TThreeVectorComplex&TThreeVectorComplex::Rotate(const TUnitVector& ahat, const Double_t angle)
TThreeVectorComplex&TThreeVectorComplex::Rotate(const Double_t phi, const Double_t theta, const Double_t psi)
Complex_tScalarProd(const TFourVectorComplex& other)
Complex_tScalarProd(const TFourVectorComplex& v1, const TFourVectorComplex& v2)
static voidTThreeVectorComplex::SetResolution(const Double_t resolution)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
TThreeVectorComplex&TThreeVectorComplex::SpaceInv()
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
TFourVectorComplex&Transform(const TLorentzTransform& xformOp)
TFourVectorComplex&Zero()

Data Members

protected:
Complex_tTThreeVectorComplex::fVector[4]Complex vector allocated on stack
static Double_tTThreeVectorComplex::fResolutionvector resolving "distance"

Class Description

									
 Lorentz Algebra Package						
									
 The present package implements all the basic algorithms dealing	
 with three-vectors and four-vectors, together with their transform-	
 ations.  Four-vectors are derived from three-vectors and inherit	
 all of their members.  Direct access to the components is provided	
 through the subscript operator [i] which covers the range 1...3 for	
 three-vectors and 0...3 for four-vectors.  Transformations are	
 implemented as a friend class so that they can operate directly on	
 the data members of the vector, which are otherwise hidden.  The	
 special transformations (rotations and boosts) inherit from the	
 general class LorentzTransform.  Products of rotations are other	
 rotations, whereas the product of a boost with anything is simply	
 a LorentzTransform.  The LorentzTransform objects can be tested	
 for the property of being a pure rotation or boost.  They can also	
 implement non-isochronous and improper transformations.		
									
 Rotations may be specified either by Euler angles or by a rotation	
 axis.  All angles are assumed to be in radians.  Vector classes are	
 defined for both Real_t and Complex_t generic types.  For complex	
 vectors there are several additional member functions to deal with	
 operations that are specific to complex numbers.			
									
 The classes comprising this package are:				
   TThreeVectorReal is a base class                   		
   TThreeVectorComplex is a base class				
   TFourVectorReal is a TThreeVectorReal				
   TFourVectorComplex is a TThreeVectorComplex			
   TLorentzTransform is a base class					
   TThreeRotation is a TLorentzTransform				
   TLorentzBoost is a TLorentzTransform				
 The following aliases are defined for these classes:			
   TUnitVector is an alias for TThreeVectorReal			
   TThreeVector is an alias for TThreeVectorReal			
   TFourVector is an alias for TFourVectorReal			
									
 This package was developed at the University of Connecticut by	
 Richard T. Jones
TFourVectorComplex & Boost(const Double_t betaX, const Double_t betaY, const Double_t betaZ)
void Streamer(TBuffer &buf)
 Put/get a complex four-vector to/from stream buffer buf.
 This method assumes that complex is stored in memory as double[2].
void Print(Option_t *option)
 Output an ascii representation for complex four-vector.
TFourVectorComplex(const Float_t *array)
TFourVectorComplex(const Double_t *array)
TFourVectorComplex(const Complex_t *array)
TFourVectorComplex(const TFourVectorComplex &another)
TFourVectorComplex(const TFourVectorReal &another)
Double_t Resolution()
Complex_t & operator[](const Int_t index)
Double_t Invariant()
Double_t InvariantSqr()
TFourVectorReal RealPart()
TFourVectorReal ImagPart()
void GetCoord(Complex_t *array)
Double_t DistanceTo(const Float_t *array)
Double_t DistanceTo(const Double_t *array)
Double_t DistanceTo(const Complex_t *array)
TFourVectorComplex & operator=(const Float_t *array)
TFourVectorComplex & operator=(const Double_t *array)
TFourVectorComplex & operator=(const Complex_t *array)
TFourVectorComplex & operator+=(const Float_t *array)
TFourVectorComplex & operator+=(const Double_t *array)
TFourVectorComplex & operator+=(const Complex_t *array)
TFourVectorComplex & Zero()
TFourVectorComplex & Conj()
TFourVectorComplex operator-()
TFourVectorComplex()
{ }
TFourVectorComplex(const Complex_t &t, const Complex_t &x, const Complex_t &y, const Complex_t &z)
TFourVectorComplex(const Double_t *array)
virtual ~TFourVectorComplex()
{ }
void GetCoord(Complex_t &t, Complex_t &x, Complex_t &y, Complex_t &z)
Double_t DistanceTo(const Complex_t t, const Complex_t x, const Complex_t y, const Complex_t z)
Double_t DistanceTo(const Double_t *array)
TFourVectorComplex & operator=(const TFourVectorReal &source)
TFourVectorComplex & operator=(const TFourVectorComplex &source)
TFourVectorComplex & operator+=(const TFourVectorReal &source)
TFourVectorComplex & operator+=(const TFourVectorComplex &source)
TFourVectorComplex & operator-=(const TFourVectorReal &source)
TFourVectorComplex & operator-=(const TFourVectorComplex &source)
TFourVectorComplex & operator-=(const Float_t *array)
TFourVectorComplex & operator-=(const Double_t *array)
TFourVectorComplex & operator-=(const Complex_t *array)
TFourVectorComplex & operator*=(const Complex_t &factor)
TFourVectorComplex & operator/=(const Complex_t &factor)
Bool_t operator==(const TFourVectorComplex &other)
Bool_t operator!=(const TFourVectorComplex &other)
TFourVectorComplex & Transform(const TLorentzTransform &xformOp)
TFourVectorComplex & Boost(const TLorentzBoost &boostOp)
TFourVectorComplex & Boost(const Double_t betaX, const Double_t betaY, const Double_t betaZ)
Complex_t ScalarProd(const TFourVectorComplex &other)
Complex_t ScalarProd(const TFourVectorComplex &v1, const TFourVectorComplex &v2)

Author: Richard T. Jones 11/16/98
Last update: Dec. 12, 1998 v1.00
Copyright (c) 1998, University of Connecticut, All rights reserved. *

ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.