Comment code, hide public data-members.
authormtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Jan 2008 20:55:41 +0000 (20:55 +0000)
committermtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 18 Jan 2008 20:55:41 +0000 (20:55 +0000)
EVE/Alieve/AliEveITSDigitsInfo.cxx
EVE/Alieve/AliEveITSDigitsInfo.h

index bb40466d21f75ebe697aa3dc847f400a76c3ba28..02ecdebaeb4b03872d975e6415774b6f7598a8a8 100644 (file)
@@ -7,10 +7,6 @@
  * full copyright notice.                                                 * 
  **************************************************************************/
 
-//__________________________________________________________________________
-// AliEveITSDigitsInfo
-//
-//
 #include <TMath.h>
 #include <TVector3.h>
 
 #include <AliITSRawStreamSDD.h>
 #include <AliITSRawStreamSSD.h>
 
-using namespace std;
-
+//______________________________________________________________________________
+//
+// Helper for selecting a range of ITS modules by type, layer, phi and
+// theta. Taken as an argument to AliEveITSDigitsInfo::GetModuleIDs().
 
 ClassImp(AliEveITSModuleSelection)
 
@@ -39,8 +37,15 @@ AliEveITSModuleSelection::AliEveITSModuleSelection():
   fMaxPhi(TMath::Pi()),
   fMinTheta(-TMath::Pi()),
   fMaxTheta(TMath::Pi())
-{}
+{
+  // Constructor.
+}
+
 
+//______________________________________________________________________________
+//
+// Stores ITS geometry information and event-data in format suitable
+// for visualization.
 
 ClassImp(AliEveITSDigitsInfo)
 
@@ -54,16 +59,22 @@ AliEveITSDigitsInfo::AliEveITSDigitsInfo() :
   fGeom (0),
   fSegSPD(0), fSegSDD(0), fSegSSD(0)
 {
+  // Default constructor.
+
   InitInternals();
 }
 
 void AliEveITSDigitsInfo::InitInternals()
 {
+  // Initialize internal geometry structures, in particular the
+  // module-id to transformation-matrix mapping and segmentation
+  // classes and data-structures.
+
   static const TEveException eH("AliEveITSDigitsInfo::InitInternals ");
 
   fGeom = new AliITSgeom();
   fGeom->ReadNewFile("$REVESYS/alice-data/ITSgeometry.det");
-  if(fGeom == 0)
+  if (fGeom == 0)
     throw(eH + "can not load ITS geometry \n");
 
   SetITSSegmentation();
@@ -119,6 +130,9 @@ void AliEveITSDigitsInfo::InitInternals()
 
 AliEveITSDigitsInfo:: ~AliEveITSDigitsInfo() 
 {
+  // Destructor.
+  // Deletes the data-maps and the tree.
+
   map<Int_t, TClonesArray*>::iterator j;
   for(j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
     delete j->second;
@@ -232,9 +246,12 @@ void AliEveITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
 
 void AliEveITSDigitsInfo::SetITSSegmentation()
 {
+  // Create the segmentation objects and fill internal
+  // data-structures.
+
   // SPD
   fSegSPD = new AliITSsegmentationSPD(fGeom);
-  //SPD geometry  
+
   Int_t m;
   Float_t fNzSPD=160;
   Float_t fZ1pitchSPD=0.0425; Float_t fZ2pitchSPD=0.0625;
@@ -254,9 +271,7 @@ void AliEveITSDigitsInfo::SetITSSegmentation()
        m==127 || m==128) dz=1.*fZ2pitchSPD; 
     fSPDZCoord[m]-=dz;
   }
-  
-  // end of SPD geometry
-  
+    
   // SDD
   fSegSDD = new AliITSsegmentationSDD(fGeom);
 
@@ -264,20 +279,19 @@ void AliEveITSDigitsInfo::SetITSSegmentation()
   fSegSSD = new AliITSsegmentationSSD(fGeom);
 }
 
-void AliEveITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
-{
-  z = fSPDZCoord[j];
-}
-
 /**************************************************************************/
 
 TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
 {
-  switch(subdet) {
-    case 0: {
+  // Return TClonesArray of digits for specified module and sub-detector-id.
+
+  switch(subdet)
+  {
+    case 0:
+    {
       TClonesArray* digitsSPD = 0;
       map<Int_t, TClonesArray*>::iterator i = fSPDmap.find(mod);
-      if(i == fSPDmap.end()) {
+      if (i == fSPDmap.end()) {
        if (fTree) {
          TBranch* br =  fTree->GetBranch("ITSDigitsSPD");
          br->SetAddress(&digitsSPD);
@@ -292,10 +306,11 @@ TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
       }
       break;
     }
-    case 1: {
+    case 1:
+    {
       TClonesArray* digitsSDD = 0;
       map<Int_t, TClonesArray*>::iterator i = fSDDmap.find(mod);
-      if(i == fSDDmap.end()) {
+      if (i == fSDDmap.end()) {
        if (fTree) {
          TBranch* br =  fTree->GetBranch("ITSDigitsSDD");
          br->SetAddress(&digitsSDD);
@@ -310,10 +325,11 @@ TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
       }
       break;
     }
-    case 2: {
+    case 2:
+    {
       TClonesArray* digitsSSD = 0;
       map<Int_t, TClonesArray*>::iterator i = fSSDmap.find(mod);
-      if(i == fSSDmap.end()) {
+      if (i == fSSDmap.end()) {
        if (fTree) {
          TBranch* br =  fTree->GetBranch("ITSDigitsSSD");
          br->SetAddress(&digitsSSD);
@@ -331,14 +347,18 @@ TClonesArray* AliEveITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
     }
     default:
       return 0;
-  } //end switch
+  }
   return 0;
 }
 
 /**************************************************************************/
-void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel, std::vector<UInt_t>& ids)
+
+void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel,
+                                      std::vector<UInt_t>& ids)
 {
-  // loop SPD
+  // Fill the id-vector with ids of modules that satisfy conditions
+  // given by the AliEveITSModuleSelection object.
+
   Int_t idx0 = 0, idx1 = 0;
   switch(sel->fType)
   {
@@ -357,15 +377,17 @@ void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel, std::vecto
     default:
       idx1 = 0;
       idx1 = fGeom->GetLastSSD();
+      break;
   }
 
   TVector3 v;
   Double_t x[9];
   Int_t lay, lad, det;
   TEveTrans mx;
-  for(Int_t id = idx0; id<idx1; id++){
+  for (Int_t id = idx0; id<idx1; ++id)
+  {
     fGeom->GetModuleId(id, lay, lad, det);
-    if(sel->fLayer==lay || sel->fLayer==-1)
+    if (sel->fLayer == lay || sel->fLayer == -1)
     {
       // check data from matrix
       mx.UnitTrans();
@@ -376,9 +398,11 @@ void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel, std::vecto
       fGeom->GetTrans(id, x);  
       mx.SetBaseVec(4, x);
       mx.GetPos(v);
-      if(v.Phi()<=sel->fMaxPhi && v.Phi()>=sel->fMinPhi &&
-         v.Theta()<=sel->fMaxTheta && v.Theta()>=sel->fMinTheta )
+      if (v.Phi()   <= sel->fMaxPhi   && v.Phi()   >= sel->fMinPhi   &&
+         v.Theta() <= sel->fMaxTheta && v.Theta() >= sel->fMinTheta)
+      {
        ids.push_back(id);
+      }
     }
   }
 }
@@ -387,29 +411,33 @@ void AliEveITSDigitsInfo::GetModuleIDs(AliEveITSModuleSelection* sel, std::vecto
 
 void AliEveITSDigitsInfo::Print(Option_t* ) const
 {
+  // Print information about stored geometry and segmentation.
+
   printf("*********************************************************\n");
-  printf("SPD module dimension (%f,%f) \n",fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
-  printf("SPD first,last module:: %d,%d \n", fGeom->GetStartSPD(),fGeom->GetLastSPD() );
-  printf("SPD num cells per module (x::%d,z::%d)\n",fSegSPD->Npx(), fSegSPD->Npz());
-  Int_t iz=0,ix = 0;
-  printf("SPD dimesion of (%d,%d) in pixel(%f,%f) \n", ix,iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
+  printf("SPD module dimension (%f,%f)\n",           fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
+  printf("SPD first,last module:: %d,%d\n",          fGeom->GetStartSPD(), fGeom->GetLastSPD() );
+  printf("SPD num cells per module (x::%d,z::%d)\n", fSegSPD->Npx(), fSegSPD->Npz());
+  Int_t iz = 0, ix = 0;
+  printf("SPD dimesion of (%d,%d) in pixel(%f,%f)\n",   ix, iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
   iz = 32;
-  printf("SPD dimesion of pixel (%d,%d) are (%f,%f) \n", ix,iz, fSegSPD->Dpx(ix)*0.001, fSegSPD->Dpz(iz)*0.001);
+  printf("SPD dimesion of pixel (%d,%d) are (%f,%f)\n", ix, iz, fSegSPD->Dpx(ix)*0.001, fSegSPD->Dpz(iz)*0.001);
  
   printf("*********************************************************\n");
-  printf("SDD module dimension (%f,%f) \n",fSegSDD->Dx()*0.0001, fSegSDD->Dz()*0.0001);
-  printf("SDD first,last module:: %d,%d \n", fGeom->GetStartSDD(),fGeom->GetLastSDD() );
-  printf("SDD num cells per module (x::%d,z::%d)\n",fSegSDD->Npx(), fSegSDD->Npz());
-  printf("SDD dimesion of pixel are (%f,%f) \n", fSegSDD->Dpx(1)*0.001,fSegSDD->Dpz(1)*0.001);
+  printf("SDD module dimension (%f,%f)\n",           fSegSDD->Dx()*0.0001, fSegSDD->Dz()*0.0001);
+  printf("SDD first,last module:: %d,%d\n",          fGeom->GetStartSDD(), fGeom->GetLastSDD());
+  printf("SDD num cells per module (x::%d,z::%d)\n", fSegSDD->Npx(), fSegSDD->Npz());
+  printf("SDD dimesion of pixel are (%f,%f)\n",      fSegSDD->Dpx(1)*0.001, fSegSDD->Dpz(1)*0.001);
+
+  Float_t ap, an;
   printf("*********************************************************\n");
-  printf("SSD module dimension (%f,%f) \n",fSegSSD->Dx()*0.0001, fSegSSD->Dz()*0.0001);
-  printf("SSD first,last module:: %d,%d \n", fGeom->GetStartSSD(),fGeom->GetLastSSD() );
-  printf("SSD strips in module %d \n",fSegSSD->Npx());
-  printf("SSD strip sizes are (%f,%f) \n", fSegSSD->Dpx(1),fSegSSD->Dpz(1));
-  fSegSSD->SetLayer(5); Float_t ap,an;  fSegSSD->Angles(ap,an);
-  printf("SSD layer 5 stereoP %f stereoN %f angle \n",ap,an); 
+  printf("SSD module dimension (%f,%f)\n",  fSegSSD->Dx()*0.0001, fSegSSD->Dz()*0.0001);
+  printf("SSD first,last module:: %d,%d\n", fGeom->GetStartSSD(), fGeom->GetLastSSD() );
+  printf("SSD strips in module %d\n",       fSegSSD->Npx());
+  printf("SSD strip sizes are (%f,%f)\n",   fSegSSD->Dpx(1), fSegSSD->Dpz(1));
+  fSegSSD->SetLayer(5);  fSegSSD->Angles(ap,an);
+  printf("SSD layer 5 stereoP %f stereoN %f angle\n", ap, an); 
   fSegSSD->SetLayer(6);  fSegSSD->Angles(ap,an);
-  printf("SSD layer 6 stereoP %f stereoN %f angle \n",ap,an); 
+  printf("SSD layer 6 stereoP %f stereoN %f angle\n", ap, an); 
 }
 
 
index 5b8daa744c2e2b11401d29e62f0a7bc52a928705..87b224ba02780a2ac6c5b7f64565183d45773a80 100644 (file)
@@ -32,64 +32,82 @@ class AliRawReader;
 /**************************************************************************/
 class AliEveITSModuleSelection
 {
-public:
-  Int_t    fType;
-  Int_t    fLayer;
-  Float_t  fMinPhi;
-  Float_t  fMaxPhi;
-  Float_t  fMinTheta;
-  Float_t  fMaxTheta; 
+protected:
+  Int_t    fType;      // Type of modules: 0 - SPD, 1 - SDD, 2 - SSD.
+  Int_t    fLayer;     // Layer, 0 - inner SPD, 5 - outer SSD.
+  Float_t  fMinPhi;    // Min phi.
+  Float_t  fMaxPhi;    // Max phi.
+  Float_t  fMinTheta;  // Min theta.
+  Float_t  fMaxTheta;  // Max theta.
   
+public:
   AliEveITSModuleSelection();
   virtual ~AliEveITSModuleSelection() {}
 
-  ClassDef(AliEveITSModuleSelection, 1);
+  Int_t   GetType() const        { return fType;     }
+  void    SetType(Int_t x)       { fType = x;        }
+  Int_t   GetLayer() const       { return fLayer;    }
+  void    SetLayer(Int_t x)      { fLayer = x;       }
+  Float_t GetMinPhi() const      { return fMinPhi;   }
+  void    SetMinPhi(Float_t x)   { fMinPhi = x;      }
+  Float_t GetMaxPhi() const      { return fMaxPhi;   }
+  void    SetMaxPhi(Float_t x)   { fMaxPhi = x;      }
+  Float_t GetMinTheta() const    { return fMinTheta; }
+  void    SetMinTheta(Float_t x) { fMinTheta = x;    }
+  Float_t GetMaxTheta() const    { return fMaxTheta; }
+  void    SetMaxTheta(Float_t x) { fMaxTheta = x;    }
+
+  void    SetPhiRange  (Float_t x, Float_t y) { fMinPhi   = x; fMaxPhi   = y; }
+  void    SetThetaRange(Float_t x, Float_t y) { fMinTheta = x; fMaxTheta = y; }
+
+  ClassDef(AliEveITSModuleSelection, 1); // Helper for selecting a range of ITS modules by type, layer, phi and theta.
 };
 
 /**************************************************************************/
 // AliEveITSDigitsInfo
 /**************************************************************************/
+
 class AliEveITSDigitsInfo : public TObject, public TEveRefCnt
 {
   AliEveITSDigitsInfo(const AliEveITSDigitsInfo&);            // Not implemented
   AliEveITSDigitsInfo& operator=(const AliEveITSDigitsInfo&); // Not implemented
 
 private:
-  Float_t fSPDZCoord[192];
+  Float_t fSPDZCoord[192];                // Precalculated z-coordinates for positions of digits.
 
   void InitInternals();
 
 protected:
-  map<Int_t,  TClonesArray*> fSPDmap;
-  map<Int_t,  TClonesArray*> fSDDmap;
-  map<Int_t,  TClonesArray*> fSSDmap;
+  map<Int_t,  TClonesArray*> fSPDmap;     // Map from module-id to SPD data.
+  map<Int_t,  TClonesArray*> fSDDmap;     // Map from module-id to SDD data.
+  map<Int_t,  TClonesArray*> fSSDmap;     // Map from module-id to SSD data.
 
   void        SetITSSegmentation();
 
 public:
-  TTree*                   fTree;
-
-  AliITSgeom*              fGeom;
-  AliITSsegmentationSPD*   fSegSPD;
-  AliITSsegmentationSDD*   fSegSDD;
-  AliITSsegmentationSSD*   fSegSSD;
-
-  Int_t                    fSPDMinVal;
-  Int_t                    fSSDMinVal;
-  Int_t                    fSDDMinVal;
-  Int_t                    fSPDMaxVal;
-  Int_t                    fSSDMaxVal;
-  Int_t                    fSDDMaxVal;
-
-  Int_t                    fSPDHighLim;
-  Int_t                    fSDDHighLim;
-  Int_t                    fSSDHighLim;
-
-  Int_t                    fSPDScaleX[5];
-  Int_t                    fSPDScaleZ[5];
-  Int_t                    fSDDScaleX[5];
-  Int_t                    fSDDScaleZ[5];
-  Int_t                    fSSDScale [5];
+  TTree*                   fTree;         // Tree from which the digits are read.
+
+  AliITSgeom*              fGeom;         // Provides mapping from module-id to transforamtion-matrix.
+  AliITSsegmentationSPD*   fSegSPD;       // Segmentation of SPD.
+  AliITSsegmentationSDD*   fSegSDD;       // Segmentation of SDD.
+  AliITSsegmentationSSD*   fSegSSD;       // Segmentation of SSD.
+
+  Int_t                    fSPDMinVal;    // Default lower limit for display of SPD digits.
+  Int_t                    fSSDMinVal;    // Default lower limit for display of SSD digits.
+  Int_t                    fSDDMinVal;    // Default lower limit for display of SDD digits.
+  Int_t                    fSPDMaxVal;    // Default high  limit for display of SPD digits.
+  Int_t                    fSSDMaxVal;    // Default high  limit for display of SSD digits.
+  Int_t                    fSDDMaxVal;    // Default high  limit for display of SDD digits.
+
+  Int_t                    fSPDHighLim;   // Maximum value of SPD digits.
+  Int_t                    fSDDHighLim;   // Maximum value of SDD digits.
+  Int_t                    fSSDHighLim;   // Maximum value of SSD digits.
+
+  Int_t                    fSPDScaleX[5]; // SPD cell-sizes along X for display of scaled-digits.
+  Int_t                    fSPDScaleZ[5]; // SPD cell-sizes along Z for display of scaled-digits.
+  Int_t                    fSDDScaleX[5]; // SDD cell-sizes along X for display of scaled-digits.
+  Int_t                    fSDDScaleZ[5]; // SDD cell-sizes along Z for display of scaled-digits.
+  Int_t                    fSSDScale [5]; // SSD cell-sizes for display of scaled-digits.
 
   AliEveITSDigitsInfo();
   virtual ~AliEveITSDigitsInfo();
@@ -105,7 +123,12 @@ public:
 
   virtual void Print(Option_t* opt="") const;
 
-  ClassDef(AliEveITSDigitsInfo, 1);
+  ClassDef(AliEveITSDigitsInfo, 1); // Stores ITS geometry information and event-data in format suitable for visualization.
 }; // endclass AliEveITSDigitsInfo
 
+inline void AliEveITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
+{
+  z = fSPDZCoord[j];
+}
+
 #endif