Cleaning violated rules

diff --git a/CRT/AliCRT.cxx b/CRT/AliCRT.cxx
index 9d3f1b6e79b93f0a927c1748ee11fb4a06ae3cc1..b099c5b3af39a1dc0d623a0fc03a268124358800 100644 (file)
--- a/CRT/AliCRT.cxx
+++ b/CRT/AliCRT.cxx
@@ -37,18 +37,21 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include "AliCRT.h"
+
 #include <TTree.h>
 
 #include "AliRun.h"
 #include "AliMagF.h"
 
-#include "AliCRT.h"
+#include "AliCRTModule.h"
 
 ClassImp(AliCRT)
 
 //_____________________________________________________________________________
 AliCRT::AliCRT()
-  : AliDetector()
+  : AliDetector(),
+    fModule(0)
 {
   //
   // Default constructor
@@ -57,7 +60,8 @@ AliCRT::AliCRT()
  
 //_____________________________________________________________________________
 AliCRT::AliCRT(const char *name, const char *title)
-  : AliDetector(name, title)
+  : AliDetector(name, title),
+    fModule(0)
 {
   //
   // Standard constructor
@@ -66,7 +70,8 @@ AliCRT::AliCRT(const char *name, const char *title)
 
 //_____________________________________________________________________________
 AliCRT::AliCRT(const AliCRT& crt)
-  : AliDetector(crt)
+  : AliDetector(crt),
+    fModule(crt.fModule)
 {
   //
   // Copy constructor
@@ -80,6 +85,7 @@ AliCRT::~AliCRT()
   //
   // Default destructor
   //
+  if ( fModule ) { delete fModule; fModule = 0; }
 }
 
 //_____________________________________________________________________________

diff --git a/CRT/AliCRT.h b/CRT/AliCRT.h
index 152705627a22fd7a8caf76f532a49bbd1ec0f3a1..9a1561c0baddf4e2754a4962de71d57bbae2096a 100644 (file)
--- a/CRT/AliCRT.h
+++ b/CRT/AliCRT.h
@@ -11,6 +11,8 @@
 
 #include "AliDetector.h"
 
+class AliCRTModule;
+
 class AliCRT : public AliDetector {
 public:
   AliCRT();
@@ -26,11 +28,12 @@ public:
   virtual TString Version() { return TString(""); }
 
   virtual void SetTreeAddress();
+  virtual void SetModule(AliCRTModule* module) {fModule = module;}
+  virtual const AliCRTModule* GetModule() const {return fModule; }
 
+protected:
+  AliCRTModule* fModule;
 private:
   ClassDef(AliCRT, 1) // Cosmic Ray Trigger (ACORDE) base class
 };
-
-
-// inline TString AliCRT::Version()
 #endif // ALICRT_H

diff --git a/CRT/AliCRTConstants.cxx b/CRT/AliCRTConstants.cxx
index 45155d470ce2f884b907fc371500aaebbfbd84f2..c0f3b891603b99dabb78607e3af59f72c2163363 100644 (file)
--- a/CRT/AliCRTConstants.cxx
+++ b/CRT/AliCRTConstants.cxx
@@ -30,20 +30,142 @@
 
 #include "AliCRTConstants.h"
 
-const Float_t AliCRTConstants::fgCageLenght          = 477.6;
-const Float_t AliCRTConstants::fgCageWidth           = 166.7;
-const Float_t AliCRTConstants::fgCageHeight          =  10.7;
-const Float_t AliCRTConstants::fgSinglePaletteLenght = 363.0;
-const Float_t AliCRTConstants::fgSinglePaletteWidth  =  19.7;
-const Float_t AliCRTConstants::fgSinglePaletteHeight =   1;
-const Float_t AliCRTConstants::fgActiveAreaGap       = 0.7;
-const Float_t AliCRTConstants::fgActiveAreaLenght    = AliCRTConstants::fgSinglePaletteLenght;
-const Float_t AliCRTConstants::fgActiveAreaWidth     = 156.7;
-const Float_t AliCRTConstants::fgActiveAreaHeight    = 2*AliCRTConstants::fgSinglePaletteHeight + AliCRTConstants::fgActiveAreaGap;
-const Float_t AliCRTConstants::fgMagnetWidth         = 654.4;
-const Float_t AliCRTConstants::fgMagnetLenght        = 1200;
-const Float_t AliCRTConstants::fgMagMinRadius        = 790;
-const Float_t AliCRTConstants::fgMagMaxRadius        = AliCRTConstants::fgMagMinRadius + 20;
-const Float_t AliCRTConstants::fgDepth               =4420; // cm
+AliCRTConstants* AliCRTConstants::fgInstance = 0;
+
+const Float_t AliCRTConstants::fgkCageLenght          = 477.6;
+const Float_t AliCRTConstants::fgkCageWidth           = 166.7;
+const Float_t AliCRTConstants::fgkCageHeight          =  10.7;
+const Float_t AliCRTConstants::fgkSinglePaletteLenght = 363.0;
+const Float_t AliCRTConstants::fgkSinglePaletteWidth  =  19.7;
+const Float_t AliCRTConstants::fgkSinglePaletteHeight =   1;
+const Float_t AliCRTConstants::fgkActiveAreaGap       = 0.7;
+const Float_t AliCRTConstants::fgkActiveAreaLenght    = AliCRTConstants::fgkSinglePaletteLenght;
+const Float_t AliCRTConstants::fgkActiveAreaWidth     = 156.7;
+const Float_t AliCRTConstants::fgkActiveAreaHeight    = 2*AliCRTConstants::fgkSinglePaletteHeight + AliCRTConstants::fgkActiveAreaGap;
+const Float_t AliCRTConstants::fgkMagnetWidth         = 654.4;
+const Float_t AliCRTConstants::fgkMagnetLenght        = 1200;
+const Float_t AliCRTConstants::fgkMagMinRadius        = 790;
+const Float_t AliCRTConstants::fgkMagMaxRadius        = AliCRTConstants::fgkMagMinRadius + 20;
+const Float_t AliCRTConstants::fgkDepth               =4420; // cm
 
 ClassImp(AliCRTConstants)
+
+//_____________________________________________________________________________
+AliCRTConstants* AliCRTConstants::Instance()
+{
+  if ( !fgInstance ) {
+    fgInstance = new AliCRTConstants;
+  }
+  return fgInstance;
+}
+
+//_____________________________________________________________________________
+AliCRTConstants::~AliCRTConstants()
+{
+  fgInstance = 0;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::CageLenght() const
+{
+  // Module lenght
+  return fgkCageLenght;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::CageWidth() const
+{
+  // Module width
+  return fgkCageWidth;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::CageHeight() const
+{
+  // Module height
+  return fgkCageHeight;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::SinglePaletteLenght() const
+{
+  // Lenght of the scintillator active zone for a single counter
+  return fgkSinglePaletteLenght;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::SinglePaletteWidth() const
+{
+  // Width of the scintillator active zone for a single counter
+  return fgkSinglePaletteWidth;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::SinglePaletteHeight() const
+{
+  // Height of the scintillator active zone for a single counter
+  return fgkSinglePaletteHeight;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::ActiveAreaGap() const
+{ 
+  // Gap betwen scintillators
+  return fgkActiveAreaGap;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::ActiveAreaLenght() const
+{
+  // Lenght of the scintillator active zone
+  return fgkActiveAreaLenght;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::ActiveAreaWidth() const
+{
+  // Width of the scintillator active zone
+  return fgkActiveAreaWidth;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::ActiveAreaHeight() const
+{
+  // Height of the scintillator active zone
+  return fgkActiveAreaHeight;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::MagnetWidth() const
+{
+  // Magnet  width
+  return fgkMagnetWidth;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::MagnetLenght() const
+{
+  // Magnet lenght
+  return fgkMagnetLenght;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::MagMinRadius() const
+{
+  // Magnet Inner radius
+  return fgkMagMinRadius;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::MagMaxRadius() const
+{
+  // Magnet outer radius
+  return fgkMagMaxRadius;
+}
+
+//_____________________________________________________________________________
+const Float_t AliCRTConstants::Depth() const
+{
+  // Alice IP depth
+  return fgkDepth;
+}

diff --git a/CRT/AliCRTConstants.h b/CRT/AliCRTConstants.h
index f162bc14bdf31d6ac09b12ae29023bbb3a93b85a..9eef5a2fd9abc10e1daaf87e9ab5247ca3320dee 100644 (file)
--- a/CRT/AliCRTConstants.h
+++ b/CRT/AliCRTConstants.h
@@ -28,39 +28,58 @@ enum ECRMode {
 
 class AliCRTConstants {
 public:
-  // Module dimentions
-  static const Float_t fgCageLenght; // Module lenght
-  static const Float_t fgCageWidth;  // Module width
-  static const Float_t fgCageHeight; // Module height
+  virtual ~AliCRTConstants();
 
-  // The dimensions of the active area of a single palette are:
-  static const Float_t fgSinglePaletteLenght; //
-  static const Float_t fgSinglePaletteWidth; //
-  static const Float_t fgSinglePaletteHeight; //
+  static AliCRTConstants* Instance();
 
-  static const Float_t fgActiveAreaGap; //
+  const Float_t CageLenght() const;
+  const Float_t CageWidth() const;
+  const Float_t CageHeight() const;
 
-  // Aproximate dimensions of the active area of the module.
-  static const Float_t fgActiveAreaLenght;
-  static const Float_t fgActiveAreaWidth; //
-  static const Float_t fgActiveAreaHeight;
+  const Float_t SinglePaletteLenght() const;
+  const Float_t SinglePaletteWidth() const;
+  const Float_t SinglePaletteHeight() const;
 
-  // Magnet
-  static const Float_t fgMagnetWidth; //
-  static const Float_t fgMagnetLenght; //
-  static const Float_t fgMagMinRadius; //
-  static const Float_t fgMagMaxRadius; //
+  const Float_t ActiveAreaGap() const;
+  const Float_t ActiveAreaLenght() const;
+  const Float_t ActiveAreaWidth() const;
+  const Float_t ActiveAreaHeight() const;
 
-  // Surface
-  static const Float_t fgDepth;
+  const Float_t MagnetWidth() const;
+  const Float_t MagnetLenght() const;
+  const Float_t MagMinRadius() const;
+  const Float_t MagMaxRadius() const;
 
-  AliCRTConstants() {}
-  virtual ~AliCRTConstants() {}
+  const Float_t Depth() const;
 
 protected:
+  AliCRTConstants() {}
   AliCRTConstants(const AliCRTConstants& ct) {}
   AliCRTConstants& operator=(const AliCRTConstants& ct) {return *this;}
 
+  static AliCRTConstants* fgInstance;
+
+  static const Float_t fgkCageLenght;
+  static const Float_t fgkCageWidth;
+  static const Float_t fgkCageHeight;
+
+  static const Float_t fgkSinglePaletteLenght;
+  static const Float_t fgkSinglePaletteWidth;
+  static const Float_t fgkSinglePaletteHeight;
+
+  static const Float_t fgkActiveAreaGap;
+
+  static const Float_t fgkActiveAreaLenght;
+  static const Float_t fgkActiveAreaWidth;
+  static const Float_t fgkActiveAreaHeight;
+
+  static const Float_t fgkMagnetWidth;
+  static const Float_t fgkMagnetLenght;
+  static const Float_t fgkMagMinRadius;
+  static const Float_t fgkMagMaxRadius;
+
+  static const Float_t fgkDepth;
+
  private:
   ClassDef(AliCRTConstants, 0)   // CRT(ACORDE) global constants
 };

diff --git a/CRT/AliCRTdigit.cxx b/CRT/AliCRTdigit.cxx
index f4c297fac5a4a0b0f0cf618ba1726b9782ec8923..d8e829b48949047e22f1801a30c920188bb76d29 100644 (file)
--- a/CRT/AliCRTdigit.cxx
+++ b/CRT/AliCRTdigit.cxx
@@ -15,11 +15,11 @@
 
 /* $Id$ */
 
+#include "AliCRTdigit.h"
+
 #include <TArrayF.h>
 #include <TArrayI.h>
 
-#include "AliCRTdigit.h"
-
 ClassImp(AliCRTdigit)
 
 //_____________________________________________________________________________

diff --git a/CRT/AliCRThit.cxx b/CRT/AliCRThit.cxx
index 275c88a1679be44e1e7b544b725143fc21c22ede..0b9a4486b71e9dcfe10af72b518231d7d897a3a9 100644 (file)
--- a/CRT/AliCRThit.cxx
+++ b/CRT/AliCRThit.cxx
@@ -15,10 +15,11 @@
 
 /* $Id$ */
 
+#include "AliCRThit.h"
+
 #include <TMath.h>
 
 #include "AliConst.h"
-#include "AliCRThit.h"
 
 ClassImp(AliCRThit)
 

diff --git a/CRT/AliCRTv1.cxx b/CRT/AliCRTv1.cxx
index 708bfb2c990e8c63a651c50a622d673d5d975fdb..69cf8ffdef9017340b6ab02d9efb7e2f103dda1a 100644 (file)
--- a/CRT/AliCRTv1.cxx
+++ b/CRT/AliCRTv1.cxx
@@ -63,7 +63,7 @@ ClassImp(AliCRTv1)
  
 //_____________________________________________________________________________
 AliCRTv1::AliCRTv1()
-  : AliCRTv0()
+  : AliCRT()
 {
   //
   // Default constructor
@@ -74,7 +74,7 @@ AliCRTv1::AliCRTv1()
  
 //_____________________________________________________________________________
 AliCRTv1::AliCRTv1(const char *name, const char *title)
-  : AliCRTv0(name, title)
+  : AliCRT(name, title)
 {
   //
   // Standard constructor
@@ -96,7 +96,7 @@ AliCRTv1::AliCRTv1(const char *name, const char *title)
 
 //_____________________________________________________________________________
 AliCRTv1::AliCRTv1(const AliCRTv1& crt)
-  : AliCRTv0(crt)
+  : AliCRT(crt)
 {
   //
   // Copy ctor.
@@ -148,6 +148,8 @@ void AliCRTv1::CreateGeometry()
   // Molasse.
   this->CreateMolasse();
 
+  AliCRTConstants* crtConstants = AliCRTConstants::Instance();
+
   // Create a big volume with air barrel above the magnet
   Float_t barrel[10];
   Float_t magnetSides = 3.;
@@ -157,8 +159,8 @@ void AliCRTv1::CreateGeometry()
   barrel[2] = magnetSides;
   barrel[3] = planesPerpendicularToZ;
   barrel[4] = -700.;
-  barrel[5] = AliCRTConstants::fgMagMinRadius;
-  barrel[6] = AliCRTConstants::fgMagMinRadius + 2.; // 2 cm width
+  barrel[5] = crtConstants->MagMinRadius();
+  barrel[6] = crtConstants->MagMinRadius() + 2.; // 2 cm width
   barrel[7] = -barrel[4];
   barrel[8] = barrel[5];
   barrel[9] = barrel[6];
@@ -167,9 +169,9 @@ void AliCRTv1::CreateGeometry()
 
   //
   Float_t box[3];
-  box[0] = AliCRTConstants::fgSinglePaletteLenght/4;
-  box[1] = AliCRTConstants::fgSinglePaletteHeight/2;
-  box[2] = AliCRTConstants::fgSinglePaletteWidth/2;
+  box[0] = crtConstants->SinglePaletteLenght()/4;
+  box[1] = crtConstants->SinglePaletteHeight()/2;
+  box[2] = crtConstants->SinglePaletteWidth()/2;
   gMC->Gsvolu("CRT6", "BOX", idtmed[1113], box, 3);
 
   // In the right side side of the magnet
@@ -181,8 +183,8 @@ void AliCRTv1::CreateGeometry()
 
   // Now put them into the volume created above
   // First above the magnet.
-  const Float_t away = (2.*barrel[5]*TMath::Sin(kDegrad*22.5))/4.;
-  const Int_t nModules = 10;
+  Float_t away = (2.*barrel[5]*TMath::Sin(kDegrad*22.5))/4.;
+  Int_t nModules = 10;
   for (Int_t i = 0; i < nModules; i++) {
     Float_t zCoordinate = i*100 - 450;
     // In the lef side
@@ -331,9 +333,9 @@ void AliCRTv1::CreateShafts()
 
   // Create a mother volume.
   Float_t pbox[3];
-  //pbox[0] = AliCRTConstants::fgDepth*TMath::Tan(67.5*kDegrad);
+  //pbox[0] = AliCRTConstants::Instance()->Depth()*TMath::Tan(67.5*kDegrad);
   pbox[0] = 12073.;
-  pbox[1] = AliCRTConstants::fgDepth;
+  pbox[1] = AliCRTConstants::Instance()->Depth();
   pbox[2] = pbox[0];
   gMC->Gsvolu("CRT", "BOX", idtmed[1114], pbox, 3);
   gMC->Gspos("CRT", 1, "ALIC", 0, 0, 0, 0, "ONLY");
@@ -447,19 +449,19 @@ void AliCRTv1::CreateShafts()
   ptube[1] = ptube[0] + 100;
   ptube[2] = (5150 - 1166)/2;
   gMC->Gsvolu("CSF3", "TUBE", idtmed[1116], ptube, 3);
-  gMC->Gspos("CSF3", 1, "CRT", -2100, AliCRTConstants::fgDepth-ptube[2], 0, idrotm[2001], "MANY");
+  gMC->Gspos("CSF3", 1, "CRT", -2100, AliCRTConstants::Instance()->Depth()-ptube[2], 0, idrotm[2001], "MANY");
 
   // PGC2 Access Shaft
   ptube[0] = 1100/2;
   ptube[1] = ptube[0] + 100;
   ptube[2] = (5150 - 690)/2;
   gMC->Gsvolu("CSF4", "TUBE", idtmed[1116], ptube, 3);
-  gMC->Gspos("CSF4", 1, "CRT", 375, AliCRTConstants::fgDepth-ptube[2], 1900 + 2987.7, idrotm[2001], "MANY");
+  gMC->Gspos("CSF4", 1, "CRT", 375, AliCRTConstants::Instance()->Depth()-ptube[2], 1900 + 2987.7, idrotm[2001], "MANY");
 
 }
 
 //_____________________________________________________________________________
-void AliCRTv1::DrawDetector()
+void AliCRTv1::DrawDetector() const
 {
   //
   // Draw a shaded view of the L3 magnet

diff --git a/CRT/AliCRTv1.h b/CRT/AliCRTv1.h
index 39d6bf6c637e3085d56bd4cc63c612f1c0e757ed..c2315dd097db81dafbf737b064041d36b42f28bb 100644 (file)
--- a/CRT/AliCRTv1.h
+++ b/CRT/AliCRTv1.h
@@ -8,9 +8,9 @@
 //  Manager class for detector: CRTv1         //
 ////////////////////////////////////////////////
 
-#include "AliCRTv0.h"
+#include "AliCRT.h"
 
-class AliCRTv1 : public AliCRTv0 {
+class AliCRTv1 : public AliCRT {
 public:
   AliCRTv1();
   AliCRTv1(const char *name, const char *title);
@@ -29,7 +29,7 @@ public:
   virtual void    CreateMaterials();
   virtual void    CreateGeometry();
   virtual void    Init();
-  virtual void    DrawDetector();
+  virtual void    DrawDetector() const;
   virtual void    StepManager();
 
 protected:

diff --git a/CRT/AliGenCRT.cxx b/CRT/AliGenCRT.cxx
index 311c69052f84215d4df9604d3ddf95608f65d59b..da0893bebb79d50a0e2d1a277293c581e1ca814f 100644 (file)
--- a/CRT/AliGenCRT.cxx
+++ b/CRT/AliGenCRT.cxx
@@ -35,6 +35,8 @@
 //
 /////////////////////////////////////////////////////////////////////////////
 
+#include "AliGenCRT.h"
+
 #include <TMCProcess.h>
 #include <TPDGCode.h>
 #include <TClonesArray.h>
@@ -43,8 +45,6 @@
 #include "AliRun.h"
 #include "AliConst.h"
 
-#include "AliGenCRT.h"
-
 ClassImp(AliGenCRT)
 
 //_____________________________________________________________________________
@@ -106,7 +106,7 @@ AliGenCRT::AliGenCRT(Int_t npart)
 
   // Set the origin above the vertex, on the surface.
   fOrigin[0] = 0.;
-  fOrigin[1] = AliCRTConstants::fgDepth; // At the surface by default.
+  fOrigin[1] = AliCRTConstants::Instance()->Depth(); // At the surface by default.
   fOrigin[2] = 0.;
 }
 
@@ -258,13 +258,13 @@ void AliGenCRT::GenerateOneSingleMuon(Bool_t withFlatMomentum)
 
   // Finaly the origin, with the smearing
   Rndm(random,6);
-  origin[0] = AliCRTConstants::fgDepth*TMath::Tan(zenith*kDegrad)*
+  origin[0] = AliCRTConstants::Instance()->Depth()*TMath::Tan(zenith*kDegrad)*
     TMath::Sin(azimuth*kDegrad);
   // + fOsigma[0]* TMath::Cos(2*random[0]*TMath::Pi())*TMath::Sqrt(-2*TMath::Log(random[1]));
 
-  origin[1] = AliCRTConstants::fgDepth;
+  origin[1] = AliCRTConstants::Instance()->Depth();
 
-  origin[2] = AliCRTConstants::fgDepth*TMath::Tan(zenith*kDegrad)*
+  origin[2] = AliCRTConstants::Instance()->Depth()*TMath::Tan(zenith*kDegrad)*
     TMath::Cos(azimuth*kDegrad);
   // + fOsigma[2]* TMath::Cos(2*random[2]*TMath::Pi())*TMath::Sqrt(-2*TMath::Log(random[3]));;
 
@@ -483,7 +483,7 @@ void AliGenCRT::InitZenithalAngleGeneration()
     if ( !fZenithDist ) {
       
       // initialize the momentum dependent coefficients, a(p) 
-      InitApWeightFactors();
+      this->InitApWeightFactors();
       
       // Define the standard function.
       char* zenithalDisributionFunction = "1 + [0]*(1 - cos(x*3.14159265358979312/180))";
@@ -508,7 +508,7 @@ void AliGenCRT::InitZenithalAngleGeneration()
 }
 
 //____________________________________________________________________________
-const Float_t AliGenCRT::GetZenithAngle(Float_t mom)
+const Float_t AliGenCRT::GetZenithAngle(Float_t mom) const
 {
 
   Float_t zenith = 0.;
@@ -548,7 +548,7 @@ const Float_t AliGenCRT::GetZenithAngle(Float_t mom)
 }
 
 //_____________________________________________________________________________
-const Float_t AliGenCRT::GetMomentum()
+const Float_t AliGenCRT::GetMomentum() const
 {
   //
   //

diff --git a/CRT/AliGenCRT.h b/CRT/AliGenCRT.h
index ac6fa6c9b9a4fe4c3da3e4b260dcfd3a5c1f3198..58bc874c2551aa22a0bcd2d4982253d685241851 100644 (file)
--- a/CRT/AliGenCRT.h
+++ b/CRT/AliGenCRT.h
@@ -37,8 +37,8 @@ class AliGenCRT : public AliGenerator {
   void SetZenithalDistributionFunction(TF1 *func) {fZenithDist = func;}
   void SetMomentumResolution(Float_t res=1.) {fPResolution=res;}
 
-  const Float_t GetMomentum();
-  const Float_t GetZenithAngle(Float_t mom);
+  const Float_t GetMomentum() const;
+  const Float_t GetZenithAngle(Float_t mom) const;
 
   // The following methods are for testing pourpuses
   TF1* GetMomentumDistibution() const {return fMomentumDist;}