From 0aec29626df0bf4fa0f1738e5b33baa45f486138 Mon Sep 17 00:00:00 2001
From: Lorenzo Moneta <Lorenzo.Moneta@cern.ch>
Date: Wed, 14 Dec 2005 11:41:16 +0000
Subject: [PATCH] update doc
git-svn-id: http://root.cern.ch/svn/root/trunk@13704 27541ba8-7e3a-0410-8455-c3a389f83636
---
mathcore/doc/LorentzVector.html | 99 +++++++++++++++------
mathcore/doc/Transformation.html | 142 +++++++++++++++----------------
mathcore/doc/Vector3D.html | 15 ++--
mathcore/doc/externalUsage.html | 72 ++++++++--------
mathcore/doc/vector.html | 2 +-
5 files changed, 185 insertions(+), 145 deletions(-)
diff --git a/mathcore/doc/LorentzVector.html b/mathcore/doc/LorentzVector.html
index 5f47927c161..0ee209898b8 100644
--- a/mathcore/doc/LorentzVector.html
+++ b/mathcore/doc/LorentzVector.html
@@ -12,7 +12,7 @@ The following typedef's, defined in the header file <em>Math/Vector4Dfwd.h</em>,
<li>ROOT::Math::XYZTVector vector based on x,y,z,t coordinates (cartesian) in double precision
<li>ROOT::Math::XYZTVectorF vector based on x,y,z,t coordinates (cartesian) in float precision
<li>ROOT::Math::PtEtaPhiEVector vector based on pt (rho),eta,phi and E (t) coordinates in double precision
-<li>ROOT::Math::PtEtaPhiEVector vector based on pt (rho),eta,phi and E (t) coordinates in double precision
+<li>ROOT::Math::PtEtaPhiMVector vector based on pt (rho),eta,phi and M (t) coordinates in double precision
<li>ROOT::Math::PxPyPzMVector vector based on px,py,pz and M (mass) coordinates in double precision
</ul>
The metric used for all the LorentzVector's is (-,-,-,+)
@@ -21,50 +21,95 @@ The metric used for all the LorentzVector's is (-,-,-,+)
<h4>Constructors and Assignment</h4>
The following declarations are available:
<pre>
- XYZTVector v1; // create an empty vector (x = 0, y = 0, z = 0, t = 0)
- XYZTVector v2(1,2,3,4); // create a vector with x=1, y = 2, z = 3, t = 4
- PtEtaPhiEVector v3( 1, 2, PI, 5); // create a vector with pt = 1, eta = 2, phi = PI, E = 5
+XYZTVector v1; // create an empty vector (x = 0, y = 0, z = 0, t = 0)
+XYZTVector v2(1,2,3,4); // create a vector with x=1, y = 2, z = 3, t = 4
+PtEtaPhiEVector v3(1,2,PI,5); // create a vector with pt = 1, eta = 2, phi = PI, E = 5
</pre>
Note that each type of vector is constructed by passing its coordinates representations, so a XYZTVector(1,2,3,4) is different from a PtEtaPhiEVector(1,2,3,4).
<p>
In addition the Vector classes can be constructed by any vector, which implements the accessors x(), y() and z() and t().
-This con be another LorentzVector3 based on a different coordinate system or even any vector of a different package, like the CLHEP HepLorentzVector that implements the required signatures.
+This cann be another ROOT::Math::LorentzVector based on a different coordinate system or even any vector of a different package, like the CLHEP HepLorentzVector that implements the required signature.
<pre>
- XYZTVector v1(1,2,3,4);
- PtEtaPhiEVector v2(v1);
+XYZTVector v1(1,2,3,4);
+PtEtaPhiEVector v2(v1);
- CLHEP::HepLorentzVector q(1,2,3,4);
- XYZTVector v3(q)
+CLHEP::HepLorentzVector q(1,2,3,4);
+XYZTVector v3(q)
</pre>
<h4>Coordinate Accessors</h4>
-To get information on the coordinates on the vector (cartesian, polar, cylindrical, etc...) see the documentation for the class ROOT::Math::LorentzVector
+All the same coordinate accessors are available through the interface of the class ROOT::Math::LorentzVector.
+For example:
+<pre>
+v1.X(); v1.X(); v1.Z(); v1.T() // returns cartesian components for the cartesian vector v1
+v2.Px(); v2.Py(); v2.Pz(); v2.E() // returns cartesian components for the cylindrical vector v2
+v1.Pt(); v1.Eta(); v1.Phi(); v1.M() // returns other components for the cartesian vector v1
+</pre>
+In addition, all the 4 coordinates of the vector can be retrieved with the GetCoordinates method:
+<pre>
+double d[4];
+v1.GetCoordinates(d); // fill d array with (x,y,z,t) components of v1
+v2.GetCoordinates(d); // fill d array with (pt,eta,phi,e) components of v2
+std::vector<double> w(4);
+v1.GetCoordinates(w.begin(),w.end()); // fill std::vector with (x,y,z,t) components of v1
+</pre>
+To get information on all the coordinate accessors see the reference documentation of ROOT::Math::LorentzVector
+
<h4>Setter Methods</h4>
-Setter methods as in CLHEP, setting each coordinate at a time are not supported. The setters methods supported are :
-<ul>
-<li> SetCoordinates(c1,c2,c3,c4) which sets the four basic coordinates, x,y,z,t for a ROOT::Math::XYZTVector and pt, eta, phi, E for a ROOT::Math::PtEtaPhiEVector
-<li>SetXYZT(x,y,z,t) which set the x,y,z,t for all type of vectors.
-</ul>
-In additions are supported as for the 3D Vectors the Set/GetCoordinates from C arrays or using iterators
+One can set only all the three coordinates via:
+<pre>
+v1.SetCoordinates(c1,c2,c3,c4); // sets the (x,y,z,t) for a XYZTVector
+v2.SetCoordinates(c1,c2,c3,c4); // sets pt,eta,phi,e for a PtEtaPhiEVector
+v2.SetXYZ(x,y,z,t); // sets the 4 cartesian components for the PtEtaPhiEVector
+</pre>
+Single coordinate setter methods are available for the basic vector coordinates, like SetX() for a XYZTVector or SetPt() for a PtEtaPhiEVector. Attempting to do a SetX() on a non cartesian vector will not compile.
+<pre>
+XYZTVector v1; v1.SetX(1) // OK setting x for a cartesian vector
+PtEtaPhiEVector v2; v2.SetX(1) // ERROR: cannot set X for a non-cartesian vector. Method will not compile
+v2.SetR(1) // OK setting Pt for a PtEtaPhiEVector vector
+</pre>
+
+In addition there are setter methods from C arrays or iterators.
+<pre>
+double d[3] = {1.,2.,3.,4.};
+XYZTVector v;
+v.SetCoordinates(d); // set (x,y,z,t) components of v using values from d
+</pre>
+or for example from an std::vector using the iterators
+<pre>
+std::vector<double> w(4);
+v.SetCoordinates(w.begin(),w.end()); // set (x,y,z,t) components of v using values from w
+</pre>
+
<h4>Arithmetic Operations</h4>
The following operations are possible between LorentzVectors classes, even of different coordinate system types:
-( v is a one of the LorentzVector class, q is a generic Vector implementing x(), y(), z() and t() and a is
-a generic scalar type: double, flot, int, etc.... )
+( v and w are two LorentzVector of the same type, q is a generic LorentzVector implementing x(), y(), z() and t() and a is a generic scalar type: double, flot, int, etc.... )
<pre>
v += q;
-v -= q;
-v1 *= a;
-v1 /= a;
+v -= q;
+v = -q;
+v *= a;
+v /= a;
+w = v + q;
+w = v - q;
+w = v * a;
+w = a * v;
+w = v / a;
+</pre>
+<h4>Comparison</h4>
+<pre>
+v == w;
+v != w;
</pre>
-Between LorentzVector classes, the following operations are possibles: ( v1 and v2 can be two vectors in different coordinate system. v3 is the same type of v1)
+<h4>Other Methods</h4>
<pre>
-v3 = v1 + v2;
-v3 = v1 - v2;
-v2 = a * v1;
-v2 = v1 * a;
-v2 = v1 / a;
+a = v.Dot(q); // dot product in metric (+,+,+,-) of two LorentzVector's
+XYZVector s = v.Vect() // return the spatial components (x,y,z)
+v.Beta(); // return beta and gamma value
+v.Gamma() // (vector must be time-like otherwise result is meaningless)
+XYZVector b = v.BoostToCM() // return boost vector which will bring the Vector in its mas frame (P=0)
</pre>
diff --git a/mathcore/doc/Transformation.html b/mathcore/doc/Transformation.html
index c4895aa5de8..3180b04e95d 100644
--- a/mathcore/doc/Transformation.html
+++ b/mathcore/doc/Transformation.html
@@ -3,7 +3,9 @@
/**
\page TransformPage Vector Transformations
-We have classes for describing 3D Rotation, LorentzRotations and Transformations which are the combinations of a Rotation and a Translation. For all the classes, the scalar type is based on double precision/
+Transformations classes are grouped in Rotations (in 3 dimensions), Lorentz transformations and Poincarre transformations, which are Translation/Rotation combinations. Each group has several members which may model physically equivalent trasformations but with different internal representations.
+<br>
+All the classes are non-template and use double precision as the scalar type
The following types of transformation classes are defined:
<ul>
@@ -13,111 +15,107 @@ The following types of transformation classes are defined:
<li>ROOT::Math::EulerAngles rotation described by the three Euler angles (phi, theta and psi) following the GoldStein
<A HREF="http://mathworld.wolfram.com/EulerAngles.html">definition</A>. </li>
<li>ROOT::Math::AxisAngle, rotation described by a vector (axis) and an angle
+<li>ROOT::Math::Quaternion, rotation described by a quaternion (4 numbers)
<li>ROOT::Math::RotationX, specialized rotation along the X axis
-<li>ROOT::Math::RotationY, specialized rotation along the X axis
-<li>ROOT::Math::RotationZ, default rotation described by a 3x3 matrix of doubles
+<li>ROOT::Math::RotationY, specialized rotation along the Y axis
+<li>ROOT::Math::RotationZ, specialized rotation along the Z axis
</ul>
<li>3D Transformations (Rotations + Translations)
<ul>
-<li>ROOT::Math::Transform3D for transformation (rotations + translation) described by a 3x4 matrix (a rotations described by a 3x3 matrix and a translations by a cartesian vector.
+<li>ROOT::Math::Transform3D, (rotations and then translation) described by a 3x4 matrix (12 numbers)
</ul>
-<li>Lorentz Rotations
+<li>Lorentz Rotations and Boost
<ul>
-<li>ROOT::Math::LorentzRotation , 4D rotation (3D rotation plus boost) described by a 4x4 matrix
+<li>ROOT::Math::LorentzRotation , 4D rotation (3D rotation plus a boost) described by a 4x4 matrix
+<li>ROOT::Math::Boost, a Lorentz boost in an arbitrary direction and described by a 4x4 symmetrix matrix (10 numbers)
+<li>ROOT::Math::BoostX, a boost in the X axis direction
+<li>ROOT::Math::BoostY, a boost in the Y axis direction
+<li>ROOT::Math::BoostZ, a boost in the Z axis direction
+ </ul>
+
</li>
</ul>
</ul>
-<h3>3D Rotations</h3>
<h4>Constructors</h4>
-It is possible to construct all types of rotation, specyfing the three Euler angles, an axis and an angle or a 3x3 matrix.
-Rotations based on a type can be constructed and assigned from a rotation based on another type. In addition it is possible to create directly rotations along the three X,Y and Z axes.
-The following constructors are available:
+All rotations and transformations are default constructible (giving the identity transformation).
+All rotations are constructible taking a number of scalar argumnts matching the number (and order of components)
<pre>
Rotation3D rI; // create a summy rotation (Identity matrix)
-Rotation3D rX(ROOT::Math::RotationX(PI)); // create a rotation along X axis of angle PI
-Rotation3D rY(ROOT::Math::RotationY(PI)); // create a rotation along Y axis of angle PI
-Rotation3D rZ(ROOT::Math::RotationZ(PI)); // create a rotation along Z axis of angle PI
-EulerAngles rE(phi, theta, psi); // create a Euler rotation with phi,theta,psi angles
-
-XYZVector u(ux,uy,uz);
-AxisAngle rA(u, delta); // create a rotation based on direction u with delta angle
-
+RotationX rX(M_PI); // create a rotationX with an angle PI
+EulerAngles rE(phi, theta, psi); // create a Euler rotation with phi,theta,psi angles
+XYZVector u(ux,uy,uz);
+AxisAngle rA(u, delta); // create a rotation based on direction u with delta angle
+</pre>
+In addition, all rotations and transformations (other than the axial rotations) and transformations are constructible from (begin,end) iterators or from pointers whicih behave like iterators.
+<pre>
double data[9];
Rotation3D r(data, data+9); // create a rotation from a rotation matrix
-
-EulerAngles r2(r); // construct an Euler Rotation from A Rotation3D
-AxisAngle r3(r2); // construct an Axis Rotation from an Euler Rotation
+std::vector<double> w(12);
+Transform3D t(w.begin(),w.end()); // create a Transform3D from the content of a std::vector
</pre>
-
-
-<h4>Rotation Operations</h4>
-
-Rotations can be applied to vector and points using the operator * or directly using the rotation class
+All rotations, except the axial rotations, are constructible and assigned from any other type of rotation (including the axial):
<pre>
-XYZVector v1(...);
-Rotation3D r(...);
-XYZVector v2 = r*v1; // rotate vector v1 using r
-v2 = r(v1) // equivalent
+Rotation3D r(ROOT::Math::RotationX(PI)); // create a rotation 3D from a rotation along X axis of angle PI
+EulerAngles r2(r); // construct an Euler Rotation from A Rotation3D
+AxisAngle r3; r3 = r2; // assign an Axis Rotation from an Euler Rotation;
</pre>
-Or they can be combined using the operator *
+Transform3D (rotation + translation) can be constructed from a rotation and a translation vector
<pre>
-Rotation3D r1(...);
-Rotation3D r2(...);
-Rotation3D r3 = r1*r2;
+Rotation3D r; XYZVector v;
+Transform3D t1(r,v); // construct from rotation and then translation
+Transform3D t2(v,r); // construct inverse from first translation then rotation
+Transform3D t3(r); // construct from only a rotation (zero translation)
+Transform3D t4(v); // construct from only translation (identity rotation)
</pre>
-It is also possible to invert a rotation or return the inverse of a rotation.
-See the API for the rotation classes, like ROOT::Math::Rotation3D, for all the available methods.
-
-<h3>3D Transfomations</h3>
-
-The 3D transfromations are composed from a rotation and a translation. They can be constructed from any type of rotation and any type of vectors. Constructors are:
-<pre>
-Transform3D t; // default constructors (identy rotation and null translation)
+<h4>Operations</h4>
+All transformations can be applied to vector and points using the <em>operator *</em> or using the <em>operator()</em> <pre>
+XYZVector v1(...);
Rotation3D r(...);
-XYZVector v(...);
-Transform3D t(r,v) // construct from rotation and vector
+XYZVector v2 = r*v1; // rotate vector v1 using r
+v2 = r(v1) // equivalent
</pre>
-A Transformation can be seen as a 3x4 matrix with the translation values present in the 4-th column
+Transformations can be combined using the operator * . Note that the rotations are not commutative ans therefore the order is important
<pre>
-double d[12];
-t.GetComponents(d, d+12);
+Rotation3D r1(...);
+Rotation3D r2(...);
+Rotation3D r3 = r2*r1; // obtain a combine rotation r3 by applying first r1 then r2
</pre>
-It is possible to return the rotation (3x3) or the vector for the translation.
+We can combine rotations of different types, like Rotation3D with any other type of rotations. The product of two different axial rotations return a Rotation3D:
<pre>
-Rotation3D r;
-XYZVector v;
-t.GetDecomposition(r,v);
+RotationX rx(1.);
+RotationY ry(2.);
+Rotation3D r = ry * rx; // rotation along X and then Y axis
</pre>
-As for the rotation, 3DTransformations are applied to vectors and points using the * operator and two transformations can be combined using the * operator. We can also invert or get the inverse of a 3DTransformation.
-See the API for the class ROOT::Math::Transform3D for all the available methods.
-
-
-It is important to note that a full 3DTransformation can be applied only to Points, since the translations have no effect to Vectors.
-
-<h3>LorentzRotation</h3>
-
-A LorentzRotation represents generic rotation in the 4D space-time or pure boosts. The data are stored as a 4x4 matrix
-The available constructors are:
+It is also possible to invert all the transformation or return the inverse of a transformation
<pre>
-LorentzRotation lr0; // construct identy LR
-
+Rotation3D r1(...);
+ r1.Invert(); // invert the rotation modifying its content
+Rotation3D r2 =r1.Inverse(); // return the inverse in a new rotation class
+</pre>
+We have used rotation as examples, but all these operations can be applied to all the transformation classes.
-Rotation3D r;
-LorentzRotation lr1(r); // construct a LR from a 3D Rotation
-Boost b2;
-LorentzRotation lr2(b2); // construct a LR from a Boost
+<h4>Set/GetComponents methods</h4>
+Common methods to all the transformations are the Get and SetComponents.
+They can be used to retrieve all the scalar values on which the trasformation is based.
+They can be used with a signature based iterators or by using any foreign matrix which implements the <em>operator(i,j)</em> or a different signatures depending on the transformation type.
+<pre>
+RotationX rx; rx.SetComponents(1.) // set agle of the X rotation
+double d[9] = {........}
+Rotation3D r; r.SetComponents(d,d+9); // set 9 components of 3D rotation
+double d[16];
+LorentzRotation lr;
+lr.GetComponents( d, d+16); // get 16 components of a LorentzRotation
+TMatrixD(3,4) m;
+Transform3D t; t.GetComponens(m); // fill matrix of size 3x4 with components of the transform3D t
+</pre>
-double m1[16];
-LorentzRotation lr3(m1,m1+16); // construct from a C array of 16 elements
-</pre>
-LorentzRotation can be applied to LorentzVectors using the * operator and, as in the case for the other transfromations, they can be combined using the * operator. We can also invert or get the inverse of a LorentzRotation.
-See the API for the class ROOT::Math::LorentzRotation for all the available methods.
+For more detailed documentation on all methods see the reference doc for the specific transformation class.
*/
diff --git a/mathcore/doc/Vector3D.html b/mathcore/doc/Vector3D.html
index 2ce0a71fc57..0f8817bdeed 100644
--- a/mathcore/doc/Vector3D.html
+++ b/mathcore/doc/Vector3D.html
@@ -47,7 +47,7 @@ v1.X(); v1.X(); v1.Z() // returns cartesian components for t
v1.Rho(); v1.Eta(); v1.Phi() // returns cylindrical components for the cartesian vector v1
r2.X(); r2.Y(); r2.Z() // returns cartesian components for the cylindrical vector r2
</pre>
-All the coordinates of the vector can be retrieved with the GetCoordinates method:
+In addition, all the 3 coordinates of the vector can be retrieved with the GetCoordinates method:
<pre>
double d[3];
v1.GetCoordinates(d); // fill d array with (x,y,z) components of v1
@@ -55,15 +55,16 @@ r2.GetCoordinates(d); // fill d array with (r,eta,phi) compo
std::vector<double> vc(3);
v1.GetCoordinates(vc.begin(),vc.end()); // fill std::vector with (x,y,z) components of v1
</pre>
-To get more information on all the coordinate accessors see the ROOT::Math::DisplacementVector3D documentation.
+To get more information on all the coordinate accessors see the reference documentation of ROOT::Math::DisplacementVector3D.
<h4>Setter Methods</h4>
One can set only all the three coordinates via:
-<ul>
-<li> SetCoordinates( c1, c2, c3) which sets the three basic coordinates, x,y,z for a XYZVector and r,theta,phi for a Polar3DVector.
-<li> SetXYZ ( x, y, z) which sets the three cartesian components.
-<li> Single coordinate setter methods like SetX() or SetY() are available for the basic vector coordinates; for example (x,y,z) for a cartesian vector and (rho, theta, phi) for a polar vector. Attempting to do a SetX() on a Polar vector will not compile.
-</ul>
+<pre>
+v1.SetCoordinates(c1,c2,c3); // sets the (x,y,z) for a XYZVector
+r2.SetCoordinates(c1,c2,c3); // sets r,theta,phi for a Polar3DVector
+r2.SetXYZ(x,y,z); // sets the three cartesian components for the Polar3DVector
+</pre>
+Single coordinate setter methods are available for the basic vector coordinates, like SetX() for a XYZVector or SetR() for a polar vector. Attempting to do a SetX() on a polar vector will not compile.
<pre>
XYZVector v1; v1.SetX(1) // OK setting x for a Cartesian vector
Polar3DVector v2; v2.SetX(1) // ERROR: cannot set X for a Polar vector. Method will not compile
diff --git a/mathcore/doc/externalUsage.html b/mathcore/doc/externalUsage.html
index 96d4d293d8e..fe24ef92b4a 100644
--- a/mathcore/doc/externalUsage.html
+++ b/mathcore/doc/externalUsage.html
@@ -6,61 +6,57 @@
\page ExtUsagePage Examples with external Packages
-<h2>Connection to Linear Algebra classes</h2>
+<h3>Connection to Linear Algebra classes</h3>
It is possible to use the Vector and Rotation classes together with the Linear Algebra classes.
-It is possiible to construct any 3D or 4D Vector from a Linear Agebra Vector class which implements the
-operator[]. It is required also to pass the index of the first coordinate in the Lineas Algebra vector.
-It is then assumed that the other coordinates, will be following contigously.
+It is possible to set and get the contents of any 3D or 4D Vector from a Linear Agebra Vector class
+which implements an iterator or something which behaves like an iterator. For example a pointer to a C array
+(double *) behaves like an iterator.
+It is then assumed that the coordinates, like (x,y,z) will be stored contigously.
<pre>
-TVectorD r2(N) // %ROOT Linear Algebra Vector containing many vectors
-XYZVector v2(&r2[INDEX]) // construct vector from x=r[INDEX], y=r[INDEX+1], z=r[INDEX+2]
-
-
-HepVector c(4) // CLHEP Linear algebra vector
-XYZTVector q(&c[0]) // construct using px=c[0], py=c[1], pz=c[2], E=c[4]
-
+TVectorD r2(N) // %ROOT Linear Algebra Vector containing many vectors
+XYZVector v2;
+v2.SetCoordinates(&r2[INDEX],&r2[index]+3); // construct vector from x=r[INDEX], y=r[INDEX+1], z=r[INDEX+2]
</pre>
-
-To construct a Linear Algebra Vector from a 3D or 4D Vector, a method to access the internal data is provided. This is provided only for Vectors and Points based on Cartesian coordinates, where it is garanted that the data are stored contigously in memory.
-Example:
-
+To fill a Linear Algebra Vector from a 3D or 4D Vector, with GetComponents() one can get the internal coordinate data.
<pre>
-XYZVector v(x,y,z);
-double * data;
-v.GetCoordinates(data);
-
-TVectorD r1(3,data); // create a new Linear Algebra vector copying the data
-TVectorD r2;
+HepVector c(3); // CLHEP Linear algebra vector
+v2.GetCoordinates(&c[0],&c[index]+3 ) // fill HepVector c with c[0] = x, c[1] = y , c[2] = z
+</pre>
+Or using TVectorD
+<pre>
+double * data[3];
+v2.GetCoordinates(data,data+3);
+TVectorD r1(3,data); // create a new Linear Algebra vector copying the data
</pre>
+In the case of transformations, constructor and method to Set/Get components exist with Linear Algebra matrices.
+The requisite is that the matrix data are stored, for example in the cse of a LorentzRotation, from (0,0) thru (3,3)
+<pre>
+TMatrixD(4,4) m;
+LorentzRotation r(m) // create LorentzRotation from matrix m
+r.GetComponents(m) // fill matrix m with LorentzRotation components
+</pre>
-<h2>Connection to Other Vector classes</h2>
-
-The ROOT::Math 3D and 4D vectors can be constructed and assigned from any Vectors which has the following pre-conditions:
-\item for 3D Vectors and Points must implement the x(), y() ans z() methods
-\item for LorentzVectors must implement the px(), py(), pz() and e() methods.
+<h3>Connection to Other Vector classes</h3>
-Example:
+The 3D and 4D vectors of teh GenVector package can be constructed and assigned from any Vector which has the following pre-conditions:
+<ul>
+<li> for 3D Vectors and Points must implement the x(), y() ans z() methods
+<li> for LorentzVectors must implement the x(), y(), z() and t() methods.
+</ul>
+
<pre>
CLHEP::Hep3Vector hv;
-XYZVector v1(hv); // create 3D Vector from CLHEP 3D Vector
+XYZVector v1(hv); // create 3D Vector from CLHEP 3D Vector
HepGeom::Point3D<double> hp;
-XYZPoint p1(hp); // create a 3D Point from CLHEP geom Point
+XYZPoint p1(hp); // create a 3D Point from CLHEP geom Point
CLHEP::HepLorentzVector hq;
-LorentzVector q(hq); // create a L.V. from CLHEP L.V.
+XYZTVector q(hq); // create a LorentzVector from CLHEP L.V.
</pre>
-Using the behavior of TVector3 and TLorentzVector as Linear Algebra Vectors (they do implement the operator[] ), we can also create a ROOT::Math Vector from them as we do from a linear algebra vector.
-
-<pre>
-TLorentzVector tq;
-LorentzVector q;
-q.SetCoordinates( &tq[0] );
-</pre>
-
*/
\ No newline at end of file
diff --git a/mathcore/doc/vector.html b/mathcore/doc/vector.html
index 6092d9b745f..976e6222478 100644
--- a/mathcore/doc/vector.html
+++ b/mathcore/doc/vector.html
@@ -74,7 +74,7 @@ It is important to note that transformations act differently on Vectors and Poi
<li><h4>Lorentz Rotation</h4>
<ul>
<li>Generic Lorentz Rotation described by a 4x4 matrix containing a 3D rotation part and a boost part (class ROOT::Math::LorentzRotation)</li>
-<li>A pure boost in an aribtrary direction and described by a 4x4 symmetric matrix or 10 numbers (class ROOT::Math::Boost)</li>
+<li>A pure boost in an arbitrary direction and described by a 4x4 symmetric matrix or 10 numbers (class ROOT::Math::Boost)</li>
<li>Boost along the x (ROOT::Math::BoostX), y (ROOT::Math::BoostY) and z (ROOT::Math::BoostZ) axis. </li>
</ul>
--
GitLab