Cleanuo Effc++ warnings (Sasha)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Sep 2006 10:55:11 +0000 (10:55 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Sep 2006 10:55:11 +0000 (10:55 +0000)
26 files changed:
MUON/AliMUONClusterDrawAZ.cxx
MUON/AliMUONClusterDrawAZ.h
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.cxx
MUON/AliMUONDetElement.cxx
MUON/AliMUONDetElement.h
MUON/AliMUONEventRecoCombi.cxx
MUON/AliMUONEventRecoCombi.h
MUON/AliMUONHitForRec.cxx
MUON/AliMUONPixel.cxx
MUON/AliMUONRecoCheck.cxx
MUON/AliMUONRecoCheck.h
MUON/AliMUONRecoTrack.cxx
MUON/AliMUONRecoTrack.h
MUON/AliMUONSegment.cxx
MUON/AliMUONSegment.h
MUON/AliMUONTrack.cxx
MUON/AliMUONTrackHit.cxx
MUON/AliMUONTrackK.cxx
MUON/AliMUONTrackK.h
MUON/AliMUONTrackParam.cxx
MUON/AliMUONTrackReconstructor.cxx
MUON/AliMUONTrackReconstructor.h

index 19210ed..f0c7d5e 100644 (file)
@@ -51,23 +51,34 @@ ClassImp(AliMUONClusterDrawAZ)
  
 //_____________________________________________________________________________
 AliMUONClusterDrawAZ::AliMUONClusterDrawAZ()
-  : TObject()
+  : TObject(),
+    fData(0x0),
+    fFind(0x0),
+    fnMu(0),
+    fEvent(0),
+    fChamber(0),
+    fidDE(0),
+    fDebug(0),
+    fModif(0)
 {
 /// Default constructor
-  fFind = NULL; fData = NULL;
   for (Int_t i=0; i<4; i++) fHist[i] = NULL;
 }
 
 //_____________________________________________________________________________
 AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(AliMUONClusterFinderAZ *clusFinder)
-  : TObject()
+  : TObject(),
+    fData(0x0),
+    fFind(clusFinder),
+    fnMu(0),
+    fEvent(0),
+    fChamber(0),
+    fidDE(0),
+    fDebug(1),
+    fModif(0)
 {
 /// Constructor
-  fFind = clusFinder;
   for (Int_t i=0; i<4; i++) fHist[i] = NULL;
-  fDebug = 1; 
-  fEvent = fChamber = fidDE = 0;
-  fModif = 0; //0; 
   Init();
 }
 
@@ -78,28 +89,6 @@ AliMUONClusterDrawAZ::~AliMUONClusterDrawAZ()
 }
 
 //_____________________________________________________________________________
-AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ&  
-AliMUONClusterDrawAZ::operator=(const AliMUONClusterDrawAZ& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-  return *this;  
-}    
-
-//_____________________________________________________________________________
 void AliMUONClusterDrawAZ::Init()
 {
 /// Initialization
index 629a2fb..3c3c0b0 100644 (file)
@@ -34,10 +34,6 @@ public:
   void     ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } // reset muons
   void     UpdateCluster(Int_t npad); // update cluster after removing non-overlapped pads
 
-protected:
-  AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
-  AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
-
 private:
   AliMUONData *fData; //!<  pointer to muon data container
   AliMUONClusterFinderAZ* fFind; //!<  pointer to ClusterFinder
@@ -52,6 +48,8 @@ private:
 
   // Functions
 
+  AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
+  AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
   void   Init(); // initialization
   void   ModifyHistos(); // modify histograms
   void   DrawHits(); // draw simulated and reconstructed hits
index 5f28e4f..1bb202f 100644 (file)
@@ -53,7 +53,16 @@ ClassImp(AliMUONClusterFinderAZ)
 
 //_____________________________________________________________________________
 AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw)
-  : AliMUONClusterFinderVS()
+  : AliMUONClusterFinderVS(),
+    fZpad(0),
+    fNpar(0),
+    fQtot(0),
+    fReco(1),
+    fCathBeg(0),
+    fDraw(0x0),
+    fPixArray(0x0),
+    fnCoupled(0),
+    fDebug(0)
 {
 /// Constructor
   fnPads[0]=fnPads[1]=0;
@@ -72,17 +81,12 @@ AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw)
 
   fSegmentation[1] = fSegmentation[0] = 0x0; 
 
-  fZpad = 0;
-  fQtot = 0;
-  fPadBeg[0] = fPadBeg[1] = fCathBeg = fNpar = fnCoupled = 0;
+  fPadBeg[0] = fPadBeg[1] = 0;
 
   if (!fgMinuit) fgMinuit = new TMinuit(8);
   if (!fgClusterFinder) fgClusterFinder = this;
   fPixArray = new TObjArray(20); 
 
-  fDebug = 0; //0;
-  fReco = 1;
-  fDraw = 0x0;
   if (draw) {
     fDebug = 1;
     fReco = 0;
@@ -92,15 +96,6 @@ AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw)
 }
 
 //_____________________________________________________________________________
-AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs)
-  : AliMUONClusterFinderVS(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-//_____________________________________________________________________________
 AliMUONClusterFinderAZ::~AliMUONClusterFinderAZ()
 {
 /// Destructor
@@ -2474,19 +2469,6 @@ void AliMUONClusterFinderAZ::FindCluster(Int_t *localMax, Int_t iMax)
 }
 
 //_____________________________________________________________________________
-AliMUONClusterFinderAZ&  
-AliMUONClusterFinderAZ::operator=(const AliMUONClusterFinderAZ& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}    
-          
-//_____________________________________________________________________________
 void AliMUONClusterFinderAZ::AddVirtualPad()
 {
 /// Add virtual pad (with small charge) to improve fit for some
index 1cff26b..019ccf7 100644 (file)
@@ -40,11 +40,7 @@ public:
   void SetReco(Int_t iReco) { fReco = iReco; } // set reco flag
   void SetStart(Int_t iCath, Int_t iPad) { fCathBeg = iCath; fPadBeg[0] = fPadBeg[1] = 0; fPadBeg[fCathBeg] = iPad; } // start
  
-protected:
-  AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
-  AliMUONClusterFinderAZ& operator=(const AliMUONClusterFinderAZ& rhs);
-
- private:
+private:
   // Some constants
   static const Int_t fgkDim = 10000; ///< array size
   static const Double_t fgkCouplMin; ///< threshold on coupling 
@@ -73,6 +69,8 @@ protected:
 
   // Functions
 
+  AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
+  AliMUONClusterFinderAZ& operator=(const AliMUONClusterFinderAZ& rhs);
   void   AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
   Bool_t Overlap(Int_t cath, AliMUONDigit *dig); // check if the pad from one cathode overlaps with a pad in the cluster on the other cathode
   Bool_t Overlap(Float_t *xy1, Int_t iPad, Float_t *xy12, Int_t iSkip); // check if pads xy1 and iPad overlap and return overlap area
index b1e1748..a73d331 100644 (file)
@@ -47,14 +47,23 @@ void fcnCombiS2(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t if
 ClassImp(AliMUONClusterFinderVS)
 
 AliMUONClusterFinderVS::AliMUONClusterFinderVS()
-  : TObject()
+  : TObject(),
+    fInput(AliMUONClusterInput::Instance()),
+    fDeclusterFlag(0),
+    fClusterSize(0),
+    fNperMax(0),
+    fGhostChi2Cut(1e6),
+    fNPeaks(0),
+    fNRawClusters(0),
+    fRawClusters(0x0),
+    fZPlane(0.),
+    fSector(0),
+    fFitStat(0)
 {
 /// Default constructor
-    fInput=AliMUONClusterInput::Instance();
     fDigitMap[0] = 0;
     fDigitMap[1] = 0;
     fTrack[0]=fTrack[1]=-1;
-    fGhostChi2Cut = 1e6; // nothing done by default
     fSeg2[0]    = 0;
     fSeg2[1]    = 0;
 
@@ -64,7 +73,6 @@ AliMUONClusterFinderVS::AliMUONClusterFinderVS()
       }
     } 
     fRawClusters = new TClonesArray("AliMUONRawCluster",1000);
-    fNRawClusters = 0;
 }
  //____________________________________________________________________________
 AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
@@ -79,12 +87,6 @@ AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
    }
 }
 
-AliMUONClusterFinderVS::AliMUONClusterFinderVS(const AliMUONClusterFinderVS & clusterFinder):TObject(clusterFinder)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
 //____________________________________________________________________________
 void AliMUONClusterFinderVS::ResetRawClusters()
 {
index aa405f6..914dee2 100644 (file)
@@ -62,9 +62,6 @@ class AliMUONClusterFinderVS : public TObject
     void ResetRawClusters();
 
  protected:
-    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
-//  Assignment operator
-    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
 
     AliMUONClusterInput*          fInput;        //!< AliMUONClusterInput instance
     AliMUONDigitMapA1*            fDigitMap[2];  ///< Hit Maps for cathode 1 and 2
@@ -111,7 +108,11 @@ class AliMUONClusterFinderVS : public TObject
     Int_t                    fTrack[2];        ///< Only digits with main contributions from these tracks are
     // considered 
     
-    //  Return pointer to raw clusters    
+ private:
+    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
+//  Assignment operator
+    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
+
     ClassDef(AliMUONClusterFinderVS,2) //Class for clustering and reconstruction of space points
       };
 #endif
index e053dd5..3120094 100644 (file)
@@ -48,7 +48,10 @@ ClassImp(AliMUONClusterInput)
 
 AliMUONClusterInput::AliMUONClusterInput()
   : TObject(),
+    fNseg(0),
+    fChamber(0),
     fCluster(0),
+    fZ(0.),
     fChargeCorrel(1.),
     fDetElemId(0)
   
@@ -93,13 +96,6 @@ AliMUONClusterInput::~AliMUONClusterInput()
     fgMathieson = 0;
 }
 
-AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
 void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
 {
   // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
index f0257eb..1298587 100644 (file)
@@ -41,7 +41,15 @@ ClassImp(AliMUONDetElement) // Class implementation in ROOT context
 
 //_________________________________________________________________________
 AliMUONDetElement::AliMUONDetElement()
-  : TObject()
+  : TObject(),
+    fidDE(0),
+    fIndex(0),
+    fChamber(0),
+    fZ(0.),
+    fNHitsForRec(0),
+    fRawClus(0x0),
+    fHitsForRec(0x0),
+    fRecModel(0x0)
 {
 /// Default constructor
   for (Int_t i = 0; i < 2; i++) {
@@ -49,23 +57,25 @@ AliMUONDetElement::AliMUONDetElement()
     fDigits[i] = NULL;
     fSeg[i] = NULL;
   }
-  fRawClus = fHitsForRec = NULL;
-  fRecModel = NULL;
 } 
 
 //_________________________________________________________________________
 AliMUONDetElement::AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel) 
-  : TObject()
+  : TObject(),
+    fidDE(idDE),
+    fIndex(0),
+    fChamber(idDE / 100 - 1),
+    fZ(0.),
+    fNHitsForRec(0),
+    fRawClus(0x0),
+    fHitsForRec(0x0),
+    fRecModel(recModel)
 {
 /// Constructor
-  fidDE = idDE;
-  fChamber = fidDE / 100 - 1;
   fDigits[0] = new TObjArray(10);
   fDigits[1] = new TObjArray(10);
   fRawClus = new TObjArray(10);
   fHitsForRec = new TClonesArray("AliMUONHitForRec",10);
-  fNHitsForRec = 0;
-  fRecModel = recModel;
   AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON");
   AliMUONSegmentation *pSegmentation = pMUON->GetSegmentation();
   fSeg[0] = pSegmentation->GetModuleSegmentation(fChamber, 0);
@@ -90,25 +100,6 @@ AliMUONDetElement::~AliMUONDetElement()
 }
 
 //_________________________________________________________________________
-AliMUONDetElement::AliMUONDetElement (const AliMUONDetElement& rhs)
-  : TObject(rhs)
-{
-/// Copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-//________________________________________________________________________
-AliMUONDetElement & AliMUONDetElement::operator = (const AliMUONDetElement& rhs)
-{
-/// Assignement operator
-
-  if (this == &rhs) return *this;
-  AliFatal( "Not implemented.");
-  return *this;
-}
-
-//_________________________________________________________________________
 Int_t AliMUONDetElement::Compare(const TObject* detElem) const
 {
 /// "Compare" function to sort in Z (towards interaction point)
index 43fdfde..ac97f9e 100644 (file)
@@ -28,8 +28,6 @@ class AliMUONDetElement : public TObject
 
   AliMUONDetElement();
   AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel); // constructor
-  AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
-  AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
   virtual ~AliMUONDetElement(); // Destructor
 
   Int_t IdDE(void) const { return fidDE; } // det. elem. ID
@@ -56,8 +54,6 @@ class AliMUONDetElement : public TObject
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* detElem) const; // "Compare" function for sorting
 
- protected:
-
  private:
  
   Int_t fidDE; ///< det. elem. ID
@@ -74,6 +70,8 @@ class AliMUONDetElement : public TObject
   AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
 
   // Functions
+  AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
+  AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
 
   ClassDef(AliMUONDetElement,0) // detection element object
     };
index 7be54ec..b6b0619 100644 (file)
@@ -45,14 +45,17 @@ AliMUONEventRecoCombi* AliMUONEventRecoCombi::fgRecoCombi = 0;
 ClassImp(AliMUONEventRecoCombi)
 
 //_________________________________________________________________________
-AliMUONEventRecoCombi::AliMUONEventRecoCombi() : TObject()
+  AliMUONEventRecoCombi::AliMUONEventRecoCombi() 
+    : TObject(),
+      fDetElems(0x0),
+      fZ(0x0),
+      fNZ(0),
+      fDEvsZ(0x0)
 {
   // Ctor
 
   fDetElems = new TClonesArray("AliMUONDetElement", 20);
   fZ = new TArrayD(20);
-  fNZ = 0;
-  fDEvsZ = NULL;
 }
 
 //_________________________________________________________________________
@@ -79,27 +82,6 @@ AliMUONEventRecoCombi::~AliMUONEventRecoCombi()
 }
 
 //_________________________________________________________________________
-AliMUONEventRecoCombi::AliMUONEventRecoCombi (const AliMUONEventRecoCombi& rhs)
-  : TObject(rhs)
-{
-  // Protected copy constructor
-  AliFatal("Not implemented.");
-}
-
-//_________________________________________________________________________
-AliMUONEventRecoCombi & AliMUONEventRecoCombi::operator = (const AliMUONEventRecoCombi& rhs)
-{
-  // Protected assignment operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-
-  return *this;
-}
-
-//_________________________________________________________________________
 void AliMUONEventRecoCombi::FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel)
 {
   // Fill event information
index 25cf12f..875a104 100644 (file)
@@ -36,8 +36,6 @@ class AliMUONEventRecoCombi : public TObject
 
  protected:
     AliMUONEventRecoCombi();
-    AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
-    AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
 
  private:
     static AliMUONEventRecoCombi* fgRecoCombi; //!<  singleton instance
@@ -46,6 +44,9 @@ class AliMUONEventRecoCombi : public TObject
     Int_t fNZ; //!<  number of different Z's
     Int_t **fDEvsZ; //!<  list of DE's vs Z-coordinates
 
+    AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
+    AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
+
     ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
       };
 #endif
index 946599c..ae4accd 100644 (file)
@@ -32,17 +32,45 @@ ClassImp(AliMUONHitForRec) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONHitForRec::AliMUONHitForRec()
-  : TObject()
+  : TObject(),
+    fBendingCoor(0.),
+    fNonBendingCoor(0.),
+    fZ(0.),
+    fBendingReso2(0.),
+    fNonBendingReso2(0.),
+    fChamberNumber(0),
+    fDetElemId(0),
+    fHitNumber(0),
+    fTTRTrack(0),
+    fTrackRefSignal(0),
+    fIndexOfFirstSegment(0),
+    fNSegments(0),
+    fFirstTrackHitPtr(0x0),
+    fLastTrackHitPtr(0x0),
+    fNTrackHits(0)
 {
 /// Default Constructor
  
-    fFirstTrackHitPtr = 0;
-    fLastTrackHitPtr = 0;
 }
 
   //__________________________________________________________________________
 AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
-  : TObject()
+  : TObject(),
+    fBendingCoor(theGhit->Y()),
+    fNonBendingCoor(theGhit->X()),
+    fZ(theGhit->Z()),
+    fBendingReso2(0.),
+    fNonBendingReso2(0.),
+    fChamberNumber(0),
+    fDetElemId(0),
+    fHitNumber(0),
+    fTTRTrack(0),
+    fTrackRefSignal(0),
+    fIndexOfFirstSegment(-1),
+    fNSegments(0),
+    fFirstTrackHitPtr(0x0),
+    fLastTrackHitPtr(0x0),
+    fNTrackHits(0)
 {
 /// Constructor for AliMUONHitForRec from a track ref. hit.
 /// Fills the bending, non bending, and Z coordinates,
@@ -50,20 +78,12 @@ AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
 /// the track number (track ref. and not TH),
 /// and the chamber number (0...).
 
-  fBendingCoor = theGhit->Y();
-  fNonBendingCoor = theGhit->X();
-  fZ = theGhit->Z();
   // fTrack = theGhit->fTrack; ?????????
   fDetElemId = theGhit->UserId();
   if (fDetElemId) fChamberNumber = fDetElemId / 100 - 1;
   else fChamberNumber = AliMUONConstants::ChamberNumber(fZ);
   // other fields will be updated in
-  // AliMUONEventReconstructor::NewHitForRecFromTrackRef,
-  // except the following ones
-  fIndexOfFirstSegment = -1;
-  fNSegments = 0;
-  fFirstTrackHitPtr = fLastTrackHitPtr = NULL;
-  fNTrackHits = 0;
+  // AliMUONEventReconstructor::NewHitForRecFromTrackRef
   return;
 }
 
@@ -85,47 +105,52 @@ AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
 
   //__________________________________________________________________________
 AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* theRawCluster)
-  : TObject()
+  : TObject(),
+    fBendingCoor(theRawCluster->GetY(0)),
+    fNonBendingCoor(theRawCluster->GetX(0)),
+    fZ(0.),
+    fBendingReso2(0.),
+    fNonBendingReso2(0.),
+    fChamberNumber(0),
+    fDetElemId(theRawCluster->GetDetElemId()),
+    fHitNumber(0),
+    fTTRTrack(-1),
+    fTrackRefSignal(-1),
+    fIndexOfFirstSegment(-1),
+    fNSegments(0),
+    fFirstTrackHitPtr(0x0),
+    fLastTrackHitPtr(0x0),
+    fNTrackHits(0)
 {
 /// Constructor for AliMUONHitForRec from a raw cluster.
 /// Fills the bending and non bending coordinates.
 
-  fNonBendingCoor = theRawCluster->GetX(0);
-  fBendingCoor = theRawCluster->GetY(0);
-  fDetElemId = theRawCluster->GetDetElemId();
   // other fields will be updated in
   // AliMUONEventReconstructor::AddHitsForRecFromRawClusters,
-  // except the following ones
-  fTTRTrack = -1;
-  fTrackRefSignal = -1;
-  fIndexOfFirstSegment = -1;
-  fNSegments = 0;
-  fFirstTrackHitPtr = fLastTrackHitPtr = NULL;
-  fNTrackHits = 0;
   return;
 }
 
   //__________________________________________________________________________
 AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& theMUONHitForRec)
-  :  TObject(theMUONHitForRec)
+  : TObject(theMUONHitForRec),
+    fBendingCoor(theMUONHitForRec.fBendingCoor),
+    fNonBendingCoor(theMUONHitForRec.fNonBendingCoor),
+    fZ(theMUONHitForRec.fZ),
+    fBendingReso2(theMUONHitForRec.fBendingReso2),
+    fNonBendingReso2(theMUONHitForRec.fNonBendingReso2),
+    fChamberNumber(theMUONHitForRec.fChamberNumber),
+    fDetElemId(theMUONHitForRec.fDetElemId),
+    fHitNumber(theMUONHitForRec.fHitNumber),
+    fTTRTrack(theMUONHitForRec.fTTRTrack),
+    fTrackRefSignal(theMUONHitForRec.fTrackRefSignal),
+    fIndexOfFirstSegment(theMUONHitForRec.fIndexOfFirstSegment),
+    fNSegments(theMUONHitForRec.fNSegments),
+    fFirstTrackHitPtr(theMUONHitForRec.fFirstTrackHitPtr),
+    fLastTrackHitPtr(theMUONHitForRec.fLastTrackHitPtr),
+    fNTrackHits(theMUONHitForRec.fNTrackHits)
 {
 /// Copy constructor
 
-  fBendingCoor = theMUONHitForRec.fBendingCoor;
-  fNonBendingCoor = theMUONHitForRec.fNonBendingCoor;
-  fZ = theMUONHitForRec.fZ;
-  fBendingReso2 = theMUONHitForRec.fBendingReso2;
-  fNonBendingReso2 = theMUONHitForRec.fNonBendingReso2;
-  fChamberNumber = theMUONHitForRec.fChamberNumber;
-  fDetElemId = theMUONHitForRec.fDetElemId;
-  fHitNumber = theMUONHitForRec.fHitNumber;
-  fTTRTrack = theMUONHitForRec.fTTRTrack;
-  fTrackRefSignal = theMUONHitForRec.fTrackRefSignal;
-  fIndexOfFirstSegment = theMUONHitForRec.fIndexOfFirstSegment;
-  fNSegments = theMUONHitForRec.fNSegments;
-  fFirstTrackHitPtr = theMUONHitForRec.fFirstTrackHitPtr;
-  fLastTrackHitPtr = theMUONHitForRec.fLastTrackHitPtr;
-  fNTrackHits = theMUONHitForRec.fNTrackHits;
 }
 
   //__________________________________________________________________________
index b89c3ad..3f1d9ea 100644 (file)
@@ -28,20 +28,22 @@ ClassImp(AliMUONPixel) // Class implementation in ROOT context
 
 //_____________________________________________________________________________
 AliMUONPixel::AliMUONPixel()
-  : TObject()
+  : TObject(),
+    fCharge(0),
+    fFlag(0)
 {
 /// Default constructor
-  fXY[0] = fXY[1] = fSize[0] = fSize[1] = fCharge = 0;
-  fFlag = 0;
+  fXY[0] = fXY[1] = fSize[0] = fSize[1] = 0;
 } 
 
 //_____________________________________________________________________________
 AliMUONPixel::AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge)
-  : TObject()
+  : TObject(),
+    fCharge(charge),
+    fFlag(0)
 {
 /// Constructor
-  fXY[0] = xc; fXY[1] = yc; fSize[0] = wx; fSize[1] = wy; fCharge = charge;
-  fFlag = 0;
+  fXY[0] = xc; fXY[1] = yc; fSize[0] = wx; fSize[1] = wy;
 }
 
 //_____________________________________________________________________________
index 5231e76..a68e5b6 100644 (file)
@@ -42,7 +42,14 @@ ClassImp(AliMUONRecoCheck)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
+  AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
+  : TObject(),
+  fRunLoader(0x0),
+  fMUONData(0x0),
+  fMuonTrackRef(0x0),
+  fTrackReco(0x0),
+  fReconstructibleTracks(0),
+  fRecoTracks(0)
 {
 /// Constructor
 
@@ -67,8 +74,6 @@ AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
   fRunLoader->LoadTrackRefs("READ");
   loader->LoadTracks("READ");
 
-  fReconstructibleTracks = 0; 
-  fRecoTracks = 0;
 }
 
 //_____________________________________________________________________________
index 38be774..0d00665 100644 (file)
@@ -45,10 +45,6 @@ public:
                 /// Return reference muon tracks
   TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
 
-protected:
-  AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
-  AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
-
 private:
   
   AliRunLoader* fRunLoader;     ///< alice run loader 
@@ -58,7 +54,10 @@ private:
   Int_t fReconstructibleTracks; ///< number of reconstructible tracks 
   Int_t fRecoTracks;            ///< number of reconstructed tracks 
 
-  ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
+  AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
+  AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
+
+  ClassDef(AliMUONRecoCheck, 0)   //Utility class to check reconstruction
 };
 
 #endif
index d9eb2a5..7d0bb7c 100644 (file)
 ClassImp(AliMUONRecoTrack)
 
 //-------------------------------------------------------------------
+AliMUONRecoTrack::AliMUONRecoTrack() 
+  : TObject(), 
+    fSign(0), 
+    fFlag(0), 
+    fZvr(0.), 
+    fChi2r(0.) 
+{ 
+//Default constructor
+}
+
+//-------------------------------------------------------------------
 AliMUONRecoTrack::AliMUONRecoTrack(Bool_t active)
-  : TObject()
+  : TObject(),
+    fSign(0),
+    fFlag(0),
+    fZvr(0.),
+    fChi2r(0.)
 {
 //Constructor of AliMUONRecoTrack
-   fSign  = 0;
-   fZvr   = 0.0;
-   fChi2r = 0.0;
    if (active) {
        for (Int_t axis=0; axis<3; axis++) {
        fPr[axis] = 0.0;
index fe6e98f..0d15828 100644 (file)
@@ -26,7 +26,7 @@
 class AliMUONRecoTrack : public TObject 
 {
   public:
-    AliMUONRecoTrack() { }
+    AliMUONRecoTrack();
     AliMUONRecoTrack(Bool_t active);
     virtual        ~AliMUONRecoTrack() { }     //desctructor
     Double_t GetChi2r() const {return fChi2r;};
index d7e52f3..fe4710b 100644 (file)
@@ -37,34 +37,47 @@ ClassImp(AliMUONSegment) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONSegment::AliMUONSegment()
-  : TObject()
+  : TObject(),
+    fHitForRecPtr1(0x0),
+    fHitForRecPtr2(0x0),
+    fBendingCoor(0.),
+    fBendingSlope(0.),
+    fBendingCoorReso2(0.),
+    fBendingSlopeReso2(0.),
+    fBendingCoorSlopeReso2(0.),
+    fBendingImpact(0.),
+    fNonBendingCoor(0.),
+    fNonBendingSlope(0.),
+    fNonBendingCoorReso2(0.),
+    fNonBendingSlopeReso2(0.),
+    fNonBendingCoorSlopeReso2(0.),
+    fNonBendingImpact(0.),
+    fZ(0.),
+    fInTrack(kFALSE)
 {
   // Default constructor
-  fHitForRecPtr1 = 0; // pointer to HitForRec in first chamber
-  fHitForRecPtr2 = 0; // pointer to HitForRec in second chamber
-  // Bending plane:
-  fBendingCoor = 0.0; // Coordinate in bending plane
-  fBendingSlope = 0.0; // Slope in bending plane
-  // Covariance in bending plane:
-  fBendingCoorReso2 = 0.0; // Covariance(coordinate C1 in first chamber)
-  fBendingSlopeReso2 = 0.0; // Covariance(slope)
-  fBendingCoorSlopeReso2 = 0.0; // Covariance(C1,slope)
-  fBendingImpact = 0.0; // Impact parameter in bending plane
-  // Non Bending plane:
-  fNonBendingCoor = 0.0; // Coordinate in non bending plane
-  fNonBendingSlope = 0.0; // Slope in non bending plane
-  // Covariance in non bending plane:
-  fNonBendingCoorReso2 = 0.0; // Covariance(coordinate C1 in first chamber)
-  fNonBendingSlopeReso2 = 0.0; // Covariance(slope)
-  fNonBendingCoorSlopeReso2 = 0.0; // Covariance(C1,slope)
-  fZ = 0.0; // z in first plane
-  fNonBendingImpact = 0.0; // Impact parameter in non bending plane
-  fInTrack = kFALSE; // TRUE if segment belongs to one track
+
 }
 
   //__________________________________________________________________________
 AliMUONSegment::AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2)
-  : TObject()
+  : TObject(),
+    fHitForRecPtr1(Hit1),
+    fHitForRecPtr2(Hit2),
+    fBendingCoor(Hit1->GetBendingCoor()),
+    fBendingSlope(0.),
+    fBendingCoorReso2(Hit1->GetBendingReso2()),
+    fBendingSlopeReso2(0.),
+    fBendingCoorSlopeReso2(0.),
+    fBendingImpact(0.),
+    fNonBendingCoor(Hit1->GetNonBendingCoor()),
+    fNonBendingSlope(0.),
+    fNonBendingCoorReso2(Hit1->GetNonBendingReso2()),
+    fNonBendingSlopeReso2(0.),
+    fNonBendingCoorSlopeReso2(0.),
+    fNonBendingImpact(0.),
+    fZ(Hit1->GetZ()),
+    fInTrack(kFALSE)
 {
   // Constructor for AliMUONSegment from two HitForRec's,
   // one, in the first chamber of the station, pointed to by "Hit1",
@@ -75,51 +88,23 @@ AliMUONSegment::AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2)
   // in bending and non bending planes.
   // Puts the "fInTrack" flag to "kFALSE".
   Double_t dz;
-  // pointers to HitForRec's
-  fHitForRecPtr1 = Hit1;
-  fHitForRecPtr2 = Hit2;
   dz = Hit1->GetZ() - Hit2->GetZ();
-  fZ = Hit1->GetZ();
+
   // bending plane
-  fBendingCoor = Hit1->GetBendingCoor();
   fBendingSlope = (fBendingCoor - Hit2->GetBendingCoor()) / dz;
   fBendingImpact = fBendingCoor - Hit1->GetZ() * fBendingSlope;
-  fBendingCoorReso2 = Hit1->GetBendingReso2();
   fBendingSlopeReso2 = ( Hit1->GetBendingReso2() +
                         Hit2->GetBendingReso2() ) / dz / dz;
   fBendingCoorSlopeReso2 = Hit1->GetBendingReso2() / dz;
   // non bending plane
-  fNonBendingCoor = Hit1->GetNonBendingCoor();
   fNonBendingSlope = (fNonBendingCoor - Hit2->GetNonBendingCoor()) / dz;
   fNonBendingImpact = fNonBendingCoor - Hit1->GetZ() * fNonBendingSlope;
-  fNonBendingCoorReso2 = Hit1->GetNonBendingReso2();
   fNonBendingSlopeReso2 = ( Hit1->GetNonBendingReso2() +
                            Hit2->GetNonBendingReso2() ) / dz / dz;
   fNonBendingCoorSlopeReso2 = Hit1->GetNonBendingReso2() / dz;
-  // "fInTrack" flag to "kFALSE"
-  fInTrack = kFALSE;
   return;
 }
 
-AliMUONSegment::AliMUONSegment (const AliMUONSegment& theMUONSegment)
-  : TObject(theMUONSegment)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-AliMUONSegment & AliMUONSegment::operator=(const AliMUONSegment& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
   //__________________________________________________________________________
 Int_t AliMUONSegment::Compare(const TObject* Segment) const
 {
index 7e0b472..2405f49 100644 (file)
@@ -56,10 +56,6 @@ class AliMUONSegment : public TObject
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* Segment) const; // "Compare" function for sorting
 
- protected:
-  AliMUONSegment (const AliMUONSegment& AliMUONSegment); // copy constructor
-  AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
-
  private:
   AliMUONHitForRec* fHitForRecPtr1; ///< pointer to HitForRec in first chamber
   AliMUONHitForRec* fHitForRecPtr2; ///< pointer to HitForRec in second chamber
@@ -82,6 +78,9 @@ class AliMUONSegment : public TObject
   Double_t fZ;                ///< Z of the segment
   Bool_t fInTrack; ///< TRUE if segment belongs to one track
   
+  AliMUONSegment (const AliMUONSegment& AliMUONSegment); // copy constructor
+  AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
+
   ClassDef(AliMUONSegment, 1) // Segment for reconstruction in ALICE dimuon spectrometer
 };
        
index f096d8e..1d552e6 100644 (file)
@@ -58,26 +58,44 @@ ClassImp(AliMUONTrack) // Class implementation in ROOT context
 
 //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack()
-  : TObject() 
+  : TObject(),
+    fTrackReconstructor(0x0),
+    fTrackParamAtVertex(),
+    fTrackParamAtHit(0x0),
+    fHitForRecAtHit(0x0),
+    fTrackHitsPtr(0x0),
+    fNTrackHits(0),
+    fFitMCS(0),
+    fFitNParam(0),
+    fFitStart(0),
+    fFitFMin(-1.),
+    fMatchTrigger(kFALSE),
+    fChi2MatchTrigger(0.),
+    fTrackID(0)
 {
   // Default constructor
   fgFitter = 0;
-  fTrackReconstructor = 0;
-  fTrackHitsPtr = NULL;
-  fTrackParamAtHit = NULL;
-  fHitForRecAtHit = NULL;
-  fTrackID = 0;
 }
 
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONTrackReconstructor* TrackReconstructor)
-  : TObject()
+  : TObject(),
+    fTrackReconstructor(TrackReconstructor),
+    fTrackParamAtVertex(),
+    fTrackParamAtHit(0x0),
+    fHitForRecAtHit(0x0),
+    fTrackHitsPtr(new TObjArray(10)),
+    fNTrackHits(0),
+    fFitMCS(0),
+    fFitNParam(3),
+    fFitStart(1),
+    fFitFMin(-1.),
+    fMatchTrigger(kFALSE),
+    fChi2MatchTrigger(0.),
+    fTrackID(0)
 {
   // Constructor from two Segment's
-  fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
-  // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
-  fTrackHitsPtr = new TObjArray(10);
-  fNTrackHits = 0;
+
   if (BegSegment) { //AZ
     AddSegment(BegSegment); // add hits from BegSegment
     AddSegment(EndSegment); // add hits from EndSegment
@@ -86,40 +104,34 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegmen
   }
   fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
   fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
-  // set fit conditions...
-  fFitMCS = 0;
-  fFitNParam = 3;
-  fFitStart = 1;
-  fFitFMin = -1.0;
-  fMatchTrigger = kFALSE;
-  fChi2MatchTrigger = 0;
-  fTrackID = 0;
   return;
 }
 
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONTrackReconstructor* TrackReconstructor)
-  : TObject()
+  : TObject(),
+    fTrackReconstructor(TrackReconstructor),
+    fTrackParamAtVertex(),
+    fTrackParamAtHit(0x0),
+    fHitForRecAtHit(0x0),
+    fTrackHitsPtr(new TObjArray(10)),
+    fNTrackHits(0),
+    fFitMCS(0),
+    fFitNParam(3),
+    fFitStart(1),
+    fFitFMin(-1.),
+    fMatchTrigger(kFALSE),
+    fChi2MatchTrigger(0.),
+    fTrackID(0)
 {
   // Constructor from one Segment and one HitForRec
-  fTrackReconstructor = TrackReconstructor; // link back to TrackReconstructor
-  // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
-  fTrackHitsPtr = new TObjArray(10);
-  fNTrackHits = 0;
+
   AddSegment(Segment); // add hits from Segment
   AddHitForRec(HitForRec); // add HitForRec
   fTrackHitsPtr->Sort(); // sort TrackHits according to increasing Z
   SetTrackParamAtVertex(); // set track parameters at vertex
   fTrackParamAtHit = new TClonesArray("AliMUONTrackParam",10);
   fHitForRecAtHit = new TClonesArray("AliMUONHitForRec",10);
-  // set fit conditions...
-  fFitMCS = 0;
-  fFitNParam = 3;
-  fFitStart = 1;
-  fFitFMin = -1.0;
-  fMatchTrigger = kFALSE;
-  fChi2MatchTrigger = 0;
-  fTrackID = 0;
   return;
 }
 
@@ -148,17 +160,28 @@ AliMUONTrack::~AliMUONTrack()
 
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
-  :  TObject(theMUONTrack)
+  : TObject(theMUONTrack),
+    fTrackReconstructor(theMUONTrack.fTrackReconstructor),
+    fTrackParamAtVertex(theMUONTrack.fTrackParamAtVertex),
+    fTrackParamAtHit(0x0),
+    fHitForRecAtHit(0x0),
+    fTrackHitsPtr(0x0),
+    fNTrackHits(theMUONTrack.fNTrackHits),
+    fFitMCS(theMUONTrack.fFitMCS),
+    fFitNParam(theMUONTrack.fFitNParam),
+    fFitStart(theMUONTrack.fFitStart),
+    fFitFMin(theMUONTrack.fFitFMin),
+    fMatchTrigger(theMUONTrack.fMatchTrigger),
+    fChi2MatchTrigger(theMUONTrack.fChi2MatchTrigger),
+    fTrackID(theMUONTrack.fTrackID)
 {
   //fTrackReconstructor = new AliMUONTrackReconstructor(*MUONTrack.fTrackReconstructor);
                                // is it right ?
                               // NO, because it would use dummy copy constructor
                               // and AliMUONTrack is not the owner of its TrackReconstructor 
-  fTrackReconstructor = theMUONTrack.fTrackReconstructor;
-  fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
+  //fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
 
  // necessary to make a copy of the objects and not only the pointers in TObjArray.
-  fTrackHitsPtr = 0;
   if (theMUONTrack.fTrackHitsPtr) {
     fTrackHitsPtr  =  new TObjArray(10);
     for (Int_t index = 0; index < (theMUONTrack.fTrackHitsPtr)->GetEntriesFast(); index++) {
@@ -169,7 +192,6 @@ AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
   }
 
   // necessary to make a copy of the objects and not only the pointers in TClonesArray.
-  fTrackParamAtHit = 0;
   if (theMUONTrack.fTrackParamAtHit) {
     fTrackParamAtHit  =  new TClonesArray("AliMUONTrackParam",10);
     for (Int_t index = 0; index < (theMUONTrack.fTrackParamAtHit)->GetEntriesFast(); index++) {
@@ -179,7 +201,6 @@ AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
   }  
 
   // necessary to make a copy of the objects and not only the pointers in TClonesArray.
-  fHitForRecAtHit = 0;
   if (theMUONTrack.fHitForRecAtHit) {
     fHitForRecAtHit  =  new TClonesArray("AliMUONHitForRec",10);
     for (Int_t index = 0; index < (theMUONTrack.fHitForRecAtHit)->GetEntriesFast(); index++) {
@@ -188,14 +209,6 @@ AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
     }
   }  
 
-  fNTrackHits       =  theMUONTrack.fNTrackHits;
-  fFitMCS           =  theMUONTrack.fFitMCS;
-  fFitNParam        =  theMUONTrack.fFitNParam;
-  fFitFMin          =  theMUONTrack.fFitFMin;
-  fFitStart         =  theMUONTrack.fFitStart;
-  fMatchTrigger     =  theMUONTrack.fMatchTrigger;
-  fChi2MatchTrigger =  theMUONTrack.fChi2MatchTrigger;
-  fTrackID          =  theMUONTrack.fTrackID;
 }
 
   //__________________________________________________________________________
index 88c6255..06e7439 100644 (file)
@@ -33,24 +33,25 @@ ClassImp(AliMUONTrackHit) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONTrackHit::AliMUONTrackHit()
-  : TObject()
+  : TObject(),
+    fTrackParam(),
+    fHitForRecPtr(0x0),
+    fNextTrackHitWithSameHitForRec(0x0),
+    fPrevTrackHitWithSameHitForRec(0x0)
 {
 /// Default constructor
 
-  fHitForRecPtr = 0;
-  fNextTrackHitWithSameHitForRec = 0;
-  fPrevTrackHitWithSameHitForRec = 0;
 }
   //__________________________________________________________________________
 AliMUONTrackHit::AliMUONTrackHit (const AliMUONTrackHit& theMUONTrackHit)
-  :  TObject(theMUONTrackHit)
+  : TObject(theMUONTrackHit),
+    fTrackParam(theMUONTrackHit.fTrackParam),
+    fHitForRecPtr(theMUONTrackHit.fHitForRecPtr),
+    fNextTrackHitWithSameHitForRec(theMUONTrackHit.fNextTrackHitWithSameHitForRec),
+    fPrevTrackHitWithSameHitForRec(theMUONTrackHit.fPrevTrackHitWithSameHitForRec)
 {
 /// Copy constructor
 
-  fTrackParam                    =  theMUONTrackHit.fTrackParam;
-  fHitForRecPtr                  =  theMUONTrackHit.fHitForRecPtr;
-  fNextTrackHitWithSameHitForRec =  theMUONTrackHit.fNextTrackHitWithSameHitForRec;
-  fPrevTrackHitWithSameHitForRec =  theMUONTrackHit.fPrevTrackHitWithSameHitForRec;
 }
   //__________________________________________________________________________
 AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& theMUONTrackHit)
@@ -74,10 +75,14 @@ AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& theMUONTrack
 }
   //__________________________________________________________________________
 AliMUONTrackHit::AliMUONTrackHit(AliMUONHitForRec* Hit)
+  : TObject(),
+    fTrackParam(),
+    fHitForRecPtr(Hit),
+    fNextTrackHitWithSameHitForRec(0x0),
+    fPrevTrackHitWithSameHitForRec(0x0)
 {
 /// Constructor from the HitForRec pointed to by "Hit"
 
-  fHitForRecPtr = Hit; // pointer to HitForRec
   // links from/to HitForRec
   if (Hit->GetNTrackHits() == 0) {
     fPrevTrackHitWithSameHitForRec = NULL;
index 11c7828..3a97361 100644 (file)
@@ -59,8 +59,31 @@ ClassImp(AliMUONTrackK) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK()
-  //AZ: TObject()
-  : AliMUONTrack() 
+  : AliMUONTrack(),
+    fStartSegment(0x0),
+    fPosition(0.),
+    fPositionNew(0.),
+    fChi2(0.),
+    fTrackHits(0x0),
+    fNmbTrackHits(0),
+    fTrackDir(1),
+    fBPFlag(kFALSE),
+    fRecover(0),
+    fSkipHit(0x0),
+    fTrackPar(0x0),
+    fTrackParNew(0x0),
+    fCovariance(0x0),
+    fWeight(0x0),
+    fParExtrap(0x0),
+    fParFilter(0x0), 
+    fParSmooth(0x0),
+    fCovExtrap(0x0),
+    fCovFilter(0x0),
+    fJacob(0x0),
+    fNSteps(0),
+    fSteps(0x0),
+    fChi2Array(0x0),
+    fChi2Smooth(0x0)
 {
 /// Default constructor
 
@@ -68,25 +91,36 @@ AliMUONTrackK::AliMUONTrackK()
   fgHitForRec = NULL; // pointer to points
   fgNOfPoints = 0; // number of points
 
-  fStartSegment = NULL;
-  fTrackHits = NULL;
-  fNmbTrackHits = 0;
-  fTrackPar = fTrackParNew = NULL;
-  fCovariance = fWeight = NULL;
-  fSkipHit = NULL;
-  fParExtrap = fParFilter = fParSmooth = NULL;
-  fCovExtrap = fCovFilter = NULL;
-  fJacob = NULL; 
-  fSteps = NULL; fNSteps = 0; 
-  fChi2Array = NULL;
-  fChi2Smooth = NULL;
-
   return;
 }
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClonesArray *hitForRec)
-  : AliMUONTrack()
+  : AliMUONTrack(),
+    fStartSegment(0x0),
+    fPosition(0.),
+    fPositionNew(0.),
+    fChi2(0.),
+    fTrackHits(0x0),
+    fNmbTrackHits(0),
+    fTrackDir(1),
+    fBPFlag(kFALSE),
+    fRecover(0),
+    fSkipHit(0x0),
+    fTrackPar(0x0),
+    fTrackParNew(0x0),
+    fCovariance(0x0),
+    fWeight(0x0),
+    fParExtrap(0x0),
+    fParFilter(0x0), 
+    fParSmooth(0x0),
+    fCovExtrap(0x0),
+    fCovFilter(0x0),
+    fJacob(0x0),
+    fNSteps(0),
+    fSteps(0x0),
+    fChi2Array(0x0),
+    fChi2Smooth(0x0)
 {
 /// Constructor
 
@@ -96,26 +130,36 @@ AliMUONTrackK::AliMUONTrackK(AliMUONTrackReconstructor *TrackReconstructor, TClo
   fgNOfPoints = fgHitForRec->GetEntriesFast(); // number of points
   fgCombi = NULL;
   if (fgTrackReconstructor->GetTrackMethod() == 3) fgCombi = AliMUONEventRecoCombi::Instance();
-
-  fStartSegment = NULL;
-  fTrackHits = NULL;
-  fNmbTrackHits = 0;
-  fChi2 = 0;
-  fTrackPar = fTrackParNew = NULL;
-  fCovariance = fWeight = NULL;
-  fSkipHit = NULL;
-  fParExtrap = fParFilter = fParSmooth = NULL;
-  fCovExtrap = fCovFilter = NULL;
-  fJacob = NULL; 
-  fSteps = NULL; fNSteps = 0; 
-  fChi2Array = NULL;
-  fChi2Smooth = NULL;
 }
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   //: AliMUONTrack(segment, segment, fgTrackReconstructor)
-  : AliMUONTrack(NULL, segment, fgTrackReconstructor)
+  : AliMUONTrack(NULL, segment, fgTrackReconstructor),
+    fStartSegment(segment),
+    fPosition(0.),
+    fPositionNew(0.),
+    fChi2(0.),
+    fTrackHits(new TObjArray(13)),
+    fNmbTrackHits(2),
+    fTrackDir(1),
+    fBPFlag(kFALSE),
+    fRecover(0),
+    fSkipHit(0x0),
+    fTrackPar(new TMatrixD(fgkSize,1)),
+    fTrackParNew(new TMatrixD(fgkSize,1)),
+    fCovariance(new TMatrixD(fgkSize,fgkSize)),
+    fWeight(new TMatrixD(fgkSize,fgkSize)),
+    fParExtrap(new TObjArray(15)),
+    fParFilter(new TObjArray(15)), 
+    fParSmooth(0x0),
+    fCovExtrap(new TObjArray(15)),
+    fCovFilter(new TObjArray(15)),
+    fJacob(new TObjArray(15)),
+    fNSteps(0),
+    fSteps(new TArrayD(15)),
+    fChi2Array(new TArrayD(13)),
+    fChi2Smooth(0x0)
 {
 /// Constructor from a segment
   Double_t dX, dY, dZ;
@@ -123,9 +167,6 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   AliMUONRawCluster *clus;
   TClonesArray *rawclusters;
 
-  fStartSegment = segment;
-  fRecover = 0;
-  fSkipHit = NULL;
   // Pointers to hits from the segment
   hit1 = segment->GetHitForRec1();
   hit2 = segment->GetHitForRec2();
@@ -136,15 +177,6 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
     hit1 = hit2;
     hit2 = segment->GetHitForRec1();
   }
-  // memory allocation for the TObjArray of pointers to reconstructed TrackHit's
-  fTrackHits = new TObjArray(13);
-  fNmbTrackHits = 2;
-  fChi2 = 0;
-  fBPFlag = kFALSE;
-  fTrackPar = new TMatrixD(fgkSize,1); // track parameters
-  fTrackParNew = new TMatrixD(fgkSize,1); // track parameters
-  fCovariance = new TMatrixD(fgkSize,fgkSize); // covariance matrix
-  fWeight = new TMatrixD(fgkSize,fgkSize); // weight matrix (inverse of covariance)
 
   // Fill array of track parameters
   if (hit1->GetChamberNumber() > 7) {
@@ -178,18 +210,6 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
   // Evaluate covariance (and weight) matrix
   EvalCovariance(dZ);
 
-  // For smoother
-  fParExtrap = new TObjArray(15);
-  fParFilter = new TObjArray(15);
-  fCovExtrap = new TObjArray(15);
-  fCovFilter = new TObjArray(15);
-  fJacob = new TObjArray(15);
-  fSteps = new TArrayD(15);
-  fNSteps = 0;
-  fChi2Array = new TArrayD(13);
-  fChi2Smooth = NULL;
-  fParSmooth = NULL;
-
   if (fgDebug < 0 ) return;
   cout << fgTrackReconstructor->GetNRecTracks()-1 << " " << fgTrackReconstructor->GetBendingMomentumFromImpactParam(segment->GetBendingImpact()) << " " << 1/(*fTrackPar)(4,0) << " ";
   if (fgTrackReconstructor->GetRecTrackRefHits()) { 
@@ -293,14 +313,6 @@ AliMUONTrackK::~AliMUONTrackK()
 }
 
   //__________________________________________________________________________
-AliMUONTrackK::AliMUONTrackK (const AliMUONTrackK& source)
-  : AliMUONTrack(source)
-{
-/// Protected copy constructor
-  AliFatal("Not implemented.");
-}
-
-  //__________________________________________________________________________
 AliMUONTrackK & AliMUONTrackK::operator=(const AliMUONTrackK& source)
 {
 /// Assignment operator
index faf296a..00a9f74 100644 (file)
@@ -75,7 +75,6 @@ class AliMUONTrackK : public AliMUONTrack {
 
  protected:
 
-  AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
   AliMUONTrackK& operator=(const AliMUONTrackK& source); // assignment operator
 
  private:
@@ -119,6 +118,7 @@ class AliMUONTrackK : public AliMUONTrack {
 
   // Functions
 
+  AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
   void EvalCovariance(Double_t dZ);
   void ParPropagation(Double_t zEnd);
   void WeightPropagation(Double_t zEnd, Bool_t smooth);
index a84cfa7..7db5380 100644 (file)
@@ -38,16 +38,16 @@ ClassImp(AliMUONTrackParam) // Class implementation in ROOT context
 
   //_________________________________________________________________________
 AliMUONTrackParam::AliMUONTrackParam()
-  : TObject()
+  : TObject(),
+    fInverseBendingMomentum(0.),
+    fBendingSlope(0.),
+    fNonBendingSlope(0.),
+    fZ(0.),
+    fBendingCoor(0.),
+    fNonBendingCoor(0.)
 {
 // Constructor
 
-  fInverseBendingMomentum = 0;
-  fBendingSlope = 0;
-  fNonBendingSlope = 0;
-  fZ = 0;
-  fBendingCoor = 0;
-  fNonBendingCoor = 0;
 }
 
   //_________________________________________________________________________
@@ -72,15 +72,16 @@ AliMUONTrackParam::operator=(const AliMUONTrackParam& theMUONTrackParam)
 }
   //_________________________________________________________________________
 AliMUONTrackParam::AliMUONTrackParam(const AliMUONTrackParam& theMUONTrackParam)
-  : TObject(theMUONTrackParam)
+  : TObject(theMUONTrackParam),
+    fInverseBendingMomentum(theMUONTrackParam.fInverseBendingMomentum), 
+    fBendingSlope(theMUONTrackParam.fBendingSlope),
+    fNonBendingSlope(theMUONTrackParam.fNonBendingSlope),
+    fZ(theMUONTrackParam.fZ),
+    fBendingCoor(theMUONTrackParam.fBendingCoor),
+    fNonBendingCoor(theMUONTrackParam.fNonBendingCoor)
 {
   // Copy constructor
-  fInverseBendingMomentum =  theMUONTrackParam.fInverseBendingMomentum; 
-  fBendingSlope           =  theMUONTrackParam.fBendingSlope; 
-  fNonBendingSlope        =  theMUONTrackParam.fNonBendingSlope; 
-  fZ                      =  theMUONTrackParam.fZ; 
-  fBendingCoor            =  theMUONTrackParam.fBendingCoor; 
-  fNonBendingCoor         =  theMUONTrackParam.fNonBendingCoor;
+
 }
 
   //_________________________________________________________________________
index a5d9cd7..6bb3d72 100644 (file)
@@ -84,15 +84,43 @@ ClassImp(AliMUONTrackReconstructor) // Class implementation in ROOT context
 
 //__________________________________________________________________________
 AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader, AliMUONData* data)
-  : TObject()
+  : TObject(),
+    fTrackMethod(1), //AZ - tracking method (1-default, 2-Kalman)
+    fMinBendingMomentum(fgkDefaultMinBendingMomentum),
+    fMaxBendingMomentum(fgkDefaultMaxBendingMomentum),
+    fMaxChi2(fgkDefaultMaxChi2),
+    fMaxSigma2Distance(fgkDefaultMaxSigma2Distance),
+    fBendingResolution(fgkDefaultBendingResolution),
+    fNonBendingResolution(fgkDefaultNonBendingResolution),
+    fChamberThicknessInX0(fgkDefaultChamberThicknessInX0),
+    fSimpleBValue(fgkDefaultSimpleBValue),
+    fSimpleBLength(fgkDefaultSimpleBLength),
+    fSimpleBPosition(fgkDefaultSimpleBPosition),
+    fRecTrackRefHits(fgkDefaultRecTrackRefHits),
+    fEfficiency(fgkDefaultEfficiency),
+    // Initializions for track ref. background events
+    fBkgTrackRefFile(0x0),
+    fBkgTrackRefTK(0x0),
+    fBkgTrackRefParticles(0x0),
+    fBkgTrackRefTTR(0x0),
+    fBkgTrackRefEventNumber(-1),
+    fHitsForRecPtr(0x0),
+    fNHitsForRec(0),
+    fRecTracksPtr(0x0),
+    fNRecTracks(0),
+    fRecTrackHitsPtr(0x0),
+    fNRecTrackHits(0),
+    fMUONData(data),
+    fLoader(loader),
+    fMuons(0)
 {
   // Constructor for class AliMUONTrackReconstructor
   SetReconstructionParametersToDefaults();
-  fTrackMethod = 1; //AZ - tracking method (1-default, 2-Kalman)
+
   // Memory allocation for the TClonesArray of hits for reconstruction
   // Is 10000 the right size ????
   fHitsForRecPtr = new TClonesArray("AliMUONHitForRec", 10000);
-  fNHitsForRec = 0; // really needed or GetEntriesFast sufficient ????
+
   // Memory allocation for the TClonesArray's of segments in stations
   // Is 2000 the right size ????
   for (Int_t st = 0; st < AliMUONConstants::NTrackingCh()/2; st++) {
@@ -102,11 +130,10 @@ AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader, AliMUOND
   // Memory allocation for the TClonesArray of reconstructed tracks
   // Is 10 the right size ????
   fRecTracksPtr = new TClonesArray("AliMUONTrack", 10);
-  fNRecTracks = 0; // really needed or GetEntriesFast sufficient ????
+
   // Memory allocation for the TClonesArray of hits on reconstructed tracks
   // Is 100 the right size ????
   fRecTrackHitsPtr = new TClonesArray("AliMUONTrackHit", 100);
-  fNRecTrackHits = 0; // really needed or GetEntriesFast sufficient ????
 
   // Sign of fSimpleBValue according to sign of Bx value at (50,50,-950).
   Float_t b[3], x[3];
@@ -122,43 +149,12 @@ AliMUONTrackReconstructor::AliMUONTrackReconstructor(AliLoader* loader, AliMUOND
   AliDebug(1,"Magnetic field from root file:");
   if ( AliLog::GetGlobalDebugLevel()>0) gAlice->Field()->Dump();
 
-  
-  // Initializions for track ref. background events
-  fBkgTrackRefFile = 0;
-  fBkgTrackRefTK = 0;
-  fBkgTrackRefParticles = 0;
-  fBkgTrackRefTTR = 0;
-  fBkgTrackRefEventNumber = -1;
-   
-  // initialize loader's
-  fLoader = loader;
-
   // initialize container
   // fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
-  fMUONData  = data;
+  //fMUONData  = data;
 
   return;
 }
-  //__________________________________________________________________________
-AliMUONTrackReconstructor::AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs)
-  : TObject(rhs)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-AliMUONTrackReconstructor & 
-AliMUONTrackReconstructor::operator=(const AliMUONTrackReconstructor& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
 
   //__________________________________________________________________________
 AliMUONTrackReconstructor::~AliMUONTrackReconstructor(void)
@@ -175,10 +171,6 @@ void AliMUONTrackReconstructor::SetReconstructionParametersToDefaults(void)
 {
   // Set reconstruction parameters to default values
   // Would be much more convenient with a structure (or class) ????
-  fMinBendingMomentum = fgkDefaultMinBendingMomentum;
-  fMaxBendingMomentum = fgkDefaultMaxBendingMomentum;
-  fMaxChi2 = fgkDefaultMaxChi2;
-  fMaxSigma2Distance = fgkDefaultMaxSigma2Distance;
 
   // ******** Parameters for making HitsForRec
   // minimum radius,
@@ -216,15 +208,6 @@ void AliMUONTrackReconstructor::SetReconstructionParametersToDefaults(void)
   fSegmentMaxDistBending[4] = TMath::Abs( 6.0 *
                                          (AliMUONConstants::DefaultChamberZ(9) - AliMUONConstants::DefaultChamberZ(8)) / 20.0);
 
-  
-  fBendingResolution = fgkDefaultBendingResolution;
-  fNonBendingResolution = fgkDefaultNonBendingResolution;
-  fChamberThicknessInX0 = fgkDefaultChamberThicknessInX0;
-  fSimpleBValue = fgkDefaultSimpleBValue;
-  fSimpleBLength = fgkDefaultSimpleBLength;
-  fSimpleBPosition = fgkDefaultSimpleBPosition;
-  fRecTrackRefHits = fgkDefaultRecTrackRefHits;
-  fEfficiency = fgkDefaultEfficiency;
   return;
 }
 
index b041f06..3971850 100644 (file)
@@ -93,10 +93,6 @@ class AliMUONTrackReconstructor : public TObject {
 
   AliMUONData*  GetMUONData() {return fMUONData;}
 
- protected:
-  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
-  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
-
  private:
 
   // Constants which should be elsewhere ????
@@ -182,6 +178,8 @@ class AliMUONTrackReconstructor : public TObject {
   Int_t fMuons; ///< AZ - number of muons within acceptance - just for tests
 
   // Functions
+  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); // copy constructor
+  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); // assignment operator
   void ResetHitsForRec(void);
   void MakeEventToBeReconstructed(void);
   void AddHitsForRecFromTrackRef(TTree *TTR, Int_t Signal);