]> git.uio.no Git - u/mrichter/AliRoot.git/commitdiff
Print() added + const
authordibari <dibari@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Nov 2001 14:53:53 +0000 (14:53 +0000)
committerdibari <dibari@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 13 Nov 2001 14:53:53 +0000 (14:53 +0000)
RICH/AliRICHChamber.h

index 4433f11c3804c2706cefd58224da48fed49cea22..814e3603cd6d508b84e5e123589908a9d666ff7f 100644 (file)
@@ -1,13 +1,16 @@
-#ifndef ALIRICHCHAMBER_H
-#define 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 <TObjArray.h>
+#include <iostream.h>
+
 #include <TRotMatrix.h>
+#include <TVector3.h>
+#include <TMath.h>
 
 #include "AliRICHTresholdMap.h"
 #include "AliSegmentation.h"
@@ -20,238 +23,117 @@ typedef enum {kMip, kCerenkov} ResponseType;
 
 class AliRICHChamber : public TObject
 {
- public:
-    
-  Int_t                fIndexMap[50];   //indeces of tresholds
-  AliRICHTresholdMap*  fTresh;          //map of tresholds
-
- public:
-    AliRICHChamber();
-    AliRICHChamber(const AliRICHChamber & Chamber);
-    ~AliRICHChamber(){}
-//
-// Set and get GEANT id  
-    Int_t   GetGid()         {return fGid;}
-    void    SetGid(Int_t id) {fGid=id;}
-//  
-// Initialisation and z-Position
-    void    Init(Int_t id);
-    // Set inner radius of sensitive volume 
-    void SetRInner(Float_t rmin) {frMin=rmin;}
-// Set outer radius of sensitive volum  
-    void SetROuter(Float_t rmax) {frMax=rmax;}  
+public:
     
-// Return inner radius of sensitive volume 
-    Float_t RInner()            {return frMin;}
-// Return outer radius of sensitive volum  
-    Float_t ROuter()            {return frMax;}
-
-    void    SetZPOS(Float_t p1) {fzPos=p1;}
-    Float_t ZPosition()         {return fzPos;}
-
-//
-//Transformation from Global to local coordinates, chamber-dependant
-    void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);
-    void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]); 
-
-//Generate pad dependent tresholds
-
-    void GenerateTresholds();
+   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;}
     
-// getter&setter for the chamber position and attitude    
    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);}    
     
-//Configure geometry model
-    void    GeometryModel(AliRICHGeometry* thisGeometry){
-      fGeometry=thisGeometry;
-    }
-    
-    
-// Configure response model
-    void    ResponseModel(AliRICHResponse* thisResponse);
-    
-    //  
-// Configure segmentation model
-    void    SetSegmentationModel(AliSegmentation* thisSegmentation) {
-       fSegmentation = thisSegmentation;
-    }
-    void    SetReconstructionModel(AliRICHClusterFinder *thisReconstruction) {
-       fReconstruction = thisReconstruction;
-    }
-
-//  
-//  Get reference to response model
-    AliRICHResponse* GetResponseModel();
-//  
-//  Get reference to segmentation model
-    AliSegmentation*  GetSegmentationModel() {
-       return fSegmentation;
-    }
-
-//  Get reference to geometry model
-    AliRICHGeometry*  GetGeometryModel() {
-       return fGeometry;
-    }
-    
-
-    AliSegmentation*  GetSegmentationModel(Int_t i) {
-       return fSegmentation;
-    }
-    
-    //
-    AliRICHClusterFinder* &GetReconstructionModel() {return fReconstruction;}
-
-// Member function forwarding to the segmentation and response models
-//
-// Calculate pulse height from energy loss  
-    Float_t IntPH(Float_t eloss, Float_t yhit) {return fResponse->IntPH(eloss,yhit);}
-    Float_t IntPH(Float_t yhit)              {return fResponse->IntPH(yhit);}
-//  
-// Ask segmentation if signal should be generated  
-    Int_t   SigGenCond(Float_t x, Float_t y, Float_t z)
-       {
-           return fSegmentation->SigGenCond(x, y, z);
-       }
-
-// Ask segmentation sector 
-    Int_t   Sector(Float_t x, Float_t y)
-       {
-           return fSegmentation->Sector(x, y);
-       }   
-    
-//
-// Initialisation of segmentation for hit  
-    void   SigGenInit(Float_t x, Float_t y, Float_t z)
-       {
-           fSegmentation->SigGenInit(x, y, z) ;
-       }
-// Configuration forwarding
-//
-    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   SetPadSize(Float_t p1, Float_t p2)
-       {
-           fSegmentation->SetPadSize(p1,p2);
-       }
-    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);
+   void              SetGeometryModel(AliRICHGeometry* pRICHGeometry)           {fGeometry=pRICHGeometry;}        
+   AliRICHGeometry*  GetGeometryModel()                                    const{return fGeometry;}
    
-//  
-// Cluster formation method
-    void   DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit, Int_t&x, Float_t newclust[6][500], ResponseType res);
- private:
-// GEANT volume if for sensitive volume of this
-    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)
+   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;}
 
-    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)
+   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
 };
-#endif
+    
+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