Changes required by Effective C++
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 4 Sep 2006 17:42:34 +0000 (17:42 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 4 Sep 2006 17:42:34 +0000 (17:42 +0000)
43 files changed:
STEER/AliAlignObj.cxx
STEER/AliAlignObjMatrix.cxx
STEER/AliCDBDump.h
STEER/AliCDBLocal.h
STEER/AliCDBManager.cxx
STEER/AliCDBManager.h
STEER/AliCDBMetaData.cxx
STEER/AliCDBPath.cxx
STEER/AliCDBStorage.h
STEER/AliCascadeVertexer.h
STEER/AliDCSValue.cxx
STEER/AliDetectorTag.cxx
STEER/AliESD.cxx
STEER/AliESD.h
STEER/AliESDCaloCluster.cxx
STEER/AliESDCaloCluster.h
STEER/AliESDV0MIParams.cxx
STEER/AliESDcascade.cxx
STEER/AliESDv0.cxx
STEER/AliEventTag.cxx
STEER/AliEventTagCuts.cxx
STEER/AliExternalTrackParam.cxx
STEER/AliFMDFloatMap.cxx
STEER/AliFMDFloatMap.h
STEER/AliMagFMaps.cxx
STEER/AliMultiplicity.cxx
STEER/AliPreprocessor.cxx
STEER/AliPreprocessor.h
STEER/AliRun.cxx
STEER/AliRunTagCuts.cxx
STEER/AliStrLine.cxx
STEER/AliTagAnalysis.cxx
STEER/AliTagAnalysis.h
STEER/AliTrackPointArray.cxx
STEER/AliTracker.cxx
STEER/AliTracker.h
STEER/AliV0vertexer.h
STEER/AliVertex.cxx
STEER/AliVertexer.cxx
STEER/AliVertexerTracks.cxx
STEER/AliVertexerTracks.h
STEER/AliXMLCollection.cxx
STEER/TTreeStream.cxx

index 8db6e34..ee4f0db 100644 (file)
@@ -92,6 +92,7 @@ AliAlignObj** AliAlignObj::fgAlignObjs[kLastLayer - kFirstLayer] = {
 
 //_____________________________________________________________________________
 AliAlignObj::AliAlignObj():
+  fVolPath(),
   fVolUID(0)
 {
   // default constructor
@@ -99,29 +100,32 @@ AliAlignObj::AliAlignObj():
 }
 
 //_____________________________________________________________________________
-AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) : TObject()
+AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) :
+  TObject(),
+  fVolPath(volpath),
+  fVolUID(voluid)
 {
   // standard constructor
   //
-  fVolPath=volpath;
-  fVolUID=voluid;
 }
 
-AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) : TObject()
+AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) :
+  TObject(),
+  fVolPath(volpath),
+  fVolUID(0)
 {
   // standard constructor
   // 
-  fVolPath=volpath;
   SetVolUID(detId,volId); 
 }
 
 //_____________________________________________________________________________
 AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
-  TObject(theAlignObj)
+  TObject(theAlignObj),
+  fVolPath(theAlignObj.GetVolPath()),
+  fVolUID(theAlignObj.GetVolUID())
 {
   //copy constructor
-  fVolPath = theAlignObj.GetVolPath();
-  fVolUID = theAlignObj.GetVolUID();
 }
 
 //_____________________________________________________________________________
index 7360895..16bd3d8 100644 (file)
 ClassImp(AliAlignObjMatrix)
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
+AliAlignObjMatrix::AliAlignObjMatrix() : 
+  AliAlignObj(),
+  fMatrix()
 {
   // Default constructor
   //
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj(volpath, voluid)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) :
+  AliAlignObj(volpath, voluid),
+  fMatrix()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   //
@@ -42,7 +46,9 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Doubl
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) : AliAlignObj(volpath,layerId,volId)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) :
+  AliAlignObj(volpath,layerId,volId),
+  fMatrix()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   // If the user explicitly sets the global variable to kFALSE then the
@@ -60,7 +66,9 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_
 
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t volUID, TGeoMatrix& m) : AliAlignObj(volpath,volUID)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t volUID, TGeoMatrix& m) :
+  AliAlignObj(volpath,volUID),
+  fMatrix()
 {
   // standard constructor with TGeoMatrix
   //
@@ -69,7 +77,9 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t volUID, TGeoM
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, TGeoMatrix& m) : AliAlignObj(volpath,layerId,volId)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, TGeoMatrix& m) :
+  AliAlignObj(volpath,layerId,volId),
+  fMatrix()
 {
   // standard constructor with TGeoMatrix
   //
@@ -79,7 +89,8 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_
 
 //_____________________________________________________________________________
 AliAlignObjMatrix::AliAlignObjMatrix(const AliAlignObj& theAlignObj) :
-  AliAlignObj(theAlignObj)
+  AliAlignObj(theAlignObj),
+  fMatrix()
 {
   //copy constructor
   //
index 86fac8b..ca5a7cc 100644 (file)
@@ -35,6 +35,8 @@ protected:
 
 private:
 
+       AliCDBDump(const AliCDBDump & source);
+       AliCDBDump & operator=(const AliCDBDump & source);
        AliCDBDump(const char* dbFile, Bool_t readOnly);
        virtual ~AliCDBDump();  
 
index ce904bb..5f031e1 100644 (file)
@@ -32,6 +32,8 @@ protected:
 
 private:
 
+       AliCDBLocal(const AliCDBLocal & source);
+       AliCDBLocal & operator=(const AliCDBLocal & source);
        AliCDBLocal(const char* baseDir);
        virtual ~AliCDBLocal();
        
index 8abdccf..661067e 100644 (file)
@@ -73,10 +73,15 @@ void AliCDBManager::Destroy() {
 
 //_____________________________________________________________________________
 AliCDBManager::AliCDBManager():
-       fDefaultStorage(NULL),
-       fDrainStorage(NULL),
-       fCache(kTRUE),
-       fRun(-1)
+  TObject(),
+  fFactories(),
+  fActiveStorages(),
+  fSpecificStorages(),
+  fDefaultStorage(NULL),
+  fDrainStorage(NULL),
+  fEntryCache(),
+  fCache(kTRUE),
+  fRun(-1)
 {
 // default constuctor
        fFactories.SetOwner(1);
@@ -689,7 +694,8 @@ void AliCDBManager::QueryCDB() {
 ///////////////////////////////////////////////////////////
 
 AliCDBParam::AliCDBParam():
-fType(), fURI()
+  fType(),
+  fURI()
 {
 // constructor
 
index 8767e69..90841f6 100644 (file)
@@ -99,6 +99,9 @@ class AliCDBManager: public TObject {
  private:
                
        AliCDBManager();
+       AliCDBManager(const AliCDBManager & source);
+       AliCDBManager & operator=(const AliCDBManager & source);
+
        static AliCDBManager* fgInstance; // AliCDBManager instance
        
        AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
index c33f1b7..d0bc667 100644 (file)
@@ -35,7 +35,8 @@ fObjectClassName(""),
 fResponsible(""),      
 fBeamPeriod(0),        
 fAliRootVersion(""),
-fComment("")   
+fComment(""),
+fProperties()  
 {
 // default constructor
 
index ee170c8..ce3956e 100644 (file)
@@ -35,8 +35,13 @@ ClassImp(AliCDBPath)
 
 //_____________________________________________________________________________
 AliCDBPath::AliCDBPath() :
-fIsValid(kTRUE),
-fIsWildcard(kFALSE)
+  TObject(),
+  fPath(""),
+  fLevel0(""),
+  fLevel1(""),
+  fLevel2(""),
+  fIsValid(kTRUE),
+  fIsWildcard(kFALSE)
 {
 // default constructor
 
@@ -44,8 +49,13 @@ fIsWildcard(kFALSE)
 
 //_____________________________________________________________________________
 AliCDBPath::AliCDBPath(const AliCDBPath& other):
-TObject(other),
-fPath(other.fPath)
+  TObject(other),
+  fPath(other.fPath),
+  fLevel0(""),
+  fLevel1(""),
+  fLevel2(""),
+  fIsValid(other.fIsValid),
+  fIsWildcard(other.fIsWildcard)
 {
 // constructor
        Init();
@@ -56,9 +66,13 @@ fPath(other.fPath)
 //_____________________________________________________________________________
 AliCDBPath::AliCDBPath(const char* level0, const char* level1,
        const char* level2):
-fLevel0(level0), 
-fLevel1(level1), 
-fLevel2(level2)
+  TObject(),
+  fPath(""),
+  fLevel0(level0), 
+  fLevel1(level1), 
+  fLevel2(level2),
+  fIsValid(kTRUE),
+  fIsWildcard(kFALSE)
 {
 // constructor
 
@@ -84,7 +98,13 @@ fLevel2(level2)
 
 //_____________________________________________________________________________
 AliCDBPath::AliCDBPath(const char* path):
-fPath(path)
+  TObject(),
+  fPath(path),
+  fLevel0(""),
+  fLevel1(""),
+  fLevel2(""),
+  fIsValid(kTRUE),
+  fIsWildcard(kFALSE)
 {
 // constructor
 
@@ -94,7 +114,13 @@ fPath(path)
 
 //_____________________________________________________________________________
 AliCDBPath::AliCDBPath(const TString& path):
-fPath(path)
+  TObject(),
+  fPath(path),
+  fLevel0(""),
+  fLevel1(""),
+  fLevel2(""),
+  fIsValid(kTRUE),
+  fIsWildcard(kFALSE)
 {
        Init();
        InitPath();
index bf63338..3ae3075 100644 (file)
@@ -106,6 +106,10 @@ protected:
        TString fType;    //! Local, Grid: base folder name - Dump: file name
        TString fBaseFolder;    //! Local, Grid: base folder name - Dump: file name
 
+ private:
+       AliCDBStorage(const AliCDBStorage & source);
+       AliCDBStorage & operator=(const AliCDBStorage & source);
+
        ClassDef(AliCDBStorage, 0);
 };
 
index c44d9a7..a3b7a32 100644 (file)
@@ -46,19 +46,36 @@ private:
   ClassDef(AliCascadeVertexer,1)  // cascade verterxer 
 };
 
-inline AliCascadeVertexer::AliCascadeVertexer() {
- fChi2max=33.; 
- fDV0min=0.015; fMassWin=0.05; fDBachMin=0.015;
- fDCAmax=0.01;  fCPAmax=0.025; 
- fRmin=0.5;     fRmax=2.5; 
+inline AliCascadeVertexer::AliCascadeVertexer() :
+  TObject(),
+  fChi2max(33.), 
+  fDV0min(0.015),
+  fMassWin(0.05),
+  fDBachMin(0.015),
+  fDCAmax(0.01),
+  fCPAmax(0.025), 
+  fRmin(0.5),
+  fRmax(2.5), 
+  fX(0),
+  fY(0),
+  fZ(0)
+{
 }
 
-inline AliCascadeVertexer::AliCascadeVertexer(const Double_t cuts[8]) {
-  fChi2max=cuts[0]; 
-  fDV0min=cuts[1];   fMassWin=cuts[2]; fDBachMin=cuts[3];
-  fDCAmax=cuts[4];   fCPAmax=cuts[5];
-  fRmin=cuts[6];     fRmax=cuts[7]; 
-  fX=fY=fZ=0.;
+inline AliCascadeVertexer::AliCascadeVertexer(const Double_t cuts[8]) :
+  TObject(),
+  fChi2max(cuts[0]), 
+  fDV0min(cuts[1]),
+  fMassWin(cuts[2]),
+  fDBachMin(cuts[3]),
+  fDCAmax(cuts[4]),
+  fCPAmax(cuts[5]),
+  fRmin(cuts[6]),
+  fRmax(cuts[7]), 
+  fX(0),
+  fY(0),
+  fZ(0)
+{
 }
 
 inline void AliCascadeVertexer::SetCuts(const Double_t cuts[8]) {
index 80bfb3b..d4d8831 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2006/07/20 09:43:46  jgrosseo
+removing dynamic types
+
 Revision 1.2  2006/07/04 14:58:11  jgrosseo
 revision of AliDCSValue: Removed wrapper classes, reduced storage size per value by factor 2
 
@@ -56,62 +59,80 @@ some more descriptions added
 
 ClassImp(AliDCSValue)
 
-AliDCSValue::AliDCSValue() : TObject()
+AliDCSValue::AliDCSValue() :
+  TObject(),
+  fType(kInvalid),
+  fBool(kFALSE),
+  fChar(0),
+  fInt(0),
+  fUInt(0),
+  fFloat(0),
+  fTimeStamp(0)
 {
   // default constructor
-
-  Init();
 }
 
-AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) : 
+  TObject(),
+  fType(kBool),
+  fBool(value),
+  fChar(0),
+  fInt(0),
+  fUInt(0),
+  fFloat(0),
+  fTimeStamp(timeStamp)
 {
   // constructor
-
-  Init();
-
-  fTimeStamp = timeStamp;
-
-  fType = kBool;
-  fBool = value;
 }
 
-AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) :
+  TObject(),
+  fType(kChar),
+  fBool(kFALSE),
+  fChar(value),
+  fInt(0),
+  fUInt(0),
+  fFloat(0),
+  fTimeStamp(timeStamp)
 {
   // constructor
-
-  Init();
-
-  fTimeStamp = timeStamp;
-
-  fType = kChar;
-  fChar = value;
 }
 
-AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) :
+  TObject(),
+  fType(kInt),
+  fBool(kFALSE),
+  fChar(0),
+  fInt(value),
+  fUInt(0),
+  fFloat(0),
+  fTimeStamp(timeStamp)
 {
   // constructor
-
-  Init();
-
-  fTimeStamp = timeStamp;
-
-  fType = kInt;
-  fInt = value;
 }
 
-AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) :
+  TObject(),
+  fType(kUInt),
+  fBool(kFALSE),
+  fChar(0),
+  fInt(0),
+  fUInt(value),
+  fFloat(0),
+  fTimeStamp(timeStamp)
 {
   // constructor
-
-  Init();
-
-  fTimeStamp = timeStamp;
-
-  fType = kUInt;
-  fUInt = value;
 }
 
-AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) :
+  TObject(),
+  fType(kFloat),
+  fBool(kFALSE),
+  fChar(0),
+  fInt(0),
+  fUInt(0),
+  fFloat(value),
+  fTimeStamp(timeStamp)
 {
   // constructor
 
@@ -123,11 +144,17 @@ AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) : TObject()
   fFloat = value;
 }
 
-AliDCSValue::AliDCSValue(const AliDCSValue& c) : TObject(c)
+AliDCSValue::AliDCSValue(const AliDCSValue& c) :
+  TObject(c),
+  fType(c.fType),
+  fBool(c.fBool),
+  fChar(c.fChar),
+  fInt(c.fInt),
+  fUInt(c.fUInt),
+  fFloat(c.fFloat),
+  fTimeStamp(c.fTimeStamp)
 {
   // copy constructor
-
-  ((AliDCSValue &)c).Copy(*this);
 }
 
 void AliDCSValue::Init()
index 1482f26..0844621 100644 (file)
 ClassImp(AliDetectorTag)
 
 //___________________________________________________________________________
-  AliDetectorTag::AliDetectorTag() :
-    TObject(),
-    fITS(kFALSE),
-    fTPC(kFALSE),
-    fTRD(kFALSE),
-    fTOF(kFALSE),
-    fHMPID(kFALSE),
-    fPHOS(kFALSE),
-    fZDC(kFALSE),
-    fMUON(kFALSE),
-    fPMD(kFALSE),
-    fEMCAL(kFALSE),
-    fVZERO(kFALSE),
-    fTZERO(kFALSE)
+AliDetectorTag::AliDetectorTag() :
+  TObject(),
+  fITS(kFALSE),
+  fTPC(kFALSE),
+  fTRD(kFALSE),
+  fTOF(kFALSE),
+  fHMPID(kFALSE),
+  fPHOS(kFALSE),
+  fZDC(kFALSE),
+  fMUON(kFALSE),
+  fPMD(kFALSE),
+  fEMCAL(kFALSE),
+  fVZERO(kFALSE),
+  fTZERO(kFALSE)
 {
   // Default constructor
 }
 
 //___________________________________________________________________________
-AliDetectorTag::AliDetectorTag(const AliDetectorTag & detTag) : TObject(detTag) {
+AliDetectorTag::AliDetectorTag(const AliDetectorTag & detTag) :
+  TObject(detTag),
+  fITS(detTag.fITS),
+  fTPC(detTag.fTPC),
+  fTRD(detTag.fTRD),
+  fTOF(detTag.fTOF),
+  fHMPID(detTag.fHMPID),
+  fPHOS(detTag.fPHOS),
+  fZDC(detTag.fZDC),
+  fMUON(detTag.fMUON),
+  fPMD(detTag.fPMD),
+  fEMCAL(detTag.fEMCAL),
+  fVZERO(detTag.fVZERO),
+  fTZERO(detTag.fTZERO)
+ {
   // DetectorTag copy constructor
-  SetITS();
-  SetTPC();
-  SetTRD();
-  SetTOF();
-  SetHMPID();
-  SetPHOS();
-  SetZDC();
-  SetMUON();
-  SetPMD();
-  SetEMCAL();
-  SetVZERO();
-  SetTZERO();
 }
 
 //___________________________________________________________________________
@@ -67,18 +69,18 @@ AliDetectorTag & AliDetectorTag::operator=(const AliDetectorTag &detTag) {
   if (this != &detTag) {
     TObject::operator=(detTag);
     
-    SetITS();
-    SetTPC();
-    SetTRD();
-    SetTOF();
-    SetHMPID();
-    SetPHOS();
-    SetZDC();
-    SetMUON();
-    SetPMD();
-    SetEMCAL();
-    SetVZERO();
-    SetTZERO();
+    fITS = detTag.fITS;
+    fTPC = detTag.fTPC;
+    fTRD = detTag.fTRD;
+    fTOF = detTag.fTOF;
+    fHMPID = detTag.fHMPID;
+    fPHOS = detTag.fPHOS;
+    fZDC = detTag.fZDC;
+    fMUON = detTag.fMUON;
+    fPMD = detTag.fPMD;
+    fEMCAL = detTag.fEMCAL;
+    fVZERO = detTag.fVZERO;
+    fTZERO = detTag.fTZERO;
   }
   return *this;
 }
index 2d4cb0e..2466749 100644 (file)
@@ -86,6 +86,7 @@ AliESD::AliESD(const AliESD& esd):
   fT0zVertex(esd.fT0zVertex),
   fSPDVertex(esd.fSPDVertex),
   fPrimaryVertex(esd.fPrimaryVertex),
+  fSPDMult(esd.fSPDMult),
   fT0timeStart(esd.fT0timeStart),
   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
@@ -110,6 +111,56 @@ AliESD::AliESD(const AliESD& esd):
   }
 }
 
+//______________________________________________________________________________
+AliESD & AliESD::operator=(const AliESD& source) {
+
+  // Assignment operator
+
+  if(&source == this) return *this;
+
+  fEventNumber = source.fEventNumber;
+  fRunNumber = source.fRunNumber;
+  fTriggerMask = source.fTriggerMask;
+  fTriggerCluster = source.fTriggerCluster;
+  fRecoVersion = source.fRecoVersion;
+  fMagneticField = source.fMagneticField;
+  fZDCN1Energy = source.fZDCN1Energy;
+  fZDCP1Energy = source.fZDCP1Energy;
+  fZDCN2Energy = source.fZDCN2Energy;
+  fZDCP2Energy = source.fZDCP2Energy;
+  fZDCEMEnergy = source.fZDCEMEnergy;
+  fZDCParticipants = source.fZDCParticipants;
+  fT0zVertex = source.fT0zVertex;
+  fSPDVertex = source.fSPDVertex;
+  fPrimaryVertex = source.fPrimaryVertex;
+  fSPDMult = source.fSPDMult;
+  fT0timeStart = source.fT0timeStart;
+  fTracks = *((TClonesArray*)source.fTracks.Clone());
+  fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
+  fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
+  fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
+  fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
+  fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
+  fV0s = *((TClonesArray*)source.fV0s.Clone());
+  fCascades = *((TClonesArray*)source.fCascades.Clone());
+  fKinks = *((TClonesArray*)source.fKinks.Clone());
+  fV0MIs = *((TClonesArray*)source.fV0MIs.Clone());
+  fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
+  fEMCALClusters = source.fEMCALClusters;
+  fFirstEMCALCluster = source.fFirstEMCALCluster;
+  fPHOSClusters = source.fPHOSClusters;
+  fFirstPHOSCluster = source.fFirstPHOSCluster;
+  fESDFMD = source.fESDFMD;
+
+  for (Int_t i=0; i<24; i++) {
+    fT0time[i] = source.fT0time[i];
+    fT0amplitude[i] = source.fT0amplitude[i];
+  }
+
+  return *this;
+
+}
+
 
 //______________________________________________________________________________
 AliESD::~AliESD()
index ac9e815..1e6c075 100644 (file)
@@ -211,6 +211,7 @@ public:
    
 protected:
   AliESD(const AliESD&);
+  AliESD &operator=(const AliESD& source);
 
   // Event Identification
   Int_t        fEventNumber;     // Event Number
index 1531517..f575ebc 100644 (file)
@@ -33,6 +33,7 @@ AliESDCaloCluster::AliESDCaloCluster() :
   fID(0),
   fClusterType(-1),
   fEMCALCluster(kFALSE),
+  fPHOSCluster(kFALSE),
   fEnergy(-1),
   fDispersion(-1),
   fChi2(-1),
@@ -43,9 +44,9 @@ AliESDCaloCluster::AliESDCaloCluster() :
   fNExMax(0),
   fEmcCpvDistance(9999),
   fNumberOfDigits(0),
-  fDigitAmplitude(0),
-  fDigitTime(0),
-  fDigitIndex(0)
+  fDigitAmplitude(0x0),
+  fDigitTime(0x0),
+  fDigitIndex(0x0)
 {
   //
   // The default ESD constructor 
@@ -60,6 +61,7 @@ AliESDCaloCluster::AliESDCaloCluster(const AliESDCaloCluster& clus) :
   fID(clus.fID),
   fClusterType(clus.fClusterType),
   fEMCALCluster(clus.fEMCALCluster),
+  fPHOSCluster(clus.fPHOSCluster),
   fEnergy(clus.fEnergy),
   fDispersion(clus.fDispersion),
   fChi2(clus.fChi2),
@@ -69,7 +71,10 @@ AliESDCaloCluster::AliESDCaloCluster(const AliESDCaloCluster& clus) :
   fM11(clus.fM11),
   fNExMax(clus.fNExMax),
   fEmcCpvDistance(clus.fEmcCpvDistance),
-  fNumberOfDigits(clus.fNumberOfDigits)
+  fNumberOfDigits(clus.fNumberOfDigits),
+  fDigitAmplitude(0x0),
+  fDigitTime(0x0),
+  fDigitIndex(0x0)
 {
   //
   // The copy constructor 
@@ -80,10 +85,6 @@ AliESDCaloCluster::AliESDCaloCluster(const AliESDCaloCluster& clus) :
 
   for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = clus.fPID[i];
 
-  fDigitAmplitude = 0x0;
-  fDigitTime = 0x0;
-  fDigitIndex = 0x0;
-
   if (clus.fNumberOfDigits > 0) {
     if (clus.fDigitAmplitude) {
       fDigitAmplitude = new UShort_t[clus.fNumberOfDigits];
@@ -103,6 +104,59 @@ AliESDCaloCluster::AliESDCaloCluster(const AliESDCaloCluster& clus) :
   }
 }
 
+//_______________________________________________________________________
+AliESDCaloCluster &AliESDCaloCluster::operator=(const AliESDCaloCluster& source)
+{
+  // assignment operator
+
+  if(&source == this) return *this;
+
+  fID = source.fID;
+  fClusterType = source.fClusterType;
+  fEMCALCluster = source.fEMCALCluster;
+  fPHOSCluster = source.fPHOSCluster;
+  fEnergy = source.fEnergy;
+  fDispersion = source.fDispersion;
+  fChi2 = source.fChi2;
+  fPrimaryIndex = source.fPrimaryIndex;
+  fM20 = source.fM20;
+  fM02 = source.fM02;
+  fM11 = source.fM11;
+  fNExMax = source.fNExMax;
+  fEmcCpvDistance = source.fEmcCpvDistance;
+  fNumberOfDigits = source.fNumberOfDigits;
+  delete fDigitAmplitude; fDigitAmplitude=0x0;
+  delete fDigitTime; fDigitTime = 0x0;
+  delete fDigitIndex; fDigitIndex = 0x0;
+
+  fGlobalPos[0] = source.fGlobalPos[0];
+  fGlobalPos[1] = source.fGlobalPos[1];
+  fGlobalPos[2] = source.fGlobalPos[2];
+
+  for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = source.fPID[i];
+
+  if (source.fNumberOfDigits > 0) {
+    if (source.fDigitAmplitude) {
+      fDigitAmplitude = new UShort_t[source.fNumberOfDigits];
+      for (Int_t i=0; i<source.fNumberOfDigits; i++)
+       fDigitAmplitude[i]=source.fDigitAmplitude[i];
+    }
+    if (source.fDigitTime) {
+      fDigitTime = new UShort_t[source.fNumberOfDigits];
+      for (Int_t i=0; i<source.fNumberOfDigits; i++)
+       fDigitTime[i]=source.fDigitTime[i];
+    }
+    if (source.fDigitIndex) {
+      fDigitIndex = new UShort_t[source.fNumberOfDigits];
+      for (Int_t i=0; i<source.fNumberOfDigits; i++)
+       fDigitIndex[i]=source.fDigitIndex[i];
+    }
+  }
+
+  return *this;
+
+}
+
 
 //_______________________________________________________________________
 AliESDCaloCluster::~AliESDCaloCluster(){ 
index 1f36a90..6f00ea7 100644 (file)
@@ -26,6 +26,7 @@ public:
 
   AliESDCaloCluster();
   AliESDCaloCluster(const AliESDCaloCluster& clus);
+  AliESDCaloCluster & operator=(const AliESDCaloCluster& source);
   virtual ~AliESDCaloCluster();
 
   void SetID(Int_t id) {fID = id;}
index 98c792d..237bfd2 100644 (file)
 ClassImp(AliESDV0MIParams)
 
 
-AliESDV0MIParams::AliESDV0MIParams(){
-  //
-  // Default constructor
-  // Consult AliESDV0MI to see actual error parameterization 
-  //
-
-  //
-  // This constants are used in the error parameterization using covariance matrix
+AliESDV0MIParams::AliESDV0MIParams() :
+  TObject(),
+  // These constants are used in the error parameterization using covariance matrix
   // minimal sigma in AP and DCA 
-  fPSigmaOffsetD0 = 0.03;      // minimal sigma of error estimate
-  fPSigmaOffsetAP0 = 0.005;    // 
+  fPSigmaOffsetD0(0.03),      // minimal sigma of error estimate
+  fPSigmaOffsetAP0(0.005),
   //
   // Effective parameterization of DCA resolution as function of pt and decay radii
   //
-  fPSigmaMaxDE    = 0.5;
-  fPSigmaOffsetDE = 0.06;
-  fPSigmaCoefDE   = 0.02;
-  fPSigmaRminDE   = 2.7;
+  fPSigmaMaxDE(0.5),
+  fPSigmaOffsetDE(0.06),
+  fPSigmaCoefDE(0.02),
+  fPSigmaRminDE(2.7),
   //
   //
   // Effective parameterization of PA resolution as function of pt and decay radii
   //
-  fPSigmaBase0APE  = 0.005;
-  fPSigmaMaxAPE    = 0.06;
-  fPSigmaR0APE     = 0.02;
-  fPSigmaR1APE     = 0.1; 
-  fPSigmaP0APE     = 0.7*0.4;
-  fPSigmaP1APE     = 0.3*0.4;
+  fPSigmaBase0APE(0.005),
+  fPSigmaMaxAPE(0.06),
+  fPSigmaR0APE(0.02),
+  fPSigmaR1APE(0.1), 
+  fPSigmaP0APE(0.7*0.4),
+  fPSigmaP1APE(0.3*0.4),
   //
   //
   // Minimax parameters
   //
-  fPMinFractionAP0 =0.5;
-  fPMaxFractionAP0 =1.5;
-  fPMinAP0         =0.003;
-  fPMinFractionD0 =0.5;
-  fPMaxFractionD0 =1.5;
-  fPMinD0         =0.05;
+  fPMinFractionAP0(0.5),
+  fPMaxFractionAP0(1.5),
+  fPMinAP0(0.003),
+  fPMinFractionD0(0.5),
+  fPMaxFractionD0(1.5),
+  fPMinD0(0.05)
+  //
+
+{
+  //
+  // Default constructor
+  // Consult AliESDV0MI to see actual error parameterization 
   //
 }
 
index 247e8f7..5518b66 100644 (file)
@@ -69,7 +69,9 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v,
                             const AliExternalTrackParam &t, Int_t i) : 
   AliESDv0(v),
   fPdgCode(kXiMinus),
+  fEffMass(-1),
   fChi2Xi(1.e+33),
+  fDcaXiDaughters(-1),
   fBachIdx(i)
 {
   //---------------------------------------------------------------------------------------------
@@ -132,14 +134,14 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v,
 }
 
 AliESDcascade::AliESDcascade(const AliESDcascade& cas) :
-  AliESDv0(cas)
+  AliESDv0(cas),
+  fPdgCode(cas.fPdgCode),
+  fEffMass(cas.fEffMass),
+  fChi2Xi(cas.fChi2Xi),
+  fDcaXiDaughters(cas.fDcaXiDaughters),
+  fBachIdx(cas.fBachIdx)
 {
   //copy constructor
-  fPdgCode = cas.fPdgCode;
-  fEffMass = cas.fEffMass;
-  fChi2Xi  = cas.fChi2Xi;
-  fDcaXiDaughters = cas.fDcaXiDaughters;
-  fBachIdx = cas.fBachIdx;
   for (int i=0; i<3; i++) {
     fPosXi[i]     = cas.fPosXi[i];
     fBachMom[i] = cas.fBachMom[i];
index ed27771..8c839f3 100644 (file)
@@ -62,14 +62,14 @@ AliESDv0::AliESDv0() :
 }
 
 AliESDv0::AliESDv0(const AliESDv0& rAliESDv0) :
-  TObject(rAliESDv0)
+  TObject(rAliESDv0),
+  fPdgCode(rAliESDv0.fPdgCode),
+  fEffMass(rAliESDv0.fEffMass),
+  fDcaV0Daughters(rAliESDv0.fDcaV0Daughters),
+  fChi2V0(rAliESDv0.fChi2V0),
+  fNidx(rAliESDv0.fNidx),
+  fPidx(rAliESDv0.fPidx)
 {
-  fPdgCode        = rAliESDv0.fPdgCode;
-  fEffMass        = rAliESDv0.fEffMass;
-  fDcaV0Daughters = rAliESDv0.fDcaV0Daughters;
-  fChi2V0         = rAliESDv0.fChi2V0;
-  fNidx           = rAliESDv0.fNidx;
-  fPidx           = rAliESDv0.fPidx;
 
   for (int i=0; i<3; i++) {
     fPos[i]  = rAliESDv0.fPos[i];
index 67fdf79..256145d 100644 (file)
@@ -97,142 +97,144 @@ ClassImp(AliEventTag)
 
 
 //___________________________________________________________________________
-AliEventTag::AliEventTag(const AliEventTag & EvTag) : TObject(EvTag) {
+AliEventTag::AliEventTag(const AliEventTag & evTag) :
+  TObject(evTag),
+  fAliceEventId(evTag.fAliceEventId),
+  fGUID(evTag.fGUID),
+  fPath(evTag.fPath),
+  fsize(evTag.fsize),
+  fmd5(evTag.fmd5),
+  fturl(evTag.fturl),
+  fNumberOfParticipants(evTag.fNumberOfParticipants),
+  fImpactParameter(evTag.fImpactParameter),
+  fPrimaryVertexFlag(evTag.fPrimaryVertexFlag),
+  fPrimaryVertexX(evTag.fPrimaryVertexX),
+  fPrimaryVertexY(evTag.fPrimaryVertexY),
+  fPrimaryVertexZ(evTag.fPrimaryVertexZ),
+  fPrimaryVertexZError(evTag.fPrimaryVertexZError),
+  fTriggerMask(evTag.fTriggerMask),
+  fTriggerCluster(evTag.fTriggerCluster),
+  fZDCNeutron1Energy(evTag.fZDCNeutron1Energy),
+  fZDCProton1Energy(evTag.fZDCProton1Energy),
+  fZDCNeutron2Energy(evTag.fZDCNeutron2Energy),
+  fZDCProton2Energy(evTag.fZDCProton2Energy),
+  fZDCEMEnergy(evTag.fZDCEMEnergy),
+  fT0VertexZ(evTag.fT0VertexZ),
+  fNumberOfTracks(evTag.fNumberOfTracks),
+  fNumberOfPositiveTracks(evTag.fNumberOfPositiveTracks),
+  fNumberOfNegativeTracks(evTag.fNumberOfNegativeTracks),
+  fNumberOfNeutralTracks(evTag.fNumberOfNeutralTracks),  
+  fNumberOfV0s(evTag.fNumberOfV0s),
+  fNumberOfCascades(evTag.fNumberOfCascades),
+  fNumberOfKinks(evTag.fNumberOfKinks),
+  fNumberOfPMDTracks(evTag.fNumberOfPMDTracks),
+  fNumberOfFMDTracks(evTag.fNumberOfFMDTracks),
+  fNumberOfPHOSClusters(evTag.fNumberOfPHOSClusters),
+  fNumberOfEMCALClusters(evTag.fNumberOfEMCALClusters),
+  fNumberOfJetCandidates(evTag.fNumberOfJetCandidates),
+  fMaxJetEnergy(evTag.fMaxJetEnergy),
+  fNumberOfHardPhotonsCandidates(evTag.fNumberOfHardPhotonsCandidates),
+  fMaxNeutralEnergy(evTag.fMaxNeutralEnergy),
+  fNumberOfChargedAbove1GeV(evTag.fNumberOfChargedAbove1GeV),
+  fNumberOfChargedAbove3GeV(evTag.fNumberOfChargedAbove3GeV),
+  fNumberOfChargedAbove10GeV(evTag.fNumberOfChargedAbove10GeV),
+  fNumberOfMuonsAbove1GeV(evTag.fNumberOfMuonsAbove1GeV),
+  fNumberOfMuonsAbove3GeV(evTag.fNumberOfMuonsAbove3GeV),
+  fNumberOfMuonsAbove10GeV(evTag.fNumberOfMuonsAbove10GeV),
+  fNumberOfElectronsAbove1GeV(evTag.fNumberOfElectronsAbove1GeV),
+  fNumberOfElectronsAbove3GeV(evTag.fNumberOfElectronsAbove3GeV),
+  fNumberOfElectronsAbove10GeV(evTag.fNumberOfElectronsAbove10GeV),
+  fNumberOfElectrons(evTag.fNumberOfElectrons),
+  fNumberOfMuons(evTag.fNumberOfMuons),
+  fNumberOfPions(evTag.fNumberOfPions),
+  fNumberOfKaons(evTag.fNumberOfKaons),
+  fNumberOfProtons(evTag.fNumberOfProtons),
+  fNumberOfLambdas(evTag.fNumberOfLambdas),
+  fNumberOfPhotons(evTag.fNumberOfPhotons),
+  fNumberOfPi0s(evTag.fNumberOfPi0s),
+  fNumberOfNeutrons(evTag.fNumberOfNeutrons),
+  fNumberOfKaon0s(evTag.fNumberOfKaon0s),
+  fTotalP(evTag.fTotalP),
+  fMeanPt(evTag.fMeanPt),
+  fMaxPt(evTag.fMaxPt),
+  fTotalNeutralP(evTag.fTotalNeutralP),
+  fMeanNeutralPt(evTag.fMeanNeutralPt),
+  fMaxNeutralPt(evTag.fMaxNeutralPt),
+  fEventPlaneAngle(evTag.fEventPlaneAngle),
+  fHBTRadii(evTag.fHBTRadii)
+ {
   // EventTag copy constructor
-  SetEventId(EvTag.GetEventId());
-  SetGUID(EvTag.GetGUID());
-  SetPath(EvTag.GetPath());
-  SetMD5(EvTag.GetMD5());
-  SetTURL(EvTag.GetTURL());
-  SetSize(EvTag.GetSize());
-  SetNumOfParticipants(EvTag.GetNumOfParticipants());
-  SetImpactParameter(EvTag.GetImpactParameter());
-  SetVertexX(EvTag.GetVertexX());
-  SetVertexY(EvTag.GetVertexY());
-  SetVertexZ(EvTag.GetVertexZ());
-  SetVertexFlag(EvTag.GetVertexFlag());
-  SetVertexZError(EvTag.GetVertexZError());
-  SetTriggerMask(EvTag.GetTriggerMask());
-  SetTriggerCluster(EvTag.GetTriggerCluster());
-  SetZDCNeutron1Energy(EvTag.GetZDCNeutron1Energy());
-  SetZDCProton1Energy(EvTag.GetZDCProton1Energy());
-  SetZDCEMEnergy(EvTag.GetZDCEMEnergy());
-  SetZDCNeutron2Energy(EvTag.GetZDCNeutron2Energy());
-  SetZDCProton2Energy(EvTag.GetZDCProton2Energy());
-  SetT0VertexZ(EvTag.GetT0VertexZ());
-  SetNumOfTracks(EvTag.GetNumOfTracks());
-  SetNumOfPosTracks(EvTag.GetNumOfPosTracks());
-  SetNumOfNegTracks(EvTag.GetNumOfNegTracks());
-  SetNumOfNeutrTracks(EvTag.GetNumOfNeutrTracks());
-  SetNumOfV0s(EvTag.GetNumOfV0s());
-  SetNumOfCascades(EvTag.GetNumOfCascades());
-  SetNumOfKinks(EvTag.GetNumOfKinks());
-  SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks());
-  SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks());
-  SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters());
-  SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters());
-  SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates());
-  SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates());
-  SetMaxJetEnergy(EvTag.GetMaxJetEnergy());
-  SetMaxNeutralEnergy(EvTag.GetMaxNeutralEnergy());
-  SetNumOfChargedAbove1GeV(EvTag.GetNumOfChargedAbove1GeV());
-  SetNumOfChargedAbove3GeV(EvTag.GetNumOfChargedAbove3GeV());
-  SetNumOfChargedAbove10GeV(EvTag.GetNumOfChargedAbove10GeV());
-  SetNumOfMuonsAbove1GeV(EvTag.GetNumOfMuonsAbove1GeV());
-  SetNumOfMuonsAbove3GeV(EvTag.GetNumOfMuonsAbove3GeV());
-  SetNumOfMuonsAbove10GeV(EvTag.GetNumOfMuonsAbove10GeV());
-  SetNumOfElectronsAbove1GeV(EvTag.GetNumOfElectronsAbove1GeV());
-  SetNumOfElectronsAbove3GeV(EvTag.GetNumOfElectronsAbove3GeV());
-  SetNumOfElectronsAbove10GeV(EvTag.GetNumOfElectronsAbove10GeV());
-  SetNumOfElectrons(EvTag.GetNumOfElectrons());
-  SetNumOfMuons(EvTag.GetNumOfMuons());
-  SetNumOfPions(EvTag.GetNumOfPions());
-  SetNumOfKaons(EvTag.GetNumOfKaons());
-  SetNumOfProtons(EvTag.GetNumOfProtons());
-  SetNumOfLambdas(EvTag.GetNumOfLambdas());
-  SetNumOfPhotons(EvTag.GetNumOfPhotons());
-  SetNumOfPi0s(EvTag.GetNumOfPi0s());
-  SetNumOfNeutrons(EvTag.GetNumOfNeutrons());
-  SetNumOfKaon0s(EvTag.GetNumOfKaon0s());
-  SetTotalMomentum(EvTag.GetTotalMomentum());
-  SetMeanPt(EvTag.GetMeanPt());
-  SetMaxPt(EvTag.GetMaxPt());
-  SetNeutralTotalMomentum(EvTag.GetNeutralTotalMomentum());
-  SetNeutralMeanPt(EvTag.GetNeutralMeanPt());
-  SetNeutralMaxPt(EvTag.GetNeutralMaxPt());
-  SetEventPlaneAngle(EvTag.GetEventPlaneAngle());
-  SetHBTRadii(EvTag.GetHBTRadii());
 }
 
 //___________________________________________________________________________
-AliEventTag & AliEventTag::operator=(const AliEventTag &EvTag) {
+AliEventTag & AliEventTag::operator=(const AliEventTag &evTag) {
   // EventTag assignment operator
-  if (this != &EvTag) {
-    TObject::operator=(EvTag);
+  if (this != &evTag) {
+    TObject::operator=(evTag);
     
-    SetEventId(EvTag.GetEventId());
-    SetGUID(EvTag.GetGUID());
-    SetPath(EvTag.GetPath());
-    SetMD5(EvTag.GetMD5());
-    SetTURL(EvTag.GetTURL());
-    SetSize(EvTag.GetSize());
-    SetNumOfParticipants(EvTag.GetNumOfParticipants());
-    SetImpactParameter(EvTag.GetImpactParameter());
-    SetVertexX(EvTag.GetVertexX());
-    SetVertexY(EvTag.GetVertexY());
-    SetVertexZ(EvTag.GetVertexZ());
-    SetVertexFlag(EvTag.GetVertexFlag());
-    SetVertexZError(EvTag.GetVertexZError());
-    SetTriggerMask(EvTag.GetTriggerMask());
-    SetTriggerCluster(EvTag.GetTriggerCluster());
-    SetZDCNeutron1Energy(EvTag.GetZDCNeutron1Energy());
-    SetZDCProton1Energy(EvTag.GetZDCProton1Energy());
-    SetZDCNeutron2Energy(EvTag.GetZDCNeutron2Energy());
-    SetZDCProton2Energy(EvTag.GetZDCProton2Energy());
-    SetZDCEMEnergy(EvTag.GetZDCEMEnergy());
-    SetT0VertexZ(EvTag.GetT0VertexZ());
-    SetNumOfTracks(EvTag.GetNumOfTracks());
-    SetNumOfPosTracks(EvTag.GetNumOfPosTracks());
-    SetNumOfNegTracks(EvTag.GetNumOfNegTracks());
-    SetNumOfNeutrTracks(EvTag.GetNumOfNeutrTracks());
-    SetNumOfV0s(EvTag.GetNumOfV0s());
-    SetNumOfCascades(EvTag.GetNumOfCascades());
-    SetNumOfKinks(EvTag.GetNumOfKinks());
-    SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks());
-    SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks());
-    SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters());
-    SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters());
-    SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates());
-    SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates());
-    SetMaxJetEnergy(EvTag.GetMaxJetEnergy());
-    SetMaxNeutralEnergy(EvTag.GetMaxNeutralEnergy());
-    SetNumOfChargedAbove1GeV(EvTag.GetNumOfChargedAbove1GeV());
-    SetNumOfChargedAbove3GeV(EvTag.GetNumOfChargedAbove3GeV());
-    SetNumOfChargedAbove10GeV(EvTag.GetNumOfChargedAbove10GeV());
-    SetNumOfMuonsAbove1GeV(EvTag.GetNumOfMuonsAbove1GeV());
-    SetNumOfMuonsAbove3GeV(EvTag.GetNumOfMuonsAbove3GeV());
-    SetNumOfMuonsAbove10GeV(EvTag.GetNumOfMuonsAbove10GeV());
-    SetNumOfElectronsAbove1GeV(EvTag.GetNumOfElectronsAbove1GeV());
-    SetNumOfElectronsAbove3GeV(EvTag.GetNumOfElectronsAbove3GeV());
-    SetNumOfElectronsAbove10GeV(EvTag.GetNumOfElectronsAbove10GeV());
-    SetNumOfElectrons(EvTag.GetNumOfElectrons());
-    SetNumOfMuons(EvTag.GetNumOfMuons());
-    SetNumOfPions(EvTag.GetNumOfPions());
-    SetNumOfKaons(EvTag.GetNumOfKaons());
-    SetNumOfProtons(EvTag.GetNumOfProtons());
-    SetNumOfLambdas(EvTag.GetNumOfLambdas());
-    SetNumOfPhotons(EvTag.GetNumOfPhotons());
-    SetNumOfPi0s(EvTag.GetNumOfPi0s());
-    SetNumOfNeutrons(EvTag.GetNumOfNeutrons());
-    SetNumOfKaon0s(EvTag.GetNumOfKaon0s());
-    SetTotalMomentum(EvTag.GetTotalMomentum());
-    SetMeanPt(EvTag.GetMeanPt());
-    SetMaxPt(EvTag.GetMaxPt());
-    SetNeutralTotalMomentum(EvTag.GetNeutralTotalMomentum());
-    SetNeutralMeanPt(EvTag.GetNeutralMeanPt());
-    SetNeutralMaxPt(EvTag.GetNeutralMaxPt());
-    SetEventPlaneAngle(EvTag.GetEventPlaneAngle());
-    SetHBTRadii(EvTag.GetHBTRadii());
+    SetEventId(evTag.GetEventId());
+    SetGUID(evTag.GetGUID());
+    SetPath(evTag.GetPath());
+    SetMD5(evTag.GetMD5());
+    SetTURL(evTag.GetTURL());
+    SetSize(evTag.GetSize());
+    SetNumOfParticipants(evTag.GetNumOfParticipants());
+    SetImpactParameter(evTag.GetImpactParameter());
+    SetVertexX(evTag.GetVertexX());
+    SetVertexY(evTag.GetVertexY());
+    SetVertexZ(evTag.GetVertexZ());
+    SetVertexFlag(evTag.GetVertexFlag());
+    SetVertexZError(evTag.GetVertexZError());
+    SetTriggerMask(evTag.GetTriggerMask());
+    SetTriggerCluster(evTag.GetTriggerCluster());
+    SetZDCNeutron1Energy(evTag.GetZDCNeutron1Energy());
+    SetZDCProton1Energy(evTag.GetZDCProton1Energy());
+    SetZDCNeutron2Energy(evTag.GetZDCNeutron2Energy());
+    SetZDCProton2Energy(evTag.GetZDCProton2Energy());
+    SetZDCEMEnergy(evTag.GetZDCEMEnergy());
+    SetT0VertexZ(evTag.GetT0VertexZ());
+    SetNumOfTracks(evTag.GetNumOfTracks());
+    SetNumOfPosTracks(evTag.GetNumOfPosTracks());
+    SetNumOfNegTracks(evTag.GetNumOfNegTracks());
+    SetNumOfNeutrTracks(evTag.GetNumOfNeutrTracks());
+    SetNumOfV0s(evTag.GetNumOfV0s());
+    SetNumOfCascades(evTag.GetNumOfCascades());
+    SetNumOfKinks(evTag.GetNumOfKinks());
+    SetNumOfPMDTracks(evTag.GetNumOfPMDTracks());
+    SetNumOfFMDTracks(evTag.GetNumOfFMDTracks());
+    SetNumOfPHOSClusters(evTag.GetNumOfPHOSClusters());
+    SetNumOfEMCALClusters(evTag.GetNumOfEMCALClusters());
+    SetNumOfJetCandidates(evTag.GetNumOfJetCandidates());
+    SetNumOfHardPhotonsCandidates(evTag.GetNumOfHardPhotonsCandidates());
+    SetMaxJetEnergy(evTag.GetMaxJetEnergy());
+    SetMaxNeutralEnergy(evTag.GetMaxNeutralEnergy());
+    SetNumOfChargedAbove1GeV(evTag.GetNumOfChargedAbove1GeV());
+    SetNumOfChargedAbove3GeV(evTag.GetNumOfChargedAbove3GeV());
+    SetNumOfChargedAbove10GeV(evTag.GetNumOfChargedAbove10GeV());
+    SetNumOfMuonsAbove1GeV(evTag.GetNumOfMuonsAbove1GeV());
+    SetNumOfMuonsAbove3GeV(evTag.GetNumOfMuonsAbove3GeV());
+    SetNumOfMuonsAbove10GeV(evTag.GetNumOfMuonsAbove10GeV());
+    SetNumOfElectronsAbove1GeV(evTag.GetNumOfElectronsAbove1GeV());
+    SetNumOfElectronsAbove3GeV(evTag.GetNumOfElectronsAbove3GeV());
+    SetNumOfElectronsAbove10GeV(evTag.GetNumOfElectronsAbove10GeV());
+    SetNumOfElectrons(evTag.GetNumOfElectrons());
+    SetNumOfMuons(evTag.GetNumOfMuons());
+    SetNumOfPions(evTag.GetNumOfPions());
+    SetNumOfKaons(evTag.GetNumOfKaons());
+    SetNumOfProtons(evTag.GetNumOfProtons());
+    SetNumOfLambdas(evTag.GetNumOfLambdas());
+    SetNumOfPhotons(evTag.GetNumOfPhotons());
+    SetNumOfPi0s(evTag.GetNumOfPi0s());
+    SetNumOfNeutrons(evTag.GetNumOfNeutrons());
+    SetNumOfKaon0s(evTag.GetNumOfKaon0s());
+    SetTotalMomentum(evTag.GetTotalMomentum());
+    SetMeanPt(evTag.GetMeanPt());
+    SetMaxPt(evTag.GetMaxPt());
+    SetNeutralTotalMomentum(evTag.GetNeutralTotalMomentum());
+    SetNeutralMeanPt(evTag.GetNeutralMeanPt());
+    SetNeutralMaxPt(evTag.GetNeutralMaxPt());
+    SetEventPlaneAngle(evTag.GetEventPlaneAngle());
+    SetHBTRadii(evTag.GetHBTRadii());
   }
   return *this;
 }
index a324266..a1bf415 100644 (file)
@@ -29,7 +29,131 @@ ClassImp(AliEventTagCuts)
 
 
 //___________________________________________________________________________
-AliEventTagCuts::AliEventTagCuts() {
+AliEventTagCuts::AliEventTagCuts() :
+  TObject(),
+
+
+
+  
+  fVxMin(-1000.0), fVxMax(1000.0), 
+  fVxFlag(kFALSE),
+  fVyMin(-1000.0), fVyMax(1000.0),  
+  fVyFlag(kFALSE),
+  fVzMin(-1000.0), fVzMax(1000.0),
+  fVzFlag(kFALSE),
+  fParticipantsMin(-1), fParticipantMax(10000),
+  fParticipantsFlag(kFALSE),
+  fImpactParamMin(-1.0), fImpactParamMax(1000.0),
+  fImpactParamFlag(kFALSE),
+  fPrimaryVertexFlag(1),
+  fPVFlag(kFALSE),
+
+  fPrimaryVertexZErrorMin(-10000.), fPrimaryVertexZErrorMax(10000.),
+  fPVzErrorFlag(kFALSE),
+  fTriggerMask(0),
+  fTriggerMaskFlag(kFALSE),
+  fTriggerCluster(0),
+  fTriggerClusterFlag(kFALSE),
+  fZDCNeutron1EnergyMin(-1.0), fZDCNeutron1EnergyMax(100000.0),
+  fZDCNeutron1EnergyFlag(kFALSE),
+  fZDCProton1EnergyMin(-1.0), fZDCProton1EnergyMax(100000.0),
+  fZDCProton1EnergyFlag(kFALSE),
+  fZDCNeutron2EnergyMin(-1.0), fZDCNeutron2EnergyMax(100000.0),
+  fZDCNeutron2EnergyFlag(kFALSE),
+  fZDCProton2EnergyMin(-1.0), fZDCProton2EnergyMax(100000.0),
+  fZDCProton2EnergyFlag(kFALSE),
+  fZDCEMEnergyMin(-1.0), fZDCEMEnergyMax(100000.0),
+  fZDCEMEnergyFlag(kFALSE),
+  fT0VertexZMin(-10000.0), fT0VertexZMax(10000.0),  
+  fT0VertexZFlag(kFALSE),
+  fMultMin(0), fMultMax(100000),  
+  fMultFlag(kFALSE),
+  fMultPosMin(-1), fMultPosMax(100000),
+  fMultPosFlag(kFALSE),
+  fMultNegMin(-1), fMultNegMax(100000),
+  fMultNegFlag(kFALSE),
+  fMultNeutrMin(-1), fMultNeutrMax(100000),
+  fMultNeutrFlag(kFALSE),
+  fV0sMin(-1), fV0sMax(1000000),
+  fV0sFlag(kFALSE),
+  fCascadesMin(-1), fCascadesMax(100000),
+  fCascadesFlag(kFALSE),
+  fkinksMin(-1), fkinksMax(1000000),
+  fkinksFlag(kFALSE),
+
+  fPMDTracksMin(-1), fPMDTracksMax(100000),
+  fPMDTracksFlag(kFALSE),
+  fFMDTracksMin(-1), fFMDTracksMax(100000),
+  fFMDTracksFlag(kFALSE),
+  fPHOSClustersMin(-1), fPHOSClustersMax(100000),
+  fPHOSClustersFlag(kFALSE),
+  fEMCALClustersMin(-1), fEMCALClustersMax(100000),
+  fEMCALClustersFlag(kFALSE),
+  fJetCandidatesMin(-1), fJetCandidatesMax(100000),
+  fJetCandidatesFlag(kFALSE),
+
+  fMaxJetEnergy(-1.0), 
+  fMaxJetEnergyFlag(kFALSE),
+  fNHardPhotonsCandidatesMin(-1), fNHardPhotonsCandidatesMax(100000),
+  fNHardPhotonsCandidatesFlag(kFALSE),
+  fMaxNeutralEnergy(-1.0), 
+  fMaxNeutralFlag(kFALSE),
+  fChargedAbove1GeVMin(-1), fChargedAbove1GeVMax(100000),
+  fChargedAbove1GeVFlag(kFALSE),
+  fChargedAbove3GeVMin(-1), fChargedAbove3GeVMax(100000),
+  fChargedAbove3GeVFlag(kFALSE),
+  fChargedAbove10GeVMin(-1), fChargedAbove10GeVMax(100000),
+  fChargedAbove10GeVFlag(kFALSE),
+  fMuonsAbove1GeVMin(-1), fMuonsAbove1GeVMax(100000),
+  fMuonsAbove1GeVFlag(kFALSE),
+  fMuonsAbove3GeVMin(-1), fMuonsAbove3GeVMax(100000),
+  fMuonsAbove3GeVFlag(kFALSE),
+  fMuonsAbove10GeVMin(-1), fMuonsAbove10GeVMax(100000), 
+  fMuonsAbove10GeVFlag(kFALSE),
+  fElectronsAbove1GeVMin(-1), fElectronsAbove1GeVMax(100000),
+  fElectronsAbove1GeVFlag(kFALSE),
+  fElectronsAbove3GeVMin(-1), fElectronsAbove3GeVMax(100000),
+  fElectronsAbove3GeVFlag(kFALSE),
+  fElectronsAbove10GeVMin(-1), fElectronsAbove10GeVMax(100000),
+  fElectronsAbove10GeVFlag(kFALSE),
+  fElectronsMin(-1), fElectronsMax(100000),
+  fElectronsFlag(kFALSE),
+  fMuonsMin(-1), fMuonsMax(100000),
+  fMuonsFlag(kFALSE),
+  fPionsMin(-1), fPionsMax(100000),
+  fPionsFlag(kFALSE),
+  fKaonsMin(-1), fKaonsMax(100000),
+  fKaonsFlag(kFALSE),
+  fProtonsMin(-1), fProtonsMax(100000),
+  fProtonsFlag(kFALSE),
+  fLambdasMin(-1), fLambdasMax(100000),
+  fLambdasFlag(kFALSE),
+  fPhotonsMin(-1), fPhotonsMax(100000),
+  fPhotonFlag(kFALSE),
+  fPi0sMin(-1), fPi0sMax(100000), 
+  fPi0sFlag(kFALSE),
+  fNeutronsMin(-1), fNeutronsMax(100000), 
+  fNeutronsFlag(kFALSE),
+  fKaon0sMin(-1), fKaon0sMax(100000), 
+  fKaon0sFlag(kFALSE),
+  fTotalPMin(-1.0), fTotalPMax(1000000.0),
+  fTotalPFlag(kFALSE),
+  fMeanPtMin(-1.0), fMeanPtMax(100000.0),
+  fMeanPtFlag(kFALSE),
+  fMaxPt(-1.0),
+  fMaxPtFlag(kFALSE),
+  fTotalNeutralPMin(-1.0), fTotalNeutralPMax(1000000.0),   
+  fTotalNeutralPFlag(kFALSE),
+  fMeanNeutralPtMin(-1.0), fMeanNeutralPtMax(1000000.0), 
+  fMeanNeutralPtFlag(kFALSE),
+  fMaxNeutralPt(-1.0), 
+  fMaxNeutralPtFlag(kFALSE),
+  fEventPlaneAngleMin(-10000000.0), fEventPlaneAngleMax(10000000.0), 
+  fEventPlaneAngleFlag(kFALSE),
+  fHBTRadiiMin(-1.0), fHBTRadiiMax(100000.0), 
+  fHBTRadiiFlag(kFALSE)
+{
   //Default constructor which calls the Reset method.
   Reset();
 }
index d1c6f36..c4ecff6 100644 (file)
@@ -60,6 +60,7 @@ AliExternalTrackParam::AliExternalTrackParam(Double_t x, Double_t alpha,
 
 //_____________________________________________________________________________
 AliExternalTrackParam::AliExternalTrackParam(const AliKalmanTrack& track) :
+  fX(0),
   fAlpha(track.GetAlpha())
 {
   //
index 0522dcd..859dd7f 100755 (executable)
@@ -39,23 +39,22 @@ AliFMDFloatMap::AliFMDFloatMap(const AliFMDFloatMap& other)
               other.fMaxRings,
               other.fMaxSectors,
               other.fMaxStrips),
-    fData(0)
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
+    fData(new Float_t[fTotal])
 {
   // Copy constructor
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
-  fData  = new Float_t[fTotal];
-  for (size_t i = 0; i < fMaxDetectors * fMaxRings 
-        * fMaxSectors * fMaxStrips; i++)
+  for (Int_t i = 0; i < fTotal; i++)
     fData[i] = other.fData[i];
 }
 
 //__________________________________________________________
-AliFMDFloatMap::AliFMDFloatMap(size_t maxDet,
-                              size_t maxRing,
-                              size_t maxSec,
-                              size_t maxStr)
+AliFMDFloatMap::AliFMDFloatMap(Int_t maxDet,
+                              Int_t maxRing,
+                              Int_t maxSec,
+                              Int_t maxStr)
   : AliFMDMap(maxDet, maxRing, maxSec, maxStr),
-    fData(0)
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
+    fData(new Float_t[fTotal])
 {
   // Constructor.
   // Parameters:
@@ -63,8 +62,6 @@ AliFMDFloatMap::AliFMDFloatMap(size_t maxDet,
   //   maxRing Maximum number of rings per detector
   //   maxSec  Maximum number of sectors per ring
   //   maxStr  Maximum number of strips per sector
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
-  fData  = new Float_t[fTotal];
   Reset();
 }
 
@@ -80,7 +77,7 @@ AliFMDFloatMap::operator=(const AliFMDFloatMap& other)
   fTotal        = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
   if (fData) delete [] fData;
   fData = new Float_t[fTotal];
-  for (size_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
+  for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
   return *this;
 }
 
@@ -89,7 +86,7 @@ void
 AliFMDFloatMap::Reset(const Float_t& val)
 {
   // Reset map to val
-  for (size_t i = 0; i < fTotal; i++) fData[i] = val;
+  for (Int_t i = 0; i < fTotal; i++) fData[i] = val;
 }
 
 //__________________________________________________________
index b9c33b5..01b1218 100755 (executable)
 class AliFMDFloatMap : public AliFMDMap
 {
 public:
-  AliFMDFloatMap(size_t  maxDet = kMaxDetectors, 
-                size_t  maxRing= kMaxRings, 
-                size_t  maxSec = kMaxSectors, 
-                size_t  maxStr = kMaxStrips);
+  AliFMDFloatMap(Int_t  maxDet = kMaxDetectors, 
+                Int_t  maxRing= kMaxRings, 
+                Int_t  maxSec = kMaxSectors, 
+                Int_t  maxStr = kMaxStrips);
   AliFMDFloatMap(const AliFMDFloatMap& o);
   virtual ~AliFMDFloatMap() { delete [] fData; }
   AliFMDFloatMap& operator=(const AliFMDFloatMap& o);
@@ -37,9 +37,9 @@ public:
                                    UShort_t sec,
                                    UShort_t str) const;
 protected:
-  size_t   fTotal;  // Total number of entries
+  Int_t   fTotal;  // Total number of entries
   Float_t* fData;   //[fTotal]
-  ClassDef(AliFMDFloatMap,1) // Map of floats
+  ClassDef(AliFMDFloatMap,2) // Map of floats
 };
 
 #endif
index 93970bf..cc37673 100644 (file)
@@ -73,6 +73,7 @@ AliMagFMaps::AliMagFMaps(const char *name, const char *title, Int_t integ,
 AliMagFMaps::AliMagFMaps(const AliMagFMaps &magf):
   AliMagFC(magf),
   fSolenoid(0),
+  fSolenoidUser(0),
   fL3Option(0)
 {
   //
index 65b9c62..36abbe6 100644 (file)
@@ -3,18 +3,26 @@
 ClassImp(AliMultiplicity)
 
 //______________________________________________________________________
-AliMultiplicity::AliMultiplicity():TObject() {
+AliMultiplicity::AliMultiplicity():
+  TObject(),
+  fNtracks(0),
+  fTh(0),
+  fPhi(0),
+  fDeltPhi(0)
+
+{
   // Default Constructor
-  fNtracks = 0;
-  fTh = 0;
-  fPhi = 0;
-  fDeltPhi = 0;
 }
 
 //______________________________________________________________________
-AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df):TObject() {
+AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df):
+  TObject(),
+  fNtracks(ntr),
+  fTh(0),
+  fPhi(0),
+  fDeltPhi(0)
+{
 // Standard constructor
-  fNtracks = ntr;
   if(ntr>0){
     fTh = new Float_t [ntr];
     fPhi = new Float_t [ntr];
@@ -25,15 +33,16 @@ AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *d
       fDeltPhi[i]=df[i];
     }
   }
-  else {
-    fTh = 0;
-    fPhi = 0;
-    fDeltPhi = 0;
-  }
 }
 
 //______________________________________________________________________
-AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):TObject(m){
+AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
+  TObject(m),
+  fNtracks(m.fNtracks),
+  fTh(0),
+  fPhi(0),
+  fDeltPhi(0)
+{
   // copy constructor
 
   Duplicate(m);
index 3b428dc..4557eb9 100644 (file)
 
 /*
 $Log$
+Revision 1.4  2006/08/08 14:20:49  jgrosseo
+Update to shuttle classes (Alberto)
+
+- Possibility to set the full object's path in the Preprocessor's and
+Shuttle's  Store functions
+- Possibility to extend the object's run validity in the same classes
+("startValidity" and "validityInfinite" parameters)
+- Implementation of the StoreReferenceData function to store reference
+data in a dedicated CDB storage.
+
 Revision 1.3  2006/07/11 12:42:43  jgrosseo
 adding parameters for extended validity range of data produced by preprocessor
 
@@ -83,6 +93,9 @@ ClassImp(AliPreprocessor)
 //______________________________________________________________________________________________
 AliPreprocessor::AliPreprocessor(const char* detector, AliShuttleInterface* shuttle) :
   TNamed(detector, ""),
+  fRun(-1),
+  fStartTime(0),
+  fEndTime(0),
   fShuttle(shuttle)
 {
        SetTitle(Form("AliPreprocessor for %s subdetector.", detector));
index 20bcb68..fc8b805 100644 (file)
@@ -46,6 +46,8 @@ class AliPreprocessor : public TNamed
     UInt_t fEndTime;    // endtime of current run
 
   private:
+    AliPreprocessor(const AliPreprocessor & source);
+    AliPreprocessor & operator=(const AliPreprocessor & source);
     AliShuttleInterface* fShuttle;   // link to Shuttle
 
     ClassDef(AliPreprocessor, 0);
index dd476a8..058b780 100644 (file)
@@ -87,6 +87,7 @@ AliRun::AliRun():
   fPDGDB(0),  //Particle factory object
   fConfigFunction(""),
   fRandom(0),
+  fBaseFileName(""),
   fIsRootGeometry(kFALSE),
   fGeometryFileName(""),
   fTriggerDescriptor(""),
@@ -117,6 +118,7 @@ AliRun::AliRun(const AliRun& arun):
   fPDGDB(0),  //Particle factory object
   fConfigFunction("\0"),
   fRandom(0),
+  fBaseFileName(""),
   fIsRootGeometry(kFALSE),
   fGeometryFileName(""),
   fTriggerDescriptor(""),
@@ -146,6 +148,7 @@ AliRun::AliRun(const char *name, const char *title):
   fPDGDB(TDatabasePDG::Instance()),        //Particle factory object!
   fConfigFunction("Config();"),
   fRandom(new TRandom3()),
+  fBaseFileName(""),
   fIsRootGeometry(kFALSE),
   fGeometryFileName(""),
   fTriggerDescriptor(""),
index 57d1f7e..3626182 100644 (file)
@@ -29,9 +29,36 @@ ClassImp(AliRunTagCuts)
 
 
 //___________________________________________________________________________
-AliRunTagCuts::AliRunTagCuts() {
+AliRunTagCuts::AliRunTagCuts() :
+  TObject(),
+  fAliceRunId(-1),                  
+  fAliceRunIdFlag(kFALSE),              
+  fAliceMagneticField(-1.),          
+  fAliceMagneticFieldFlag(kFALSE),      
+  fAliceRunStartTimeMin(-1),        
+  fAliceRunStartTimeMax(-1),        
+  fAliceRunStartTimeFlag(kFALSE),       
+  fAliceRunStopTimeMin(-1),         
+  fAliceRunStopTimeMax(-1),         
+  fAliceRunStopTimeFlag(kFALSE),        
+  fAlirootVersion(""),              
+  fAlirootVersionFlag(kFALSE),          
+  fRootVersion(""),                 
+  fRootVersionFlag(kFALSE),             
+  fGeant3Version(""),               
+  fGeant3VersionFlag(kFALSE),           
+  fAliceRunQuality(0),             
+  fAliceRunQualityFlag(kFALSE),         
+  fAliceBeamEnergy(-1),             
+  fAliceBeamEnergyFlag(kFALSE),         
+  fAliceBeamType(""),               
+  fAliceBeamTypeFlag(kFALSE),           
+  fAliceCalibrationVersion(-1),    
+  fAliceCalibrationVersionFlag(kFALSE),
+  fAliceDataType(-1),                
+  fAliceDataTypeFlag(kFALSE)
+{
   //Default constructor which calls the Reset method.
-  Reset();
 }
 
 //___________________________________________________________________________
index 5f57fd5..28aee26 100644 (file)
 ClassImp(AliStrLine)
 
 //________________________________________________________
-AliStrLine::AliStrLine() {
+AliStrLine::AliStrLine() :
+  TObject(),
+  fTpar(0),
+  fDebug(0)
+ {
   // Default constructor
   for(Int_t i=0;i<3;i++) {
     fP0[i] = 0.;
     fCd[i] = 0.;
   }
-  fTpar = 0.;
-  SetDebug();
 }
 
 //________________________________________________________
-AliStrLine::AliStrLine(Double_t *point, Double_t *cd,Bool_t twopoints) {
+AliStrLine::AliStrLine(Double_t *point, Double_t *cd,Bool_t twopoints) :
+  TObject(),
+  fTpar(0),
+  fDebug(0)
+{
   // Standard constructor
   // if twopoints is true:  point and cd are the 3D coordinates of
   //                        two points defininig the straight line
index 8bceacf..d334489 100644 (file)
@@ -45,7 +45,9 @@ TChain *AliTagAnalysis::fgChain = 0;
 //___________________________________________________________________________
 AliTagAnalysis::AliTagAnalysis(): 
   TObject(),
-  ftagresult(0)
+  ftagresult(0x0),
+  fTagDirName(),
+  fChain(0x0)
 {
   //Default constructor for a AliTagAnalysis
 }
index f9b3241..8ab0c17 100644 (file)
@@ -47,6 +47,10 @@ class AliTagAnalysis : public TObject {
     
   static TChain *fgChain; //tag chain 
   TChain *fChain; //tag chain 
+
+ private:
+  AliTagAnalysis(const AliTagAnalysis & source);
+  AliTagAnalysis & operator=(const AliTagAnalysis & source);
        
   ClassDef(AliTagAnalysis,0)  
 };
index 47ea074..92b2b15 100644 (file)
 ClassImp(AliTrackPointArray)
 
 //______________________________________________________________________________
-AliTrackPointArray::AliTrackPointArray()
+AliTrackPointArray::AliTrackPointArray() :
+  TObject(),
+  fNPoints(0),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fSize(0),
+  fCov(0),
+  fVolumeID(0)
 {
-  fNPoints = fSize = 0;
-  fX = fY = fZ = 0;
-  fVolumeID = 0;
-  fCov = 0;
 }
 
 //______________________________________________________________________________
 AliTrackPointArray::AliTrackPointArray(Int_t npoints):
-  fNPoints(npoints)
+  TObject(),
+  fNPoints(npoints),
+  fX(new Float_t[npoints]),
+  fY(new Float_t[npoints]),
+  fZ(new Float_t[npoints]),
+  fSize(6*npoints),
+  fCov(new Float_t[fSize]),
+  fVolumeID(new UShort_t[npoints])
 {
   // Constructor
   //
-  fSize = 6*npoints;
-  fX = new Float_t[npoints];
-  fY = new Float_t[npoints];
-  fZ = new Float_t[npoints];
-  fVolumeID = new UShort_t[npoints];
-  fCov = new Float_t[fSize];
 }
 
 //______________________________________________________________________________
 AliTrackPointArray::AliTrackPointArray(const AliTrackPointArray &array):
-  TObject(array)
+  TObject(array),
+  fNPoints(array.fNPoints),
+  fX(new Float_t[fNPoints]),
+  fY(new Float_t[fNPoints]),
+  fZ(new Float_t[fNPoints]),
+  fSize(array.fSize),
+  fCov(new Float_t[fSize]),
+  fVolumeID(new UShort_t[fNPoints])
 {
   // Copy constructor
   //
-  fNPoints = array.fNPoints;
-  fSize = array.fSize;
-  fX = new Float_t[fNPoints];
-  fY = new Float_t[fNPoints];
-  fZ = new Float_t[fNPoints];
-  fVolumeID = new UShort_t[fNPoints];
-  fCov = new Float_t[fSize];
   memcpy(fX,array.fX,fNPoints*sizeof(Float_t));
   memcpy(fY,array.fY,fNPoints*sizeof(Float_t));
   memcpy(fZ,array.fZ,fNPoints*sizeof(Float_t));
@@ -150,18 +155,26 @@ Bool_t AliTrackPointArray::HasVolumeID(UShort_t volid) const
 ClassImp(AliTrackPoint)
 
 //______________________________________________________________________________
-AliTrackPoint::AliTrackPoint()
+AliTrackPoint::AliTrackPoint() :
+  TObject(),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fVolumeID(0)
 {
   // Default constructor
   //
-  fX = fY = fZ = 0;
-  fVolumeID = 0;
   memset(fCov,0,6*sizeof(Float_t));
 }
 
 
 //______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid)
+AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid) :
+  TObject(),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fVolumeID(0)
 {
   // Constructor
   //
@@ -170,7 +183,12 @@ AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov
 }
 
 //______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid)
+AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid) :
+  TObject(),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fVolumeID(0)
 {
   // Constructor
   //
@@ -180,7 +198,11 @@ AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t vo
 
 //______________________________________________________________________________
 AliTrackPoint::AliTrackPoint(const AliTrackPoint &p):
-  TObject(p)
+  TObject(p),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fVolumeID(0)
 {
   // Copy constructor
   //
index 68f67fa..75d1601 100644 (file)
@@ -34,6 +34,7 @@ const AliMagF *AliTracker::fgkFieldMap=0;
 ClassImp(AliTracker)
 
 AliTracker::AliTracker():
+  TObject(),
   fX(0),
   fY(0),
   fZ(0),
@@ -47,6 +48,23 @@ AliTracker::AliTracker():
   if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
 }
 
+//__________________________________________________________________________
+AliTracker::AliTracker(const AliTracker &atr):
+  TObject(atr),
+  fX(atr.fX),
+  fY(atr.fY),
+  fZ(atr.fZ),
+  fSigmaX(atr.fSigmaX),
+  fSigmaY(atr.fSigmaY),
+  fSigmaZ(atr.fSigmaZ)
+{
+  //--------------------------------------------------------------------
+  // The default constructor.
+  //--------------------------------------------------------------------
+  if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
+}
+
+//__________________________________________________________________________
 void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
   //--------------------------------------------------------------------
   //This passes the field map to the reconstruction.
index f843908..12a468c 100644 (file)
@@ -22,13 +22,10 @@ class AliTrackPoint;
 class AliTracker : public TObject {
 public:
 
-  enum {kTrackInward, kTrackBack, kTrackRefit} Propagation_t; //type of propagation
+  enum Propagation_t {kTrackInward, kTrackBack, kTrackRefit}; //type of propagation
   
   AliTracker();
-  AliTracker(const AliTracker &atr): TObject(atr)
-    {Fatal("Copy ctor","Not Implemented!\n");}
-  // AliTracker & operator=(const AliTracker &)
-  //  {Fatal("= op","Not Implemented\n");return *this;}
+  AliTracker(const AliTracker &atr);
   virtual ~AliTracker(){}
   virtual Int_t Clusters2Tracks(AliESD *event)=0;
   virtual Int_t PropagateBack(AliESD *event)=0;
index c33420e..28d5e35 100644 (file)
@@ -43,20 +43,34 @@ private:
   ClassDef(AliV0vertexer,1)  // V0 verterxer 
 };
 
-inline AliV0vertexer::AliV0vertexer() {
-  fChi2max=33.; 
-  fDNmin=0.015; fDPmin=0.015;
-  fDCAmax=0.01; fCPAmax=0.025; 
-  fRmin=0.5;    fRmax=2.5; 
-  fX=fY=fZ=0.;
+inline AliV0vertexer::AliV0vertexer() :
+  TObject(),
+  fChi2max(33.), 
+  fDNmin(0.015),
+  fDPmin(0.015),
+  fDCAmax(0.01),
+  fCPAmax(0.025), 
+  fRmin(0.5),
+  fRmax(2.5), 
+  fX(0),
+  fY(0),
+  fZ(0)
+{
 }
 
-inline AliV0vertexer::AliV0vertexer(const Double_t cuts[7]) {
-  fChi2max=cuts[0]; 
-  fDNmin=cuts[1];   fDPmin=cuts[2];
-  fDCAmax=cuts[3];  fCPAmax=cuts[4];
-  fRmin=cuts[5];    fRmax=cuts[6]; 
-  fX=fY=fZ=0.;
+inline AliV0vertexer::AliV0vertexer(const Double_t cuts[7]) :
+  TObject(),
+  fChi2max(cuts[0]), 
+  fDNmin(cuts[1]),
+  fDPmin(cuts[2]),
+  fDCAmax(cuts[3]),
+  fCPAmax(cuts[4]),
+  fRmin(cuts[5]),
+  fRmax(cuts[6]), 
+  fX(0),
+  fY(0),
+  fZ(0)
+{
 }
 
 inline void AliV0vertexer::SetCuts(const Double_t cuts[7]) {
index fbdb2ab..be23abf 100644 (file)
 ClassImp(AliVertex)
 
 //--------------------------------------------------------------------------
-AliVertex::AliVertex() : TNamed() {
+AliVertex::AliVertex() :
+  TNamed(),
+  fSigma(0),
+  fNContributors(0)
+{
 //
 // Default Constructor, set everything to 0
 //
   for(Int_t k=0;k<3;k++) fPosition[k]   = 0;
-  fSigma = 0;
-  fNContributors=0;
 }
 
 //--------------------------------------------------------------------------
 AliVertex::AliVertex(Double_t position[3],Double_t dispersion,
-               Int_t nContributors): TNamed() {
+                    Int_t nContributors):
+  TNamed(),
+  fSigma(dispersion),
+  fNContributors(nContributors)
+{
   //
   // Standard Constructor
   //
 
   for(Int_t k=0;k<3;k++) fPosition[k]   = position[k];
-  fSigma         = dispersion;
-  fNContributors = nContributors;
   SetName("BaseVertex");
 
 }
 
 //--------------------------------------------------------------------------
-AliVertex::AliVertex(const AliVertex &source): TNamed(source) {
+AliVertex::AliVertex(const AliVertex &source):
+  TNamed(source),
+  fSigma(source.GetDispersion()),
+  fNContributors(source.GetNContributors())
+{
   //
   // Copy constructor
   //
   for(Int_t i=0;i<3;i++)fPosition[i] = source.fPosition[i];
-  fSigma = source.GetDispersion();
-  fNContributors = source.GetNContributors();
 }
 
 //--------------------------------------------------------------------------
index d3690d9..c5db58e 100644 (file)
@@ -46,7 +46,9 @@ AliVertexer::AliVertexer(const AliVertexer &vtxr) :
   TObject(vtxr),
   fCurrentVertex(vtxr.fCurrentVertex),
   fFirstEvent(vtxr.fFirstEvent),
-  fLastEvent(vtxr.fLastEvent)
+  fLastEvent(vtxr.fLastEvent),
+  fDebug(vtxr.fDebug),
+  fMult(vtxr.fMult)
 {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
index 733ac47..8802526 100644 (file)
@@ -42,11 +42,14 @@ AliVertexerTracks::AliVertexerTracks():
 TObject(),
 fVert(),
 fCurrentVertex(0),
+fMinTracks(2),
+fMinITSClusters(5),
 fTrkArray(),
 fTrksToSkip(0),
 fNTrksToSkip(0),
 fDCAcut(0),
 fAlgo(1),
+fNSigma(3),
 fDebug(0)
 {
 //
@@ -63,11 +66,14 @@ AliVertexerTracks::AliVertexerTracks(Double_t xStart, Double_t yStart):
 TObject(),
 fVert(),
 fCurrentVertex(0),
+fMinTracks(2),
+fMinITSClusters(5),
 fTrkArray(),
 fTrksToSkip(0),
 fNTrksToSkip(0),
 fDCAcut(0),
 fAlgo(1),
+fNSigma(3),
 fDebug(0)
 {
 //
index 23764b3..0ee8b81 100644 (file)
@@ -102,6 +102,9 @@ class AliVertexerTracks : public TObject {
   // fAlgo=5 finds the average point among DCA points of all pairs of tracks
   //         approximated as straight lines 
 
+ private:
+  AliVertexerTracks(const AliVertexerTracks & source);
+  AliVertexerTracks & operator=(const AliVertexerTracks & source);
 
   ClassDef(AliVertexerTracks,4) // 3D Vertexing with ESD tracks 
 };
index 61e6c76..049a66f 100644 (file)
@@ -33,7 +33,8 @@ ClassImp(AliXMLCollection)
 //___________________________________________________________________________
   AliXMLCollection::AliXMLCollection() :
     TObject(),
-    fCollectionName(0)
+    fCollectionName(),
+    fout()
 {
   //Default constructor
 }
index 346d0ef..ec145f2 100644 (file)
@@ -271,6 +271,7 @@ TTreeStream::TTreeStream(const char *treename):
   fBranches(0),
   fTree(new TTree(treename, treename)),
   fCurrentIndex(0),
+  fId(0),
   fNextName(),
   fNextNameCounter(),
   fStatus(0)