changes to be compliant with Eff C++ rules
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 31 Oct 2006 18:10:01 +0000 (18:10 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 31 Oct 2006 18:10:01 +0000 (18:10 +0000)
31 files changed:
ITS/AliITSBeamTestDigitizer.cxx
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeSim.cxx
ITS/AliITSDigitizer.cxx
ITS/AliITSFDigitizer.cxx
ITS/AliITSMultReconstructor.cxx
ITS/AliITSMultReconstructor.h
ITS/AliITSPreprocessorSDD.cxx
ITS/AliITSPreprocessorSDD.h
ITS/AliITSTableSSD.cxx
ITS/AliITSTableSSD.h
ITS/AliITSTrigger.cxx
ITS/AliITSdcsSSD.cxx
ITS/AliITSetfSDD.cxx
ITS/AliITShit.cxx
ITS/AliITSmodule.cxx
ITS/AliITSsDigitize.cxx
ITS/AliITSsDigitize.h
ITS/AliITSsimulation.cxx
ITS/AliITSsimulationFastPoints.h
ITS/AliITSsimulationFastPointsV0.cxx
ITS/AliITSsimulationFastPointsV0.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSSD.cxx
ITS/AliITSstatistics.cxx
ITS/AliITSstatistics.h
ITS/AliITSvBeamTestITS04.cxx
ITS/AliITSvPPRcoarseasymm.cxx
ITS/AliITSvPPRcoarseasymm.h

index d0484fc..b1ac155 100644 (file)
@@ -26,36 +26,46 @@ ClassImp(AliITSBeamTestDigitizer)
 
 
 //_____________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask() 
-{  
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask(), 
+fEvIn(0),
+fEvFin(0),
+fRunNumber(-1),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0){  
   //
   // Default constructor
   //
-  fRunLoader = 0;
-  fLoader =0;
-  fEvIn=0;
-  fEvFin=0;
-  fFlagHeader=kTRUE;
-  fDATEEvType=7;
-  fRunNumber=-1;
   SetFlagInit();
   SetOptDate();
-  fPeriod=kNov04;
 } 
 
 //_____________________________________________________________
-  AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Char_t* opt,const char* filename):TTask(name,title) 
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Char_t* opt,const char* filename):TTask(name,title),
+fEvIn(0),
+fEvFin(0),
+fRunNumber(-1),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0) 
 {  
   //
   // Standard constructor 
   //
-  fRunLoader=0;
-  fLoader=0;
-  fEvIn=0;
-  fEvFin=0;
-  fDATEEvType=7;
-  fFlagHeader=kTRUE;
-  fRunNumber=-1;
   SetOptDate();
 
   TString choice(opt);
@@ -67,19 +77,23 @@ AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask()
  } 
 
 //_____________________________________________________________
-  AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run, Char_t* opt,const char* filename):TTask(name,title) 
-
-{  
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run, Char_t* opt,const char* filename):TTask(name,title), 
+fEvIn(0),
+fEvFin(0),
+fRunNumber(run),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0){  
   //
   // Constructor 
   //
-  fRunLoader=0;
-  fLoader=0;
-  fEvIn=0;
-  fEvFin=0;
-  fDATEEvType=7;
-  fFlagHeader=kTRUE;
-  fRunNumber=run;
   SetOptDate();
   TString choice(opt);
   Bool_t aug04 = choice.Contains("Aug04");
@@ -125,24 +139,28 @@ void AliITSBeamTestDigitizer::Init(const char* filename){
 
 
 //______________________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt){
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt),
+fEvIn(bt.fEvIn),
+fEvFin(bt.fEvFin),
+fRunNumber(bt.fRunNumber),
+fDATEEvType(bt.fDATEEvType),
+fFlagHeader(bt.fFlagHeader),
+fFlagInit(bt.fFlagInit),
+fOptDate(bt.fOptDate),
+fDigitsFileName(bt.fDigitsFileName),
+fRawdataFileName(bt.fRawdataFileName),
+fPeriod(bt.fPeriod),
+fRunLoader(bt.fRunLoader),
+fLoader(bt.fLoader),
+fHeader(bt.fHeader){
   // Copy constructor. 
-  //not allowed
-  if(this==&bt) return;
-  Error("Copy constructor",
-       "You are not allowed to make a copy of the AliITSBeamTestDigitizer");
-  exit(1);
-
 }
 //______________________________________________________________________
 AliITSBeamTestDigitizer& AliITSBeamTestDigitizer::operator=(const AliITSBeamTestDigitizer &source){
-    // Assignment operator. This is a function which is not allowed to be
-    // done to the ITS beam test digitizer. It exits with an error.
-    // Inputs:
-    if(this==&source) return *this;
-    Error("operator=","You are not allowed to make a copy of the AliITSBeamTestDigitizer");
-    exit(1);
-    return *this; //fake return
+    // Assignment operator. 
+  this->~AliITSBeamTestDigitizer();
+  new(this) AliITSBeamTestDigitizer(source);
+  return *this;
 }
 
 
index 2376ded..9038083 100644 (file)
@@ -142,23 +142,39 @@ fFirstcall(kTRUE){
   SelectVertexer(" "); 
   SetRunNumber();
 }
-/*
+
 //______________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec)
+AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
+fNMod(rec.fNMod),
+fReconstruction(rec.fReconstruction),
+fSegmentation(rec.fSegmentation),
+fCalibration(rec.fCalibration),
+fPreProcess(rec.fPreProcess),
+fPostProcess(rec.fPostProcess),
+fDigits(rec.fDigits),
+fNdtype(rec.fNdtype),
+fCtype(rec.fCtype),
+fNctype(rec.fNctype),
+fRecPoints(rec.fRecPoints),
+fNRecPoints(rec.fNRecPoints),
+fSelectedVertexer(rec.fSelectedVertexer),
+fLoader(rec.fLoader),
+fRunNumber(rec.fRunNumber),
+fFirstcall(rec.fFirstcall)
 {
 
   // Copy constructor. 
-  Error("Copy constructor","Copy constructor not allowed");
+
 }
 //______________________________________________________________________
 AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
-    // Assignment operator. This is a function which is not allowed to be
-    // done.
-    Error("operator=","Assignment operator not allowed\n");
-    return *this; 
+    // Assignment operator. 
+    this->~AliITSDetTypeRec();
+    new(this) AliITSDetTypeRec(source);
+    return *this;
 
 }
-*/
+
 //_____________________________________________________________________
 AliITSDetTypeRec::~AliITSDetTypeRec(){
   //Destructor
index 0f695a7..600bf7e 100644 (file)
@@ -158,23 +158,35 @@ AliITSDetTypeSim::~AliITSDetTypeSim(){
     fDigits=0;
 }
 //----------------------------------------------------------------------
-AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(source){
+AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(source),
+fSimulation(source.fSimulation),   // [NDet]
+fSegmentation(source.fSegmentation), // [NDet]
+fCalibration(source.fCalibration),     // [NMod]
+fPreProcess(source.fPreProcess),   // [] e.g. Fill fHitModule with hits
+fPostProcess(source.fPostProcess),  // [] e.g. Wright Raw data
+fNSDigits(source.fNSDigits),    //! number of SDigits
+fSDigits(source.fSDigits),      //! [NMod][NSDigits]
+fNDigits(source.fNDigits),     //! number of Digits
+fRunNumber(source.fRunNumber),   //! Run number (to access DB)
+fDigits(source.fDigits),       //! [NMod][NDigits]
+fHitClassName(source.fHitClassName), // String with Hit class name.
+fSDigClassName(source.fSDigClassName),// String with SDigit class name.
+fDigClassName(), // String with digit class name.
+fLoader(source.fLoader),      // local pointer to loader
+fFirstcall(source.fFirstcall)
+{
     // Copy Constructor for object AliITSDetTypeSim not allowed
-
-    if(this==&source) return;
-    Error("Copy constructor",
-         "You are not allowed to make a copy of the AliITSDetTypeSim");
-    exit(1);
+  for(Int_t i=0;i<fgkNdettypes;i++){
+    fDigClassName[i] = source.fDigClassName[i];
+  }
 }
 //----------------------------------------------------------------------
 AliITSDetTypeSim& AliITSDetTypeSim::operator=(const AliITSDetTypeSim &source){
     // The = operator for object AliITSDetTypeSim
  
-    if(&source==this) return *this;
-    Error("operator=",
-         "You are not allowed to make a copy of the AliITSDetTypeSIm");
-    exit(1);
-    return *this;
+  this->~AliITSDetTypeSim();
+  new(this) AliITSDetTypeSim(source);
+  return *this;
 }
 
 //______________________________________________________________________
index 96759db..e2fab30 100644 (file)
 ClassImp(AliITSDigitizer)
 
 //______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer() : AliDigitizer(){
+AliITSDigitizer::AliITSDigitizer() : AliDigitizer(),
+fITS(0),
+fModActive(0),
+fInit(kFALSE),
+fRoif(-1),
+fRoiifile(0),
+fFlagFirstEv(kTRUE){
     // Default constructor. Assign fITS since it is never written out from
     // here. 
     // Inputs:
@@ -52,15 +58,15 @@ AliITSDigitizer::AliITSDigitizer() : AliDigitizer(){
     // Return:
     //      A blank AliITSDigitizer class.
 
-    fITS      = 0;
-    fModActive   = 0;
-    fRoif     = -1;
-    fRoiifile = 0;
-    fInit     = kFALSE;
-    fFlagFirstEv =kTRUE;
 }
 //______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr){
+AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr),
+fITS(0),
+fModActive(0),
+fInit(kFALSE),
+fRoif(-1),
+fRoiifile(0),
+fFlagFirstEv(kTRUE){
     // Standard constructor. Assign fITS since it is never written out from
     // here. 
     // Inputs:
@@ -70,21 +76,15 @@ AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr){
     // Return:
     //      An AliItSDigitizer class.
 
-    fITS      = 0;
-    fModActive   = 0;
-    fRoif     = -1;
-    fRoiifile = 0;
-    fInit     = kFALSE;
-    fFlagFirstEv =kTRUE;
 }
 
 //______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer(const AliITSDigitizer &/*rec*/):AliDigitizer(/*rec*/){
+//AliITSDigitizer::AliITSDigitizer(const AliITSDigitizer &/*rec*/):AliDigitizer(/*rec*/){
     // Copy constructor. 
 
-  Error("Copy constructor","Copy constructor not allowed");
+//  Error("Copy constructor","Copy constructor not allowed");
   
-}
+//}
 //______________________________________________________________________
 AliITSDigitizer& AliITSDigitizer::operator=(const AliITSDigitizer& /*source*/){
     // Assignment operator. This is a function which is not allowed to be
index 47d376c..e67e5ce 100644 (file)
 ClassImp(AliITSFDigitizer)
 
 //______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer() : AliDigitizer(){
+AliITSFDigitizer::AliITSFDigitizer() : AliDigitizer(),
+fITS(0),
+fInit(kFALSE){
 //
 // Default constructor.
 //
-    fITS      = 0;
-    fInit     = kFALSE;
 }
 //______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr){
+AliITSFDigitizer::AliITSFDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr),
+fITS(0),
+fInit(kFALSE){
 //
 // Standard constructor.
 //
-    fITS      = 0;
-    fInit     = kFALSE;
 }
 //______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer(const AliITSFDigitizer &/*rec*/):AliDigitizer(/*rec*/){
+AliITSFDigitizer::AliITSFDigitizer(const AliITSFDigitizer &rec):AliDigitizer(rec),
+fITS(rec.fITS),
+fInit(rec.fInit){
     // Copy constructor. 
-
-  Error("Copy constructor","Copy constructor not allowed");
   
 }
 //______________________________________________________________________
index bdf8937..f84af41 100644 (file)
@@ -39,7 +39,33 @@ ClassImp(AliITSMultReconstructor)
 
 
 //____________________________________________________________________
-AliITSMultReconstructor::AliITSMultReconstructor() {
+AliITSMultReconstructor::AliITSMultReconstructor():
+fGeometry(0),
+fClustersLay1(0),
+fClustersLay2(0),
+fTracklets(0),
+fAssociationFlag(0),
+fNClustersLay1(0),
+fNClustersLay2(0),
+fNTracklets(0),
+fPhiWindow(0),
+fZetaWindow(0),
+fOnlyOneTrackletPerC2(0),
+fHistOn(0),
+fhClustersDPhiAcc(0),
+fhClustersDThetaAcc(0),
+fhClustersDZetaAcc(0),
+fhClustersDPhiAll(0),
+fhClustersDThetaAll(0),
+fhClustersDZetaAll(0),
+fhDPhiVsDThetaAll(0),
+fhDPhiVsDThetaAcc(0),
+fhDPhiVsDZetaAll(0),
+fhDPhiVsDZetaAcc(0),
+fhetaTracklets(0),
+fhphiTracklets(0),
+fhetaClustersLay1(0),
+fhphiClustersLay1(0){
   // Method to reconstruct the charged particles multiplicity with the 
   // SPD (tracklets).
 
@@ -95,17 +121,42 @@ AliITSMultReconstructor::AliITSMultReconstructor() {
 }
 
 //______________________________________________________________________
-AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : TObject(mr) {
+AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : TObject(mr),
+fGeometry(mr.fGeometry),
+fClustersLay1(mr.fClustersLay1),
+fClustersLay2(mr.fClustersLay2),
+fTracklets(mr.fTracklets),
+fAssociationFlag(mr.fAssociationFlag),
+fNClustersLay1(mr.fNClustersLay1),
+fNClustersLay2(mr.fNClustersLay2),
+fNTracklets(mr.fNTracklets),
+fPhiWindow(mr.fPhiWindow),
+fZetaWindow(mr.fZetaWindow),
+fOnlyOneTrackletPerC2(mr.fOnlyOneTrackletPerC2),
+fHistOn(mr.fHistOn),
+fhClustersDPhiAcc(mr.fhClustersDPhiAcc),
+fhClustersDThetaAcc(mr.fhClustersDThetaAcc),
+fhClustersDZetaAcc(mr.fhClustersDZetaAcc),
+fhClustersDPhiAll(mr.fhClustersDPhiAll),
+fhClustersDThetaAll(mr.fhClustersDThetaAll),
+fhClustersDZetaAll(mr.fhClustersDZetaAll),
+fhDPhiVsDThetaAll(mr.fhDPhiVsDThetaAll),
+fhDPhiVsDThetaAcc(mr.fhDPhiVsDThetaAcc),
+fhDPhiVsDZetaAll(mr.fhDPhiVsDZetaAll),
+fhDPhiVsDZetaAcc(mr.fhDPhiVsDZetaAcc),
+fhetaTracklets(mr.fhetaTracklets),
+fhphiTracklets(mr.fhphiTracklets),
+fhetaClustersLay1(mr.fhetaClustersLay1),
+fhphiClustersLay1(mr.fhphiClustersLay1) {
   // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSMultReconstructor","Copy constructor not allowed\n");
+
 }
 
 //______________________________________________________________________
-AliITSMultReconstructor& AliITSMultReconstructor::operator=(const AliITSMultReconstructor& /* mr */){
+AliITSMultReconstructor& AliITSMultReconstructor::operator=(const AliITSMultReconstructor& mr){
   // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
+  this->~AliITSMultReconstructor();
+  new(this) AliITSMultReconstructor(mr);
   return *this;
 }
 
index 563e671..0df91b0 100644 (file)
@@ -57,7 +57,7 @@ public:
 
 protected:
   AliITSMultReconstructor(const AliITSMultReconstructor& mr);
-  AliITSMultReconstructor& operator=(const AliITSMultReconstructor& /* mr */);
+  AliITSMultReconstructor& operator=(const AliITSMultReconstructor& mr);
 
   AliITSgeom*   fGeometry;            // ITS geometry
   
index a0c6d7d..097b49b 100644 (file)
@@ -1,5 +1,7 @@
 /////////////////////////////////////////
 // Class for SDD digits preprocessing  //
+//                                     //
+//                                     //
 ////////////////////////////////////////
 
 #include "AliITSPreprocessorSDD.h"
@@ -13,9 +15,8 @@
 
 const Int_t AliITSPreprocessorSDD::fgkNumberOfSDD = 260;
 const Int_t AliITSPreprocessorSDD::fgkNumberOfChannels = 512;
-const char* AliITSPreprocessorSDD::fgkNameHistoPedestals ="hpedestal";
-const char* AliITSPreprocessorSDD::fgkNameHistoNoise="hnoise";
-
+const TString AliITSPreprocessorSDD::fgkNameHistoPedestals = "hpedestal";
+const TString AliITSPreprocessorSDD::fgkNameHistoNoise = "hnoise";
 ClassImp(AliITSPreprocessorSDD)
 
 
@@ -74,8 +75,8 @@ UInt_t AliITSPreprocessorSDD::Process(TMap*/* dcsAliasMap*/){
     for(Int_t ich=0;ich<numOfBadChannels[imod];ich++){
       cal->SetBadChannel(ich,badCh[imod][ich]);
     }
-    sprintf(namehisto,"%s_%d",fgkNameHistoPedestals,imod);
-    sprintf(namehisto2,"%s_%d",fgkNameHistoNoise,imod);
+    sprintf(namehisto,"%s_%d",fgkNameHistoPedestals.Data(),imod);
+    sprintf(namehisto2,"%s_%d",fgkNameHistoNoise.Data(),imod);
     TH1F* hbas = (TH1F*)f1->Get(namehisto);
     TH1F* hnoi = (TH1F*)f2->Get(namehisto2);
     for(Int_t ien=0;ien<fgkNumberOfChannels;ien++){
index d6485f5..0fc52e4 100644 (file)
@@ -18,21 +18,22 @@ class AliITSPreprocessorSDD : public AliPreprocessor {
  public:
  
   AliITSPreprocessorSDD(const char* detector, AliShuttleInterface* shuttle):
-    AliPreprocessor(detector,shuttle){;}
+    AliPreprocessor(detector,shuttle){SetName("SDD");}
   virtual ~AliITSPreprocessorSDD(){;}
 
 
 
  protected:      
+
+
   
   virtual UInt_t Process(TMap* dcsAliasMap);
 
   static const Int_t fgkNumberOfSDD;       // number of SDD modules 
   static const Int_t fgkNumberOfChannels;  // number of channels per module
-  static const char* fgkNameHistoPedestals; // name of pedestal histogram
-  static const char* fgkNameHistoNoise;     // name of noise histogram
-
-  ClassDef(AliITSPreprocessorSDD,1)  // Alice ITS-SDD preprocessor.
+  static const TString fgkNameHistoPedestals; //name of ped. histo
+  static const TString fgkNameHistoNoise;  //name of noise histo
+  ClassDef(AliITSPreprocessorSDD,2)  // Alice ITS-SDD preprocessor.
 
  };
 
index 5576ab4..6daaf2d 100644 (file)
 
 ClassImp(AliITSTableSSD)
 ////////////////////////////////////////////////////////////////////////
-// Version: 0
-// Origin: Massimo Masera
-// March 2002
-//
+// Version: 0                                                         //
+// Origin: Massimo Masera                                             //
+// March 2002                                                         //
+//                                                                    //
 // AliITSTableSSD is used by AliITSsimulationSSD class to fill the AliITSpList
 // object starting from the map with energy depositions
-
+////////////////////////////////////////////////////////////////////////
 //----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD() : TObject(){
+AliITSTableSSD::AliITSTableSSD() : TObject(),
+fDim(0),
+fArray(0){
   // Default Constructor
-  fDim=0;
-  fArray=0;
   for(Int_t i=0;i<2;i++){
     fCurrUse[i]=0;
     fCurrFil[i]=0;
   }
 }
 //----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source){
+AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source),
+fDim(source.fDim),
+fArray(source.fArray){
   // Copy constructor
 
     if(this == &source) return;
-    fDim=source.fDim;
     fArray = new Int_t [fDim];
     fCurrUse[0]=(source.fCurrUse)[0];
     fCurrUse[1]=(source.fCurrUse)[1];
@@ -63,7 +64,9 @@ AliITSTableSSD& AliITSTableSSD::operator=(const AliITSTableSSD & source){
     return *this;
 }
 //----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(){
+AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(),
+fDim(0),
+fArray(0){
   // Standard constructor
   fDim=noelem*2;
   fArray = new Int_t [fDim];
@@ -102,6 +105,7 @@ void AliITSTableSSD::Add(Int_t side,Int_t strip){
 }
 //----------------------------------------------------------------------
 void AliITSTableSSD::Clear(){
+  //clear arrays
   fCurrUse[0]= 0;
   fCurrUse[1] = 0;
   fCurrFil[0]= 0;
index 884c72d..ad6bf9a 100644 (file)
@@ -3,6 +3,12 @@
 /* Copyright(c) 2002-2003, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice     */
 
+///////////////////////////////////////////////////////////
+// AliITSTableSSD is used by AliITSsimulationSSD class to// 
+//fill the AliITSpList  object starting from the map with// 
+//energy depositions                                     //
+///////////////////////////////////////////////////////////
+
 #include "Rtypes.h"
 #include <TObject.h>
 
@@ -21,7 +27,7 @@ class AliITSTableSSD : public TObject{
     virtual void Clear(Option_t*)  {TObject::Clear();}
 
  private:
-    Int_t SearchValue(Int_t *arr, Int_t refer, Int_t max){
+    Int_t SearchValue(Int_t *arr, Int_t refer, Int_t max) const{
        for(Int_t i=0;i<max;i++)if(arr[i]==refer)return i;
        return -1;}
  private:
index 93d14cf..800ad8c 100644 (file)
 //______________________________________________________________________
 ClassImp(AliITSTrigger)
 ////////////////////////////////////////////////////////////////////////
-//
-// Version 1
-// Modified by D. Elia, C. Jorgensen
-// March 2006
-//
-// Version 0
-// Written by J. Conrad, E. Lopez Torres 
-// October 2005
-//
-// AliITSTrigger: implementation of the SPD Fast-OR based triggers.
-//
+//                                                                    //
+// Version 1                                                          //
+// Modified by D. Elia, C. Jorgensen                                  //
+// March 2006                                                         //
+//                                                                    //
+// Version 0                                                          //
+// Written by J. Conrad, E. Lopez Torres                              //
+// October 2005                                                       //
+//                                                                    //
+// AliITSTrigger: implementation of the SPD Fast-OR based triggers.   //
+//                                                                    //
 ////////////////////////////////////////////////////////////////////////
 
 //______________________________________________________________________
 AliITSTrigger::AliITSTrigger()
-  : AliTriggerDetector()
-{
-   SetName("ITS");
-   CreateInputs();
+  : AliTriggerDetector(),
+fGlobalFOThreshold(1),
+fHighMultFOThreshold(150){
+
+  //standard constructor
+  SetName("ITS");
+  CreateInputs();
 
-   // set parameters to define trigger condition thresholds
-   fGlobalFOThreshold = 1;
-   fHighMultFOThreshold = 150; 
+  // set parameters to define trigger condition thresholds
+  //fGlobalFOThreshold = 1;
+  //fHighMultFOThreshold = 150; 
 }
 
 //______________________________________________________________________
index 48427ba..e08796c 100644 (file)
@@ -26,14 +26,30 @@ ClassImp(AliITSdcsSSD)
 
 // Constructor and Destructor
 //______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(){
+  AliITSdcsSSD::AliITSdcsSSD():
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(0),
+fNstrips(0),
+fNInvalid(0),
+fISigma(0),
+fInvalidP(0),
+fInvalidN(0){
     // Default Constructor
 
-    fInvalidP = 0;
-    fInvalidN = 0;
 }
 //______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSCalibration *resp){
+AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSCalibration *resp):
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(0),
+fNstrips(0),
+fNInvalid(0),
+fISigma(0),
+fInvalidP(0),
+fInvalidN(0){
     // Standard constructor
 
     fNstrips =(Float_t) (((AliITSsegmentationSSD*)seg)->Npx());
@@ -72,22 +88,18 @@ AliITSdcsSSD::~AliITSdcsSSD() {
     delete fInvalidN;
 }
 //______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source){
+AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source),
+fCouplingPR(source.fCouplingPR),
+fCouplingPL(source.fCouplingPL),
+fCouplingNR(source.fCouplingNR),
+fCouplingNL(source.fCouplingNL),
+fNstrips(source.fNstrips),
+fNInvalid(source.fNInvalid),
+fISigma(source.fISigma),
+fInvalidP(source.fInvalidP),
+fInvalidN(source.fInvalidN){
     //     Copy Constructor 
 
-    if(&source == this) return;
-
-    this->fCouplingPR = source.fCouplingPR;
-    this->fCouplingPL = source.fCouplingPL;
-    this->fCouplingNR = source.fCouplingNR;
-    this->fCouplingNL = source.fCouplingNL;
-    this->fNstrips = source.fNstrips;
-    this->fNInvalid = source.fNInvalid;
-    this->fISigma = source.fISigma;
-    this->fInvalidP = source.fInvalidP;
-    this->fInvalidN = source.fInvalidN;
-
-    return;
 }
 //_________________________________________________________________________
 AliITSdcsSSD& AliITSdcsSSD::operator=(const AliITSdcsSSD &source) {
index dd96628..2daca2a 100644 (file)
@@ -39,25 +39,41 @@ Int_t ppower(Int_t b, Int_t e) {
   return power;
 }
 
-AliITSetfSDD::AliITSetfSDD() {
+AliITSetfSDD::AliITSetfSDD():
+fTimeDelay(0),
+fSamplingTime(0),
+fT0(0),
+fDf(0.),
+fA0(0.) ,
+fZeroM(0),
+fZeroR(0),
+fZeroI(0),
+fPoleM(0),
+fPoleR(0),
+fPoleI(0),
+fTfR(0),
+fTfI(0),
+fWR(0),
+fWI(0){
   // Default constructor
-  fTimeDelay = 0.;
-  fSamplingTime = 0.;
-  fT0 = 0.;
-  fDf = 0.;
-  fA0 = 0.;
-  fZeroM = 0;
-  fZeroR = 0;
-  fPoleM = 0;
-  fPoleR = 0;
-  fPoleI = 0;
-  fTfR = 0;
-  fTfI = 0;
-  fWR = 0;
-  fWI = 0;
 }
 
-AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif)
+AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif):
+fTimeDelay(0),
+fSamplingTime(0),
+fT0(0),
+fDf(0.),
+fA0(0.) ,
+fZeroM(0),
+fZeroR(0),
+fZeroI(0),
+fPoleM(0),
+fPoleR(0),
+fPoleI(0),
+fTfR(0),
+fTfI(0),
+fWR(0),
+fWI(0)
 {
   // Standard constructor. sampling time in ns
 
@@ -190,20 +206,6 @@ AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif)
 
 }
 
-//______________________________________________________________________
-AliITSetfSDD::AliITSetfSDD(const AliITSetfSDD &obj) : TObject(obj) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSetfSDD","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSetfSDD& AliITSetfSDD::operator=(const AliITSetfSDD& /* obj */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
 
 AliITSetfSDD::~AliITSetfSDD(){
   // Destructor
index a0b6050..dcb73d1 100644 (file)
@@ -189,7 +189,21 @@ ClassImp(AliITShit)
 //
 ////////////////////////////////////////////////////////////////////////
 //_____________________________________________________________________________
-AliITShit::AliITShit():AliHit(){
+AliITShit::AliITShit():AliHit(),
+fStatus(0),
+fLayer(0),
+fLadder(0),
+fDet(0),
+fPx(0.0),
+fPy(0.0),
+fPz(0.0),
+fDestep(0.0),
+fTof(0.0),
+fStatus0(0),
+fx0(0.0),
+fy0(0.0),
+fz0(0.0),
+ft0(0.0){
     // Default Constructor
     // Zero data member just to be safe.
     // Intputs:
@@ -199,24 +213,24 @@ AliITShit::AliITShit():AliHit(){
     // Return:
     //    A default created AliITShit class.
 
-    fStatus = 0; // Track Status
-    fLayer  = 0;  // Layer number
-    fLadder = 0; // Ladder number
-    fDet    = 0;    // Detector number  
-    fPx     = 0.0;     // PX of particle at the point of the hit
-    fPy     = 0.0;     // PY of particle at the point of the hit
-    fPz     = 0.0;     // PZ of particle at the point of the hit
-    fDestep = 0.0; // Energy deposited in the current step
-    fTof    = 0.0;    // Time of flight at the point of the hit
-    fStatus0 = 0; // zero status bit by default.
-    fx0     = 0.0;     // Starting point of this step
-    fy0     = 0.0;     // Starting point of this step
-    fz0     = 0.0;     // Starting point of this step
-    ft0     = 0.0;     // Starting point of this step
 }
 AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
                     Float_t tof,TLorentzVector &x,TLorentzVector &x0,
-                    TLorentzVector &p) : AliHit(shunt, track){
+                    TLorentzVector &p) : AliHit(shunt, track),
+fStatus(vol[3]),
+fLayer(vol[0]),
+fLadder(vol[2]),
+fDet(vol[1]),
+fPx(p.Px()),
+fPy(p.Py()),
+fPz(p.Pz()),
+fDestep(edep),
+fTof(tof),
+fStatus0(vol[4]),
+fx0(x0.X()),
+fy0(x0.Y()),
+fz0(x0.Z()),
+ft0(x0.T()){
 ////////////////////////////////////////////////////////////////////////
 // Create ITS hit
 //     The creator of the AliITShit class. The variables shunt and
@@ -237,27 +251,29 @@ AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
     // Return:
     //    A default created AliITShit class.
 
-    fLayer      = vol[0];  // Layer number
-    fLadder     = vol[2];  // Ladder number
-    fDet        = vol[1];  // Detector number
-    fStatus     = vol[3];  // Track status flags
-    fStatus0    = vol[4];  // Track status flag for start position.
+
+
     fX          = x.X();   // Track X global position
     fY          = x.Y();   // Track Y global position
     fZ          = x.Z();   // Track Z global position
-    fPx         = p.Px();  // Track X Momentum
-    fPy         = p.Py();  // Track Y Momentum
-    fPz         = p.Pz();  // Track Z Momentum
-    fDestep     = edep;    // Track dE/dx for this step
-    fTof        = tof   ;  // Track Time of Flight for this step
-    fx0         = x0.X();  // Track X global position
-    fy0         = x0.Y();  // Track Y global position
-    fz0         = x0.Z();  // Track Z global position
-    ft0         = x0.T();     // Starting point of this step
 }
 //______________________________________________________________________
 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-    AliHit(shunt, track){
+    AliHit(shunt, track),
+fStatus(vol[3]),
+fLayer(vol[0]),
+fLadder(vol[2]),
+fDet(vol[1]),
+fPx(hits[3]),
+fPy(hits[4]),
+fPz(hits[5]),
+fDestep(hits[6]),
+fTof(hits[7]),
+fStatus0(0),
+fx0(0.0),
+fy0(0.0),
+fz0(0.0),
+ft0(0.0){
 ////////////////////////////////////////////////////////////////////////
 // Create ITS hit
 //     The creator of the AliITShit class. The variables shunt and
@@ -289,23 +305,9 @@ AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
     //    none.
     // Return:
     //    A standard created AliITShit class.
-  fLayer      = vol[0];   // Layer number
-  fLadder     = vol[2];   // Ladder number
-  fDet        = vol[1];   // Detector number
-  fStatus     = vol[3];   // Track status flags
   fX          = hits[0];  // Track X global position
   fY          = hits[1];  // Track Y global position
   fZ          = hits[2];  // Track Z global position
-  fPx         = hits[3];  // Track X Momentum
-  fPy         = hits[4];  // Track Y Momentum
-  fPz         = hits[5];  // Track Z Momentum
-  fDestep     = hits[6];  // Track dE/dx for this step
-  fTof        = hits[7];  // Track Time of Flight for this step
-  fStatus0 = 0;// Track Status of Starting point
-  fx0 = 0.0;     // Starting point of this step
-  fy0 = 0.0;     // Starting point of this step
-  fz0 = 0.0;     // Starting point of this step
-  ft0 = 0.0;     // Starting point of this step
 }
 //______________________________________________________________________
 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
index db7a2ce..b9e45cb 100644 (file)
@@ -40,20 +40,24 @@ ClassImp(AliITSmodule)
 // Constructors and deconstructor
 //________________________________________________________________________
 //
-AliITSmodule::AliITSmodule() {
+AliITSmodule::AliITSmodule():
+fITS(0),
+fIndex(0),
+fHitsM(0),
+fTrackIndex(0),
+fHitIndex(0) {
     // constructor
 
-    fHitsM       = 0;
-    fTrackIndex  = 0;
-    fHitIndex    = 0;
-    fITS         = 0;
-
 }
 //_________________________________________________________________________
-AliITSmodule::AliITSmodule(Int_t index) {
+AliITSmodule::AliITSmodule(Int_t index):
+fITS(0),
+fIndex(index),
+fHitsM(0),
+fTrackIndex(0),
+fHitIndex(0) {
   // constructor
 
-    fIndex      = index;
     fHitsM      = new TObjArray();
     fTrackIndex = new TArrayI(16);
     fHitIndex   = new TArrayI(16);
@@ -74,22 +78,25 @@ AliITSmodule::~AliITSmodule() {
     fITS = 0; // We don't delete this pointer since it is just a copy.
 }
 //____________________________________________________________________________
-AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source){
+AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source),
+fITS(source.fITS),
+fIndex(source.fIndex),
+fHitsM(source.fHitsM),
+fTrackIndex(source.fTrackIndex),
+fHitIndex(source.fHitIndex){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor 
 ////////////////////////////////////////////////////////////////////////
-  Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
-  exit(1);
+
 }
 //_____________________________________________________________________________
 AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
 ////////////////////////////////////////////////////////////////////////
 //    Assignment operator 
 ////////////////////////////////////////////////////////////////////////
-    if(&source == this) return *this;
-    Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
-    exit(1);
-    return *this; // fake return neded on Sun
+  this->~AliITSmodule();
+  new(this) AliITSmodule(source);
+  return *this;
 }
 //_________________________________________________________________________
 // 
index 0b78671..cf5d526 100644 (file)
 #include "AliITS.h"
 #include "AliITSsDigitize.h"
 #include "AliITSgeom.h"
+
+/////////////////////////////////////////////////////////
+//                                                     //
+//                                                     //
+//                                                     //
+///////////////////////////////////////////////////////// 
 ClassImp(AliITSsDigitize)
 //______________________________________________________________________
-AliITSsDigitize::AliITSsDigitize(){
+AliITSsDigitize::AliITSsDigitize():
+fInit(kFALSE),
+fEnt(0),
+fEnt0(0),
+fITS(0),
+fRunLoader(0x0){
     // Default constructor.
     // Inputs:
     //  none.
@@ -41,13 +51,15 @@ AliITSsDigitize::AliITSsDigitize(){
     // Return:
     //    A zero-ed constructed AliITSsDigitize class.
  
-    fRunLoader = 0x0;
-    fITS      = 0;
     fDet[0] = fDet[1] = fDet[2] = kTRUE;
-    fInit     = kFALSE;
 }
 //______________________________________________________________________
-AliITSsDigitize::AliITSsDigitize(const char* filename){
+AliITSsDigitize::AliITSsDigitize(const char* filename):
+fInit(),
+fEnt(0),
+fEnt0(0),
+fITS(0),
+fRunLoader(0x0){
     // Standard constructor.
     // Inputs:
     //  const char* filename    filename containing the digits to be
@@ -130,7 +142,7 @@ Bool_t AliITSsDigitize::Init(){
     return fInit;
 }
 //______________________________________________________________________
-Bool_t AliITSsDigitize::InitSDig(){
+Bool_t AliITSsDigitize::InitSDig() const {
     // Sets up SDigitization part of AliITSDetType..
     // Inputs:
     //      none.
index cee86c7..09f1a60 100644 (file)
@@ -1,11 +1,16 @@
-#ifndef ALIITSSDIGITIZATION_H
-#define ALIITSSDIGITIATION_H
+#ifndef ALIITSSDIGITIZE_H
+#define ALIITSSDIGITIZE_H
 /* Copyright (c) 1998-2001, ALICE Experiment at CERN, All rights reserved *
  * See cxx source for full Copyright notice                               */
  
 /*
   $Id$
  */
+/////////////////////////////////////////////////////////
+//                                                     //
+//                                                     //
+//                                                     //
+///////////////////////////////////////////////////////// 
  
 #include <TTask.h>
  
@@ -20,10 +25,13 @@ class AliITSsDigitize : public TTask{
     virtual Bool_t Init();
     virtual void Exec(const Option_t *opt="ALL");
  private:
-    Bool_t InitSDig();  // Standard SDigitization initilization.
+    Bool_t InitSDig() const;  // Standard SDigitization initilization.
  private:
 //    TFile   *fFile;    //! pointer to the file contatining the hits and
 //                       // and will contain the SDigits
+    AliITSsDigitize(const AliITSsDigitize &source); // copy  constructor
+    AliITSsDigitize& operator=(const AliITSsDigitize &source); // operator=
+
     
     Bool_t  fDet[3];   //! logical specifing which detectors to reconstruct.
     Bool_t  fInit;     //! True if Init was sucessfull, else false.
index a66b275..838cbd0 100644 (file)
@@ -27,6 +27,7 @@ ClassImp(AliITSsimulation)
 
 //______________________________________________________________________
 AliITSsimulation::AliITSsimulation(): TObject(),
+fDetType(0),
 fpList(0),
 fModule(0),
 fEvent(0),
@@ -38,10 +39,10 @@ fDebug(0){
     //    none.
     // Return:
     //    a default constructed AliITSsimulation class
-  fDetType = 0;
 }
 //______________________________________________________________________
 AliITSsimulation::AliITSsimulation(AliITSDetTypeSim *dettyp): TObject(),
+fDetType(dettyp),
 fpList(0),
 fModule(0),
 fEvent(0),
@@ -53,7 +54,6 @@ fDebug(0){
     //    none.
     // Return:
     //    a default constructed AliITSsimulation class
-  fDetType = dettyp;
 }
 //__________________________________________________________________________
 AliITSsimulation::~AliITSsimulation(){
@@ -71,7 +71,12 @@ AliITSsimulation::~AliITSsimulation(){
     }
    }
 //__________________________________________________________________________
-AliITSsimulation::AliITSsimulation(const AliITSsimulation &s) : TObject(s){
+AliITSsimulation::AliITSsimulation(const AliITSsimulation &s) : TObject(s),
+fDetType(s.fDetType),
+fpList(s.fpList),
+fModule(s.fModule),
+fEvent(s.fEvent),
+fDebug(s.fDebug){
     //     Copy Constructor
     // Inputs:
     //    const AliITSsimulation &s  simulation class to copy from
@@ -81,8 +86,6 @@ AliITSsimulation::AliITSsimulation(const AliITSsimulation &s) : TObject(s){
     //    a standard constructed AliITSsimulation class with values the same
     //    as that of s.
  
-    *this = s;
-    return;
 }
 
 //_________________________________________________________________________
index d10f90b..5c97ffb 100644 (file)
@@ -14,8 +14,9 @@ class AliITSsimulationFastPoints : public AliITSsimulation
 {
 
 public:
-  AliITSsimulationFastPoints(); // default constructor
+  AliITSsimulationFastPoints(); // default constructor  
   virtual ~AliITSsimulationFastPoints() {;} 
+  virtual AliITSsimulation& operator=(const AliITSsimulation&){return *this;}
   void CreateFastRecPoints(AliITSmodule *mod,Int_t module,TRandom *rndm, 
                           TClonesArray* recp);
   void CreateFastRecPoints(Int_t module,TClonesArray* recp);
index 92dab6a..114c788 100644 (file)
 
 ClassImp(AliITSsimulationFastPointsV0)
 
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0()
-{
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0():
+fNrecp(0),
+fSx(0),
+fSz(0){
   // default constructor
-  fSx = 0;
-  fSz = 0;
 }
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const char *dataType){
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const char *dataType):
+fNrecp(0),
+fSx(0),
+fSz(0){
   //constructor
   Info("AliITSsimulationFastPointsV0","Standard constructor %s",dataType);
   fSx = new AliITSstatistics(2);
   fSz = new AliITSstatistics(2);
 }
 //______________________________________________________________________
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &/*rec*/):AliITSsimulation(/*rec*/){
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 & rec):AliITSsimulation(rec),
+fNrecp(rec.fNrecp),
+fSx(rec.fSx),
+fSz(rec.fSz){
     // Copy constructor. 
 
-  Error("Copy constructor","Copy constructor not allowed");
-  
 }
 //______________________________________________________________________
-AliITSsimulationFastPointsV0& AliITSsimulationFastPointsV0::operator=(const AliITSsimulationFastPointsV0& /*source*/){
-    // Assignment operator. This is a function which is not allowed to be
-    // done.
-    Error("operator=","Assignment operator not allowed\n");
-    return *this; 
+AliITSsimulationFastPointsV0& AliITSsimulationFastPointsV0::operator=(const AliITSsimulationFastPointsV0&  /*source*/){
+    // Assignment operator
+  Error("operator=","Assignment operator not allowed");
+  return *this;
 }
 
 //----------------------------------------------------------
index 694b8a5..da09e1f 100644 (file)
@@ -16,7 +16,7 @@ class AliITSsimulationFastPointsV0 : public AliITSsimulation
 public:
   AliITSsimulationFastPointsV0(); // default constructor
   AliITSsimulationFastPointsV0(const char *dataType); // standard constructor
-  AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &);
+  AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &rec);
   AliITSsimulationFastPointsV0 & operator=(const AliITSsimulationFastPointsV0 &);  
   virtual AliITSsimulation& operator=(const AliITSsimulation &)
     {return *this;};
index d2146a2..c777389 100644 (file)
@@ -131,8 +131,10 @@ fAnodeFire(0),
 fHis(0),
 fD(),
 fT1(),
+fT2(),
 fTol(),
 fTreeB(0),
+fParam(0),
 fFileName(),
 fFlag(kFALSE),
 fCheckNoise(kFALSE),
@@ -149,14 +151,36 @@ fScaleSize(0){
     SetCheckNoise();
 }
 //______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
-    AliITSsimulation(source){
+AliITSsimulationSDD::AliITSsimulationSDD(const AliITSsimulationSDD &source) :
+    AliITSsimulation(source),
+fITS(source.fITS),
+fHitMap2(source.fHitMap2),
+fHitSigMap2(source.fHitSigMap2),
+fHitNoiMap2(source.fHitNoiMap2),
+fStream(source.fStream),
+fElectronics(source.fElectronics),
+fInZR(source.fInZR),
+fInZI(source.fInZI),
+fOutZR(source.fOutZR),
+fOutZI(source.fOutZI),
+fAnodeFire(source.fAnodeFire),
+fHis(source.fHis),
+fD(source.fD),
+fT1(source.fT1),
+fT2(source.fT2),
+fTol(source.fTol),
+fTreeB(source.fTreeB),
+fParam(source.fParam),
+fFileName(source.fFileName),
+fFlag(source.fFlag),
+fCheckNoise(source.fCheckNoise),
+fCrosstalkFlag(source.fCrosstalkFlag),
+fDoFFT(source.fDoFFT),
+fNofMaps(source.fNofMaps),
+fMaxNofSamples(source.fMaxNofSamples),
+fScaleSize(source.fScaleSize){
     // Copy constructor to satify Coding roules only.
 
-    if(this==&source) return;
-    Error("AliITSsimulationSDD","Not allowed to make a copy of "
-          "AliITSsimulationSDD Using default creater instead");
-    AliITSsimulationSDD();
 }
 //______________________________________________________________________
 AliITSsimulationSDD& AliITSsimulationSDD::operator=(const AliITSsimulationSDD &src){
index f794499..653eea8 100644 (file)
@@ -34,7 +34,7 @@ class AliITSsimulationSDD : public AliITSsimulation {
     //Standard Constructor
     AliITSsimulationSDD(AliITSDetTypeSim* dettyp);
     // Copy operator
-    AliITSsimulationSDD(AliITSsimulationSDD &source);
+    AliITSsimulationSDD(const AliITSsimulationSDD &source);
     virtual ~AliITSsimulationSDD(); // Destructor
     // = operator
     AliITSsimulationSDD& operator=(const AliITSsimulationSDD &source);
index 35301a9..c99a00c 100644 (file)
@@ -142,7 +142,10 @@ AliITSsimulationSPD::~AliITSsimulationSPD(){
 //______________________________________________________________________
 AliITSsimulationSPD::AliITSsimulationSPD(const 
                                                   AliITSsimulationSPD 
-                                                  &s) : AliITSsimulation(s){
+                                                  &s) : AliITSsimulation(s),
+fHis(s.fHis),
+fSPDname(s.fSPDname),
+fCoupling(s.fCoupling){
     //     Copy Constructor
     // Inputs:
     //    AliITSsimulationSPD &s The original class for which
@@ -151,8 +154,6 @@ AliITSsimulationSPD::AliITSsimulationSPD(const
     //    none.
     // Return:
 
-    *this = s;
-    return;
 }
 //______________________________________________________________________
 AliITSsimulationSPD&  AliITSsimulationSPD::operator=(const 
index 31553f7..f6a6ee6 100644 (file)
@@ -124,10 +124,16 @@ AliITSsimulation& AliITSsimulationSSD::operator=(
 }
 //______________________________________________________________________
 AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source):
-    AliITSsimulation(source){
+    AliITSsimulation(source),
+fMapA2(source.fMapA2),
+fIonE(source.fIonE),
+fDifConst(),
+fDriftVel(){
   // copy constructor
-
-  *this = source;
+  fDifConst[0] = source.fDifConst[0];
+  fDifConst[1] = source.fDifConst[1];
+  fDriftVel[0] = source.fDriftVel[0];
+  fDriftVel[1] = source.fDriftVel[1];
 }
 //______________________________________________________________________
 AliITSsimulationSSD::~AliITSsimulationSSD() {
index 1d17da6..90b4ef3 100644 (file)
 ClassImp(AliITSstatistics)
 
 //
-AliITSstatistics::AliITSstatistics() : TObject(){
+AliITSstatistics::AliITSstatistics() : TObject(),
+fN(0),
+fOrder(0),
+fX(0),
+fW(0){
 //
 // default contructor
 //
-    fX = 0;
-    fW = 0;
-    fN = 0;
-    fOrder = 0;
-    return;
 }
 
 
-AliITSstatistics::AliITSstatistics(Int_t order) : TObject(){
+AliITSstatistics::AliITSstatistics(Int_t order) : TObject(),
+fN(0),
+fOrder(order),
+fX(0),
+fW(0){
 //
 // contructor to a specific order in the moments
 //
-    fOrder = order;
     fX = new Double_t[order];
     fW = new Double_t[order];
     for(Int_t i=0;i<order;i++) {fX[i] = 0.0; fW[i] = 0.0;}
-    fN = 0;
     return;
 }
 
@@ -51,7 +52,7 @@ AliITSstatistics::~AliITSstatistics(){
     fOrder = 0;
 }
 //_______________________________________________________________
-AliITSstatistics& AliITSstatistics::operator=(AliITSstatistics &source){
+AliITSstatistics& AliITSstatistics::operator=(const AliITSstatistics &source){
 // operator =
 
      if(this==&source) return *this;
@@ -73,7 +74,11 @@ AliITSstatistics& AliITSstatistics::operator=(AliITSstatistics &source){
          return *this;
 }
 //_______________________________________________________________
-AliITSstatistics::AliITSstatistics(AliITSstatistics &source) : TObject(source){
+AliITSstatistics::AliITSstatistics(const AliITSstatistics &source) : TObject(source),
+fN(0),
+fOrder(0),
+fX(0),
+fW(0){
 // Copy constructor
 
      if(this==&source) return;
index 6de2498..29612b2 100644 (file)
@@ -16,8 +16,8 @@ class AliITSstatistics : public TObject {
  public:
   AliITSstatistics();
   AliITSstatistics(Int_t order);
-  AliITSstatistics(AliITSstatistics &source); // copy  constructor
-  AliITSstatistics& operator=(AliITSstatistics &source); // operator=
+  AliITSstatistics(const AliITSstatistics &source); // copy  constructor
+  AliITSstatistics& operator=(const AliITSstatistics &source); // operator=
   virtual ~AliITSstatistics();
   void Reset();
   void AddValue(Double_t x,Double_t w);
@@ -27,16 +27,16 @@ class AliITSstatistics : public TObject {
   Double_t GetNth(Int_t order);
   Double_t GetMean() {// returns the mean
     return GetNth(1);};
-  Int_t GetN(){// returns the number of entries
+  Int_t GetN() const{// returns the number of entries
     return fN;
   };
-  Int_t GetOrder(){// returns the order of the moment of the distribution
+  Int_t GetOrder() const {// returns the order of the moment of the distribution
     return fOrder;
   };
-  Double_t GetXN(Int_t order){// returns X^N
+  Double_t GetXN(Int_t order) const{// returns X^N
     return fX[order-1];
   };
-  Double_t GetWN(Int_t order){// returns W^N
+  Double_t GetWN(Int_t order)const {// returns W^N
     return fW[order-1];
   };
   Double_t GetRMS();
index b8e4b07..ca3233c 100644 (file)
@@ -90,15 +90,20 @@ const Double_t AliITSvBeamTestITS04::fgkSSD1y = 80.6;
 ClassImp(AliITSvBeamTestITS04)
     
 //_____________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS()
-{
+  AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS(),
+fITSmotherVolume(0),
+fNspd(fgkNumberOfSPD),
+fNsdd(fgkNumberOfSDD),
+fNssd(fgkNumberOfSSD),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE){
     //
     // Constructor
     //
     
-    SetNumberOfSPD(fgkNumberOfSPD);
-    SetNumberOfSDD(fgkNumberOfSDD);
-    SetNumberOfSSD(fgkNumberOfSSD);
+  // SetNumberOfSPD(fgkNumberOfSPD);
+  //  SetNumberOfSDD(fgkNumberOfSDD);
+  //  SetNumberOfSSD(fgkNumberOfSSD);
     
     fIdN = 3;         
     fIdName    = new TString[fIdN];
@@ -109,25 +114,31 @@ AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS()
     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
     
     //for writing out geometry
-    fGeomDetOut   = kFALSE; 
+    //fGeomDetOut   = kFALSE; 
 
     // for reading in geometry (JC)
-    fGeomDetIn = kFALSE;
+    //fGeomDetIn = kFALSE;
 
     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
 }
 
 //_____________________________________________________________
 AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title)
-    : AliITS(name,title)
+  : AliITS(name,title),
+fITSmotherVolume(0),
+fNspd(fgkNumberOfSPD),
+fNsdd(fgkNumberOfSDD),
+fNssd(fgkNumberOfSSD),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE)
 {
     //
     // Constructor
     //
     
-    SetNumberOfSPD(fgkNumberOfSPD);
-    SetNumberOfSDD(fgkNumberOfSDD);
-    SetNumberOfSSD(fgkNumberOfSSD);
+    //SetNumberOfSPD(fgkNumberOfSPD);
+    //SetNumberOfSDD(fgkNumberOfSDD);
+    //SetNumberOfSSD(fgkNumberOfSSD);
     
     fIdN = 3;         
     fIdName    = new TString[fIdN];
@@ -138,20 +149,24 @@ AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title)
     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
     
     //for writing out geometry
-    fGeomDetOut   = kFALSE; // Don't write .det file
+    //fGeomDetOut   = kFALSE; // Don't write .det file
 
     // for reading in geometry (JC)
-    fGeomDetIn = kFALSE;
+    //fGeomDetIn = kFALSE;
 
     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';    
 }
 
 //______________________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source) :  AliITS(source){
-  //Copy constructor (dummy)
-    if(&source == this) return;
-    Warning("Copy Constructor","Not allowed to copy AliITSvSDD03");
-    return;
+AliITSvBeamTestITS04::AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source) :  AliITS(source),
+fITSmotherVolume(source.fITSmotherVolume),
+fNspd(source.fNspd),
+fNsdd(source.fNsdd),
+fNssd(source.fNssd),
+fGeomDetOut(source.fGeomDetOut),
+fGeomDetIn(source.fGeomDetIn){
+  //Copy constructor 
+
 }
 //______________________________________________________________________
 AliITSvBeamTestITS04& AliITSvBeamTestITS04::operator=(const AliITSvBeamTestITS04 &source){
index df969ae..d857d8b 100644 (file)
 ClassImp(AliITSvPPRcoarseasymm)
  
 //_____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm() {
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm():
+fMajorVersion(9),
+fMinorVersion(0),
+fRails(0),
+fSuppMat(0) {
 ////////////////////////////////////////////////////////////////////////
 //    Standard default constructor for the ITS version 6.
 ////////////////////////////////////////////////////////////////////////
@@ -59,11 +63,13 @@ AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm() {
     fIdN = 0;
     fIdName = 0;
     fIdSens    = 0;
-    fMajorVersion = 9;
-    fMinorVersion = 0;
 }
 //_____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : AliITS(name, title){
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : AliITS(name, title),
+fMajorVersion(9),
+fMinorVersion(0),
+fRails(0),
+fSuppMat(0) {
 ////////////////////////////////////////////////////////////////////////
 //    Standard constructor for the ITS version 6.
 ////////////////////////////////////////////////////////////////////////
@@ -78,18 +84,17 @@ AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title
     fIdName[5] = "ITS6";
     fIdSens    = new Int_t[fIdN];
     for (Int_t i=0;i<fIdN;i++) fIdSens[i]=0;
-    fMajorVersion = 9;
-    fMinorVersion = 0;
 }
 //____________________________________________________________________________
 AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const AliITSvPPRcoarseasymm &s) :
- AliITS(s){
+ AliITS(s),
+fMajorVersion(s.fMajorVersion),
+fMinorVersion(s.fMinorVersion),
+fRails(s.fRails),
+fSuppMat(s.fSuppMat){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 6.
 ////////////////////////////////////////////////////////////////////////
-    if(&s == this) return;
-    Warning("Copy Constructor","Not allowed to copy AliITSvPPRcoarseasymm");
-    return;
 }
 //_____________________________________________________________________________
 AliITSvPPRcoarseasymm& AliITSvPPRcoarseasymm::operator=(const AliITSvPPRcoarseasymm &source){
index 789b336..00a3e34 100644 (file)
@@ -33,10 +33,10 @@ class AliITSvPPRcoarseasymm : public AliITS {
     virtual void   SetSupportMaterial(Int_t v=0){ 
         // Set material of the services supports
         fSuppMat = v;}                      
-    virtual Int_t GetRails(){ 
+    virtual Int_t GetRails() const { 
         // Get flag for rails
         return fRails;}
-    virtual Int_t GetSupportMaterial(){ 
+    virtual Int_t GetSupportMaterial() const{ 
         // Get material of the services supports 
         return fSuppMat;}                
     virtual Int_t GetMajorVersion() const {// return Major Version Number