[u/mrichter/AliRoot.git] / ITS / AliITSgeom.h

#ifndef ALIITSGEOM_H
#define ALIITSGEOM_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

/////////////////////////////////////////////////////////////////////////
//  ITS geometry manipulation routines.
//  Created April 15 1999.
//  version: 0.0.0
//  By: Bjorn S. Nilsen
//
//     A package of geometry routines to do transformations between
// local, detector active area, and ALICE global coordinate system in such
// a way as to allow for detector alignment studies and the like. All of
// the information needed to do the coordinate transformation are kept in
// a specialized structure for ease of implementation.
/////////////////////////////////////////////////////////////////////////
#include <fstream.h>
#include <TObjArray.h>
#include <TVector.h>

#include "AliITSgeomSPD.h"
#include "AliITSgeomSDD.h"
#include "AliITSgeomSSD.h"


struct AliITSgeomS {
    Int_t   fShapeIndex; // Shape index for this volume
    Float_t fx0,fy0,fz0; // Translation vector
    Float_t frx,fry,frz; // Rotation about axis, angle radians
    Float_t fr[9];       // the rotation matrix
    Float_t angles[6];   // module center, theta and phi
    Double_t rottrack[3][3]; // the tracking rotation matrix
};

//_______________________________________________________________________

class AliITSgeom : public TObject {

 public:
    AliITSgeom();                            // Default constructor
    AliITSgeom(const char *filename);        // Constructor
    AliITSgeom(const AliITSgeom &source);    // Copy constructor
    //    void operator=(const AliITSgeom &source);// = operator
    AliITSgeom& operator=(const AliITSgeom &source);// = operator

    virtual ~AliITSgeom();                   // Default destructor

    Int_t GetNdetectors(Int_t layer) const {return fNdet[layer-1];}// return number of detector a ladder has
    Int_t GetNladders(Int_t layer)   const {return fNlad[layer-1];}// return number of laders a layer has
    Int_t GetNlayers()               const {return fNlayers;} // return number of layer the ITS has
    void GetAngles(Int_t lay,Int_t lad,Int_t det,
			  Float_t &rx,Float_t &ry,Float_t &rz)const {
                          rx = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].frx;
                          ry = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fry;
                          rz = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].frz;} // Get agnles of roations for a give module
    void GetTrans(Int_t lay,Int_t lad,Int_t det,
			 Float_t &x,Float_t &y,Float_t &z)const {
                         x = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
                         y = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
                         z = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;} // get translation for a given module
    void SetByAngles(Int_t lay,Int_t lad,Int_t det,
		     Float_t rx,Float_t ry,Float_t rz);
    void SetByAngles(Int_t index,Double_t angl[]);
    void SetTrans(Int_t lay,Int_t lad,Int_t det,
			 Float_t x,Float_t y,Float_t z){
                         fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0 = x;
                         fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0 = y;
                         fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0 = z;}// Set translation vector for a give module
    void SetTrans(Int_t index,Double_t x[]);
    void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Float_t *mat);
    void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Double_t *mat);
    void GetRotMatrix(Int_t index,Float_t *mat);
    void GetRotMatrix(Int_t index,Double_t *mat);
    Int_t GetStartDet(Int_t dtype );
    Int_t GetLastDet(Int_t dtype);
    Int_t GetStartSPD() {return GetModuleIndex(1,1,1);} // return starting index for SPD
    Int_t GetLastSPD() {return GetModuleIndex(2,fNlad[1],fNdet[1]);}// return Ending index for SPD
    Int_t GetStartSDD() {return GetModuleIndex(3,1,1);} // return starting index for SDD
    Int_t GetLastSDD() {return GetModuleIndex(4,fNlad[3],fNdet[3]);}// return Ending index for SDD
    Int_t GetStartSSD() {return GetModuleIndex(5,1,1);} // return starting index for SSD
    Int_t GetLastSSD() {return GetModuleIndex(6,fNlad[5],fNdet[5]);}// return Ending index for SSD
    Int_t GetIndexMax() {return GetModuleIndex(fNlayers,fNlad[fNlayers-1],
					       fNdet[fNlayers-1])+1;}// return Ending index for all ITS
    void GtoL(Int_t lay,Int_t lad,Int_t det,const Float_t *g,Float_t *l);
    void GtoL(const Int_t *id,const Float_t *g,Float_t *l);
    void GtoL(const Int_t index,const Float_t *g,Float_t *l);
    void GtoL(Int_t lay,Int_t lad,Int_t det,const Double_t *g,Double_t *l);
    void GtoL(const Int_t *id,const Double_t *g,Double_t *l);
    void GtoL(const Int_t index,const Double_t *g,Double_t *l);
    void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
		      const Float_t *g,Float_t *l);
    void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
		      const Double_t *g,Double_t *l);
    void LtoG(Int_t lay,Int_t lad,Int_t det,const Float_t *l,Float_t *g);
    void LtoG(const Int_t *id,const Float_t *l,Float_t *g);
    void LtoG(const Int_t index,const Float_t *l,Float_t *g);
    void LtoG(Int_t lay,Int_t lad,Int_t det,const Double_t *l,Double_t *g);
    void LtoG(const Int_t *id,const Double_t *l,Double_t *g);
    void LtoG(const Int_t index,const Double_t *l,Double_t *g);
    void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
		      const Float_t *l,Float_t *g);
    void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
		      const Double_t *l,Double_t *g);
    void LtoL(const Int_t *id1,const Int_t *id2,Double_t *l1,Double_t *l2);
    void LtoL(const Int_t index1,const Int_t index2,Double_t *l1,Double_t *l2);
    void LtoLMomentum(const Int_t *id1,const Int_t *id2,
		      const Double_t *l1,Double_t *l2);
    void GtoLErrorMatrix(const Int_t index,Double_t **g,Double_t **l);
    void LtoGErrorMatrix(const Int_t index,Double_t **l,Double_t **g);
    void LtoLErrorMatrix(const Int_t index1,const Int_t index2,
			 Double_t **l1,Double_t **l2);
    Int_t GetModuleIndex(Int_t lay,Int_t lad,Int_t det);
    void GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det);
    void GlobalChange(Float_t  *tran,Float_t  *rot);
    void GlobalCylindericalChange(Float_t *tran,Float_t *rot);
    void RandomChange(Float_t *stran,Float_t *srot);
    void RandomCylindericalChange(Float_t *stran,Float_t *srot);
    void PrintComparison(FILE *fp,AliITSgeom *other);
    void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det);
    ofstream &PrintGeom(ofstream &out);
    ifstream &ReadGeom(ifstream &in);
    virtual Int_t IsVersion() const {return 1;} // return version number
    void AddShape(TObject *shp){fShape->AddLast(shp);} // Add Shapes
    virtual TObject *GetShape(Int_t lay,Int_t lad,Int_t det)
	const {return fShape->At(fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].
				 fShapeIndex);} // return specific TShape

    TObjArray *Shape() {return fShape;} // return Shapes array

    void GeantToTracking(AliITSgeom &source); // This converts the geometry
    // transformations from that used by the ITS and it's Monte Carlo to that
    // used by the track finding code.
    // Usage:
    // AliITSgeom *gm,*gt;
    // gm = ((AliITS *) ITS)->GetITSgeom();
    // gt->GeantToTracking(*gm);
    // This allocates and fills gt with the geometry transforms between the
    // global coordinate system to the local coordinate system used to do
    // tracking.

    void GtoLtracking(Int_t lay,Int_t lad,Int_t det,const Double_t *g,Double_t *l);
    void LtoGtracking(Int_t lay,Int_t lad,Int_t det,const Double_t *l,Double_t *g);
    void GetCenterThetaPhi(Int_t lay,Int_t lad,Int_t det, TVector &x) const {
                       x(0) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
		       x(1) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
		       x(2) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;	                         		 
		       x(3) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[0];
		       x(4) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[1];
		       x(5) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[2];
		       x(6) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[3];
		       x(7) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[4];
		       x(8) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[5];

}

 private:
    Int_t        fNlayers; // The number of layers.
    Int_t        *fNlad;   // Array of the number of ladders/layer(layer)
    Int_t        *fNdet;   // Array of the number of detectors/ladder(layer)
    AliITSgeomS  **fGm;     // Structure of translation and rotation.
    TObjArray    *fShape;  // Array of shapes and detector information.
    
    ClassDef(AliITSgeom,1) // ITS geometry class
};

#endif
Commit	Line	Data
b79e4bc3	1	#ifndef ALIITSGEOM_H
b79e4bc3	2	#define ALIITSGEOM_H
3da30618	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
58005f18	8	/////////////////////////////////////////////////////////////////////////
	9	// ITS geometry manipulation routines.
	10	// Created April 15 1999.
	11	// version: 0.0.0
	12	// By: Bjorn S. Nilsen
	13	//
	14	// A package of geometry routines to do transformations between
	15	// local, detector active area, and ALICE global coordinate system in such
	16	// a way as to allow for detector alignment studies and the like. All of
	17	// the information needed to do the coordinate transformation are kept in
	18	// a specialized structure for ease of implementation.
	19	/////////////////////////////////////////////////////////////////////////
	20	#include <fstream.h>
e8189707	21	#include <TObjArray.h>
	22	#include <TVector.h>
	23
cd44574c	24	#include "AliITSgeomSPD.h"
	25	#include "AliITSgeomSDD.h"
	26	#include "AliITSgeomSSD.h"
58005f18	27
58005f18	28
085bb6ed	29	struct AliITSgeomS {
58005f18	30	Int_t fShapeIndex; // Shape index for this volume
	31	Float_t fx0,fy0,fz0; // Translation vector
	32	Float_t frx,fry,frz; // Rotation about axis, angle radians
	33	Float_t fr[9]; // the rotation matrix
e8189707	34	Float_t angles[6]; // module center, theta and phi
e8189707	35	Double_t rottrack[3][3]; // the tracking rotation matrix
58005f18	36	};
	37
	38	//_______________________________________________________________________
	39
	40	class AliITSgeom : public TObject {
b79e4bc3	41
58005f18	42	public:
085bb6ed	43	AliITSgeom(); // Default constructor
	44	AliITSgeom(const char *filename); // Constructor
	45	AliITSgeom(const AliITSgeom &source); // Copy constructor
	46	// void operator=(const AliITSgeom &source);// = operator
	47	AliITSgeom& operator=(const AliITSgeom &source);// = operator
	48
	49	virtual ~AliITSgeom(); // Default destructor
	50
	51	Int_t GetNdetectors(Int_t layer) const {return fNdet[layer-1];}// return number of detector a ladder has
	52	Int_t GetNladders(Int_t layer) const {return fNlad[layer-1];}// return number of laders a layer has
	53	Int_t GetNlayers() const {return fNlayers;} // return number of layer the ITS has
593d2ea1	54	void GetAngles(Int_t lay,Int_t lad,Int_t det,
593d2ea1	55	Float_t &rx,Float_t &ry,Float_t &rz)const {
085bb6ed	56	rx = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].frx;
	57	ry = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fry;
	58	rz = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].frz;} // Get agnles of roations for a give module
593d2ea1	59	void GetTrans(Int_t lay,Int_t lad,Int_t det,
593d2ea1	60	Float_t &x,Float_t &y,Float_t &z)const {
085bb6ed	61	x = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
	62	y = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
	63	z = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;} // get translation for a given module
58005f18	64	void SetByAngles(Int_t lay,Int_t lad,Int_t det,
58005f18	65	Float_t rx,Float_t ry,Float_t rz);
b79e4bc3	66	void SetByAngles(Int_t index,Double_t angl[]);
593d2ea1	67	void SetTrans(Int_t lay,Int_t lad,Int_t det,
58005f18	68	Float_t x,Float_t y,Float_t z){
085bb6ed	69	fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0 = x;
	70	fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0 = y;
	71	fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0 = z;}// Set translation vector for a give module
b79e4bc3	72	void SetTrans(Int_t index,Double_t x[]);
58005f18	73	void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Float_t *mat);
b79e4bc3	74	void GetRotMatrix(Int_t lay,Int_t lad,Int_t det,Double_t *mat);
	75	void GetRotMatrix(Int_t index,Float_t *mat);
	76	void GetRotMatrix(Int_t index,Double_t *mat);
085bb6ed	77	Int_t GetStartDet(Int_t dtype );
	78	Int_t GetLastDet(Int_t dtype);
	79	Int_t GetStartSPD() {return GetModuleIndex(1,1,1);} // return starting index for SPD
	80	Int_t GetLastSPD() {return GetModuleIndex(2,fNlad[1],fNdet[1]);}// return Ending index for SPD
	81	Int_t GetStartSDD() {return GetModuleIndex(3,1,1);} // return starting index for SDD
	82	Int_t GetLastSDD() {return GetModuleIndex(4,fNlad[3],fNdet[3]);}// return Ending index for SDD
	83	Int_t GetStartSSD() {return GetModuleIndex(5,1,1);} // return starting index for SSD
	84	Int_t GetLastSSD() {return GetModuleIndex(6,fNlad[5],fNdet[5]);}// return Ending index for SSD
b79e4bc3	85	Int_t GetIndexMax() {return GetModuleIndex(fNlayers,fNlad[fNlayers-1],
085bb6ed	86	fNdet[fNlayers-1])+1;}// return Ending index for all ITS
58005f18	87	void GtoL(Int_t lay,Int_t lad,Int_t det,const Float_t g,Float_t l);
	88	void GtoL(const Int_t id,const Float_t g,Float_t *l);
	89	void GtoL(const Int_t index,const Float_t g,Float_t l);
b79e4bc3	90	void GtoL(Int_t lay,Int_t lad,Int_t det,const Double_t g,Double_t l);
	91	void GtoL(const Int_t id,const Double_t g,Double_t *l);
	92	void GtoL(const Int_t index,const Double_t g,Double_t l);
	93	void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
	94	const Float_t g,Float_t l);
	95	void GtoLMomentum(Int_t lay,Int_t lad,Int_t det,
	96	const Double_t g,Double_t l);
58005f18	97	void LtoG(Int_t lay,Int_t lad,Int_t det,const Float_t l,Float_t g);
	98	void LtoG(const Int_t id,const Float_t l,Float_t *g);
	99	void LtoG(const Int_t index,const Float_t l,Float_t g);
b79e4bc3	100	void LtoG(Int_t lay,Int_t lad,Int_t det,const Double_t l,Double_t g);
	101	void LtoG(const Int_t id,const Double_t l,Double_t *g);
	102	void LtoG(const Int_t index,const Double_t l,Double_t g);
	103	void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
	104	const Float_t l,Float_t g);
	105	void LtoGMomentum(Int_t lay,Int_t lad,Int_t det,
	106	const Double_t l,Double_t g);
	107	void LtoL(const Int_t id1,const Int_t id2,Double_t l1,Double_t l2);
	108	void LtoL(const Int_t index1,const Int_t index2,Double_t l1,Double_t l2);
	109	void LtoLMomentum(const Int_t id1,const Int_t id2,
	110	const Double_t l1,Double_t l2);
	111	void GtoLErrorMatrix(const Int_t index,Double_t g,Double_t l);
	112	void LtoGErrorMatrix(const Int_t index,Double_t l,Double_t g);
	113	void LtoLErrorMatrix(const Int_t index1,const Int_t index2,
	114	Double_t l1,Double_t l2);
58005f18	115	Int_t GetModuleIndex(Int_t lay,Int_t lad,Int_t det);
593d2ea1	116	void GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det);
58005f18	117	void GlobalChange(Float_t tran,Float_t rot);
	118	void GlobalCylindericalChange(Float_t tran,Float_t rot);
	119	void RandomChange(Float_t stran,Float_t srot);
	120	void RandomCylindericalChange(Float_t stran,Float_t srot);
	121	void PrintComparison(FILE fp,AliITSgeom other);
	122	void PrintData(FILE *fp,Int_t lay,Int_t lad,Int_t det);
	123	ofstream &PrintGeom(ofstream &out);
	124	ifstream &ReadGeom(ifstream &in);
085bb6ed	125	virtual Int_t IsVersion() const {return 1;} // return version number
085bb6ed	126	void AddShape(TObject *shp){fShape->AddLast(shp);} // Add Shapes
593d2ea1	127	virtual TObject *GetShape(Int_t lay,Int_t lad,Int_t det)
085bb6ed	128	const {return fShape->At(fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].
	129	fShapeIndex);} // return specific TShape
	130
	131	TObjArray *Shape() {return fShape;} // return Shapes array
58005f18	132
b79e4bc3	133	void GeantToTracking(AliITSgeom &source); // This converts the geometry
	134	// transformations from that used by the ITS and it's Monte Carlo to that
	135	// used by the track finding code.
	136	// Usage:
	137	// AliITSgeom gm,gt;
	138	// gm = ((AliITS *) ITS)->GetITSgeom();
	139	// gt->GeantToTracking(*gm);
	140	// This allocates and fills gt with the geometry transforms between the
	141	// global coordinate system to the local coordinate system used to do
	142	// tracking.
085bb6ed	143
e8189707	144	void GtoLtracking(Int_t lay,Int_t lad,Int_t det,const Double_t g,Double_t l);
	145	void LtoGtracking(Int_t lay,Int_t lad,Int_t det,const Double_t l,Double_t g);
	146	void GetCenterThetaPhi(Int_t lay,Int_t lad,Int_t det, TVector &x) const {
	147	x(0) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
	148	x(1) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
	149	x(2) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;
	150	x(3) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[0];
	151	x(4) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[1];
	152	x(5) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[2];
	153	x(6) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[3];
	154	x(7) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[4];
	155	x(8) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[5];
	156
	157	}
	158
085bb6ed	159	private:
	160	Int_t fNlayers; // The number of layers.
	161	Int_t *fNlad; // Array of the number of ladders/layer(layer)
	162	Int_t *fNdet; // Array of the number of detectors/ladder(layer)
	163	AliITSgeomS **fGm; // Structure of translation and rotation.
	164	TObjArray *fShape; // Array of shapes and detector information.
b79e4bc3	165
b79e4bc3	166	ClassDef(AliITSgeom,1) // ITS geometry class
58005f18	167	};
	168
	169	#endif