new SDD preprocessor + removal of eff C++ warning (base) - E. Crescio
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Oct 2006 17:28:55 +0000 (17:28 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Oct 2006 17:28:55 +0000 (17:28 +0000)
69 files changed:
ITS/AliITSBadChannelsSPD.cxx
ITS/AliITSCalibration.cxx
ITS/AliITSCalibrationSDD.cxx
ITS/AliITSCalibrationSPD.cxx
ITS/AliITSCalibrationSSD.cxx
ITS/AliITSChannelSPD.cxx
ITS/AliITSClusterFinder.cxx
ITS/AliITSClusterFinder.h
ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSSD.h
ITS/AliITSClusterFinderV2.cxx
ITS/AliITSClusterFinderV2.h
ITS/AliITSClusterFinderV2SDD.cxx
ITS/AliITSClusterFinderV2SPD.cxx
ITS/AliITSClusterFinderV2SSD.cxx
ITS/AliITSDDLRawData.cxx
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeRec.h
ITS/AliITSEventHeader.cxx
ITS/AliITSIOTrack.cxx
ITS/AliITSLoader.cxx
ITS/AliITSLoader.h
ITS/AliITSMapA1.cxx
ITS/AliITSMapA2.cxx
ITS/AliITSPreprocessorSDD.cxx [new file with mode: 0644]
ITS/AliITSPreprocessorSDD.h [new file with mode: 0644]
ITS/AliITSPreprocessorSPD.cxx
ITS/AliITSRad.cxx
ITS/AliITSRad.h
ITS/AliITSRawCluster.cxx
ITS/AliITSRawData.cxx
ITS/AliITSRawStream.cxx
ITS/AliITSRawStreamSDD.cxx
ITS/AliITSRawStreamSSD.cxx
ITS/AliITSRawStreamSSDv1.cxx
ITS/AliITSRecPoint.cxx
ITS/AliITSTransientDigit.cxx
ITS/AliITSTransientDigit.h
ITS/AliITSclusterSSD.cxx
ITS/AliITSclusterV2.cxx
ITS/AliITSclusterV2.h
ITS/AliITSclustererV2.cxx
ITS/AliITSclustererV2.h
ITS/AliITSdigit.cxx
ITS/AliITSdigit.h
ITS/AliITSdigitSDD.cxx
ITS/AliITSdigitSPD.cxx
ITS/AliITSgeom.cxx
ITS/AliITSgeom.h
ITS/AliITSgeomMatrix.cxx
ITS/AliITSgeomMatrix.h
ITS/AliITSgeomSDD.cxx
ITS/AliITSgeomSPD.cxx
ITS/AliITSgeomSSD.cxx
ITS/AliITSpList.cxx
ITS/AliITSpListItem.cxx
ITS/AliITSpListItem.h
ITS/AliITSpackageSSD.cxx
ITS/AliITSresponseSPD.cxx
ITS/AliITSresponseSSD.cxx
ITS/AliITSsegmentation.cxx
ITS/AliITSsegmentationSDD.cxx
ITS/AliITSsegmentationSPD.cxx
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsimulationFastPoints.h
ITS/ITSbaseLinkDef.h
ITS/ITSrecLinkDef.h
ITS/libITSbase.pkg
ITS/libITSrec.pkg

index c832654..a8fb7c9 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.2  2005/11/03 13:09:19  hristov
+Removing meaningless const declarations (linuxicc)
+
 Revision 1.1  2005/10/11 12:31:50  masera
 Preprocessor classes for SPD (Paul Nilsson)
 
@@ -52,14 +55,13 @@ AliITSBadChannelsSPD::AliITSBadChannelsSPD(void) :
 
 //__________________________________________________________________________
 AliITSBadChannelsSPD::AliITSBadChannelsSPD(const AliITSBadChannelsSPD &bc) :
-  TObject(bc)
-{
+  TObject(bc),
+fIndexArraySize(bc.fIndexArraySize),
+fBadChannelsArraySize(bc.fBadChannelsArraySize),
+fIndexArray(0),
+fBadChannelsArray(0){
   // Default copy constructor
 
-  // Copy array sizes
-  fIndexArraySize = bc.fIndexArraySize;
-  fBadChannelsArraySize = bc.fBadChannelsArraySize;
-
   // Create new arrays
   fIndexArray = new Int_t[fIndexArraySize];
   fBadChannelsArray = new Int_t[fBadChannelsArraySize];
index 90dc078..f170722 100644 (file)
@@ -60,27 +60,30 @@ fResponse(){
 
 //______________________________________________________________________
 AliITSCalibration::AliITSCalibration(const AliITSCalibration &ob):
-  TObject(ob)
+TObject(ob),
+fDataType(ob.fDataType),
+fdv(ob.fdv),
+fN(ob.fN),
+fT(ob.fT),
+fGeVcharge(ob.fGeVcharge),
+fResponse(ob.fResponse)
 {
   // Copy constructor
-  // not implemented
-  AliWarning("Copy constructor not implemented!");
-}
 
+}
+/*
 //______________________________________________________________________________
 AliITSCalibration& AliITSCalibration::operator= (const AliITSCalibration& source)
 {
   // Asignment operator
-  // not implemented
-  if(this==&source) return *this;
 
-  AliWarning("Asignment operator not implemented!");
+  this->~AliITSCalibration();
+  new(this) AliITSCalibration(source);
+  return *this;
 
-  ((TObject *)this)->operator=(source);
 
-  return *this;
 }
-
+*/
 //______________________________________________________________________
 Double_t AliITSCalibration::MobilityElectronSiEmp() const {
     // Computes the electron mobility in cm^2/volt-sec. Taken from SILVACO
index 225c3dc..c60c868 100644 (file)
@@ -249,6 +249,7 @@ void AliITSCalibrationSDD::PrintGains() const{
              ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
        }
 }
+
 //______________________________________________________________________
 void AliITSCalibrationSDD::Print(){
   // Print SDD response Parameters
index 94be4a4..70570c7 100644 (file)
@@ -45,7 +45,9 @@ fCouplCol(fgkCouplColDefault),
 fCouplRow(fgkCouplRowDefault),
 fBiasVoltage(fgkBiasVoltageDefault),
 fNrDead(0),
-fNrNoisy(0){
+fDeadChannels(0),
+fNrNoisy(0),
+fNoisyChannels(0){
   // constructor
 
    SetThresholds(fgkThreshDefault,fgkSigmaDefault);
index 138e367..5e9c1e2 100644 (file)
@@ -32,19 +32,45 @@ const Double_t AliITSCalibrationSSD::fgkSigmaNDefault = 2.;
 ClassImp(AliITSCalibrationSSD)
 
 //______________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(){
+AliITSCalibrationSSD::AliITSCalibrationSSD():
+fNPar(0),
+fDetPar(0),
+fNoiseP(0),
+fNoiseN(0),
+fSigmaP(0),
+fSigmaN(0),
+fGainP(0),
+fGainN(0),
+fNoisP(0),
+fNoisN(0),
+fNoisePThreshold(0),
+fNoisyPChannelsList(0),
+fNoiseNThreshold(0),
+fNoisyNChannelsList(0),
+fDeadNChannelsList(0),
+fDeadPChannelsList(0){
     // Default Constructor
 
-    fDetPar = 0;
-    fNPar   = 0;
-       fNoiseP = 0;
-    fNoiseN = 0;
-    fSigmaP = 0;
-    fSigmaN = 0;
     SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
 }
 //______________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType){
+AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType):
+fNPar(0),
+fDetPar(0),
+fNoiseP(0),
+fNoiseN(0),
+fSigmaP(0),
+fSigmaN(0),
+fGainP(0),
+fGainN(0),
+fNoisP(0),
+fNoisN(0),
+fNoisePThreshold(0),
+fNoisyPChannelsList(0),
+fNoiseNThreshold(0),
+fNoisyNChannelsList(0),
+fDeadNChannelsList(0),
+fDeadPChannelsList(0){
     // constructor
 
     SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
@@ -68,29 +94,6 @@ AliITSCalibrationSSD::~AliITSCalibrationSSD(){
     delete [] fDetPar;
 }
 //______________________________________________________________________
-AliITSCalibrationSSD& AliITSCalibrationSSD::operator=(const AliITSCalibrationSSD &src) {
-    // = operator.
-
-    if(&src == this) return *this;
-
-    this->fNPar      = src.fNPar;
-    for(Int_t i=0;i<this->fNPar;i++) this->fDetPar[i] = src.fDetPar[i];
-    this->fNoiseP    = src.fNoiseP;
-    this->fNoiseN    = src.fNoiseN;
-    this->fSigmaP    = src.fSigmaP;
-    this->fSigmaN    = src.fSigmaN;
-    this->fDataType  = src.fDataType;
-
-    return *this;
-}
-//_________________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(const AliITSCalibrationSSD &src) :
-    AliITSCalibration(src) {
-    // copy constructor
-
-    *this = src;
-}
-//______________________________________________________________________
 void AliITSCalibrationSSD::SetDetParam(Double_t  *par){
     // set det param
     Int_t i;
index d3562af..88e1e13 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.2  2005/11/03 13:09:19  hristov
+Removing meaningless const declarations (linuxicc)
+
 Revision 1.1  2005/10/11 12:31:50  masera
 Preprocessor classes for SPD (Paul Nilsson)
 
@@ -56,12 +59,11 @@ fRow(-1)
 
 //__________________________________________________________________________
 AliITSChannelSPD::AliITSChannelSPD(const AliITSChannelSPD &ch) :
-  TObject(ch)
-{
+  TObject(ch),
+fColumn(ch.fColumn),
+fRow(ch.fRow){
   // Copy constructor
 
-  fColumn = ch.fColumn;
-  fRow = ch.fRow;
 }
 
 //__________________________________________________________________________
@@ -89,10 +91,10 @@ Bool_t AliITSChannelSPD::operator==(const AliITSChannelSPD &channel) const
 }
 
 //__________________________________________________________________________
-AliITSChannelSPD::AliITSChannelSPD(Int_t column, Int_t row)
-{
+AliITSChannelSPD::AliITSChannelSPD(Int_t column, Int_t row):
+fColumn(column),
+fRow(row){
   // Constructor for already existing channel
 
-  fColumn = column;
-  fRow = row;
+
 }
index d7407c6..3855d6f 100644 (file)
@@ -58,6 +58,7 @@ fDebug(0),
 fModule(0),
 fDigits(0),
 fNdigits(0),
+fDetTypeRec(dettyp),
 fClusters(0),
 fNRawClusters(0),
 fMap(0),
@@ -77,7 +78,6 @@ fNPeaks(-1){
     SetNperMax();
     SetClusterSize();
     SetDeclusterFlag();
-    fDetTypeRec = dettyp;
 }
 //----------------------------------------------------------------------
 AliITSClusterFinder::AliITSClusterFinder(AliITSDetTypeRec* dettyp,
@@ -110,20 +110,22 @@ fNPeaks(-1){
     SetClusterSize();
     SetDeclusterFlag();
 }
+/*
 //______________________________________________________________________
 AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) : TObject(source) {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
   Fatal("AliITSClusterFinder","Copy constructor not allowed\n");
 }
+*/
 
 //______________________________________________________________________
-AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder& /* source */){
+//AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder& /* source */){
   // Assignment operator
   // Assignment is not allowed. The method is protected to avoid misuse.
-  Fatal("= operator","Assignment operator not allowed\n");
-  return *this;
-}
+//  Fatal("= operator","Assignment operator not allowed\n");
+//  return *this;
+//}
 
 //----------------------------------------------------------------------
 AliITSClusterFinder::~AliITSClusterFinder(){
index adda623..eb52a92 100644 (file)
@@ -112,10 +112,6 @@ class AliITSClusterFinder :public TObject{
     void InitGeometry(); 
  
   protected:
-    // methods 
-    AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
-    // assignment operator
-    AliITSClusterFinder& operator=(const AliITSClusterFinder &source);
    // data members       
 
    Int_t              fDebug;         //! Debug flag/level
@@ -139,6 +135,11 @@ class AliITSClusterFinder :public TObject{
     Int_t fNdet[2200];           // detector index  
     Int_t fNlayer[2200];         // detector layer
 
+ private:
+    AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
+    // assignment operator
+    AliITSClusterFinder& operator=(const AliITSClusterFinder &source);
+    
 
     ClassDef(AliITSClusterFinder,6) //Class for clustering and reconstruction of space points
 };
index f25750e..6d9b0be 100644 (file)
@@ -63,21 +63,21 @@ fMinNCells(0){
     SetDx();
     SetDz();
 }
-
+/*
 //______________________________________________________________________
 AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD &source) : AliITSClusterFinder(source) {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
   Fatal("AliITSClusterFinderSPD","Copy constructor not allowed\n");
 }
-
+*/
 //______________________________________________________________________
-AliITSClusterFinderSPD& AliITSClusterFinderSPD::operator=(const AliITSClusterFinderSPD& /* source */){
+//AliITSClusterFinderSPD& AliITSClusterFinderSPD::operator=(const AliITSClusterFinderSPD& /* source */){
   // Assignment operator
   // Assignment is not allowed. The method is protected to avoid misuse.
-  Fatal("= operator","Assignment operator not allowed\n");
-  return *this;
-}
+  //Fatal("= operator","Assignment operator not allowed\n");
+  //return *this;
+//}
 //______________________________________________________________________
 void AliITSClusterFinderSPD::FindRawClusters(Int_t module){   
     // input of Cluster Finder
index 97a2c0e..f45b35e 100644 (file)
@@ -24,12 +24,17 @@ class AliITSClusterFinderSSD: public AliITSClusterFinder{
   AliITSClusterFinderSSD();
   AliITSClusterFinderSSD(AliITSDetTypeRec* dettyp);
   AliITSClusterFinderSSD(AliITSDetTypeRec* dettyp, TClonesArray *digits);
+
   //   AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesArray *digits);
   virtual ~AliITSClusterFinderSSD();
   void FindRawClusters(Int_t module);    
   
  protected:
-    virtual AliITSsegmentationSSD* GetSeg()const{
+
+  AliITSClusterFinderSSD(const AliITSClusterFinderSSD &source);    // Copy constructor
+  AliITSClusterFinderSSD& operator=(const AliITSClusterFinderSSD &source);// = operator
+  
+  virtual AliITSsegmentationSSD* GetSeg()const{
         return (AliITSsegmentationSSD*)fDetTypeRec->GetSegmentationModel(2);}
   void      InitReconstruction();
   Bool_t    CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
index a6074d4..0a1cd6a 100644 (file)
@@ -32,28 +32,28 @@ ClassImp(AliITSClusterFinderV2)
 
 extern AliRun *gAlice;
 
-AliITSClusterFinderV2::AliITSClusterFinderV2(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp){
+AliITSClusterFinderV2::AliITSClusterFinderV2(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp),
+fNModules(0),
+fEvent(0){
 
   //Default constructor
-  fEvent = 0;
-  fModule = 0;
   fNModules = dettyp->GetITSgeom()->GetIndexMax();
 }
-
+/*
 //______________________________________________________________________
 AliITSClusterFinderV2::AliITSClusterFinderV2(const AliITSClusterFinderV2 &source) : AliITSClusterFinder(source) {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
   Fatal("AliITSClusterFinderV2","Copy constructor not allowed\n");
 }
-
+*/
 //______________________________________________________________________
-AliITSClusterFinderV2& AliITSClusterFinderV2::operator=(const AliITSClusterFinderV2& /* source */){
+//AliITSClusterFinderV2& AliITSClusterFinderV2::operator=(const AliITSClusterFinderV2& /* source */){
   // Assignment operator
   // Assignment is not allowed. The method is protected to avoid misuse.
-  Fatal("= operator","Assignment operator not allowed\n");
-  return *this;
-}
+  //Fatal("= operator","Assignment operator not allowed\n");
+  //return *this;
+//}
 
 
 //______________________________________________________________________
index a41f9b0..a765aaa 100644 (file)
@@ -41,7 +41,7 @@ protected:
   };
   class AliBin {
   public:
-    AliBin() {fIndex=0; fQ=0; fMask=0xFFFFFFFE;}
+    AliBin():fIndex(0),fMask(0xFFFFFFFE),fQ(0){}
     void SetIndex(UInt_t idx) {fIndex=idx;}
     void SetQ(UShort_t q)  {fQ=q;}
     void SetMask(UInt_t m) {fMask=m;}
index 4aa5bb8..c6ed0c8 100644 (file)
@@ -36,17 +36,17 @@ ClassImp(AliITSClusterFinderV2SDD)
 
 extern AliRun *gAlice;
 
-AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fNySDD(256),
+fNzSDD(256),
+fYpitchSDD(0.01825),
+fZpitchSDD(0.02940),
+fHwSDD(3.5085),
+fHlSDD(3.7632),
+fYoffSDD(0.0425){
 
   //Default constructor
 
-  fNySDD=256; fNzSDD=256;
-  fYpitchSDD=0.01825;
-  fZpitchSDD=0.02940;
-  fHwSDD=3.5085; fHlSDD=3.7632;
-  fYoffSDD=0.0425;
-
-
 
 }
  
index f92dabf..c0f11d4 100644 (file)
@@ -32,16 +32,19 @@ ClassImp(AliITSClusterFinderV2SPD)
 
 extern AliRun *gAlice;
 
-AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fLastSPD1(0),
+fNySPD(256),
+fNzSPD(160),
+fYpitchSPD(0.0050),
+fZ1pitchSPD(0.0425),
+fZ2pitchSPD(0.0625),
+fHwSPD(0.64),
+fHlSPD(3.48){
 
   //Default constructor
 
   fLastSPD1=fDetTypeRec->GetITSgeom()->GetModuleIndex(2,1,1)-1;
-
-  fNySPD=256; fNzSPD=160;
-  fYpitchSPD=0.0050;
-  fZ1pitchSPD=0.0425; fZ2pitchSPD=0.0625;
-  fHwSPD=0.64; fHlSPD=3.48;
   fYSPD[0]=0.5*fYpitchSPD;
   for (Int_t m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD; 
   fZSPD[0]=fZ1pitchSPD;
index beb343d..6de5e1e 100644 (file)
 ClassImp(AliITSClusterFinderV2SSD)
 
 
-AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fLastSSD1(0),
+fYpitchSSD(0.0095),
+fHwSSD(3.65),
+fHlSSD(2.00),
+fTanP(0.0275),
+fTanN(0.0075){
 
   //Default constructor
 
   fLastSSD1=fDetTypeRec->GetITSgeom()->GetModuleIndex(6,1,1)-1;
-  fYpitchSSD=0.0095;
-  fHwSSD=3.65;
-  fHlSSD=2.00;
-  fTanP=0.0275;
-  fTanN=0.0075;
-
-
 
 }
  
index 7e9bf7f..ccdf3c2 100644 (file)
 ClassImp(AliITSDDLRawData)
 
 ////////////////////////////////////////////////////////////////////////////////////////
-AliITSDDLRawData::AliITSDDLRawData(){
+AliITSDDLRawData::AliITSDDLRawData():
+fVerbose(0),
+fIndex(-1),
+fHalfStaveModule(-1){
   //Default constructor
-  fIndex=-1;
-  fHalfStaveModule=-1;
-  fVerbose=0;
+
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
 AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) : 
-    TObject(source){
+    TObject(source),
+fVerbose(source.fVerbose),
+fIndex(source.fIndex),
+fHalfStaveModule(source.fHalfStaveModule){
   //Copy Constructor
-  this->fIndex=source.fIndex;
-  this->fHalfStaveModule=source.fHalfStaveModule;
-  this->fVerbose=source.fVerbose;
-  return;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
index 237ce95..2376ded 100644 (file)
@@ -26,7 +26,6 @@
 #include "TTree.h"
 
 #include "AliCDBManager.h"
-#include "AliCDBStorage.h"
 #include "AliCDBEntry.h"
 #include "AliITSClusterFinder.h"
 #include "AliITSClusterFinderV2.h"
@@ -57,7 +56,23 @@ const Int_t AliITSDetTypeRec::fgkDefaultNModulesSSD = 1698;
 ClassImp(AliITSDetTypeRec)
 
 //________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(): TObject(){
+AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
+fNMod(0),
+fReconstruction(0),
+fSegmentation(0),
+fCalibration(0),
+fPreProcess(0),
+fPostProcess(0),
+fDigits(0),
+fNdtype(0),
+fCtype(0),
+fNctype(0),
+fRecPoints(0),
+fNRecPoints(0),
+fSelectedVertexer(),
+fLoader(0),
+fRunNumber(0),
+fFirstcall(kTRUE){
     // Default Constructor
     // Inputs:
     //    none.
@@ -65,31 +80,35 @@ AliITSDetTypeRec::AliITSDetTypeRec(): TObject(){
     //    none.
     // Return:
     //    A properly zero-ed AliITSDetTypeRec class.
-  fReconstruction = 0;
-  fSegmentation = 0;
-  fCalibration = 0;
-  fPreProcess = 0;
-  fPostProcess = 0;
-  fDigits = 0;;
+
   for(Int_t i=0; i<3; i++){
     fClusterClassName[i]=0;
     fDigClassName[i]=0;
     fRecPointClassName[i]=0;
   }
-  fNdtype = 0;
-  fCtype = 0;
-  fNMod = 0;
-  fNctype = 0;
-  fRecPoints = 0;
-  fNRecPoints = 0;
+
   SelectVertexer(" ");
-  fLoader = 0;
-  fRunNumber = 0;
-  fFirstcall = kTRUE;
+
 
 }
 //________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){
+AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(),
+fNMod(0),
+fReconstruction(0),
+fSegmentation(0),
+fCalibration(0),
+fPreProcess(0),
+fPostProcess(0),
+fDigits(0),
+fNdtype(0),
+fCtype(0),
+fNctype(0),
+fRecPoints(0),
+fNRecPoints(0),
+fSelectedVertexer(),
+fLoader(loader),
+fRunNumber(0),
+fFirstcall(kTRUE){
     // Standard Constructor
     // Inputs:
     //    none.
@@ -99,10 +118,6 @@ AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){
     //   
 
   fReconstruction = new TObjArray(fgkNdettypes);
-  fSegmentation = 0;
-  fCalibration = 0;
-  fPreProcess = 0;
-  fPostProcess = 0;
   fDigits = new TObjArray(fgkNdettypes);
   for(Int_t i=0; i<3; i++){
     fClusterClassName[i]=0;
@@ -124,30 +139,28 @@ AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){
     fNctype[i]=0;
   }
   
-  SelectVertexer(" ");
-  fLoader = loader;
+  SelectVertexer(" "); 
   SetRunNumber();
-  fFirstcall = kTRUE;
 }
+/*
 //______________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec &/*rec*/):TObject(/*rec*/){
-    // Copy constructor. 
+AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec)
+{
 
+  // Copy constructor. 
   Error("Copy constructor","Copy constructor not allowed");
-  
 }
 //______________________________________________________________________
-AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& /*source*/){
+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; 
-}
 
+}
+*/
 //_____________________________________________________________________
 AliITSDetTypeRec::~AliITSDetTypeRec(){
   //Destructor
  
   if(fReconstruction){
@@ -413,21 +426,19 @@ Bool_t AliITSDetTypeRec::GetCalibration() {
 
   if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
        AliWarning("Calibration object retrieval failed! Dummy calibration will be used.");
-       AliCDBStorage *localStor = 
-               AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
+       AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage();
+       AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
        
-       entrySPD = localStor->Get("ITS/Calib/CalibSPD", run);
-       entrySDD = localStor->Get("ITS/Calib/CalibSDD", run);
-       entrySSD = localStor->Get("ITS/Calib/CalibSSD", run);
-       entry2SPD = localStor->Get("ITS/Calib/RespSPD", run);
-       entry2SDD = localStor->Get("ITS/Calib/RespSDD", run);
-       entry2SSD = localStor->Get("ITS/Calib/RespSSD", run);
+       entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
+       entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
+       entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
+       entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
+       entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
+       entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
+       
+       AliCDBManager::Instance()->SetDefaultStorage(origStorage);
   }
 
-  if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
-    AliError("Calibration data was not found in $ALICE_ROOT!");
-    return kFALSE;
-  }
  
   TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
   if(!isCacheActive)entrySPD->SetObject(NULL);
index f5f4d08..074aba5 100644 (file)
@@ -31,9 +31,7 @@ class AliITSDetTypeRec : public TObject {
   public:
     AliITSDetTypeRec(); // Default constructor
     AliITSDetTypeRec(AliITSLoader *loader); // Standard constructor
-    AliITSDetTypeRec(const AliITSDetTypeRec& rec);
-    AliITSDetTypeRec& operator=(const AliITSDetTypeRec &source);
-
     virtual ~AliITSDetTypeRec(); // Proper Destructor
     AliITSgeom* GetITSgeom()const{return GetLoader()->GetITSgeom();}
 
@@ -102,6 +100,9 @@ class AliITSDetTypeRec : public TObject {
 
   private:
     // private methods
+    AliITSDetTypeRec(const AliITSDetTypeRec& rec);
+    AliITSDetTypeRec& operator=(const AliITSDetTypeRec &source);
     virtual void SetLoader(AliITSLoader* loader) {fLoader=loader;}
     static const Int_t fgkNdettypes;          // number of det. types
     static const Int_t fgkDefaultNModulesSPD; // Total numbers of SPD modules by default
index 6168acc..0a8636a 100644 (file)
@@ -11,7 +11,9 @@ ClassImp(AliITSEventHeader)
 
   
 //_____________________________________________________________
-AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader()
+  AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader(),
+fEventTypeSDD(),
+fJitterSDD(0)
 {
   //
   // Defaulst Constructor
@@ -29,14 +31,15 @@ AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader()
     fMiniEvId[idet]=0;
     fSubDet[idet]=0;
     fVersion[idet]=0;
-    fJitterSDD=0;
   }
   
   
 }
 
 //_____________________________________________________________
-AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(name)
+AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(name),
+fEventTypeSDD(),
+fJitterSDD(-123)
 {
   //
   // Constructor
@@ -52,7 +55,6 @@ AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(na
     fMiniEvId[idet]=0;
     fSubDet[idet]=0;
     fVersion[idet]=0;
-    fJitterSDD=-123;
   }
   
 
index 40b6d18..ec9b9b0 100644 (file)
@@ -8,22 +8,45 @@
 
 ClassImp(AliITSIOTrack)
 
-AliITSIOTrack::AliITSIOTrack() {
+AliITSIOTrack::AliITSIOTrack():
+fLab(-3),
+fTPCLab(-3),
+fX(0.),
+fY(0.),
+fZ(0.),
+fPx(0.),
+fPy(0.),
+fPz(0.),
+fStateVPhi(0.),
+fStateVZ(0.),
+fStateVD(0.),
+fStateVTgl(0.),
+fStateVC(0.),
+fRadius(0.),
+fPid(0),
+fCharge(0),
+fMass(0.),
+fDz(0.),
+fdEdx(0.),
+fC00(0.),
+fC10(0.),
+fC11(0.),
+fC20(0.),
+fC21(0.),
+fC22(0.),
+fC30(0.),
+fC31(0.),
+fC32(0.),
+fC33(0.),
+fC40(0.),
+fC41(0.),
+fC42(0.),
+fC43(0.),
+fC44(0.) {
 //Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
 // default constructor
-  fLab=-3;
-  fTPCLab=-3;   
-  fX=fZ=fY=0.; 
-  fPx=fPy=fPz=0.;
-  fDz=0.;
-  for (Int_t i=0;i<6;i++) {fIdModules[i]=fIdPoints[i]=-1; fIdPoints[i]=-1;}
-  fStateVPhi=0.; fStateVZ=0.; fStateVD=0.; fStateVTgl=0.; fStateVC=0.;
-  fRadius=0.; fCharge=0; 
-  fMass =0.;
-  fdEdx=0.;
-  fPid=0;
-  fC00=fC10=fC11=fC20=fC21=fC22=fC30=fC31=fC32=fC33=fC40=fC41=fC42=fC43=fC44=0.; 
 
+  for (Int_t i=0;i<6;i++) {fIdModules[i]=fIdPoints[i]=-1; fIdPoints[i]=-1;}
 }
    
 
index ac8f83a..b7c3d27 100644 (file)
@@ -18,15 +18,17 @@ const TString AliITSLoader::fgkDefaultCascadeContainerName = "Cascade";
 ClassImp(AliITSLoader)
 
 /**********************************************************************/
-  AliITSLoader::AliITSLoader():AliLoader(){
+  AliITSLoader::AliITSLoader():AliLoader(),
+fITSpid(0),
+fGeom(0){
   // Default constructor
-  fITSpid = 0;
-  fGeom = 0;
 }
 /*********************************************************************/
 AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
-AliLoader(name,topfoldername){
-  //ctor   
+AliLoader(name,topfoldername),
+fITSpid(0),
+fGeom(0){
+  //Constructor   
     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
         "Raw Clusters");
@@ -60,12 +62,12 @@ AliLoader(name,topfoldername){
     fDataLoaders->Add(cascadeDataLoader);
     cascadeDataLoader->SetEventFolder(fEventFolder);
     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
-    fITSpid=0;
-    fGeom = 0;
 }
 /**********************************************************************/
 AliITSLoader::AliITSLoader(const Char_t *name,TFolder *topfolder): 
-AliLoader(name,topfolder) {
+  AliLoader(name,topfolder),
+fITSpid(0),
+fGeom(0){
   //ctor  
     AliDataLoader*  rawClustersDataLoader = new AliDataLoader(
         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
@@ -100,24 +102,8 @@ AliLoader(name,topfolder) {
     fDataLoaders->Add(cascadeDataLoader);
     cascadeDataLoader->SetEventFolder(fEventFolder);
     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
-    fITSpid = 0;
-    fGeom = 0;
-}
-
-//______________________________________________________________________
-AliITSLoader::AliITSLoader(const AliITSLoader &ob) : AliLoader(ob) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSLoader","Copy constructor not allowed\n");
 }
 
-//______________________________________________________________________
-AliITSLoader& AliITSLoader::operator=(const AliITSLoader& /* ob */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
-}
 
 /**********************************************************************/
 AliITSLoader::~AliITSLoader(){
@@ -142,6 +128,7 @@ AliITSLoader::~AliITSLoader(){
     UnloadCascades();
     dl = GetCascadeDataLoader();
     fDataLoaders->Remove(dl);
+  
     if(fGeom)delete fGeom;
     fGeom = 0;
 }
index 0925a70..4e0825f 100644 (file)
@@ -15,9 +15,6 @@ class AliITSLoader: public AliLoader{
     AliITSLoader();
     AliITSLoader(const Char_t *name,const Char_t *topfoldername);
     AliITSLoader(const Char_t *name,TFolder *topfolder);
-    AliITSLoader(const AliITSLoader &ob); // copy constructor
-    AliITSLoader& operator=(const AliITSLoader & /* source */); // ass.
-
 
     virtual ~AliITSLoader();
 
@@ -118,6 +115,9 @@ class AliITSLoader: public AliLoader{
     void  AdoptITSpid(AliITSpidESD* pid) {fITSpid=pid;}
   protected:
 
+    AliITSLoader(const AliITSLoader &ob); // copy constructor
+    AliITSLoader& operator=(const AliITSLoader & /* source */); // ass.
+
     // METHODS
     virtual void   MakeRawClustersContainer() {GetRawClLoader()->MakeTree();}
     Int_t          PostRawClusters(){
@@ -143,6 +143,8 @@ class AliITSLoader: public AliLoader{
     static const TString fgkDefaultCascadeContainerName;      //default fo cascade container name
     AliITSpidESD* fITSpid; //! pointer for ITS pid
     AliITSgeom *fGeom;     //! pointer to the ITS geometry class
+
+
     ClassDef(AliITSLoader,5) // Loader for additional ITS specific trees.
 };
  
index 588dd05..a1e94bd 100644 (file)
 
 ClassImp(AliITSMapA1)
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(){
+AliITSMapA1::AliITSMapA1():
+fSegmentation(0),
+fNpx(0),
+fNpz(0),
+fObjects(0),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(0){
     // default constructor
 
-    fSegmentation = 0;
-    fNpz          = 0;
-    fNpx          = 0;
-    fMaxIndex     = 0;
-    fHitMap       = 0;
-    fObjects      = 0;
-    fNobjects     = 0;
-    fMapThreshold = 0;
-    fMapThresholdArr = 0;
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg){
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg):
+fSegmentation(seg),
+fNpx(0),
+fNpz(0),
+fObjects(0),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(0){
     //constructor
 
-    fSegmentation = seg;
     fNpz          = fSegmentation->Npz();
     fNpx          = fSegmentation->Npx();
     fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
     fHitMap       = new Int_t[fMaxIndex];
-    fObjects      = 0;
-    fNobjects     = 0;
-    fMapThreshold = 0;
-    fMapThresholdArr = 0;
     ClearMap();
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj){
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj):
+fSegmentation(seg),
+fNpx(0),
+fNpz(0),
+fObjects(obj),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(0){
     //constructor
 
-    fNobjects     = 0;
-    fSegmentation = seg;
-    fNpz          = fSegmentation->Npz();
-    fNpx          = fSegmentation->Npx();
-    fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
-    fHitMap       = new Int_t[fMaxIndex];
-    fObjects      =  obj;
-    if(fObjects) fNobjects = fObjects->GetEntriesFast();
-    fMapThreshold = 0;
-    fMapThresholdArr = 0;
-    ClearMap();
+  fNpz          = fSegmentation->Npz();
+  fNpx          = fSegmentation->Npx();
+  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
+  fHitMap       = new Int_t[fMaxIndex];
+  if(fObjects) fNobjects = fObjects->GetEntriesFast();
+  ClearMap();
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, Int_t thr){
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, Int_t thr):
+fSegmentation(seg),
+fNpx(0),
+fNpz(0),
+fObjects(obj),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(thr){
     //constructor
 
-    fNobjects     = 0;
-    fSegmentation = seg;
-    fNpz          = fSegmentation->Npz();
-    fNpx          = fSegmentation->Npx();
-    fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
-    fHitMap       = new Int_t[fMaxIndex];
-    fObjects      =  obj;
-    if(fObjects) fNobjects = fObjects->GetEntriesFast();
-    fMapThreshold = thr;
-    ClearMap();
+  fNpz          = fSegmentation->Npz();
+  fNpx          = fSegmentation->Npx();
+  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
+  fHitMap       = new Int_t[fMaxIndex];
+  if(fObjects) fNobjects = fObjects->GetEntriesFast();
+  ClearMap();
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, TArrayI thr){
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, TArrayI thr):
+fSegmentation(seg),
+fNpx(0),
+fNpz(0),
+fObjects(obj),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(thr),
+fHitMap(0),
+fMapThreshold(0){
     //constructor
 
-    fNobjects     = 0;
-    fSegmentation = seg;
-    fNpz          = fSegmentation->Npz();
-    fNpx          = fSegmentation->Npx();
-    fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
-    fHitMap       = new Int_t[fMaxIndex];
-    fObjects      =  obj;
-    if(fObjects) fNobjects = fObjects->GetEntriesFast();
-    fMapThreshold = 0;
-    fMapThresholdArr = thr;
-    ClearMap();
+  fNpz          = fSegmentation->Npz();
+  fNpx          = fSegmentation->Npx();
+  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
+  fHitMap       = new Int_t[fMaxIndex];
+  if(fObjects) fNobjects = fObjects->GetEntriesFast();
+  ClearMap();
 }
 
 //______________________________________________________________________
@@ -113,23 +130,23 @@ AliITSMapA1::~AliITSMapA1(){
 AliITSMapA1& AliITSMapA1::operator=(const AliITSMapA1 &source) {
     //    Assignment operator
 
-    if(&source == this) return *this;
-
-    this->fNpx          = source.fNpx;
-    this->fNpz          = source.fNpz;
-    this->fObjects      = source.fObjects;
-    this->fNobjects     = source.fNobjects;
-    this->fMaxIndex     = source.fMaxIndex;
-    this->fHitMap       = source.fHitMap;
-    this->fMapThreshold = source.fMapThreshold;
-    this->fMapThresholdArr = source.fMapThresholdArr;
-    return *this;
+  this->~AliITSMapA1();
+  new(this) AliITSMapA1(source);
+  return *this;
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source){
-    //     Copy Constructor
-
-    *this = source;
+AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source),
+fSegmentation(source.fSegmentation),
+fNpx(source.fNpx),
+fNpz(source.fNpz),
+fObjects(source.fObjects),
+fNobjects(source.fNobjects),
+fMaxIndex(source.fMaxIndex),
+fMapThresholdArr(source.fMapThresholdArr),
+fHitMap(source.fHitMap),
+fMapThreshold(source.fMapThreshold){
+  //     Copy Constructor
+  
 }
 //______________________________________________________________________
 void AliITSMapA1::ClearMap(){
index 83fbbfb..e65b6a3 100644 (file)
 ClassImp(AliITSMapA2)
 
 //______________________________________________________________________
-AliITSMapA2::AliITSMapA2(){
+AliITSMapA2::AliITSMapA2():
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(0),
+fScaleSizeZ(0){
     // default constructor
 
     fSegmentation  = 0;
     fNpz           = 0;
     fNpx           = 0;
     fMaxIndex      = 0;
-    fHitMapD       = 0;
     fObjects       = 0;
     fNobjects      = 0;
-    fMapThresholdD =0.;
 }
 //______________________________________________________________________
-AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg){
+AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg):
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(1),
+fScaleSizeZ(1){
     //constructor
 
-    fScaleSizeZ    = 1;
-    fScaleSizeX    = 1;
     fSegmentation  = seg;
     fNpz           = fSegmentation->Npz();
     fNpx           = fSegmentation->Npx();
     fMaxIndex      = fNpz*fNpx+fNpx;       // 2 halves of detector
     fHitMapD       = new Double_t[fMaxIndex+1];
-    fMapThresholdD = 0.;
     fObjects       = 0;
     fNobjects      = 0;
     ClearMap();
 }
 //______________________________________________________________________
 AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg,
-                        Int_t scalesizeX, Int_t scalesizeZ){
+                        Int_t scalesizeX, Int_t scalesizeZ):
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(scalesizeX),
+fScaleSizeZ(scalesizeZ){
     //constructor
 
     fSegmentation  = seg;
-    fScaleSizeX    = scalesizeX;
-    fScaleSizeZ    = scalesizeZ;
     fNpz           = fScaleSizeZ*fSegmentation->Npz();
     fNpx           = fScaleSizeX*fSegmentation->Npx();
     fMaxIndex      = fNpz*fNpx+fNpx;             // 2 halves of detector
     fHitMapD       = new Double_t[fMaxIndex+1];
-    fMapThresholdD = 0.;
     fObjects       = 0;
     fNobjects      = 0;
     ClearMap();
 }
 //______________________________________________________________________
 AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *obj, 
-                        Double_t thresh){
+                        Double_t thresh):
+fHitMapD(0),
+fMapThresholdD(thresh),
+fScaleSizeX(1),
+fScaleSizeZ(1){
     //constructor
 
     fNobjects      = 0;
-    fScaleSizeZ    = 1;
-    fScaleSizeX    = 1;
     fSegmentation  = seg;
     fNpz           = fSegmentation->Npz();
     fNpx           = fSegmentation->Npx();
@@ -93,7 +99,6 @@ AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *obj,
     fHitMapD       = new Double_t[fMaxIndex+1];
     fObjects       =  obj;
     if (fObjects) fNobjects = fObjects->GetEntriesFast();
-    fMapThresholdD = thresh;
     ClearMap();
 }
 //______________________________________________________________________
@@ -103,29 +108,23 @@ AliITSMapA2::~AliITSMapA2(){
     if (fHitMapD) delete[] fHitMapD;
 }
 //______________________________________________________________________
-AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source){
+AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source),
+fHitMapD(source.fHitMapD),
+fMapThresholdD(source.fMapThresholdD),
+fScaleSizeX(source.fScaleSizeX),
+fScaleSizeZ(source.fScaleSizeZ){
     //     Copy Constructor 
 
-    if(&source == this) return;
-
-    this->fMapThresholdD = source.fMapThresholdD;
-    this->fScaleSizeX    = source.fScaleSizeX;
-    this->fScaleSizeZ    = source.fScaleSizeZ;
-    this->fHitMapD       = source.fHitMapD;
-    return;
 }
 //______________________________________________________________________
 AliITSMapA2& AliITSMapA2::operator=(const AliITSMapA2 &source) {
     //    Assignment operator
+  this->~AliITSMapA2();
+  new(this) AliITSMapA2(source);
+  return *this;
 
-    if(&source == this) return *this;
-
-    this->fMapThresholdD = source.fMapThresholdD;
-    this->fScaleSizeX    = source.fScaleSizeX;
-    this->fScaleSizeZ    = source.fScaleSizeZ;
-    this->fHitMapD       = source.fHitMapD;
-    return *this;
 }
+
 //______________________________________________________________________
 void AliITSMapA2::ClearMap(){
     //clear array
diff --git a/ITS/AliITSPreprocessorSDD.cxx b/ITS/AliITSPreprocessorSDD.cxx
new file mode 100644 (file)
index 0000000..a0c6d7d
--- /dev/null
@@ -0,0 +1,99 @@
+/////////////////////////////////////////
+// Class for SDD digits preprocessing  //
+////////////////////////////////////////
+
+#include "AliITSPreprocessorSDD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliShuttleInterface.h"
+#include "AliCDBMetaData.h"
+#include "TObjArray.h"
+#include "TH1F.h"
+#include "AliLog.h"
+#include "TFile.h"
+
+const Int_t AliITSPreprocessorSDD::fgkNumberOfSDD = 260;
+const Int_t AliITSPreprocessorSDD::fgkNumberOfChannels = 512;
+const char* AliITSPreprocessorSDD::fgkNameHistoPedestals ="hpedestal";
+const char* AliITSPreprocessorSDD::fgkNameHistoNoise="hnoise";
+
+ClassImp(AliITSPreprocessorSDD)
+
+
+UInt_t AliITSPreprocessorSDD::Process(TMap*/* dcsAliasMap*/){
+
+  //preprocessing. 
+
+  UInt_t result = 0;
+  const char* filename = GetFile(kDAQ,"PEDESTALS","GDC");
+  const char* filenamen= GetFile(kDAQ,"NOISE","GDC");
+  const char* filenamed= GetFile(kDAQ,"DEADCHANNELS","GDC");
+  TFile* f1 = TFile::Open(filename,"r");
+  TFile* f2 = TFile::Open(filenamen,"r");
+  Char_t namehisto[20];
+  Char_t namehisto2[20];
+
+  FILE* filed = fopen(filenamed,"read");
+  Int_t numOfBadChannels[fgkNumberOfSDD];
+  Int_t** badCh = new Int_t*[fgkNumberOfSDD];
+  
+  Char_t row[50];
+  Int_t nSDD=0;
+  Char_t str[20];
+  char dims[1];
+  Int_t dim;
+  sprintf(str,"MODULE=%d",0);
+  while(!feof(filed)){
+    fscanf(filed,"%s\n",row);
+    if(strcmp(row,str)==0){
+      fscanf(filed,"%s %d\n",dims,&dim);
+      badCh[nSDD] = new Int_t[dim];
+      numOfBadChannels[nSDD]=dim;
+      for(Int_t ibad=0;ibad<dim;ibad++){
+       fscanf(filed,"%d\n",&badCh[nSDD][ibad]);
+      }      
+    }
+    nSDD++;
+    sprintf(str,"MODULE=%d",nSDD);
+  }
+  
+
+
+  AliCDBMetaData *md1= new AliCDBMetaData(); // metaData describing the object
+  md1->SetObjectClassName("AliITSCalibration");
+  md1->SetResponsible("Elisabetta Crescio");
+  md1->SetBeamPeriod(0);
+  md1->SetAliRootVersion("head September 2005"); //root version
+  md1->SetComment("This is a test");
+
+  TObjArray respSDD(260);
+  respSDD.SetOwner(kFALSE);
+  
+  for(Int_t imod=0;imod<fgkNumberOfSDD;imod++){
+    AliITSCalibrationSDD *cal = new AliITSCalibrationSDD("simulated");
+    cal->SetDeadChannels(numOfBadChannels[imod]);
+    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);
+    TH1F* hbas = (TH1F*)f1->Get(namehisto);
+    TH1F* hnoi = (TH1F*)f2->Get(namehisto2);
+    for(Int_t ien=0;ien<fgkNumberOfChannels;ien++){
+      cal->SetBaseline(ien,hbas->GetBinContent(ien+1));
+      cal->SetNoiseAfterElectronics(ien,hnoi->GetBinContent(ien+1));
+    }
+    respSDD.Add(cal);
+  }
+
+  result = Store("Calib","Data",&respSDD,md1);
+
+  for(Int_t i=0;i<fgkNumberOfSDD;i++){
+    delete badCh[i];
+  }
+  delete [] badCh;
+  f1->Close();
+  f2->Close();
+  fclose(filed);
+  return result;
+
+}
diff --git a/ITS/AliITSPreprocessorSDD.h b/ITS/AliITSPreprocessorSDD.h
new file mode 100644 (file)
index 0000000..d6485f5
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef ALIITSPREPROCESSORSDD_H
+#define ALIITSPREPROCESSORSDD_H
+
+////////////////////////////////////////////////////
+//  Class for the                                 //
+//  SDD beam test digit preprocessing             //
+//  Origin: E. Crescio - crescio@to.infn.it       //
+//                                                //
+////////////////////////////////////////////////////
+
+
+#include "AliPreprocessor.h"
+
+
+class AliITSPreprocessorSDD : public AliPreprocessor { 
+
+ public:
+  AliITSPreprocessorSDD(const char* detector, AliShuttleInterface* shuttle):
+    AliPreprocessor(detector,shuttle){;}
+  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.
+
+ };
+
+
+
+#endif
+
+    
index a83a730..9a4b8ea 100644 (file)
@@ -54,26 +54,28 @@ Preprocessor classes for SPD (Paul Nilsson)
 #include "AliCDBEntry.h"
 #include "AliITSCalibrationSPD.h" 
 ClassImp(AliITSPreprocessorSPD)
-
-
 //__________________________________________________________________________
 AliITSPreprocessorSPD::AliITSPreprocessorSPD(void):
-  fITSLoader(0x0),
-  fRunLoader(0x0),
-  fThresholdRatio(5.),
-  fThreshold(5),
-  fMaximumNumberOfEvents(1000000),
-  fHighestModuleNumber(0),
-  fSelectedAlgorithm(kOptimizedForRealData),
-  fGeometryMode(kALICEGeometry),
-  fNumberOfBadChannels(0),
-  fInit(kFALSE),
-  fVMEMode(kFALSE),
-  fDigitsHistogram(0),
-  fBadChannelsObjArray(0),
-  fBadChannelsIntArray(0),
-  fBadChannelsIndexArray(0),
-  fBadChannelsContainer(0)
+fITSLoader(0x0),
+fRunLoader(0x0),
+fThresholdRatio(5.),
+fThreshold(5),
+fMaximumNumberOfEvents(1000000),
+fNumberOfModules(0),
+fHighestModuleNumber(0),
+fNumberOfColumns(0),
+fNumberOfRows(0),
+fSelectedAlgorithm(kOptimizedForRealData),
+fGeometryMode(kALICEGeometry),
+fNumberOfBadChannels(0),
+  fIndex(0),
+fInit(kFALSE),
+fVMEMode(kFALSE),
+fDigitsHistogram(0),
+fBadChannelsObjArray(0),
+fBadChannelsIntArray(0),
+fBadChannelsIndexArray(0),
+fBadChannelsContainer(0)
 {
   // Default constructor for the SPD preprocessor
   //
@@ -90,7 +92,24 @@ AliITSPreprocessorSPD::AliITSPreprocessorSPD(const char *fileName, const char *m
                                             const char *fileNameg, const Int_t maxNumberOfEvents):
   fITSLoader(0x0),
   fRunLoader(0x0),
-  fInit(kFALSE)
+  fThresholdRatio(0),
+  fThreshold(0),
+  fMaximumNumberOfEvents(1000000),
+  fNumberOfModules(0),
+  fHighestModuleNumber(0),
+  fNumberOfColumns(0),
+  fNumberOfRows(0),
+  fSelectedAlgorithm(kOptimizedForRealData),
+  fGeometryMode(kALICEGeometry),
+  fNumberOfBadChannels(0),
+  fIndex(0),
+  fInit(kFALSE),
+  fVMEMode(kFALSE),
+  fDigitsHistogram(0),
+  fBadChannelsObjArray(0),
+  fBadChannelsIntArray(0),
+  fBadChannelsIndexArray(0),
+  fBadChannelsContainer(0)
 {
   // Standard constructor for the SPD preprocessor
   //
@@ -113,28 +132,33 @@ AliITSPreprocessorSPD::AliITSPreprocessorSPD(const char *fileName, const char *m
 
 //__________________________________________________________________________
 AliITSPreprocessorSPD::AliITSPreprocessorSPD(const AliITSPreprocessorSPD &prep) :
-  TTask(prep)
+TTask(prep),
+  fITSLoader(prep.fITSLoader),
+  fRunLoader(prep.fRunLoader),
+  fThresholdRatio(prep.fThresholdRatio),
+  fThreshold(prep.fThreshold),
+  fMaximumNumberOfEvents(prep.fMaximumNumberOfEvents),
+  fNumberOfModules(prep.fNumberOfModules),
+  fHighestModuleNumber(prep.fHighestModuleNumber),
+  fNumberOfColumns(prep.fNumberOfColumns),
+  fNumberOfRows(prep.fNumberOfRows),
+  fSelectedAlgorithm(prep.fSelectedAlgorithm),
+  fGeometryMode(prep.fGeometryMode),
+  fNumberOfBadChannels(prep.fNumberOfBadChannels),
+  fIndex(prep.fIndex),
+  fInit(prep.fInit),
+  fVMEMode(prep.fVMEMode),
+  fDigitsHistogram(prep.fDigitsHistogram),
+  fBadChannelsObjArray(prep.fBadChannelsObjArray),
+  fBadChannelsIntArray(prep.fBadChannelsIntArray),
+  fBadChannelsIndexArray(prep.fBadChannelsIndexArray),
+  fBadChannelsContainer(prep.fBadChannelsContainer)
 {
   // Default copy constructor
   // Notice that only pointer addresses are copied!
   // Memory allocations of new objects are not done.
 
-  fITSLoader = prep.fITSLoader;
-  fRunLoader = prep.fRunLoader;
-  fThresholdRatio = prep.fThresholdRatio;
-  fThreshold = prep.fThreshold;
-  fMaximumNumberOfEvents = prep.fMaximumNumberOfEvents;
-  fHighestModuleNumber = prep.fHighestModuleNumber;
-  fSelectedAlgorithm = prep.fSelectedAlgorithm;
-  fGeometryMode = prep.fGeometryMode;
-  fNumberOfBadChannels = prep.fNumberOfBadChannels;
-  fInit = prep.fInit;
-  fVMEMode = prep.fVMEMode;
-  fDigitsHistogram = prep.fDigitsHistogram;
-  fBadChannelsObjArray = prep.fBadChannelsObjArray;
-  fBadChannelsIntArray = prep.fBadChannelsIntArray;
-  fBadChannelsIndexArray = prep.fBadChannelsIndexArray;
-  fBadChannelsContainer = prep.fBadChannelsContainer;
+
 }
 
 
@@ -1410,17 +1434,20 @@ Bool_t AliITSPreprocessorSPD::Store(AliCDBId& /*id*/, AliCDBMetaData* /*md*/, In
 
   AliInfo("Storing bad channels");
  
-  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
+  if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
+    AliWarning("No storage set! Will use dummy one");
+    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+  }
 
+  
+  AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
   if(!entrySPD){
     AliWarning("Calibration object retrieval failed! Dummy calibration will be used.");
+    AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage();
+    AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
        
-    AliCDBStorage *localStor = AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
-    entrySPD = localStor->Get("ITS/Calib/CalibSPD", runNumber);
-    if(!entrySPD){
-      AliFatal("Cannot find SPD calibration entry!");
-      return kFALSE;
-    }
+    entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
+    AliCDBManager::Instance()->SetDefaultStorage(origStorage);
   }
 
   TObjArray *respSPD = (TObjArray *)entrySPD->GetObject();
@@ -1445,18 +1472,12 @@ Bool_t AliITSPreprocessorSPD::Store(AliCDBId& /*id*/, AliCDBMetaData* /*md*/, In
     }
   }
     
-
-  AliCDBStorage *storage = AliCDBManager::Instance()->GetDefaultStorage();
-  if(!storage) {
-    AliWarning("No default storage set! Will use dummy one");
-    storage = AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
-    if(!storage) AliFatal("Could not even set dummy storage! Something very strange is happening...");
-  }
-
-  status = storage->Put(entrySPD);
+  
+  AliCDBManager::Instance()->Put(entrySPD);
   entrySPD->SetObject(NULL);
   entrySPD->SetOwner(kTRUE);
 
   delete entrySPD;
+  status=kTRUE;
   return status;
 }
index b05a49c..5f79163 100644 (file)
@@ -9,18 +9,27 @@
 
 ClassImp(AliITSRad)
 //______________________________________________________________________
-AliITSRad::AliITSRad() {
+AliITSRad::AliITSRad():
+imax(0),
+jmax(0),
+fmrad1(0),
+fmrad2(0),
+fmrad3(0),
+fmrad4(0),
+fmrad5(0),
+fmrad6(0) {
     // Default constructor
 
-
-  fmrad1 = 0;
-  fmrad2 = 0;
-  fmrad3 = 0;
-  fmrad4 = 0;
-  fmrad5 = 0;
-  fmrad6 = 0;
 }
-AliITSRad::AliITSRad(Int_t iimax, Int_t jjmax) {
+AliITSRad::AliITSRad(Int_t iimax, Int_t jjmax):
+imax(0),
+jmax(0),
+fmrad1(0),
+fmrad2(0),
+fmrad3(0),
+fmrad4(0),
+fmrad5(0),
+fmrad6(0){
 
   imax=iimax;
   jmax=jjmax;
index 1a6010a..100a471 100644 (file)
@@ -31,6 +31,10 @@ public:
   
 private:
 
+  AliITSRad(const AliITSRad &source); // copy constructor
+  // assignment operator
+  AliITSRad& operator=(const AliITSRad &source);
+
   Int_t           imax;        // first dimension of the matrices
   Int_t           jmax;        // second dimension of the matrices
   
index 31aef41..731ffe3 100644 (file)
@@ -24,8 +24,8 @@
 ////////////////////////////////////////////////////
 ClassImp(AliITSRawCluster)
 //______________________________________________________________________
-  AliITSRawCluster::AliITSRawCluster(){
-// default constructor
-  fMultiplicity = 0;
+  AliITSRawCluster::AliITSRawCluster():
+fMultiplicity(0){
+  // default constructor
 }
 
index 1b07edf..fb45ad2 100644 (file)
@@ -11,23 +11,21 @@ ClassImp(AliITSInStream)
 
 //_____________________________________________________________________________
 
-AliITSInStream::AliITSInStream()
-{
+AliITSInStream::AliITSInStream():
+fStreamLen(0),
+fInStream(0){
   //default constructor
-  fStreamLen=0;
-  fInStream=0;
 }
 //_____________________________________________________________________________
 
-AliITSInStream::AliITSInStream(UInt_t length)
-{
+AliITSInStream::AliITSInStream(UInt_t length):
+fStreamLen(length),
+fInStream(0){
   //
   // Creates a stream of unsigned chars
   //
   
-  fStreamLen = length;
-  fInStream = new UChar_t[length]; 
-  
+  fInStream = new UChar_t[length];   
   ClearStream(); 
   
 }
@@ -40,12 +38,11 @@ AliITSInStream::~AliITSInStream()
 }
 
 //__________________________________________________________________________
-AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source){
+AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source),
+fStreamLen(source.fStreamLen),
+fInStream(source.fInStream){
   //     Copy Constructor 
-  if(&source == this) return;
-  this->fStreamLen = source.fStreamLen;
-  this->fInStream = source.fInStream;
-  return;
+
 }
 
 //_________________________________________________________________________
@@ -81,20 +78,22 @@ ClassImp(AliITSOutStream)
   
   //_______________________________________________________________________
   
-  AliITSOutStream::AliITSOutStream() {
+AliITSOutStream::AliITSOutStream():
+fStreamLen(0),
+fOutStream(0){
   //default constructor
-  fStreamLen=0;
-  fOutStream=0;
+
 }
 
 //__________________________________________________________________________
 
-AliITSOutStream::AliITSOutStream(UInt_t length) {
+AliITSOutStream::AliITSOutStream(UInt_t length):
+fStreamLen(length),
+fOutStream(0){
   //
   // Creates a stream of unsigned chars
   //
   
-  fStreamLen = length;
   fOutStream = new UInt_t[length];  
   ClearStream(); 
   
@@ -108,12 +107,11 @@ AliITSOutStream::~AliITSOutStream()
 }
 
 //__________________________________________________________________________
-AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source){
+AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source),
+fStreamLen(source.fStreamLen),
+fOutStream(source.fOutStream){
   //     Copy Constructor 
-  if(&source == this) return;
-  this->fStreamLen = source.fStreamLen;
-  this->fOutStream = source.fOutStream;
-  return;
+
 }
 
 //_________________________________________________________________________
index eb1b437..55aceec 100644 (file)
 ClassImp(AliITSRawStream)
 
 
-AliITSRawStream::AliITSRawStream(AliRawReader* rawReader)
+AliITSRawStream::AliITSRawStream(AliRawReader* rawReader):
+fRawReader(rawReader),
+fModuleID(-1),
+fPrevModuleID(-1),
+fCoord1(-1),
+fCoord2(-1),
+fSignal(-1)
 {
 // create an object to read ITS raw digits
 
-  fRawReader = rawReader;
-  fModuleID = fPrevModuleID = fCoord1 = fCoord2 = fSignal = -1;
 }
 
 AliITSRawStream::AliITSRawStream(const AliITSRawStream& stream) :
-  TObject(stream)
+  TObject(stream),
+fRawReader(stream.fRawReader),
+fModuleID(stream.fModuleID),
+fPrevModuleID(stream.fPrevModuleID),
+fCoord1(stream.fCoord1),
+fCoord2(stream.fCoord2),
+fSignal(stream.fSignal)
 {
-  Fatal("AliITSRawStream", "copy constructor not implemented");
+  //copy constructor
 }
 
 AliITSRawStream& AliITSRawStream::operator = (const AliITSRawStream& 
index 3c893d0..7babff8 100644 (file)
@@ -43,16 +43,15 @@ const Int_t AliITSRawStreamSDD::fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
 const UInt_t AliITSRawStreamSDD::fgkCodeLength[8] =  {8, 18, 2, 3, 4, 5, 6, 7};
 
 AliITSRawStreamSDD::AliITSRawStreamSDD(AliRawReader* rawReader) :
-  AliITSRawStream(rawReader)
-{
+  AliITSRawStream(rawReader),
+fData(0),
+fSkip(0),
+fEventId(0),
+fCarlosId(0),
+fChannel(0),
+fJitter(0){
 // create an object to read ITS SDD raw digits
   
-  fData = 0;
-  fSkip = 0;
-  fEventId = 0;
-  fCarlosId = 0;
-  fChannel = 0;
-  fJitter  = 0;
   for(Int_t i=0;i<2;i++){
     fChannelData[i]=0;
     fLastBit[i]=0;
index 132b4c8..317be9d 100644 (file)
@@ -208,7 +208,8 @@ const Int_t AliITSRawStreamSSD::fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
 
 
 AliITSRawStreamSSD::AliITSRawStreamSSD(AliRawReader* rawReader) :
-  AliITSRawStream(rawReader)
+  AliITSRawStream(rawReader),
+fData(0)
 {
 // create an object to read ITS SSD raw digits
 
index 39bb2ca..9b73bf2 100644 (file)
@@ -28,12 +28,11 @@ ClassImp(AliITSRawStreamSSDv1)
 
 
 AliITSRawStreamSSDv1::AliITSRawStreamSSDv1(AliRawReader* rawReader) :
-  AliITSRawStreamSSD(rawReader)
-{
+  AliITSRawStreamSSD(rawReader),
+fADModule(0),
+fADC(0){
 // create an object to read ITS SSD raw digits
 
-  fADC =0;
-  fADModule=0;
   fRawReader->SelectEquipment(17,102,102);
 }
 
index 462353f..792ef04 100644 (file)
 ClassImp(AliITSRecPoint)
 
 //_____________________________________________________________
-AliITSRecPoint::AliITSRecPoint(): AliCluster() {
+AliITSRecPoint::AliITSRecPoint(): AliCluster(),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(0){
     // default creator
-    fXloc=fZloc=fdEdX=0.;
-    fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;fChargeRatio=0;
-    fGeom=0;
 }
 
 //_____________________________________________________________
-AliITSRecPoint::AliITSRecPoint(AliITSgeom* geom): AliCluster() {
+AliITSRecPoint::AliITSRecPoint(AliITSgeom* geom): AliCluster(),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(geom) {
     // default creator
-    fXloc=fZloc=fdEdX=0.;
-    fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;fChargeRatio=0;
-    fGeom=geom;
+
 }
 
 //________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit){
+AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(geom)
+{
   //standard constructor used in AliITSClusterFinderV2
-  fIndex=lab[3];
-  fQ=hit[4];
-  fNy    = info[0];
-  fNz    = info[1];
-  fLayer = info[2];
-  fChargeRatio = 0;
+
+
   fType=0;
   fDeltaProb=0.;
   
@@ -74,44 +102,48 @@ AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t
   
 }
 //_______________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(const AliITSRecPoint& pt):AliCluster(pt){
+AliITSRecPoint::AliITSRecPoint(const AliITSRecPoint& pt):AliCluster(pt),
+fXloc(pt.fXloc),
+fZloc(pt.fZloc),
+fdEdX(pt.fdEdX),
+fIndex(pt.fIndex),
+fQ(pt.fQ),
+fLayer(pt.fLayer),
+fNz(pt.fNz),
+fNy(pt.fNy),
+fChargeRatio(pt.fChargeRatio),
+fType(pt.fType),
+fDeltaProb(pt.fDeltaProb),
+fGeom(pt.fGeom){
   //Copy constructor
-  fXloc = pt.fXloc;
-  fZloc = pt.fZloc;
-  fdEdX = pt.fdEdX;
-  fIndex= pt.fIndex;
-  fQ = pt.fQ;
-  fNy = pt.fNy;
-  fNz = pt.fNz;
-  fLayer = pt.fLayer;
-  fChargeRatio = pt.fChargeRatio;
-  fType = pt.fType;
-  fDeltaProb = pt.fDeltaProb;
-  fGeom = pt.fGeom;
 
 }
 
 //______________________________________________________________________
-AliITSRecPoint& AliITSRecPoint::operator=(const AliITSRecPoint& /* source */){
+AliITSRecPoint& AliITSRecPoint::operator=(const AliITSRecPoint& source){
   // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Fatal("= operator","Assignment operator not allowed\n");
+
+  this->~AliITSRecPoint();
+  new(this) AliITSRecPoint(source);
   return *this;
+
 }
 
 //________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit){
+AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(0){
   //standard constructor used in AliITSClusterFinderV2
-  fXloc=fZloc=fdEdX=0.;
-  fIndex=lab[3];
-  fQ=hit[4];
-  fNy    = info[0];
-  fNz    = info[1];
-  fLayer = info[2];
-  fChargeRatio = 0;
-  fType=0;
-  fDeltaProb=0.;  
-  fGeom = 0;
 }
 
 //----------------------------------------------------------------------
index 59d92ea..07d7f13 100644 (file)
@@ -29,26 +29,26 @@ ClassImp(AliITSTransientDigit)
 
 //______________________________________________________________________
 AliITSTransientDigit::AliITSTransientDigit(Float_t phys,const Int_t *digits): 
-    AliITSdigitSDD(phys,digits) {
+    AliITSdigitSDD(phys,digits),
+fTrackList(0) {
     // Creates a digit object in a list of digits to be updated
 
     fTrackList   = new TObjArray;  
 }
 //__________________________________________________________________________
 AliITSTransientDigit::AliITSTransientDigit(const AliITSTransientDigit &source):
- AliITSdigitSDD(source){
+ AliITSdigitSDD(source),
+fTrackList(source.fTrackList){
     // Copy Constructor 
-    if(&source == this) return;
-    this->fTrackList = source.fTrackList;
-    return;
 }
 //_________________________________________________________________________
 AliITSTransientDigit& AliITSTransientDigit::operator=(
     const AliITSTransientDigit &source) {
     // Assignment operator
-    if(&source == this) return *this;
-    this->fTrackList = source.fTrackList;
-    return *this;
+  this->~AliITSTransientDigit();
+  new(this) AliITSTransientDigit(source);
+  return *this;
+
 }
 //______________________________________________________________________
 void AliITSTransientDigit::Print(ostream *os){
index bbc1750..5af060d 100644 (file)
@@ -9,7 +9,7 @@
 class AliITSTransientDigit : public AliITSdigitSDD {
 
  public:
-    AliITSTransientDigit() {/*default constructor*/fTrackList=0;}
+    AliITSTransientDigit() : fTrackList(0) {}
     // Standard constructor with digits and "phys"
     AliITSTransientDigit(Float_t phys,const Int_t *digits);
     virtual ~AliITSTransientDigit(){/*destructor delets TObjArray fTracklist */
index 1108337..e5acb51 100644 (file)
 ClassImp(AliITSclusterSSD)
 
 //______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(){
+AliITSclusterSSD::AliITSclusterSSD():
+fSide(kTRUE),
+fDigits(0),
+fNDigits(0),
+fDigitsIndex(0),
+fNCrosses(0),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(kFALSE),
+fRightNeighbour(kFALSE),
+fConsumed(kFALSE),
+fTotalSignal(-1),
+fNTracks(-1){
     // default constructor
-
-    fSide        = kTRUE;
-    fDigits      = 0;
-    fNDigits     = 0;
-    fDigitsIndex = 0;
-    fNCrosses    = 0;
-    fTotalSignal = -1;
-    fNTracks      = -1;
-    fLeftNeighbour  = kFALSE;
-    fRightNeighbour = kFALSE;
-    fCrossedClusterIndexes = 0;
-    fConsumed=kFALSE;
 }
 //______________________________________________________________________
 AliITSclusterSSD::AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes, 
-                                  TObjArray *Digits, Bool_t side){
+                                  TObjArray *Digits, Bool_t side):
+fSide(side),
+fDigits(Digits),
+fNDigits(ndigits),
+fDigitsIndex(0),
+fNCrosses(0),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(kFALSE),
+fRightNeighbour(kFALSE),
+fConsumed(kFALSE),
+fTotalSignal(-1),
+fNTracks(-1){
     // non-default constructor
 
-    fNDigits = ndigits;
-    fDigits = Digits;
-    fSide = side;
     fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );        
-    fNCrosses    = 0;
     fCrossedClusterIndexes = new TArrayI(300);
-    fLeftNeighbour  = kFALSE;
-    fRightNeighbour = kFALSE;
-    fTotalSignal =-1;
-    fNTracks    = -1;
-    fConsumed=kFALSE;
 }
 //______________________________________________________________________
 AliITSclusterSSD::~AliITSclusterSSD(){
@@ -73,20 +74,23 @@ AliITSclusterSSD::~AliITSclusterSSD(){
 }
 //______________________________________________________________________
 AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) : 
-    TObject(OneSCluster){
+TObject(OneSCluster),
+fSide(OneSCluster.fSide),
+fDigits(OneSCluster.fDigits),
+fNDigits(OneSCluster.fNDigits),
+fDigitsIndex(0),
+fNCrosses(OneSCluster.fNCrosses),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(OneSCluster.fLeftNeighbour),
+fRightNeighbour(OneSCluster.fRightNeighbour),
+fConsumed(OneSCluster.fConsumed),
+fTotalSignal(-1),
+fNTracks(-1){
     // copy constructor
 
-    if (this == &OneSCluster) return;
-    fNDigits = OneSCluster.fNDigits;
-    fSide=OneSCluster.fSide;
-    fDigits=OneSCluster.fDigits;
     fDigitsIndex = new TArrayI(fNDigits);
-    fLeftNeighbour  = OneSCluster.fLeftNeighbour;
-    fRightNeighbour = OneSCluster.fRightNeighbour;
     fTotalSignal =-1;
     fNTracks     = -1;
-    fNCrosses = OneSCluster.fNCrosses;
-    fConsumed = OneSCluster.fConsumed;
     Int_t i;
     for (i = 0; i< fNCrosses ; i++){
        fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
index 1d1b43a..e52d42a 100644 (file)
 #include "AliITSclusterV2.h"
 
 ClassImp(AliITSclusterV2)
+//_______________________________________________________
+AliITSclusterV2::AliITSclusterV2() : AliCluster(),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0) {
+  //default constructor
+}
+
+//_______________________________________________________
+AliITSclusterV2::AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0){
+  //standard constructor
+}
index 6023f72..bfd5672 100644 (file)
 //_____________________________________________________________________________
 class AliITSclusterV2 : public AliCluster {
 public:
-  AliITSclusterV2() : AliCluster() {
-    fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;
-  }
-  AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit) {
-    fIndex=lab[3];
-    fQ=hit[4];
-    fNy    = info[0];
-    fNz    = info[1];
-    fLayer = info[2];
-    fChargeRatio = 0;
-    fType=0;
-    fDeltaProb=0.;
-  }
-
+  AliITSclusterV2(); 
+  AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info); 
   void Use(Int_t = 0) {fQ=-fQ;}
   void UnUse() {fQ=TMath::Abs(fQ);}
   void SetQ(Float_t q) {fQ=q;}
index 2cafb66..c572f22 100644 (file)
@@ -29,15 +29,63 @@ ClassImp(AliITSclustererV2)
 
 extern AliRun *gAlice;
 
-AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
+AliITSclustererV2::AliITSclustererV2():
+fNModules(0),
+fEvent(0),
+fI(0),
+fLastSPD1(0),
+fNySPD(0),
+fNzSPD(0),
+fYpitchSPD(0),
+fZ1pitchSPD(0),
+fZ2pitchSPD(0),
+fHwSPD(0),
+fHlSPD(0),
+fNySDD(0),
+fNzSDD(0),
+fYpitchSDD(0),
+fZpitchSDD(0),
+fHwSDD(0),
+fHlSDD(0),
+fYoffSDD(0),
+fLastSSD1(0),
+fYpitchSSD(0),
+fHwSSD(0),
+fHlSSD(0),
+fTanP(0),
+fTanN(0){
+   //default constructor
+ }
+AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom):
+fNModules(0),
+fEvent(0),
+fI(0),
+fLastSPD1(0),
+fNySPD(256),
+fNzSPD(160),
+fYpitchSPD(0.0050),
+fZ1pitchSPD(0.0425),
+fZ2pitchSPD(0.0625),
+fHwSPD(0.64),
+fHlSPD(3.48),
+fNySDD(256),
+fNzSDD(256),
+fYpitchSDD(0.01825),
+fZpitchSDD(0.02940),
+fHwSDD(3.5085),
+fHlSDD(3.7632),
+fYoffSDD(0.0425),
+fLastSSD1(0),
+fYpitchSSD(0.0095),
+fHwSSD(3.65),
+fHlSSD(2.00),
+fTanP(0.0275),
+fTanN(0.0075) {
   //------------------------------------------------------------
   // Standard constructor
   //------------------------------------------------------------
   AliITSgeom *g=(AliITSgeom*)geom;
 
-  fEvent=0;
-  fI=0;
-
   Int_t mmax=geom->GetIndexMax();
   if (mmax>2200) {
      Fatal("AliITSclustererV2","Too many ITS subdetectors !"); 
@@ -58,10 +106,6 @@ AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
 
   //SPD geometry  
   fLastSPD1=g->GetModuleIndex(2,1,1)-1;
-  fNySPD=256; fNzSPD=160;
-  fYpitchSPD=0.0050;
-  fZ1pitchSPD=0.0425; fZ2pitchSPD=0.0625;
-  fHwSPD=0.64; fHlSPD=3.48;
   fYSPD[0]=0.5*fYpitchSPD;
   for (m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD; 
   fZSPD[0]=fZ1pitchSPD;
@@ -78,20 +122,8 @@ AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
     fZSPD[m]-=dz;
   }
 
-  //SDD geometry 
-  fNySDD=256; fNzSDD=256;
-  fYpitchSDD=0.01825;
-  fZpitchSDD=0.02940;
-  fHwSDD=3.5085; fHlSDD=3.7632;
-  fYoffSDD=0.0425;
-
   //SSD geometry
   fLastSSD1=g->GetModuleIndex(6,1,1)-1;
-  fYpitchSSD=0.0095;
-  fHwSSD=3.65;
-  fHlSSD=2.00;
-  fTanP=0.0275;
-  fTanN=0.0075;
 
 }
 
index 01d2978..028403f 100644 (file)
@@ -22,7 +22,7 @@ class AliITSRawStream;
 
 class AliITSclustererV2 : public TObject {
 public:
-  AliITSclustererV2(){ fEvent=0; fI=0;}
+  AliITSclustererV2();
   AliITSclustererV2(const AliITSgeom *geom);
 
   void SetEvent(Int_t event) { fEvent=event; }
@@ -56,7 +56,7 @@ private:
   };
   class AliBin {
   public:
-    AliBin() {fIndex=0; fQ=0; fMask=0xFFFFFFFE;}
+    AliBin():fIndex(0),fMask(0xFFFFFFFE),fQ(0) {}
     void SetIndex(UInt_t idx) {fIndex=idx;}
     void SetQ(UShort_t q)  {fQ=q;}
     void SetMask(UInt_t m) {fMask=m;}
index 1ef5b3d..ce81fe6 100644 (file)
 
 #include "AliITSdigit.h"
 
+
 //______________________________________________________________________
 ClassImp(AliITSdigit)
-AliITSdigit::AliITSdigit(const Int_t *digits) {
+
+AliITSdigit::AliITSdigit():
+fCoord1(0),
+fCoord2(0),
+fSignal(0){
+  //default constructor. zero all values.
+}
+
+
+AliITSdigit::AliITSdigit(const Int_t *digits):
+fCoord1(digits[0]),
+fCoord2(digits[1]),
+fSignal(digits[2]){
   // Creates a real data digit object
 
-  fCoord1       = digits[0];
-  fCoord2       = digits[1];
-  fSignal       = digits[2];
 }
 //______________________________________________________________________
 void AliITSdigit::Print(ostream *os) {
index b76d027..953711d 100644 (file)
@@ -16,12 +16,12 @@ class TObjArray;
 class TArrayI;
 class TArrayF;
 
+
 //______________________________________________________________________
 class AliITSdigit: public TObject  {
 
  public:
-    AliITSdigit() {//default constructor. zero all values.
-       fSignal=fCoord1=fCoord2=0;}
+    AliITSdigit();
     //Standard Constructor. Fills class from array digits
     AliITSdigit(const Int_t *digits);
     //Destructor
index 79ab1fd..72112b4 100644 (file)
@@ -31,7 +31,9 @@ ClassImp(AliITSdigitSDD)
 
 
 //______________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(){
+AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(),
+fPhysics(0),
+fSignalExpanded(0){
     // default constructor, zero coordinates and set array
     // elements to clearly unphysical values. A value of 0 may
     // be a valide track of hit number.
@@ -39,16 +41,16 @@ AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(){
 
     for(i=0;i<fgkSsdd;i++) fTracks[i] = -3;
     for(i=0;i<fgkSsdd;i++) fHits[i]   = -1;
-    fPhysics = 0;
     for(i=0;i<fgkSsdd;i++) fTcharges[i] = 0;
     SetSignalExpanded(-1000);
 }
 //________________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits): AliITSdigit(digits){
+AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits): AliITSdigit(digits),
+fPhysics(phys),
+fSignalExpanded(0){
  
    // Creates a simulated SDD digit object to be updated
 
-    fPhysics = phys;
     SetSignalExpanded(-1000);
 }
 
@@ -68,7 +70,9 @@ void AliITSdigitSDD::InitObject(Float_t phys,const Int_t *tracks,
 //_____________________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits,
                               const Int_t *tracks,const Int_t *hits,
-                              const Float_t *charges):AliITSdigit(digits){
+                              const Float_t *charges):AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
 
 // standard constructor
   InitObject(phys,tracks,hits,charges);
@@ -76,7 +80,9 @@ AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits,
 }
 //_____________________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
-    const Int_t *tracks,const Int_t *hits,const Float_t *charges, Int_t sige): AliITSdigit(digits) {
+    const Int_t *tracks,const Int_t *hits,const Float_t *charges, Int_t sige): AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
 
   //constructor setting also fSignalExpanded
   InitObject(phys,tracks,hits,charges);
@@ -86,7 +92,9 @@ AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
 //_____________________________________________________________________________
 AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
     const Int_t *tracks,const Int_t *hits,const Float_t *charges,
-    AliITSCalibrationSDD* resp): AliITSdigit(digits) {
+    AliITSCalibrationSDD* resp): AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
 
   //constructor setting fSignalExpanded through AliITSCalibrationSDD
   InitObject(phys,tracks,hits,charges);
index 98bf4ba..2db9fca 100644 (file)
@@ -27,7 +27,8 @@
 ClassImp(AliITSdigitSPD)
 
 //______________________________________________________________________
-AliITSdigitSPD::AliITSdigitSPD():AliITSdigit(){
+AliITSdigitSPD::AliITSdigitSPD():AliITSdigit(),
+fSignalSPD(0){
     // default constructor, zero coordinates and set array
     // elements to clearly unphysical values. A value of 0 may
     // be a valide track of hit number.
@@ -37,7 +38,8 @@ AliITSdigitSPD::AliITSdigitSPD():AliITSdigit(){
     for(i=0;i<fgkSspd;i++) fHits[i]    = -1;
 }
 //______________________________________________________________________
-AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits){
+AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits):
+fSignalSPD(digits[2]){
     // Creates a SPD digit object
     Int_t i;
 
@@ -46,11 +48,11 @@ AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits){
     fCoord1       = digits[0];
     fCoord2       = digits[1];
     fSignal       = 1;
-    fSignalSPD    = digits[2];
-}
+ }
 //______________________________________________________________________
 AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,
-                              const Int_t *hits){
+                              const Int_t *hits):
+fSignalSPD(digits[2]){
     // Creates a simulated SPD digit object
 
     for(Int_t i=0; i<fgkSspd; i++) {
@@ -60,7 +62,6 @@ AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,
     fCoord1       = digits[0];
     fCoord2       = digits[1];
     fSignal       = 1;
-    fSignalSPD    = digits[2];
 }
 //______________________________________________________________________
 Int_t AliITSdigitSPD::GetListOfTracks(TArrayI &t){
index 58d8100..1c659bc 100644 (file)
@@ -165,6 +165,7 @@ fShape(0,0)      // Array of shapes and detector information.
     fShape.SetOwner(kTRUE);
     return;
 }
+
 //______________________________________________________________________
 AliITSgeom::AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,
                        const Int_t *ndets,Int_t mods):
@@ -630,7 +631,16 @@ fShape(0,0)      // TObjArray of detector geom.
 }
 
 //______________________________________________________________________
-AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source){
+AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source),
+fVersion(source.fVersion),
+fTrans(source.fTrans),
+fNmodules(source.fNmodules),
+fNlayers(source.fNlayers),
+fNlad(source.fNlad),
+fNdet(source.fNdet),
+fGm(source.fGm),
+fShape(source.fShape)
+{
     //     The copy constructor for the AliITSgeom class. It calls the
     // = operator function. See the = operator function for more details.
     // Inputs:
@@ -641,8 +651,8 @@ AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source){
     // Return:
     //     none.
 
-    *this = source;  // Just use the = operator for now.
-    return;
+  *this = source;  // Just use the = operator for now.
+  return;
 }
 
 //______________________________________________________________________
index d3c315d..d86ec36 100644 (file)
@@ -38,6 +38,8 @@ class AliITSgeom : public TObject {
     AliITSgeom(const char *filename);  // Constructor
     AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,const Int_t *ndets,
                Int_t nmods); // Constructor
+    AliITSgeom(const AliITSgeom &source);    // Copy constructor
+    AliITSgeom& operator=(const AliITSgeom &source);// = operator
     virtual ~AliITSgeom();             // Default destructor
     // Zero and reinitilizes this class.
     void Init(Int_t itype,Int_t nlayers,const Int_t *nlads,
@@ -761,9 +763,6 @@ class AliITSgeom : public TObject {
 
     void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,Float_t &xout,Float_t &zout);
 
- protected:
-    AliITSgeom(const AliITSgeom &source);    // Copy constructor
-    AliITSgeom& operator=(const AliITSgeom &source);// = operator
 
  private:
     TString    fVersion; // Transformation version.
index 0f0813e..e6be244 100644 (file)
@@ -83,10 +83,14 @@ fPath(){     // Path in geometry to this module
     }// end for i
     fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
 }
-/*
+
 //----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) : 
-    TObject(sourse){
+AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) : 
+    TObject(source),
+fDetectorIndex(source.fDetectorIndex),
+fCylR(source.fCylR),
+fCylPhi(source.fCylPhi),
+fPath(source.fPath){
     // The standard Copy constructor. This make a full / proper copy of
     // this class.
     // Inputs:
@@ -96,20 +100,15 @@ AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) :
     // Return:
     //    A copy constructes AliITSgeomMatrix class.
        Int_t i,j;
-
-       this->fDetectorIndex = sourse.fDetectorIndex;
        for(i=0;i<3;i++){
-               this->fid[i]     = sourse.fid[i];
-               this->frot[i]    = sourse.frot[i];
-               this->ftran[i]   = sourse.ftran[i];
-               this->fCylR      = sourse.fCylR;
-               this->fCylPhi    = sourse.fCylPhi;
-               for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
+               this->fid[i]     = source.fid[i];
+               this->frot[i]    = source.frot[i];
+               this->ftran[i]   = source.ftran[i];
+               for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
        }// end for i
-     this->fPath   = sourse.fPath;
 }
 //----------------------------------------------------------------------
-void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
+AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
     // The standard = operator. This make a full / proper copy of
     // this class.
     // The standard Copy constructor. This make a full / proper copy of
@@ -120,20 +119,23 @@ void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
     //    none.
     // Return:
     //    A copy of the source AliITSgeomMatrix class.
-       Int_t i,j;
+  if(this == &source)return *this;
+  Int_t i,j;
 
-       this->fDetectorIndex = sourse.fDetectorIndex;
-       for(i=0;i<3;i++){
-               this->fid[i]     = sourse.fid[i];
-               this->frot[i]    = sourse.frot[i];
-               this->ftran[i]   = sourse.ftran[i];
-               this->fCylR      = sourse.fCylR;
-               this->fCylPhi    = sourse.fCylPhi;
-               for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
-       }// end for i
-     this->fPath   = sourse.fPath;
+  this->fDetectorIndex = source.fDetectorIndex;
+  this->fCylR      = source.fCylR;
+  this->fCylPhi    = source.fCylPhi;
+  for(i=0;i<3;i++){
+    this->fid[i]     = source.fid[i];
+    this->frot[i]    = source.frot[i];
+    this->ftran[i]   = source.ftran[i];
+
+    for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+  }
+  this->fPath   = source.fPath;
+  return *this;
 }
-*/
+
 //----------------------------------------------------------------------
 AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
                         const Double_t rot[3],const Double_t tran[3]):
index 245b520..29ee980 100644 (file)
@@ -29,6 +29,10 @@ class AliITSgeomMatrix : public TObject {
         AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
                          Int_t idt,const Int_t id[3],
                          const Double_t tran[3]);
+       // Copy constructor
+       AliITSgeomMatrix(const AliITSgeomMatrix &source);
+       // Assignment operator
+       AliITSgeomMatrix& operator=(const AliITSgeomMatrix &source); 
        virtual ~AliITSgeomMatrix(){}; // default constructor.
        // Prints a line describing the output format of the function Print.
        void PrintComment(ostream *os) const;
@@ -148,10 +152,6 @@ class AliITSgeomMatrix : public TObject {
      void MakeFigures() const;
      //
  private: // private functions
-       // Copy constructor
-       AliITSgeomMatrix(const AliITSgeomMatrix &source);
-       // Assignment operator
-       void operator=(const AliITSgeomMatrix &sourse); // copy
        // Given the rotation matrix fm it fills the rotation angles frot
        void MatrixFromAngle();
        // Given the rotation angles frot it fills the rotation matrix fm
index 2ede369..eac5ba5 100644 (file)
@@ -139,57 +139,36 @@ AliITSgeomSDD::~AliITSgeomSDD(){
     fAnodeLowEdgeR = 0;
 }
 //________________________________________________________________________
-AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source){
-    // Copy constructor
-    Int_t i;
-
-    if(this==&source) return;
-    fName=source.fName;
-    fTitle=source.fTitle;
-    fMat=source.fMat;
-    fDx=source.fDx;
-    fDy=source.fDy;
-    fDz=source.fDz;
-    this->fPeriod    = source.fPeriod;
-    this->fDvelocity = source.fDvelocity;
-    this->fNAnodesL  = source.fNAnodesL;
-    this->fNAnodesR  = source.fNAnodesR;
-    this->fAnodeXL  = source.fAnodeXL;
-    this->fAnodeXR  = source.fAnodeXR;
-    if(fAnodeLowEdgeL!=0) delete fAnodeLowEdgeL;
-    this->fAnodeLowEdgeL = new Float_t[fNAnodesL];
-    if(fAnodeLowEdgeR!=0) delete fAnodeLowEdgeR;
-    this->fAnodeLowEdgeR = new Float_t[fNAnodesR];
-    for(i=0;i<fNAnodesL;i++)this->fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
-    for(i=0;i<fNAnodesR;i++)this->fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
-    return;
+AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source),
+fPeriod(source.fPeriod),
+fDvelocity(source.fDvelocity),
+fNAnodesL(source.fNAnodesL),
+fNAnodesR(source.fNAnodesR),
+fAnodeXL(source.fAnodeXL),
+fAnodeXR(source.fAnodeXR),
+fAnodeLowEdgeL(0),
+fAnodeLowEdgeR(0),
+fName(source.fName),
+fTitle(source.fTitle),
+fMat(source.fMat),
+fDx(source.fDx),
+fDy(source.fDy),
+fDz(source.fDz){
+    // Copy constructor  
+  fAnodeLowEdgeL = new Float_t[fNAnodesL];
+  fAnodeLowEdgeR = new Float_t[fNAnodesR];
+  for(Int_t i=0;i<fNAnodesL;i++) fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
+  for(Int_t i=0;i<fNAnodesR;i++) fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
 }
 //________________________________________________________________________
 AliITSgeomSDD& AliITSgeomSDD::operator=(AliITSgeomSDD &source){
     // = operator
-    Int_t i;
 
-    if(this==&source) return *this;
-    fName=source.fName;
-    fTitle=source.fTitle;
-    fMat=source.fMat;
-    fDx=source.fDx;
-    fDy=source.fDy;
-    fDz=source.fDz;
-    this->fPeriod    = source.fPeriod;
-    this->fDvelocity = source.fDvelocity;
-    this->fNAnodesL  = source.fNAnodesL;
-    this->fNAnodesR  = source.fNAnodesR;
-    this->fNAnodesR  = source.fNAnodesR;
-    this->fAnodeXL  = source.fAnodeXL;
-    this->fAnodeXR  = source.fAnodeXR;
-    if(fAnodeLowEdgeL!=0) delete fAnodeLowEdgeL;
-    this->fAnodeLowEdgeL = new Float_t[fNAnodesL];
-    if(fAnodeLowEdgeR!=0) delete fAnodeLowEdgeR;
-    this->fAnodeLowEdgeR = new Float_t[fNAnodesR];
-    for(i=0;i<fNAnodesL;i++)this->fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
-    for(i=0;i<fNAnodesR;i++)this->fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
-    return *this;
+  this->~AliITSgeomSDD();
+  new(this) AliITSgeomSDD(source);
+  return *this;
+
 }
 //______________________________________________________________________
 void AliITSgeomSDD::Local2Det(Float_t xl,Float_t zl,Int_t &a,Int_t &t,Int_t &s){
index df45da3..f33042a 100644 (file)
@@ -94,33 +94,31 @@ void AliITSgeomSPD::ReSetBins(Float_t dy,Int_t nx,Float_t *bx,
     return;
 }
 //______________________________________________________________________
-AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source){
+AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source),
+fName(source.fName),
+fTitle(source.fTitle),
+fMat(source.fMat),
+fDx(source.fDx),
+fDy(source.fDy),
+fDz(source.fDz),
+fNbinx(source.fNbinx),
+fNbinz(source.fNbinz),
+fLowBinEdgeX(0),
+fLowBinEdgeZ(0){
     // Copy constructor
+  InitLowBinEdgeX();
+  InitLowBinEdgeZ();
+  for(Int_t i=0;i<fNbinx;i++) fLowBinEdgeX[i] = source.fLowBinEdgeX[i];
+  for(Int_t i=0;i<fNbinz;i++) fLowBinEdgeZ[i] = source.fLowBinEdgeZ[i];
 
-    *this = source; // just use the = operator for now.
-    return;
+  
 }
 //______________________________________________________________________
 AliITSgeomSPD& AliITSgeomSPD::operator=(AliITSgeomSPD &source){
     // = operator
-    Int_t i;
-
-    if(&source == this) return *this;
-    fName=source.fName;
-    fTitle=source.fTitle;
-    fMat=source.fMat;
-    fDx=source.fDx;
-    fDy=source.fDy;
-    fDz=source.fDz;
-    if(this->fLowBinEdgeX) delete[] (this->fLowBinEdgeX);
-    if(this->fLowBinEdgeZ) delete[] (this->fLowBinEdgeZ);
-    this->fNbinx = source.fNbinx;
-    this->fNbinz = source.fNbinz;
-    this->InitLowBinEdgeX();
-    this->InitLowBinEdgeZ();
-    for(i=0;i<fNbinx;i++) this->fLowBinEdgeX[i] = source.fLowBinEdgeX[i];
-    for(i=0;i<fNbinz;i++) this->fLowBinEdgeZ[i] = source.fLowBinEdgeZ[i];
-    return *this;
+  this->~AliITSgeomSPD();
+  new(this) AliITSgeomSPD(source);
+  return *this;
 }
 //______________________________________________________________________
 AliITSgeomSPD::~AliITSgeomSPD(){
index 4f46d4b..8ef056c 100644 (file)
@@ -122,25 +122,13 @@ AliITSgeomSSD::~AliITSgeomSSD(){
     fAngleN = 0.0;
 }
 //______________________________________________________________________
-AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
+AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source),
+fName(source.fName),fTitle(source.fTitle),fMat(source.fMat),fDx(source.fDx),fDy(source.fDy),fDz(source.fDz),fNp(source.fNp),fNn(source.fNn),fLowEdgeP(0),fLowEdgeN(0),fAngleP(source.fAngleP),fAngleN(source.fAngleN){
 ////////////////////////////////////////////////////////////////////////
 //    copy  constructor
 ////////////////////////////////////////////////////////////////////////
     Int_t i;
 
-    if(this == &source) return;
-    fName = source.fName;
-    fTitle = source.fTitle;
-    fMat = source.fMat;
-    fDx = source.fDx;
-    fDy = source.fDy;
-    fDz = source.fDz;
-    this->fNp = source.fNp;
-    this->fNn = source.fNn;
-    delete fLowEdgeP;
-    delete fLowEdgeN;
-    this->fAngleP = source.fAngleP;
-    this->fAngleN = source.fAngleN;
     fLowEdgeP = new Float_t[fNp];
     fLowEdgeN = new Float_t[fNn];
     for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
@@ -152,26 +140,11 @@ AliITSgeomSSD& AliITSgeomSSD::operator=(const AliITSgeomSSD &source) {
 ////////////////////////////////////////////////////////////////////////
 //    assignment operator
 ////////////////////////////////////////////////////////////////////////
-    Int_t i;
 
-    if(this == &source) return *this;
-    fName = source.fName;
-    fTitle = source.fTitle;
-    fMat = source.fMat;
-    fDx = source.fDx;
-    fDy = source.fDy;
-    fDz = source.fDz;
-    this->fNp = source.fNp;
-    this->fNn = source.fNn;
-    delete fLowEdgeP;
-    delete fLowEdgeN;
-    this->fAngleP = source.fAngleP;
-    this->fAngleN = source.fAngleN;
-    fLowEdgeP = new Float_t[fNp];
-    fLowEdgeN = new Float_t[fNn];
-    for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
-    for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
-    return *this;
+  this->~AliITSgeomSSD();
+  new(this) AliITSgeomSSD(source);
+  return *this;
+
 }
 //______________________________________________________________________
 void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
index 7c6e821..837552a 100644 (file)
 
 ClassImp(AliITSpList)
 //______________________________________________________________________
-AliITSpList::AliITSpList(){
+AliITSpList::AliITSpList():
+fNi(0),
+fNj(0),
+fa(0),
+fEntries(0){
     // Default constructor
     // Inputs:
     //    none.
@@ -41,12 +45,13 @@ AliITSpList::AliITSpList(){
     // Return:
     //    A zeroed/empty AliITSpList class.
 
-    fNi = 0;
-    fNj = 0;
-    fa  = 0;
 }
 //______________________________________________________________________
-AliITSpList::AliITSpList(Int_t imax,Int_t jmax){
+AliITSpList::AliITSpList(Int_t imax,Int_t jmax):
+fNi(imax),
+fNj(jmax),
+fa(0),
+fEntries(0){
     // Standard constructor
     // Inputs:
     //    none.
@@ -55,9 +60,6 @@ AliITSpList::AliITSpList(Int_t imax,Int_t jmax){
     // Return:
     //    A setup AliITSpList class.
 
-    fNi = imax;
-    fNj = jmax;
-    fEntries = 0;
     fa = new TClonesArray("AliITSpListItem",fNi*fNj);
 }
 //______________________________________________________________________
@@ -121,28 +123,16 @@ AliITSpList& AliITSpList::operator=(const AliITSpList &source){
     // Return:
     //    A copied AliITSpList object.
 
-    if(this == &source) return *this;
-
-    if(this->fa!=0){ // if this->fa exists delete it first.
-      fa->Delete();
-      delete fa;
-      fa = 0;
-    } // end if this->fa!=0
-    this->fNi = source.fNi;
-    this->fNj = source.fNj;
-    this->fa = new TClonesArray(*(source.fa));
-    this->fEntries = source.fEntries;
-
-    return *this;
+  this->~AliITSpList();
+  new(this) AliITSpList(source);
+  return *this;
 }
 //______________________________________________________________________
-AliITSpList::AliITSpList(const AliITSpList &source) : AliITSMap(source){
+AliITSpList::AliITSpList(const AliITSpList &source) : AliITSMap(source),
+fNi(source.fNi),fNj(source.fNj),fa(0),fEntries(source.fEntries){
     // Copy constructor
 
-  fNi = source.fNi;
-  fNj = source.fNj;
   fa = new TClonesArray(*(source.fa));
-  fEntries = source.fEntries;
 }
 //______________________________________________________________________
 void AliITSpList::AddItemTo(Int_t fileIndex, AliITSpListItem *pl) {
index 14d191f..b5222ac 100644 (file)
 //************************************************************************
 ClassImp(AliITSpListItem)
 //______________________________________________________________________
-AliITSpListItem::AliITSpListItem(){
+AliITSpListItem::AliITSpListItem():
+fmodule(-1),
+findex(-1),
+fTsignal(0.0),
+fNoise(0.0),
+fSignalAfterElect(0.0){
     // Default constructor
     // Inputs:
     //    none.
@@ -35,19 +40,19 @@ AliITSpListItem::AliITSpListItem(){
     // Return:
     //    A zeroed/empty AliITSpListItem class.
 
-    fmodule = -1;
-    findex  = -1;
     for(Int_t i=0;i<this->fgksize;i++){
         this->fTrack[i]  = -2;
         this->fHits[i]   = -1;
         this->fSignal[i] = 0.0;
     } // end if i
-    fTsignal = 0.0;
-    fNoise   = 0.0;
-    fSignalAfterElect = 0.0;
 }
 //______________________________________________________________________
-AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise){
+AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise):
+fmodule(module),
+findex(index),
+fTsignal(0.0),
+fNoise(noise),
+fSignalAfterElect(0.0){
     // Standard noise constructor
     // Inputs:
     //    Int_t module   The module where this noise occurred
@@ -58,20 +63,20 @@ AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise){
     // Return:
     //    A setup and noise filled AliITSpListItem class.
 
-    this->fmodule    = module;
-    this->findex     = index;
     for(Int_t i=0;i<this->fgksize;i++){
         this->fTrack[i]  = -2;
         this->fSignal[i] = 0.0;
         this->fHits[i]   = -1;
     } // end if i
-    this->fTsignal = 0.0;
-    this->fSignalAfterElect = 0.0;
-    this->fNoise   = noise;
 }
 //______________________________________________________________________
 AliITSpListItem::AliITSpListItem(Int_t track,Int_t hit,Int_t module,
-                               Int_t index,Double_t signal){
+                               Int_t index,Double_t signal):
+fmodule(module),
+findex(index),
+fTsignal(signal),
+fNoise(0.0),
+fSignalAfterElect(0.0){
     // Standard signal constructor
     // Inputs:
     //    Int_t track     The track number which produced this signal
@@ -84,8 +89,6 @@ AliITSpListItem::AliITSpListItem(Int_t track,Int_t hit,Int_t module,
     // Return:
     //    A setup and signal filled  AliITSpListItem class.
 
-    this->fmodule    = module;
-    this->findex     = index;
     this->fTrack[0]  = track;
     this->fHits[0]   = hit;
     this->fSignal[0] = signal;
@@ -94,9 +97,6 @@ AliITSpListItem::AliITSpListItem(Int_t track,Int_t hit,Int_t module,
         this->fSignal[i] = 0.0;
         this->fHits[i]   = -1;
     } // end if i
-    this->fTsignal = signal;
-    this->fNoise   = 0.0;
-    this->fSignalAfterElect   = 0.0;
 }
 //______________________________________________________________________
 AliITSpListItem::~AliITSpListItem(){
@@ -118,40 +118,19 @@ AliITSpListItem& AliITSpListItem::operator=(const AliITSpListItem &source){
     //    none.
     // Return:
     //    A copied AliITSpListItem object
-    Int_t i;
-
-    if(this == &source) return *this;
+  this->~AliITSpListItem();
+  new(this) AliITSpListItem(source);
+  return *this;
 
-    this->fmodule = source.fmodule;
-    this->findex  = source.findex;
-    for(i=0;i<this->fgksize;i++){
-        this->fTrack[i]  = source.fTrack[i];
-        this->fSignal[i] = source.fSignal[i];
-        this->fHits[i]   = source.fHits[i];
-    } // end if i
-    this->fTsignal = source.fTsignal;
-    this->fNoise   = source.fNoise;
-    this->fSignalAfterElect   = source.fSignalAfterElect;
-    /*
-    cout <<"this fTrack[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<this->fTrack[i]<<",";
-    cout <<" fHits[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<this->fHits[i]<<",";
-    cout <<" fSignal[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<this->fSignal[i]<<",";
-    cout << endl;
-    cout <<"source fTrack[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<source.fTrack[i]<<",";
-    cout <<" fHits[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<source.fHits[i]<<",";
-    cout <<" fSignal[0-9]=";
-    for(i=0;i<this->fgksize;i++) cout <<source.fSignal[i]<<",";
-    cout << endl;
-    */
-    return *this;
 }
 //______________________________________________________________________
-AliITSpListItem::AliITSpListItem(AliITSpListItem &source) : TObject(source){
+AliITSpListItem::AliITSpListItem(const AliITSpListItem &source) : 
+TObject(source),
+fmodule(source.fmodule),
+findex(source.findex),
+fTsignal(source.fTsignal),
+fNoise(source.fNoise),
+fSignalAfterElect(source.fSignalAfterElect){
     // Copy operator
     // Inputs:
     //    AliITSpListItem &source   A AliITSpListItem Object
@@ -159,8 +138,13 @@ AliITSpListItem::AliITSpListItem(AliITSpListItem &source) : TObject(source){
     //    none.
     // Return:
     //    A copied AliITSpListItem object
+  
+    for(Int_t i=0;i<this->fgksize;i++){
+      this->fTrack[i]  = source.fTrack[i];
+      this->fSignal[i] = source.fSignal[i];
+      this->fHits[i]   = source.fHits[i];
+    } // end if i
 
-    *this = source;
 }
 //______________________________________________________________________
 void AliITSpListItem::AddSignal(Int_t track,Int_t hit,Int_t module,
index 96e990f..616837f 100644 (file)
@@ -20,7 +20,7 @@ class AliITSpListItem: public TObject {
     // Class destrutor
     virtual ~AliITSpListItem();
     // Copy Oporator
-    AliITSpListItem(AliITSpListItem &source);
+    AliITSpListItem(const AliITSpListItem &source);
     // = Opoerator
     virtual AliITSpListItem& operator=(const AliITSpListItem &source);
     // Returns the signal value in the list of signals
index 0b3c144..284bd20 100644 (file)
@@ -30,23 +30,27 @@ ClassImp(AliITSpackageSSD)
 //skowron@if.pw.edu.pl
 //
 //--------------------------------------------------------------------------
-AliITSpackageSSD::AliITSpackageSSD()
-{
+AliITSpackageSSD::AliITSpackageSSD():
+fClustersN(0),
+fClustersP(0),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
   // constructor
-  fNclustersN=0;
-  fClusterNIndexes = 0; 
-               
-  fNclustersP=0;
-  fClusterPIndexes = 0;
-  if (fgkDebug) cout<<"Default Ctor was used\n>>>>>>>>>>>>>><<<<<<<<<<<<<";
 }
 
 
 /*******************************************************/
 
 AliITSpackageSSD::AliITSpackageSSD
-  (TClonesArray *clustersP, TClonesArray *clustersN)
-{
+(TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
   // constructor
   fClustersP=clustersP;
   fClustersN=clustersN;
@@ -61,9 +65,13 @@ AliITSpackageSSD::AliITSpackageSSD
 /*******************************************************/
 
 
-AliITSpackageSSD::AliITSpackageSSD
-  ( Int_t len, TClonesArray *clustersP, TClonesArray *clustersN)
-{      
+AliITSpackageSSD::AliITSpackageSSD(Int_t len, TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){   
   // constructor
   fClustersP=clustersP;
   fClustersN=clustersN;
@@ -88,17 +96,16 @@ AliITSpackageSSD::~AliITSpackageSSD()
 /*******************************************************/
 
 AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) : 
-    TObject(package){
+    TObject(package),
+fClustersN(package.fClustersN),
+fClustersP(package.fClustersP),
+fNclustersN(package.fNclustersN),
+fNclustersP(package.fNclustersP),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
   // copy constractor
   Int_t i;  //iterator
  
-  if (this == &package) return;
-  fClustersN = package.fClustersN;
-  fClustersP = package.fClustersP;
-  
-  fNclustersN= package.fNclustersN;
-  fNclustersP= package.fNclustersP;
-  
   for ( i =0; i<fNclustersN;i++)
     {
       fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
@@ -109,9 +116,6 @@ AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) :
       fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
     }
   
-  if (fgkDebug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
-  
-  return; 
   
 }
 /*******************************************************/
index 223bf22..1855bf8 100644 (file)
@@ -35,8 +35,11 @@ const Float_t AliITSresponseSPD::fgkEccentricityDiffDefault = 0.85;
 ClassImp(AliITSresponseSPD)    
 //______________________________________________________________________
 AliITSresponseSPD::AliITSresponseSPD():
-  AliITSresponse(){
-
+  AliITSresponse(),
+fCouplCol(0),
+fCouplRow(0),
+fCouplOpt(0),
+fEccDiff(0){
 
   // constructor
   SetCouplingParam(fgkCouplingColDefault,fgkCouplingRowDefault);
index 3efc68c..6905616 100644 (file)
@@ -36,7 +36,15 @@ const Int_t AliITSresponseSSD::fgkZSThreshold = 3;
 ClassImp(AliITSresponseSSD)
 
 //______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(){
+AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(),
+fADCpereV(0),
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(9),
+fZSThreshold(0),
+fOption1(),
+fOption2(){
     // Default Constructor
 
   SetDiffCoeff(fgkDiffCoeffDefault,0.);
@@ -47,17 +55,24 @@ AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(){
 }
 
 //______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &ob) : AliITSresponse(ob) {
+AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &ob) : AliITSresponse(ob),
+fADCpereV(ob.fADCpereV),
+fCouplingPR(ob.fCouplingPR),
+fCouplingPL(ob.fCouplingPL),
+fCouplingNR(ob.fCouplingNR),
+fCouplingNL(ob.fCouplingNL),
+fZSThreshold(ob.fZSThreshold),
+fOption1(ob.fOption1),
+fOption2(ob.fOption2) {
   // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSresponseSSD","Copy constructor not allowed\n");
+
 }
 
 //______________________________________________________________________
-AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD& /* ob */){
+AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD& ob){
   // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
+  this->~AliITSresponseSSD();
+  new(this) AliITSresponseSSD(ob);
   return *this;
 }
 
index d5b1b75..10abd1c 100644 (file)
 ClassImp(AliITSsegmentation)
 
 //_____________________________________________________________
-AliITSsegmentation::AliITSsegmentation(){
+AliITSsegmentation::AliITSsegmentation():
+fDx(0),
+fDz(0),
+fDy(0),
+fGeom(0),
+fCorr(0){
   // Default constructor
-  SetDetSize(0.,0.,0.);
-  fGeom = 0;
-  fCorr = 0;
 }
 
 //_____________________________________________________________
@@ -52,7 +55,12 @@ AliITSsegmentation& AliITSsegmentation::operator=(
 }
 //______________________________________________________________________
 AliITSsegmentation::AliITSsegmentation(const AliITSsegmentation &source):
-    TObject(source){
+    TObject(source),
+fDx(0),
+fDz(0),
+fDy(0),
+fGeom(0),
+fCorr(0){
     // copy constructor
   source.Copy(*this);
 }
index 7f035b4..2821ecc 100644 (file)
@@ -39,7 +39,12 @@ const Int_t AliITSsegmentationSDD::fgkNsamplesDefault = 256;
 ClassImp(AliITSsegmentationSDD)
 //----------------------------------------------------------------------
 AliITSsegmentationSDD::AliITSsegmentationSDD(AliITSgeom* geom,
-                                            AliITSCalibration *resp){
+                                            AliITSCalibration *resp):
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
   // constructor
    fGeom=geom;
    AliITSCalibrationSDD* sp = (AliITSCalibrationSDD*)resp;
@@ -51,7 +56,12 @@ AliITSsegmentationSDD::AliITSsegmentationSDD(AliITSgeom* geom,
 
 }
 //______________________________________________________________________
-AliITSsegmentationSDD::AliITSsegmentationSDD() : AliITSsegmentation(){
+AliITSsegmentationSDD::AliITSsegmentationSDD() : AliITSsegmentation(),
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
   // Default constructor
    fDriftSpeed=0;  
    SetDetSize(fgkDxDefault,fgkDzDefault,fgkDyDefault);
@@ -81,7 +91,12 @@ AliITSsegmentationSDD& AliITSsegmentationSDD::operator=(const AliITSsegmentation
 
 //____________________________________________________________________________
 AliITSsegmentationSDD::AliITSsegmentationSDD(const AliITSsegmentationSDD &source) :
-    AliITSsegmentation(source){
+    AliITSsegmentation(source),
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
   // copy constructor
   source.Copy(*this);
 }
index 1fcf0a4..f1f1d2e 100644 (file)
 ClassImp(AliITSsegmentationSPD)
 
 //_____________________________________________________________________________
-  AliITSsegmentationSPD::AliITSsegmentationSPD(): AliITSsegmentation(){
+  AliITSsegmentationSPD::AliITSsegmentationSPD(): AliITSsegmentation(),
+fNpx(0),
+fNpz(0){
   // Default constructor
-  fNpx = 0;
-  fNpz = 0;
   for(Int_t k=0; k<256; k++){
     fCellSizeX[k] = 0.;
     fCellSizeZ[k] = 0.;
@@ -188,11 +188,11 @@ Float_t AliITSsegmentationSPD::ZpitchFromCol(Int_t col) const {
     return pitchz;
 }
 //______________________________________________________________________
-AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSgeom *gm){
+AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSgeom *gm):
+fNpx(0),
+fNpz(0){
   // Constructor
    fCorr=0;
-   fNpx = 0;
-   fNpz = 0;
    Init(); 
    fGeom = gm;
 
@@ -219,7 +219,9 @@ AliITSsegmentationSPD& AliITSsegmentationSPD::operator=(const AliITSsegmentation
 }
 //____________________________________________________________________________
 AliITSsegmentationSPD::AliITSsegmentationSPD(const AliITSsegmentationSPD &source) :
-    AliITSsegmentation(source){
+    AliITSsegmentation(source),
+fNpx(0),
+fNpz(0){
   // copy constructor
   source.Copy(*this);
 }
index 6dba076..a6d03d6 100644 (file)
@@ -31,11 +31,29 @@ const Float_t AliITSsegmentationSSD::fgkPitchDefault = 95.;
 const Int_t AliITSsegmentationSSD::fgkNstripsDefault = 768;
 
 ClassImp(AliITSsegmentationSSD)
-AliITSsegmentationSSD::AliITSsegmentationSSD(): AliITSsegmentation(){
+AliITSsegmentationSSD::AliITSsegmentationSSD(): AliITSsegmentation(),
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
     // default constructor
 }
 //----------------------------------------------------------------------
-AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom){
+AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom):
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
     // constuctor
     fGeom = geom;
     fCorr = 0;
@@ -75,7 +93,16 @@ AliITSsegmentationSSD& AliITSsegmentationSSD::operator=(
 }
 //______________________________________________________________________
 AliITSsegmentationSSD::AliITSsegmentationSSD(const AliITSsegmentationSSD &source):
-    AliITSsegmentation(source){
+    AliITSsegmentation(source),
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
     // copy constructor
   source.Copy(*this);
 }
index 890824a..d10f90b 100644 (file)
@@ -23,12 +23,9 @@ public:
   virtual void SetSegmentationModel(Int_t dt, AliITSsegmentation *seg){fDetType->SetSegmentationModel(dt,seg);}
   virtual AliITSsegmentation* GetSegmentationModel(Int_t dt){return fDetType->GetSegmentationModel(dt);}
 
-  
-private:
+ private:
 
-  virtual AliITSsimulation& operator=(const AliITSsimulation &)
-    {return *this;} 
-  
+    
     virtual void SetSigmaRPhi(Double_t sigmarphi[6]);  
     virtual void SetSigmaZ(Double_t sigmaz[6]);  
     virtual void SetSigmaDe(Double_t sigmade[6]);  
@@ -39,8 +36,6 @@ private:
     Double_t ThrDe(Int_t layer) const {return fThrDe[layer-1];} 
 
 
-private:
-
     Double_t fSigmaRPhi[6];              // Sigmas in rphi for the 6 layers
     Double_t fSigmaZ[6];                 // Sigmas in Z for the 6 layers
     Double_t fSigmaDe[6];                // Sigmas in energy loss for the 6 layers
index 89d2439..4cf30c0 100644 (file)
 #pragma link C++ class AliITSRawStreamSSD+;
 #pragma link C++ class AliITSRawStreamSSDv1+;
 #pragma link C++ class AliITSEventHeader+;
-// SPD preprocessing
-#pragma link C++ class AliITSBadChannelsAuxSPD+;
-#pragma link C++ class AliITSBadChannelsSPD+;
-#pragma link C++ class AliITSChannelSPD+;
-#pragma link C++ class AliITSPreprocessorSPD+;
+
 
 
 #endif
index dc5bafc..8bd9b60 100644 (file)
 #pragma link C++ class AliITSBeamTestDigitizer+;
 //multiplicity
 #pragma link C++ class AliITSMultReconstructor+;
+// SPD and SDD preprocessing
+#pragma link C++ class AliITSBadChannelsAuxSPD+;
+#pragma link C++ class AliITSBadChannelsSPD+;
+#pragma link C++ class AliITSChannelSPD+;
+#pragma link C++ class AliITSPreprocessorSPD+;
+#pragma link C++ class AliITSPreprocessorSDD+;
 
 #endif
index 660dbef..b35d0bc 100644 (file)
@@ -39,10 +39,6 @@ SRCS =       AliITSgeom.cxx \
                AliITSEventHeader.cxx \
                AliITSRawStreamSSDv1.cxx \
                AliITSRawData.cxx  \
-               AliITSBadChannelsAuxSPD.cxx \
-               AliITSBadChannelsSPD.cxx  \
-               AliITSChannelSPD.cxx  \
-               AliITSPreprocessorSPD.cxx  \
 
 HDRS:=  $(SRCS:.cxx=.h)
 
index dacaeb3..0fe7c83 100644 (file)
@@ -50,7 +50,12 @@ SRCS =       AliITSDetTypeRec.cxx \
                AliITSBeamTestDigSPD.cxx \
                AliITSBeamTestDigSSD.cxx \
                AliITSBeamTestDigitizer.cxx \
-               AliITSMultReconstructor.cxx
+               AliITSMultReconstructor.cxx \
+               AliITSPreprocessorSPD.cxx \
+               AliITSBadChannelsAuxSPD.cxx \
+               AliITSBadChannelsSPD.cxx  \
+               AliITSChannelSPD.cxx  \
+               AliITSPreprocessorSDD.cxx   
 
 HDRS:=  $(SRCS:.cxx=.h)