[u/mrichter/AliRoot.git] / RICH / AliRICHChamber.h

#ifndef AliRICHChamber_h
#define AliRICHChamber_h

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

/* $Id$ */

#include <Riostream.h>

#include <TRotMatrix.h>
#include <TVector3.h>
#include <TMath.h>

#include "AliRICHTresholdMap.h"
#include "AliSegmentation.h"
#include "AliRICHGeometry.h"
#include "AliRICHResponse.h"

class AliRICHClusterFinder;

typedef enum {kMip, kCerenkov} ResponseType;

class AliRICHChamber : public TObject
{
public:
    
   Int_t                fIndexMap[50];   //indeces of tresholds
   AliRICHTresholdMap*  fTresh;          //map of tresholds

public:
// ctor & dtor      
   AliRICHChamber();                                  // default ctor
   AliRICHChamber(const AliRICHChamber & Chamber){}   // copy ctor 
   ~AliRICHChamber(){}                                // dtor
// The following staff is defined in AliRICHChamber.cxx:
   void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);//Transformation from local to global coordinates, chamber-dependant
   void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]);//Transformation from Global to local coordinates, chamber-dependant 
   void GenerateTresholds();                              //Generate pad dependent tresholds
   void DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit, Int_t&x, Float_t newclust[6][500], ResponseType res);// Cluster formation method
// Inline methods:   
   void    Init(Int_t id)           {fSegmentation->Init(id);} // Recalculates all the values after some of them have been changed
   
   void    SetGid(Int_t id)         {fGid=id;}           // Set and get GEANT id  
   Int_t   GetGid()            const{return fGid;}       // Get GEANT id  

   void SetRInner(Float_t rmin)     {frMin=rmin;}        // Set inner radius of sensitive volume   
   Float_t RInner()            const{return frMin;}      // Return inner radius of sensitive volume 
   
   void SetROuter(Float_t rmax)     {frMax=rmax;}        // Set outer radius of sensitive volum  
   Float_t ROuter()            const{return frMax;}      // Return outer radius of sensitive volum  
 
   void    SetZPOS(Float_t p1)      {fzPos=p1;}
   Float_t ZPosition()         const{return fzPos;}
    
   void         SetChamberTransform(Float_t x,Float_t y,Float_t z,TRotMatrix *pRotMatrix) {fX=x; fY=y; fZ=z; fpRotMatrix=pRotMatrix;}
   TRotMatrix * GetRotMatrix()                                                    const   {return fpRotMatrix;}
   Float_t      GetX()                                                            const   {return fX;}
   Float_t      GetY()                                                            const   {return fY;}
   Float_t      GetZ()                                                            const   {return fZ;}    
   Float_t      GetOffset()                                                       const   {return TMath::Sqrt(fX*fX+fY*fY+fZ*fZ);}    
    
   void              SetGeometryModel(AliRICHGeometry* pRICHGeometry)           {fGeometry=pRICHGeometry;}        
   AliRICHGeometry*  GetGeometryModel()                                    const{return fGeometry;}
   
   void              SetResponseModel(AliRICHResponse* pRICHResponse)            {fResponse=pRICHResponse;}
   AliRICHResponse*  GetResponseModel()                                     const{return fResponse;}
   
   void              SetSegmentationModel(AliSegmentation* pRICHSegmentation)   {fSegmentation=pRICHSegmentation;}
   AliSegmentation*  GetSegmentationModel(Int_t i=0)                       const{return fSegmentation;}
   
   void                  SetReconstructionModel(AliRICHClusterFinder *pRICHReconstruction)    {fReconstruction=pRICHReconstruction;}
   AliRICHClusterFinder* &GetReconstructionModel()                                            {return fReconstruction;}

   void   SigGenInit(Float_t x, Float_t y, Float_t z)   {fSegmentation->SigGenInit(x, y, z) ;}
   Int_t  SigGenCond(Float_t x, Float_t y, Float_t z)	{return fSegmentation->SigGenCond(x, y, z);}
   Int_t  Sector(Float_t x, Float_t y)                  {return fSegmentation->Sector(x, y);} // Returns number of sector containing (x,y) position    
   void   SetPadSize(Float_t p1, Float_t p2)            {fSegmentation->SetPadSize(p1,p2);}
   
   Float_t IntPH(Float_t eloss, Float_t yhit)                        {return fResponse->IntPH(eloss,yhit);}
   Float_t IntPH(Float_t yhit)                                       {return fResponse->IntPH(yhit);}
   void   SetSigmaIntegration(Float_t p)                             {fResponse->SetSigmaIntegration(p);}
   void   SetChargeSlope(Float_t p)                                  {fResponse->SetChargeSlope(p);}
   void   SetChargeSpread(Float_t p1, Float_t p2)                    {fResponse->SetChargeSpread(p1,p2);}
   void   SetMaxAdc(Float_t p)                                       {fResponse->SetMaxAdc(p);}
   void   SetSqrtKx3(Float_t p)                                      {fResponse->SetSqrtKx3(p);}
   void   SetKx2(Float_t p)                                          {fResponse->SetKx2(p);}
   void   SetKx4(Float_t p)                                          {fResponse->SetKx4(p);}
   void   SetSqrtKy3(Float_t p)                                      {fResponse->SetSqrtKy3(p);}
   void   SetKy2(Float_t p)                                          {fResponse->SetKy2(p);}
   void   SetKy4(Float_t p)                                          {fResponse->SetKy4(p);}    
   void   SetPitch(Float_t p)                                        {fResponse->SetPitch(p);}
   void   SetWireSag(Int_t p)                                        {fResponse->SetWireSag(p);}
   void   SetVoltage(Int_t p)                                        {fResponse->SetVoltage(p);}    
   
   void   SetGapThickness(Float_t thickness)                         {fGeometry->SetGapThickness(thickness);} 
   void   SetProximityGapThickness(Float_t thickness)                {fGeometry->SetProximityGapThickness(thickness);}
   void   SetQuartzLength(Float_t length)                            {fGeometry->SetQuartzLength(length);}
   void   SetQuartzWidth(Float_t width)                              {fGeometry->SetQuartzWidth(width);}
   void   SetQuartzThickness(Float_t thickness)                      {fGeometry->SetQuartzThickness(thickness);}
   void   SetOuterFreonLength(Float_t length)                        {fGeometry->SetOuterFreonLength(length);}
   void   SetOuterFreonWidth(Float_t width)                          {fGeometry->SetOuterFreonWidth(width);}
   void   SetInnerFreonLength(Float_t length)                        {fGeometry->SetInnerFreonLength(length);}
   void   SetInnerFreonWidth(Float_t width)                          {fGeometry->SetInnerFreonWidth(width);}
   void   SetFreonThickness(Float_t thickness)                       {fGeometry->SetFreonThickness(thickness);}
   
   AliRICHChamber& operator=(const AliRICHChamber& rhs){return *this;}
   
   inline virtual void Print(Option_t *sOption)const;   

private:
   Float_t frMin;                                         // Minimum Chamber size
   Float_t frMax;                                         // Maximum Chamber size 
   Int_t   fGid;                                          // Id tag 
   Float_t fzPos;                                         // z-position of this chamber

   TRotMatrix *fpRotMatrix;                               // Rotation matrix of the chamber with respect to MRS 
   Float_t fX,fY,fZ;                                      // Position of the center of the chamber in MRS (cm)

   AliSegmentation               *fSegmentation;          // Segmentation model for each chamber
   AliRICHResponse               *fResponse;              // Response model for each chamber
   AliRICHGeometry               *fGeometry;              // Geometry model for each chamber
   AliRICHClusterFinder          *fReconstruction;        // Reconstruction model for each chamber
   ClassDef(AliRICHChamber,1)                             // A single RICH chamber desription
};
    
inline void AliRICHChamber::Print(Option_t *sOption)const
{
   TObject::Print(sOption);
   cout<<"X="<<fX<<endl;   
   cout<<"Y="<<fY<<endl;
   cout<<"Z="<<fZ<<endl;
   TVector3 vector3(fX,fY,fZ);
   cout<<"Offset="<<vector3.Mag()<<endl;
   cout<<"Polar angle="<<vector3.Theta()/TMath::Pi()*180<<endl;
   cout<<"Azimithal angle="<<vector3.Phi()/TMath::Pi()*180<<endl;
}// inline void AliRICHChamber::Print(Option_t *sOPtion)
     
#endif //AliRICHChamber_h
Commit	Line	Data
06b2d19f	1	#ifndef AliRICHChamber_h
06b2d19f	2	#define AliRICHChamber_h
2e5f0f7b	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	/* $Id$ */
	8
7118aef0	9	#include <Riostream.h>
06b2d19f	10
2e5f0f7b	11	#include <TRotMatrix.h>
06b2d19f	12	#include <TVector3.h>
06b2d19f	13	#include <TMath.h>
2e5f0f7b	14
4faf338d	15	#include "AliRICHTresholdMap.h"
a2f7eaf6	16	#include "AliSegmentation.h"
237c933d	17	#include "AliRICHGeometry.h"
237c933d	18	#include "AliRICHResponse.h"
2e5f0f7b	19
2e5f0f7b	20	class AliRICHClusterFinder;
237c933d	21
237c933d	22	typedef enum {kMip, kCerenkov} ResponseType;
2e5f0f7b	23
	24	class AliRICHChamber : public TObject
	25	{
06b2d19f	26	public:
2e5f0f7b	27
06b2d19f	28	Int_t fIndexMap[50]; //indeces of tresholds
	29	AliRICHTresholdMap* fTresh; //map of tresholds
	30
	31	public:
	32	// ctor & dtor
	33	AliRICHChamber(); // default ctor
	34	AliRICHChamber(const AliRICHChamber & Chamber){} // copy ctor
	35	~AliRICHChamber(){} // dtor
	36	// The following staff is defined in AliRICHChamber.cxx:
	37	void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);//Transformation from local to global coordinates, chamber-dependant
	38	void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]);//Transformation from Global to local coordinates, chamber-dependant
	39	void GenerateTresholds(); //Generate pad dependent tresholds
	40	void DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit, Int_t&x, Float_t newclust[6][500], ResponseType res);// Cluster formation method
	41	// Inline methods:
	42	void Init(Int_t id) {fSegmentation->Init(id);} // Recalculates all the values after some of them have been changed
	43
	44	void SetGid(Int_t id) {fGid=id;} // Set and get GEANT id
	45	Int_t GetGid() const{return fGid;} // Get GEANT id
4faf338d	46
06b2d19f	47	void SetRInner(Float_t rmin) {frMin=rmin;} // Set inner radius of sensitive volume
	48	Float_t RInner() const{return frMin;} // Return inner radius of sensitive volume
	49
	50	void SetROuter(Float_t rmax) {frMax=rmax;} // Set outer radius of sensitive volum
	51	Float_t ROuter() const{return frMax;} // Return outer radius of sensitive volum
	52
	53	void SetZPOS(Float_t p1) {fzPos=p1;}
	54	Float_t ZPosition() const{return fzPos;}
2e5f0f7b	55
957589ce	56	void SetChamberTransform(Float_t x,Float_t y,Float_t z,TRotMatrix *pRotMatrix) {fX=x; fY=y; fZ=z; fpRotMatrix=pRotMatrix;}
	57	TRotMatrix * GetRotMatrix() const {return fpRotMatrix;}
	58	Float_t GetX() const {return fX;}
	59	Float_t GetY() const {return fY;}
	60	Float_t GetZ() const {return fZ;}
06b2d19f	61	Float_t GetOffset() const {return TMath::Sqrt(fXfX+fYfY+fZ*fZ);}
2e5f0f7b	62
06b2d19f	63	void SetGeometryModel(AliRICHGeometry* pRICHGeometry) {fGeometry=pRICHGeometry;}
06b2d19f	64	AliRICHGeometry* GetGeometryModel() const{return fGeometry;}
957589ce	65
06b2d19f	66	void SetResponseModel(AliRICHResponse* pRICHResponse) {fResponse=pRICHResponse;}
	67	AliRICHResponse* GetResponseModel() const{return fResponse;}
	68
	69	void SetSegmentationModel(AliSegmentation* pRICHSegmentation) {fSegmentation=pRICHSegmentation;}
	70	AliSegmentation* GetSegmentationModel(Int_t i=0) const{return fSegmentation;}
	71
	72	void SetReconstructionModel(AliRICHClusterFinder *pRICHReconstruction) {fReconstruction=pRICHReconstruction;}
	73	AliRICHClusterFinder* &GetReconstructionModel() {return fReconstruction;}
237c933d	74
06b2d19f	75	void SigGenInit(Float_t x, Float_t y, Float_t z) {fSegmentation->SigGenInit(x, y, z) ;}
	76	Int_t SigGenCond(Float_t x, Float_t y, Float_t z) {return fSegmentation->SigGenCond(x, y, z);}
	77	Int_t Sector(Float_t x, Float_t y) {return fSegmentation->Sector(x, y);} // Returns number of sector containing (x,y) position
	78	void SetPadSize(Float_t p1, Float_t p2) {fSegmentation->SetPadSize(p1,p2);}
	79
	80	Float_t IntPH(Float_t eloss, Float_t yhit) {return fResponse->IntPH(eloss,yhit);}
	81	Float_t IntPH(Float_t yhit) {return fResponse->IntPH(yhit);}
	82	void SetSigmaIntegration(Float_t p) {fResponse->SetSigmaIntegration(p);}
	83	void SetChargeSlope(Float_t p) {fResponse->SetChargeSlope(p);}
	84	void SetChargeSpread(Float_t p1, Float_t p2) {fResponse->SetChargeSpread(p1,p2);}
	85	void SetMaxAdc(Float_t p) {fResponse->SetMaxAdc(p);}
	86	void SetSqrtKx3(Float_t p) {fResponse->SetSqrtKx3(p);}
	87	void SetKx2(Float_t p) {fResponse->SetKx2(p);}
	88	void SetKx4(Float_t p) {fResponse->SetKx4(p);}
	89	void SetSqrtKy3(Float_t p) {fResponse->SetSqrtKy3(p);}
	90	void SetKy2(Float_t p) {fResponse->SetKy2(p);}
	91	void SetKy4(Float_t p) {fResponse->SetKy4(p);}
	92	void SetPitch(Float_t p) {fResponse->SetPitch(p);}
	93	void SetWireSag(Int_t p) {fResponse->SetWireSag(p);}
	94	void SetVoltage(Int_t p) {fResponse->SetVoltage(p);}
	95
	96	void SetGapThickness(Float_t thickness) {fGeometry->SetGapThickness(thickness);}
	97	void SetProximityGapThickness(Float_t thickness) {fGeometry->SetProximityGapThickness(thickness);}
	98	void SetQuartzLength(Float_t length) {fGeometry->SetQuartzLength(length);}
	99	void SetQuartzWidth(Float_t width) {fGeometry->SetQuartzWidth(width);}
	100	void SetQuartzThickness(Float_t thickness) {fGeometry->SetQuartzThickness(thickness);}
	101	void SetOuterFreonLength(Float_t length) {fGeometry->SetOuterFreonLength(length);}
	102	void SetOuterFreonWidth(Float_t width) {fGeometry->SetOuterFreonWidth(width);}
	103	void SetInnerFreonLength(Float_t length) {fGeometry->SetInnerFreonLength(length);}
	104	void SetInnerFreonWidth(Float_t width) {fGeometry->SetInnerFreonWidth(width);}
	105	void SetFreonThickness(Float_t thickness) {fGeometry->SetFreonThickness(thickness);}
	106
	107	AliRICHChamber& operator=(const AliRICHChamber& rhs){return *this;}
	108
	109	inline virtual void Print(Option_t *sOption)const;
	110
	111	private:
	112	Float_t frMin; // Minimum Chamber size
	113	Float_t frMax; // Maximum Chamber size
	114	Int_t fGid; // Id tag
	115	Float_t fzPos; // z-position of this chamber
	116
	117	TRotMatrix *fpRotMatrix; // Rotation matrix of the chamber with respect to MRS
	118	Float_t fX,fY,fZ; // Position of the center of the chamber in MRS (cm)
	119
	120	AliSegmentation *fSegmentation; // Segmentation model for each chamber
	121	AliRICHResponse *fResponse; // Response model for each chamber
	122	AliRICHGeometry *fGeometry; // Geometry model for each chamber
	123	AliRICHClusterFinder *fReconstruction; // Reconstruction model for each chamber
	124	ClassDef(AliRICHChamber,1) // A single RICH chamber desription
2e5f0f7b	125	};
06b2d19f	126
	127	inline void AliRICHChamber::Print(Option_t *sOption)const
	128	{
	129	TObject::Print(sOption);
	130	cout<<"X="<<fX<<endl;
	131	cout<<"Y="<<fY<<endl;
	132	cout<<"Z="<<fZ<<endl;
	133	TVector3 vector3(fX,fY,fZ);
	134	cout<<"Offset="<<vector3.Mag()<<endl;
	135	cout<<"Polar angle="<<vector3.Theta()/TMath::Pi()*180<<endl;
	136	cout<<"Azimithal angle="<<vector3.Phi()/TMath::Pi()*180<<endl;
	137	}// inline void AliRICHChamber::Print(Option_t *sOPtion)
	138
	139	#endif //AliRICHChamber_h