[u/mrichter/AliRoot.git] / STEER / AliAlignObj.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-----------------------------------------------------------------
//   Implementation of the alignment object class through
//   1) the abstract class AliAlignObj
//   2) two derived concrete representation of alignment object class:
//      - AliAlignObjAngles
//      - AliAlignObjMatrix
//-----------------------------------------------------------------
/*****************************************************************************
 * AliAlignObjAngles: derived alignment class storing alignment information  *
 *   for a single volume in form of three doubles for the translation        *
 *   and three doubles for the rotation expressed with the euler angles      *
 *   in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html),  *
 *   also known as roll, pitch, yaw. PLEASE NOTE THE ANGLES SIGNS ARE        *
 *   INVERSE WITH RESPECT TO THIS REFERENCE!!! In this way the representation*
 *   is fully consistent with the TGeo Rotation methods.                     *
 *****************************************************************************/

#include "AliAlignObj.h"
//#include "AliLog.h"

ClassImp(AliAlignObj)

//_____________________________________________________________________________
AliAlignObj::AliAlignObj():
  fVolUID(0)
{
  // dummy constructor
}

//_____________________________________________________________________________
AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
  TObject(theAlignObj)
{
  //copy constructor
  fVolPath = theAlignObj.GetVolPath();
  fVolUID = theAlignObj.GetVolUID();
}

//_____________________________________________________________________________
AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
{
  // assignment operator
  if(this==&theAlignObj) return *this;
  fVolPath = theAlignObj.GetVolPath();
  fVolUID = theAlignObj.GetVolUID();
  return *this;
}

//_____________________________________________________________________________
AliAlignObj::~AliAlignObj()
{
  // dummy destructor
}

//_____________________________________________________________________________
void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
{
  // Calculates the rotation matrix using the 
  // Euler angles in "x y z" notation
  Double_t degrad = TMath::DegToRad();
  Double_t sinpsi = TMath::Sin(degrad*angles[0]);
  Double_t cospsi = TMath::Cos(degrad*angles[0]);
  Double_t sinthe = TMath::Sin(degrad*angles[1]);
  Double_t costhe = TMath::Cos(degrad*angles[1]);
  Double_t sinphi = TMath::Sin(degrad*angles[2]);
  Double_t cosphi = TMath::Cos(degrad*angles[2]);

  rot[0] =  costhe*cosphi;
  rot[1] = -costhe*sinphi;
  rot[2] =  sinthe;
  rot[3] =  sinpsi*sinthe*cosphi + cospsi*sinphi;
  rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
  rot[5] = -costhe*sinpsi;
  rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
  rot[7] =  cospsi*sinthe*sinphi + sinpsi*cosphi;
  rot[8] =  costhe*cospsi;
}

//_____________________________________________________________________________
Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
{
  // Calculates the Euler angles in "x y z" notation
  // using the rotation matrix
  if(rot[0]<1e-7 || rot[8]<1e-7) return kFALSE;
  Double_t raddeg = TMath::RadToDeg();
  angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
  angles[1]=raddeg*TMath::ASin(rot[2]);
  angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
  return kTRUE;
}

//_____________________________________________________________________________
void AliAlignObj::Print(Option_t *) const
{
  // Print the contents of the
  // alignment object in angles and
  // matrix representations
  Double_t tr[3];
  GetTranslation(tr);
  Double_t angles[3];
  GetAngles(angles);
  TGeoHMatrix m;
  GetMatrix(m);
  const Double_t *rot = m.GetRotationMatrix();
  printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
  printf("%12.6f%12.6f%12.6f    Tx = %12.6f    Psi   = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
  printf("%12.6f%12.6f%12.6f    Ty = %12.6f    Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
  printf("%12.6f%12.6f%12.6f    Tz = %12.6f    Phi   = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);

}


//=============================================================================

ClassImp(AliAlignObjAngles)

//_____________________________________________________________________________
AliAlignObjAngles::AliAlignObjAngles() //: AliAlignObj()
{
  // default constructor
  fTranslation[0]=fTranslation[1]=fTranslation[2]=0.;
  fRotation[0]=fRotation[1]=fRotation[2]=0.;
}

//_____________________________________________________________________________
AliAlignObjAngles::AliAlignObjAngles(const AliAlignObjAngles& theAlignObj) :
  AliAlignObj(theAlignObj)
{
  // copy constructor
  Double_t tr[3];
  theAlignObj.GetTranslation(tr);
  SetTranslation(tr[0],tr[1],tr[2]);
  Double_t rot[3];
  theAlignObj.GetAngles(rot);
  SetRotation(rot[0],rot[1],rot[2]);
}

//_____________________________________________________________________________
AliAlignObjAngles &AliAlignObjAngles::operator =(const AliAlignObjAngles& theAlignObj)
{
  // assignment operator
  if(this==&theAlignObj) return *this;
  ((AliAlignObj *)this)->operator=(theAlignObj);

  Double_t tr[3];
  theAlignObj.GetTranslation(tr);
  SetTranslation(tr[0],tr[1],tr[2]);
  Double_t rot[3];
  theAlignObj.GetAngles(rot);
  SetRotation(rot[0],rot[1],rot[2]);
  return *this;
}

//_____________________________________________________________________________
AliAlignObjAngles::~AliAlignObjAngles()
{
  // default destructor
}

//_____________________________________________________________________________
void AliAlignObjAngles::SetTranslation(const TGeoMatrix& m)
{
  // Sets the translation parameters from an existing TGeoMatrix
  if(m.IsTranslation()){
    const Double_t* tr = m.GetTranslation();
    fTranslation[0]=tr[0];  fTranslation[1]=tr[1]; fTranslation[2]=tr[2];
  }else{
//     AliWarning("Argument matrix is not a translation! Setting zero-translation.");
    fTranslation[0] = fTranslation[1] = fTranslation[2] = 0.;
  }
}

//_____________________________________________________________________________
Bool_t AliAlignObjAngles::SetRotation(const TGeoMatrix& m)
{
  // Sets the rotation components from an existing TGeoMatrix
  if(m.IsRotation()){
    const Double_t* rot = m.GetRotationMatrix();
    return MatrixToAngles(rot,fRotation);
  }else{
//     AliWarning("Argument matrix is not a rotation! Setting yaw-pitch-roll to zero.");
    fRotation[0] = fRotation[1] = fRotation[2] = 0.;
    return kTRUE;
  }
}

//_____________________________________________________________________________
void AliAlignObjAngles::SetMatrix(const TGeoMatrix& m)
{
  // Sets both the rotation and translation components from an
  // existing TGeoMatrix
  SetTranslation(m);
  SetRotation(m);
}

//_____________________________________________________________________________
void AliAlignObjAngles::GetPars(Double_t tr[], Double_t angles[]) const
{
  // Returns the translations and the rotation angles
  GetTranslation(tr);
  GetAngles(angles);
}

//_____________________________________________________________________________
void AliAlignObjAngles::GetMatrix(TGeoHMatrix& m) const
{
  // Extracts the information in an existing TGeoHMatrix using the translations
  // and the rotation parameters
  m.SetTranslation(&fTranslation[0]);
  Double_t rot[9];
  AnglesToMatrix(fRotation,rot);
  m.SetRotation(rot);
}

//=============================================================================

ClassImp(AliAlignObjMatrix)

//_____________________________________________________________________________
AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
{
  // Default constructor
}

AliAlignObjMatrix::AliAlignObjMatrix(const AliAlignObjMatrix& theAlignObj) :
  AliAlignObj(theAlignObj)
{
  //copy constructor
  //
  Double_t tr[3];
  theAlignObj.GetTranslation(tr);
  SetTranslation(tr[0],tr[1],tr[2]);
  Double_t rot[3];
  theAlignObj.GetAngles(rot);
  SetRotation(rot[0],rot[1],rot[2]);
}

AliAlignObjMatrix &AliAlignObjMatrix::operator =(const AliAlignObjMatrix& theAlignObj)
{  
  // assignment operator
  //
  if(this==&theAlignObj) return *this;
  ((AliAlignObj *)this)->operator=(theAlignObj);
  Double_t tr[3];
  theAlignObj.GetTranslation(tr);
  SetTranslation(tr[0],tr[1],tr[2]);
  Double_t rot[3];
  theAlignObj.GetAngles(rot);
  SetRotation(rot[0],rot[1],rot[2]);
  return *this;
}

AliAlignObjMatrix::~AliAlignObjMatrix()
{
  // Destructor
  //
}

//_____________________________________________________________________________
void AliAlignObjMatrix::SetTranslation(Double_t x, Double_t y, Double_t z)
{
  // Sets the translation parameters
  Double_t tr[3];
  tr[0]=x; tr[1]=y; tr[2]=z;
  fMatrix.SetTranslation(tr);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::SetTranslation(const TGeoMatrix& m)
{
  // Sets the translation parameters from an existing TGeoMatrix
  const Double_t *tr = m.GetTranslation();
  fMatrix.SetTranslation(tr);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::SetRotation(Double_t psi, Double_t theta, Double_t phi)
{
  // Sets the rotation parameters
  Double_t angles[3] = {psi, theta, phi};
  Double_t rot[9];
  AnglesToMatrix(angles,rot);
  fMatrix.SetRotation(rot);
}

//_____________________________________________________________________________
Bool_t AliAlignObjMatrix::SetRotation(const TGeoMatrix& m)
{
  // Sets the rotation parameters from an existing TGeoMatrix
  const Double_t* rot = m.GetRotationMatrix();
  fMatrix.SetRotation(rot);
  return kTRUE;
}

//_____________________________________________________________________________
void AliAlignObjMatrix::SetMatrix(const TGeoMatrix& m)
{
  // Set rotation matrix and translation
  // using TGeoMatrix
  SetTranslation(m);
  SetRotation(m);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::SetPars(Double_t x, Double_t y, Double_t z,
		       Double_t psi, Double_t theta, Double_t phi)
{
  // Set rotation matrix and translation
  // using 3 angles and 3 translations
  SetTranslation(x,y,z);
  SetRotation(psi,theta,phi);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::GetTranslation(Double_t *tr) const
{
  // Get Translation from TGeoMatrix
  const Double_t* translation = fMatrix.GetTranslation();
  tr[0] = translation[0];
  tr[1] = translation[1];
  tr[2] = translation[2];
}

//_____________________________________________________________________________
Bool_t AliAlignObjMatrix::GetAngles(Double_t *angles) const
{
  // Get rotation angles from the TGeoHMatrix
  const Double_t* rot = fMatrix.GetRotationMatrix();
  return MatrixToAngles(rot,angles);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::GetPars(Double_t tr[], Double_t angles[]) const
{
  // Gets the translations and the rotation angles
  GetTranslation(tr);
  GetAngles(angles);
}

//_____________________________________________________________________________
void AliAlignObjMatrix::GetMatrix(TGeoHMatrix& m) const
{
  // Extracts the translations and the rotation parameters
  // in an existing TGeoHMatrix
  const Double_t *tr = fMatrix.GetTranslation();
  m.SetTranslation(tr);
  const Double_t *rot = fMatrix.GetRotationMatrix();
  m.SetRotation(rot);
}
Commit	Line	Data
c18195b9	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//-----------------------------------------------------------------
	17	// Implementation of the alignment object class through
	18	// 1) the abstract class AliAlignObj
	19	// 2) two derived concrete representation of alignment object class:
	20	// - AliAlignObjAngles
	21	// - AliAlignObjMatrix
	22	//-----------------------------------------------------------------
fdf65bb5	23	/*****************************************************************************
	24	* AliAlignObjAngles: derived alignment class storing alignment information *
	25	* for a single volume in form of three doubles for the translation *
	26	* and three doubles for the rotation expressed with the euler angles *
	27	* in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html), *
	28	* also known as roll, pitch, yaw. PLEASE NOTE THE ANGLES SIGNS ARE *
	29	* INVERSE WITH RESPECT TO THIS REFERENCE!!! In this way the representation*
	30	* is fully consistent with the TGeo Rotation methods. *
	31	*****************************************************************************/
c18195b9	32
	33	#include "AliAlignObj.h"
	34	//#include "AliLog.h"
	35
	36	ClassImp(AliAlignObj)
	37
	38	//_____________________________________________________________________________
	39	AliAlignObj::AliAlignObj():
	40	fVolUID(0)
	41	{
	42	// dummy constructor
	43	}
	44
	45	//_____________________________________________________________________________
	46	AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
	47	TObject(theAlignObj)
	48	{
	49	//copy constructor
	50	fVolPath = theAlignObj.GetVolPath();
	51	fVolUID = theAlignObj.GetVolUID();
	52	}
	53
	54	//_____________________________________________________________________________
	55	AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
	56	{
	57	// assignment operator
	58	if(this==&theAlignObj) return *this;
	59	fVolPath = theAlignObj.GetVolPath();
	60	fVolUID = theAlignObj.GetVolUID();
	61	return *this;
	62	}
	63
	64	//_____________________________________________________________________________
	65	AliAlignObj::~AliAlignObj()
	66	{
	67	// dummy destructor
	68	}
	69
	70	//_____________________________________________________________________________
	71	void AliAlignObj::AnglesToMatrix(const Double_t angles, Double_t rot) const
	72	{
fdf65bb5	73	// Calculates the rotation matrix using the
fdf65bb5	74	// Euler angles in "x y z" notation
c18195b9	75	Double_t degrad = TMath::DegToRad();
	76	Double_t sinpsi = TMath::Sin(degrad*angles[0]);
	77	Double_t cospsi = TMath::Cos(degrad*angles[0]);
	78	Double_t sinthe = TMath::Sin(degrad*angles[1]);
	79	Double_t costhe = TMath::Cos(degrad*angles[1]);
	80	Double_t sinphi = TMath::Sin(degrad*angles[2]);
	81	Double_t cosphi = TMath::Cos(degrad*angles[2]);
	82
	83	rot[0] = costhe*cosphi;
	84	rot[1] = -costhe*sinphi;
	85	rot[2] = sinthe;
	86	rot[3] = sinpsisinthecosphi + cospsi*sinphi;
	87	rot[4] = -sinpsisinthesinphi + cospsi*cosphi;
	88	rot[5] = -costhe*sinpsi;
	89	rot[6] = -cospsisinthecosphi + sinpsi*sinphi;
	90	rot[7] = cospsisinthesinphi + sinpsi*cosphi;
	91	rot[8] = costhe*cospsi;
	92	}
	93
	94	//_____________________________________________________________________________
	95	Bool_t AliAlignObj::MatrixToAngles(const Double_t rot, Double_t angles) const
	96	{
fdf65bb5	97	// Calculates the Euler angles in "x y z" notation
fdf65bb5	98	// using the rotation matrix
c18195b9	99	if(rot[0]<1e-7 \|\| rot[8]<1e-7) return kFALSE;
	100	Double_t raddeg = TMath::RadToDeg();
	101	angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
	102	angles[1]=raddeg*TMath::ASin(rot[2]);
	103	angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
	104	return kTRUE;
	105	}
	106
	107	//_____________________________________________________________________________
	108	void AliAlignObj::Print(Option_t *) const
	109	{
	110	// Print the contents of the
	111	// alignment object in angles and
	112	// matrix representations
	113	Double_t tr[3];
	114	GetTranslation(tr);
	115	Double_t angles[3];
	116	GetAngles(angles);
	117	TGeoHMatrix m;
	118	GetMatrix(m);
	119	const Double_t *rot = m.GetRotationMatrix();
	120	printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
	121	printf("%12.6f%12.6f%12.6f Tx = %12.6f Psi = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
	122	printf("%12.6f%12.6f%12.6f Ty = %12.6f Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
	123	printf("%12.6f%12.6f%12.6f Tz = %12.6f Phi = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
	124
	125	}
	126
	127
	128	//=============================================================================
	129
	130	ClassImp(AliAlignObjAngles)
	131
	132	//_____________________________________________________________________________
	133	AliAlignObjAngles::AliAlignObjAngles() //: AliAlignObj()
	134	{
	135	// default constructor
	136	fTranslation[0]=fTranslation[1]=fTranslation[2]=0.;
	137	fRotation[0]=fRotation[1]=fRotation[2]=0.;
	138	}
	139
	140	//_____________________________________________________________________________
	141	AliAlignObjAngles::AliAlignObjAngles(const AliAlignObjAngles& theAlignObj) :
	142	AliAlignObj(theAlignObj)
	143	{
	144	// copy constructor
	145	Double_t tr[3];
	146	theAlignObj.GetTranslation(tr);
	147	SetTranslation(tr[0],tr[1],tr[2]);
	148	Double_t rot[3];
	149	theAlignObj.GetAngles(rot);
	150	SetRotation(rot[0],rot[1],rot[2]);
	151	}
	152
	153	//_____________________________________________________________________________
	154	AliAlignObjAngles &AliAlignObjAngles::operator =(const AliAlignObjAngles& theAlignObj)
	155	{
	156	// assignment operator
	157	if(this==&theAlignObj) return *this;
	158	((AliAlignObj *)this)->operator=(theAlignObj);
	159
	160	Double_t tr[3];
	161	theAlignObj.GetTranslation(tr);
	162	SetTranslation(tr[0],tr[1],tr[2]);
163	Double_t rot[3];
164	theAlignObj.GetAngles(rot);
165	SetRotation(rot[0],rot[1],rot[2]);
166	return *this;
167	}
168
169	//_____________________________________________________________________________
170	AliAlignObjAngles::~AliAlignObjAngles()
171	{
172	// default destructor
173	}
174
175	//_____________________________________________________________________________
176	void AliAlignObjAngles::SetTranslation(const TGeoMatrix& m)
177	{
fdf65bb5	178	// Sets the translation parameters from an existing TGeoMatrix
c18195b9	179	if(m.IsTranslation()){
	180	const Double_t* tr = m.GetTranslation();
	181	fTranslation[0]=tr[0]; fTranslation[1]=tr[1]; fTranslation[2]=tr[2];
	182	}else{
	183	// AliWarning("Argument matrix is not a translation! Setting zero-translation.");
	184	fTranslation[0] = fTranslation[1] = fTranslation[2] = 0.;
	185	}
	186	}
	187
	188	//_____________________________________________________________________________
	189	Bool_t AliAlignObjAngles::SetRotation(const TGeoMatrix& m)
	190	{
fdf65bb5	191	// Sets the rotation components from an existing TGeoMatrix
c18195b9	192	if(m.IsRotation()){
	193	const Double_t* rot = m.GetRotationMatrix();
	194	return MatrixToAngles(rot,fRotation);
	195	}else{
	196	// AliWarning("Argument matrix is not a rotation! Setting yaw-pitch-roll to zero.");
	197	fRotation[0] = fRotation[1] = fRotation[2] = 0.;
	198	return kTRUE;
	199	}
	200	}
	201
	202	//_____________________________________________________________________________
	203	void AliAlignObjAngles::SetMatrix(const TGeoMatrix& m)
	204	{
fdf65bb5	205	// Sets both the rotation and translation components from an
fdf65bb5	206	// existing TGeoMatrix
c18195b9	207	SetTranslation(m);
	208	SetRotation(m);
	209	}
	210
	211	//_____________________________________________________________________________
	212	void AliAlignObjAngles::GetPars(Double_t tr[], Double_t angles[]) const
	213	{
fdf65bb5	214	// Returns the translations and the rotation angles
c18195b9	215	GetTranslation(tr);
	216	GetAngles(angles);
	217	}
	218
	219	//_____________________________________________________________________________
	220	void AliAlignObjAngles::GetMatrix(TGeoHMatrix& m) const
	221	{
fdf65bb5	222	// Extracts the information in an existing TGeoHMatrix using the translations
fdf65bb5	223	// and the rotation parameters
c18195b9	224	m.SetTranslation(&fTranslation[0]);
	225	Double_t rot[9];
	226	AnglesToMatrix(fRotation,rot);
	227	m.SetRotation(rot);
	228	}
	229
	230	//=============================================================================
	231
	232	ClassImp(AliAlignObjMatrix)
	233
	234	//_____________________________________________________________________________
	235	AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
	236	{
	237	// Default constructor
	238	}
	239
	240	AliAlignObjMatrix::AliAlignObjMatrix(const AliAlignObjMatrix& theAlignObj) :
	241	AliAlignObj(theAlignObj)
	242	{
	243	//copy constructor
	244	//
	245	Double_t tr[3];
	246	theAlignObj.GetTranslation(tr);
	247	SetTranslation(tr[0],tr[1],tr[2]);
	248	Double_t rot[3];
	249	theAlignObj.GetAngles(rot);
	250	SetRotation(rot[0],rot[1],rot[2]);
	251	}
	252
	253	AliAlignObjMatrix &AliAlignObjMatrix::operator =(const AliAlignObjMatrix& theAlignObj)
	254	{
	255	// assignment operator
	256	//
	257	if(this==&theAlignObj) return *this;
	258	((AliAlignObj *)this)->operator=(theAlignObj);
	259	Double_t tr[3];
	260	theAlignObj.GetTranslation(tr);
	261	SetTranslation(tr[0],tr[1],tr[2]);
	262	Double_t rot[3];
	263	theAlignObj.GetAngles(rot);
	264	SetRotation(rot[0],rot[1],rot[2]);
	265	return *this;
	266	}
	267
	268	AliAlignObjMatrix::~AliAlignObjMatrix()
	269	{
	270	// Destructor
	271	//
	272	}
	273
	274	//_____________________________________________________________________________
	275	void AliAlignObjMatrix::SetTranslation(Double_t x, Double_t y, Double_t z)
	276	{
fdf65bb5	277	// Sets the translation parameters
c18195b9	278	Double_t tr[3];
	279	tr[0]=x; tr[1]=y; tr[2]=z;
	280	fMatrix.SetTranslation(tr);
	281	}
	282
	283	//_____________________________________________________________________________
	284	void AliAlignObjMatrix::SetTranslation(const TGeoMatrix& m)
	285	{
fdf65bb5	286	// Sets the translation parameters from an existing TGeoMatrix
c18195b9	287	const Double_t *tr = m.GetTranslation();
	288	fMatrix.SetTranslation(tr);
	289	}
	290
	291	//_____________________________________________________________________________
	292	void AliAlignObjMatrix::SetRotation(Double_t psi, Double_t theta, Double_t phi)
	293	{
fdf65bb5	294	// Sets the rotation parameters
c18195b9	295	Double_t angles[3] = {psi, theta, phi};
	296	Double_t rot[9];
	297	AnglesToMatrix(angles,rot);
	298	fMatrix.SetRotation(rot);
	299	}
	300
	301	//_____________________________________________________________________________
	302	Bool_t AliAlignObjMatrix::SetRotation(const TGeoMatrix& m)
	303	{
fdf65bb5	304	// Sets the rotation parameters from an existing TGeoMatrix
c18195b9	305	const Double_t* rot = m.GetRotationMatrix();
	306	fMatrix.SetRotation(rot);
	307	return kTRUE;
	308	}
	309
	310	//_____________________________________________________________________________
	311	void AliAlignObjMatrix::SetMatrix(const TGeoMatrix& m)
	312	{
	313	// Set rotation matrix and translation
	314	// using TGeoMatrix
	315	SetTranslation(m);
	316	SetRotation(m);
	317	}
	318
	319	//_____________________________________________________________________________
	320	void AliAlignObjMatrix::SetPars(Double_t x, Double_t y, Double_t z,
	321	Double_t psi, Double_t theta, Double_t phi)
	322	{
	323	// Set rotation matrix and translation
	324	// using 3 angles and 3 translations
	325	SetTranslation(x,y,z);
	326	SetRotation(psi,theta,phi);
	327	}
	328
	329	//_____________________________________________________________________________
	330	void AliAlignObjMatrix::GetTranslation(Double_t *tr) const
	331	{
	332	// Get Translation from TGeoMatrix
	333	const Double_t* translation = fMatrix.GetTranslation();
	334	tr[0] = translation[0];
	335	tr[1] = translation[1];
	336	tr[2] = translation[2];
	337	}
	338
	339	//_____________________________________________________________________________
	340	Bool_t AliAlignObjMatrix::GetAngles(Double_t *angles) const
	341	{
	342	// Get rotation angles from the TGeoHMatrix
	343	const Double_t* rot = fMatrix.GetRotationMatrix();
	344	return MatrixToAngles(rot,angles);
	345	}
	346
	347	//_____________________________________________________________________________
	348	void AliAlignObjMatrix::GetPars(Double_t tr[], Double_t angles[]) const
	349	{
fdf65bb5	350	// Gets the translations and the rotation angles
c18195b9	351	GetTranslation(tr);
	352	GetAngles(angles);
	353	}
	354
	355	//_____________________________________________________________________________
	356	void AliAlignObjMatrix::GetMatrix(TGeoHMatrix& m) const
	357	{
fdf65bb5	358	// Extracts the translations and the rotation parameters
fdf65bb5	359	// in an existing TGeoHMatrix
c18195b9	360	const Double_t *tr = fMatrix.GetTranslation();
	361	m.SetTranslation(tr);
	362	const Double_t *rot = fMatrix.GetRotationMatrix();
	363	m.SetRotation(rot);
	364	}
	365