Code revision:
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 May 2004 12:29:00 +0000 (12:29 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 May 2004 12:29:00 +0000 (12:29 +0000)
- includes
- hiding non implemented copy constructors/assignement operators
  in protected area
- added copyright, CVS Id (if missing)
- naming coding conventions
- constant functions
- initialization of base class in constructors
(I. Hrivnacova)

155 files changed:
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONChamber.cxx
MUON/AliMUONChamber.h
MUON/AliMUONChamberGeometry.h
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONChamberTrigger.h
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.cxx
MUON/AliMUONClusterInput.h
MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONConstants.h
MUON/AliMUONData.cxx
MUON/AliMUONData.h
MUON/AliMUONDataInterface.cxx
MUON/AliMUONDataInterface.h
MUON/AliMUONDigit.cxx
MUON/AliMUONDigit.h
MUON/AliMUONDigitizer.cxx
MUON/AliMUONDigitizer.h
MUON/AliMUONDigitizerv1.cxx
MUON/AliMUONDigitizerv1.h
MUON/AliMUONDigitizerv2.cxx
MUON/AliMUONDigitizerv2.h
MUON/AliMUONDisplay.cxx
MUON/AliMUONDisplay.h
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONEventReconstructor.h
MUON/AliMUONFactory.cxx
MUON/AliMUONFactory.h
MUON/AliMUONGeometryConstituent.cxx
MUON/AliMUONGeometryConstituent.h
MUON/AliMUONGeometryEnvelope.cxx
MUON/AliMUONGeometryEnvelope.h
MUON/AliMUONGlobalTrigger.cxx
MUON/AliMUONGlobalTrigger.h
MUON/AliMUONHit.cxx
MUON/AliMUONHit.h
MUON/AliMUONHitForRec.cxx
MUON/AliMUONHitForRec.h
MUON/AliMUONHitMapA1.cxx
MUON/AliMUONHitMapA1.h
MUON/AliMUONLoader.h
MUON/AliMUONLocalTrigger.cxx
MUON/AliMUONLocalTrigger.h
MUON/AliMUONMerger.cxx
MUON/AliMUONMerger.h
MUON/AliMUONPadHit.cxx
MUON/AliMUONPadHit.h
MUON/AliMUONPixel.cxx
MUON/AliMUONPixel.h
MUON/AliMUONPoints.cxx
MUON/AliMUONPoints.h
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRawCluster.h
MUON/AliMUONRecoDisplay.cxx
MUON/AliMUONRecoDisplay.h
MUON/AliMUONRecoEvent.cxx
MUON/AliMUONRecoEvent.h
MUON/AliMUONRecoTrack.cxx
MUON/AliMUONRecoTrack.h
MUON/AliMUONReconstHit.cxx
MUON/AliMUONReconstHit.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONReconstructor.h
MUON/AliMUONResponse.cxx
MUON/AliMUONResponse.h
MUON/AliMUONResponseTrigger.cxx
MUON/AliMUONResponseTrigger.h
MUON/AliMUONResponseTriggerV1.cxx
MUON/AliMUONResponseTriggerV1.h
MUON/AliMUONResponseV0.cxx
MUON/AliMUONResponseV0.h
MUON/AliMUONSDigitizerv1.cxx
MUON/AliMUONSDigitizerv1.h
MUON/AliMUONSegment.cxx
MUON/AliMUONSegment.h
MUON/AliMUONSegmentationSlat.cxx
MUON/AliMUONSegmentationSlat.h
MUON/AliMUONSegmentationSlatModule.cxx
MUON/AliMUONSegmentationSlatModule.h
MUON/AliMUONSegmentationSlatModuleN.cxx
MUON/AliMUONSegmentationSlatModuleN.h
MUON/AliMUONSegmentationSlatN.cxx
MUON/AliMUONSegmentationSlatN.h
MUON/AliMUONSegmentationTrigger.cxx
MUON/AliMUONSegmentationTrigger.h
MUON/AliMUONSegmentationTriggerX.cxx
MUON/AliMUONSegmentationTriggerX.h
MUON/AliMUONSegmentationTriggerY.cxx
MUON/AliMUONSegmentationTriggerY.h
MUON/AliMUONSegmentationV0.cxx
MUON/AliMUONSegmentationV0.h
MUON/AliMUONSegmentationV01.cxx
MUON/AliMUONSegmentationV01.h
MUON/AliMUONSegmentationV02.cxx
MUON/AliMUONSegmentationV02.h
MUON/AliMUONSegmentationV04.cxx
MUON/AliMUONSegmentationV04.h
MUON/AliMUONSegmentationV05.cxx
MUON/AliMUONSegmentationV05.h
MUON/AliMUONSegmentationV1.cxx
MUON/AliMUONSegmentationV1.h
MUON/AliMUONSlatGeometryBuilder.cxx
MUON/AliMUONSlatGeometryBuilder.h
MUON/AliMUONSt1Decoder.h
MUON/AliMUONSt1ElectronicElement.cxx
MUON/AliMUONSt1ElectronicElement.h
MUON/AliMUONSt1GeometryBuilder.cxx
MUON/AliMUONSt1GeometryBuilder.h
MUON/AliMUONSt1GeometryBuilderV2.cxx
MUON/AliMUONSt1GeometryBuilderV2.h
MUON/AliMUONSt1IniReader.h
MUON/AliMUONSt1Response.h
MUON/AliMUONSt1ResponseParameter.h
MUON/AliMUONSt1ResponseRule.h
MUON/AliMUONSt1Segmentation.cxx
MUON/AliMUONSt1Segmentation.h
MUON/AliMUONSt1SpecialMotif.h
MUON/AliMUONSt2GeometryBuilder.cxx
MUON/AliMUONSt2GeometryBuilder.h
MUON/AliMUONTrack.cxx
MUON/AliMUONTrack.h
MUON/AliMUONTrackHit.cxx
MUON/AliMUONTrackHit.h
MUON/AliMUONTrackK.cxx
MUON/AliMUONTrackK.h
MUON/AliMUONTrackParam.cxx
MUON/AliMUONTrackParam.h
MUON/AliMUONTransientDigit.cxx
MUON/AliMUONTransientDigit.h
MUON/AliMUONTriggerCircuit.cxx
MUON/AliMUONTriggerCircuit.h
MUON/AliMUONTriggerConstants.cxx
MUON/AliMUONTriggerConstants.h
MUON/AliMUONTriggerDecision.cxx
MUON/AliMUONTriggerDecision.h
MUON/AliMUONTriggerGeometryBuilder.cxx
MUON/AliMUONTriggerGeometryBuilder.h
MUON/AliMUONTriggerLut.cxx
MUON/AliMUONTriggerLut.h
MUON/AliMUONTriggerTrack.cxx
MUON/AliMUONTriggerTrack.h
MUON/AliMUONVGeometryBuilder.cxx
MUON/AliMUONVGeometryBuilder.h
MUON/AliMUONv0.cxx
MUON/AliMUONv0.h
MUON/AliMUONv1.cxx
MUON/AliMUONv1.h
MUON/AliMUONv3.cxx
MUON/AliMUONv3.h

index 2a6b1d70974dc685e2025ee260bca989736ec059..2361689e38eb88a1e8f6d433f7fd1ddfc4d24a68 100644 (file)
 //          for the first and second chambers in the station, respectively
 
 ClassImp(AliMUON)
+
 //__________________________________________________________________
 AliMUON::AliMUON()
+  : AliDetector(),
+    fNCh(0),
+    fNTrackingCh(0),
+    fMUONData(0),
+    fSplitLevel(0),
+    fChambers(0),
+    fGeometryBuilders(0),
+    fTriggerCircuits(0),
+    fAccCut(kFALSE),
+    fAccMin(0.),
+    fAccMax(0.),   
+    fMaxStepGas(0.),
+    fMaxStepAlu(0.),
+    fMaxDestepGas(0.),
+    fMaxDestepAlu(0.),
+    fMaxIterPad(0),
+    fCurIterPad(0),
+    fMerger(0)
 {
 // Default Constructor
 //
-    fNCh             = 0;
-    fNTrackingCh     = 0;
     fIshunt          = 0;
-    fChambers        = 0;
-    fGeometryBuilders = 0; 
-    fTriggerCircuits = 0;
-    fAccMin          = 0.;
-    fAccMax          = 0.;   
-    fAccCut          = kFALSE;
-    fMerger          = 0;
-    fMUONData        = 0;
-    fSplitLevel      = 0;
 }
+
 //__________________________________________________________________
 AliMUON::AliMUON(const char *name, const char *title)
-  : AliDetector(name,title)
+  : AliDetector(name,title),
+    fNCh(AliMUONConstants::NCh()),
+    fNTrackingCh(AliMUONConstants::NTrackingCh()),
+    fMUONData(0),
+    fSplitLevel(0),
+    fChambers(0),
+    fGeometryBuilders(0),
+    fTriggerCircuits(0),
+    fAccCut(kFALSE),
+    fAccMin(0.),
+    fAccMax(0.),   
+    fMaxStepGas(0.1),
+    fMaxStepAlu(0.1),
+    fMaxDestepGas(-1), // Negatives values are ignored by geant3 CONS200 
+    fMaxDestepAlu(-1), // in the calculation of the tracking parameters
+    fMaxIterPad(0),
+    fCurIterPad(0),
+    fMerger(0)
 {
 //Begin_Html
 /*
 <img src="gif/alimuon.gif">
 */
 //End_Html
-  fMUONData  = 0x0;
-  fSplitLevel= 0;
-  fIshunt     =  0;
 
-  fNCh             = AliMUONConstants::NCh(); 
-  fNTrackingCh     = AliMUONConstants::NTrackingCh();
+  fIshunt =  0;
 
   SetMarkerColor(kRed);//
 //
@@ -151,33 +173,22 @@ AliMUON::AliMUON(const char *name, const char *title)
       } // Chamber stCH (0, 1) in 
     }     // Station st (0...)
     
-    // Negatives values are ignored by geant3 CONS200 in the calculation of the tracking parameters
-    fMaxStepGas=0.1; 
-    fMaxStepAlu=0.1;  
-    fMaxDestepGas=-1;
-    fMaxDestepAlu=-1;
-    
-    fMaxIterPad   = 0;
-    fCurIterPad   = 0;
-    
-    fAccMin          = 0.;
-    fAccMax          = 0.;   
-    fAccCut          = kFALSE;
-    
     // cp new design of AliMUONTriggerDecision
     fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
     for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
       fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);          
     }
-    fMerger = 0;
 }
+
 //____________________________________________________________________
-AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
+AliMUON::AliMUON(const AliMUON& rMUON)
+ : AliDetector(rMUON)
 {
-// Dummy copy constructor
-    ;
-    
+// Protected copy constructor
+
+  Fatal("AliMUONMergerModule", "Not implemented.");
 }
+
 //____________________________________________________________________
 AliMUON::~AliMUON()
 {
@@ -200,6 +211,19 @@ AliMUON::~AliMUON()
   }
   delete fMUONData;
 }
+
+//________________________________________________________________________
+AliMUON& AliMUON::operator = (const AliMUON& rhs)
+{
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
+}
+
 //_____________________________________________________________________________
 void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
 {
@@ -219,11 +243,6 @@ void AliMUON::BuildGeometry()
     }
   }
 }
-//___________________________________________________________________
-Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
-{
-  return 9999;
-}
 //__________________________________________________________________
 void  AliMUON::SetTreeAddress()
 {
@@ -461,9 +480,9 @@ AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters)
     TClonesArray *theClusters = clusters;
     Int_t nclust = theClusters->GetEntriesFast();
     if (nclust && hit->PHlast() > 0) {
-       AliMUON::fMaxIterPad=hit->PHlast();
-       AliMUON::fCurIterPad=hit->PHfirst();
-       return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
+       fMaxIterPad=hit->PHlast();
+       fCurIterPad=hit->PHfirst();
+       return (AliMUONPadHit*) clusters->UncheckedAt(fCurIterPad-1);
     } else {
        return 0;
     }
@@ -474,9 +493,9 @@ AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
   // To be removed
 // Get next pad (in iterator) 
 //
-    AliMUON::fCurIterPad++;
-    if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
-       return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
+    fCurIterPad++;
+    if (fCurIterPad <= fMaxIterPad) {
+       return (AliMUONPadHit*) clusters->UncheckedAt(fCurIterPad-1);
     } else {
        return 0;
     }
@@ -514,13 +533,6 @@ AliMUONMerger*  AliMUON::Merger()
     return fMerger;
 }
 //________________________________________________________________________
-AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
-{
-// copy operator
-// dummy version
-    return *this;
-}
-//________________________________________________________________________
 void AliMUON::RemapTrackHitIDs(Int_t* map)
 {
 // Remaps the track numbers in the hits arrays, so that they correspond
index 39261244c87c11fab38b01f12a3e91480c45b8ac..ae57d4874c489f62ae04f611afe0845f3039acfa 100644 (file)
@@ -4,17 +4,22 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
-/* $Id$ */
-
+// Revision of includes 07/05/2004
 
 ////////////////////////////////////////////////
 //  AliDetector Class for MUON subsystem      //
 ////////////////////////////////////////////////
-#include "TObjArray.h"
+
+#include <TObjArray.h>
+
 #include "AliDetector.h"
 #include "AliMUONData.h"
 #include "AliMUONChamber.h"
 
+class TVector;
+class TFile;
+class TTree;
+
 class AliLoader;
 class AliSegmentation;
 class AliMUONTriggerCircuit;
@@ -29,17 +34,15 @@ class AliMUONMerger;
 class AliMUONVGeometryBuilder;
 class AliESD;
 
-
-class AliMUON : public  AliDetector {
- public:
+class AliMUON : public  AliDetector 
+{
 public:
     AliMUON();
     AliMUON(const char *name, const char *title);
-    AliMUON(const AliMUON& rMUON);
     virtual       ~AliMUON();
    
     void           AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder);
     virtual void   BuildGeometry();
-    Int_t          DistancetoPrimitive(Int_t px, Int_t py);
     AliMUONData*   GetMUONData() {return fMUONData;}
     virtual Int_t  IsVersion()   const {return 0;}
 
@@ -106,13 +109,14 @@ class AliMUON : public  AliDetector {
     // Return pointers to digits
     AliMUONRawCluster    *RawCluster(Int_t ichamber, Int_t icathod,
                                     Int_t icluster);
-    // Copy Operator
+    // Inherited and overridden from AliModule:
+    virtual void RemapTrackHitIDs(Int_t * map);
+
+  protected:
+    AliMUON(const AliMUON& rMUON);
     AliMUON& operator = (const AliMUON& rhs);
 
-  // Inherited and overridden from AliModule:
-    virtual void RemapTrackHitIDs(Int_t * map);
 
- protected:
     Int_t                 fNCh;                // Number of chambers   
     Int_t                 fNTrackingCh;        // Number of tracking chambers*
     AliMUONData*          fMUONData;           // Data container for MUON subsystem  
index f50e80bfe6db72919470dcfdde8ad66adf6e4cbc..710005f0166fdb34b6c739eab09ceb515d07862c 100644 (file)
 
 /* $Id$ */
 
+// --- ROOT includes ---
+#include <TRandom.h>
+#include <TMath.h>
+
 // --- MUON includes ---
 #include "AliMUONChamber.h"
 #include "AliMUONChamberGeometry.h"
 
-// --- ROOT includes ---
-
-#include "TRandom.h"
-#include "TMath.h"
-
 ClassImp(AliMUONChamber)       
 
-    AliMUONChamber::AliMUONChamber()
+AliMUONChamber::AliMUONChamber()
+  : TObject(), 
+    fId(0),
+    fdGas(0.),
+    fdAlu(0.),
+    fZ(0.),
+    fnsec(1),
+    frMin(0.),
+    frMax(0.),
+    fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
+    fSegmentation(0),
+    fReconstruction(0),
+    fResponse(0),
+    fGeometry(0)
 {
 // Default constructor
-    fSegmentation = 0;
-    fResponse=0;
-    fnsec=1;
-    fReconstruction=0;
-    fGeometry = 0;
-    
-    fId=0;
-    // to avoid mistakes if ChargeCorrelInit is not called
-    fCurrentCorrel =1;
 }
 
-    AliMUONChamber::AliMUONChamber(Int_t id) 
+AliMUONChamber::AliMUONChamber(Int_t id) 
+  : TObject(), 
+    fId(id),
+    fdGas(0.),
+    fdAlu(0.),
+    fZ(0.),
+    fnsec(1),
+    frMin(0.),
+    frMax(0.),
+    fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
+    fSegmentation(0),
+    fReconstruction(0),
+    fResponse(0),
+    fGeometry(0)
 {
 // Construtor with chamber id 
     fSegmentation = new TObjArray(2);
     fSegmentation->AddAt(0,0);
     fSegmentation->AddAt(0,1);
-    fResponse=0;
-    fnsec=1;
-    fReconstruction=0;
-    fId=id;
+
     fGeometry = new AliMUONChamberGeometry(fId);
-    // to avoid mistakes if ChargeCorrelInit is not called
-    fCurrentCorrel =1;
+}
+
+AliMUONChamber::AliMUONChamber(const AliMUONChamber& rChamber)
+  : TObject(rChamber)
+{
+// Protected copy constructor
+
+  Fatal("AliMUONMergerModule", "Not implemented.");
+ // Dummy copy constructor
 }
 
 AliMUONChamber::~AliMUONChamber() 
@@ -65,12 +85,16 @@ AliMUONChamber::~AliMUONChamber()
   delete fGeometry;
 }
 
-AliMUONChamber::AliMUONChamber(const AliMUONChamber& rChamber):TObject(rChamber)
+AliMUONChamber & AliMUONChamber::operator =(const AliMUONChamber& rhs)
 {
- // Dummy copy constructor
-     ;
-}
+// Protected assignement operator
 
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
+}
 
 Bool_t  AliMUONChamber::IsSensId(Int_t volId) const 
 {
@@ -214,8 +238,3 @@ void AliMUONChamber::InitGeo(Float_t /*zpos*/)
 }
 
 
-AliMUONChamber & AliMUONChamber::operator =(const AliMUONChamber& /*rhs*/)
-{
-// Dummy assignment operator
-    return *this;
-}
index e5434c5a70a8c5e441ac324ab732d0025a012938..dc48ffad8ca9fca0e5da07dbc218587b9b5a23e3 100644 (file)
@@ -4,55 +4,47 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
+
+#include <TObject.h>
+#include <TObjArray.h>
 
-#include "TObjArray.h"
 #include "AliSegmentation.h"
 #include "AliMUONResponse.h"
 
 class AliMUONClusterFinderVS;
-//class AliMUONResponse ;
-//class AliSegmentation ;
 class AliMUONChamberGeometry;
 
-class AliMUONChamber:
-public TObject
+class AliMUONChamber : public TObject
 {
  public:
     AliMUONChamber();
     AliMUONChamber(Int_t id);
-    AliMUONChamber(const AliMUONChamber & rChamber);
     virtual ~AliMUONChamber();
     
 //
 // Get chamber Id
-  virtual Int_t   GetId() {return fId;}
+  virtual Int_t   GetId() const {return fId;}
 //
 
 // Get chamber Id
   virtual Bool_t  IsSensId(Int_t volId) const;
-/*
-// Get GEANT id of sensitive volume
-  virtual Int_t   GetGid() {return fGid;}
-// Set GEANT id of sensitive volume
-  virtual void    SetGid(Int_t id) {fGid=id;}
-//
-*/
   
 // Initialisation
   virtual void    Init();
 // Set z-position of chamber  
   virtual void    SetZ(Float_t Z) {fZ = Z;}
 // Get z-position of chamber  
-  virtual Float_t Z(){return fZ;}
+  virtual Float_t Z() const {return fZ;}
 // Set inner radius of sensitive volume 
   virtual void SetRInner(Float_t rmin) {frMin=rmin;}
 // Set outer radius of sensitive volum  
   virtual void SetROuter(Float_t rmax) {frMax=rmax;}  
 
 // Return inner radius of sensitive volume 
-  virtual  Float_t RInner()            {return frMin;}
+  virtual  Float_t RInner() const      {return frMin;}
 // Return outer radius of sensitive volum  
-  virtual Float_t ROuter()            {return frMax;}  
+  virtual Float_t ROuter() const       {return frMax;}  
 //  
 // Set response model
   virtual void    SetResponseModel(AliMUONResponse* thisResponse) {fResponse=thisResponse;}
@@ -77,7 +69,7 @@ public TObject
 //  Get pointer to cluster reconstruction model
   virtual AliMUONClusterFinderVS* &ReconstructionModel(){return fReconstruction;}
 // Get number of segmentation sectors  
-  virtual Int_t Nsec()              {return fnsec;}
+  virtual Int_t Nsec() const        {return fnsec;}
 // Set number of segmented cathodes (1 or 2)  
   virtual void  SetNsec(Int_t nsec) {fnsec=nsec;}
 //
@@ -118,8 +110,8 @@ public TObject
 // Initialize geometry related parameters  
   virtual void    InitGeo(Float_t z);
 //
-  virtual Float_t DGas() {return fdGas;}
-  virtual Float_t DAlu() {return fdAlu;}  
+  virtual Float_t DGas() const {return fdGas;}
+  virtual Float_t DAlu() const {return fdAlu;}  
   virtual void SetDGas(Float_t DGas) {fdGas = DGas;}
   virtual void SetDAlu(Float_t DAlu) {fdAlu = DAlu;}  
   virtual void SetChargeCorrel(Float_t correl) {fResponse->SetChargeCorrel(correl);}
@@ -128,15 +120,15 @@ public TObject
   void SetGeometry(AliMUONChamberGeometry* geometry) {fGeometry = geometry;}
   AliMUONChamberGeometry* GetGeometry() const {return fGeometry; }
 
-// assignment operator  
-  AliMUONChamber& operator =(const AliMUONChamber& rhs);
   
  protected:
+  AliMUONChamber(const AliMUONChamber & rChamber);
+  // assignment operator  
+  AliMUONChamber& operator =(const AliMUONChamber& rhs);
+
   Int_t   fId;   // chamber number
   Float_t fdGas; // half gaz gap
   Float_t fdAlu; // half Alu width  
-  //Int_t   fGid;  // GEANT volume if for sensitive volume of this chamber
-                   // moved to AliMUONChamberGeometry
   Float_t fZ;    // Z position (cm)
   Int_t   fnsec; // number of semented cathode planes
   Float_t frMin; // innermost sensitive radius
index 018227edce6ac0b52b30fcba35873afff663d49a..5131f39bf985c551ba50f09599093dd30d0679f1 100644 (file)
@@ -1,4 +1,9 @@
-// $Id$
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Revision of includes 07/05/2004
+
 //
 // Class AliMUONChamberGeometry
 // -----------------------------
@@ -25,12 +30,8 @@ class AliMUONChamberGeometry : public TObject
   public:
     AliMUONChamberGeometry(Int_t chamberId);
     AliMUONChamberGeometry();
-    AliMUONChamberGeometry(const AliMUONChamberGeometry& rhs);
     virtual ~AliMUONChamberGeometry();
 
-    // operators  
-    AliMUONChamberGeometry& operator = (const AliMUONChamberGeometry& rhs);
-  
     // methods
         
           // adding virtual envelopes  
@@ -100,6 +101,11 @@ class AliMUONChamberGeometry : public TObject
     const TObjArray*       GetEnvelopes() const;
     Bool_t IsSensitiveVolume(Int_t volId) const; 
 
+  protected:
+    AliMUONChamberGeometry(const AliMUONChamberGeometry& rhs);
+    // operators  
+    AliMUONChamberGeometry& operator = (const AliMUONChamberGeometry& rhs);
+
   private:
     // methods
     AliMUONGeometryEnvelope* FindEnvelope(const TString& name) const;
index 7a61ca188cb89c721eaf38c3efcfa21f1c9ef652..289ea24508cc25fcb1f4f22a9ef94a716f262d26 100644 (file)
 /* $Id$ */
 
 #include "AliMUONChamberTrigger.h"
-#include "AliMUONSegmentationTrigger.h"
 #include "AliMUONResponseTrigger.h"
-#include "AliMUONResponseTriggerV1.h"
-#include <TObjArray.h>
-#include <TMath.h>
-#include <Riostream.h>
 
 ClassImp(AliMUONChamberTrigger)
 
 //-------------------------------------------
 
 AliMUONChamberTrigger::AliMUONChamberTrigger()
+  : AliMUONChamber()
 {
 // Default constructor
 }
 
 
-AliMUONChamberTrigger::AliMUONChamberTrigger(Int_t id) : AliMUONChamber(id)
+AliMUONChamberTrigger::AliMUONChamberTrigger(Int_t id) 
+  : AliMUONChamber(id)
 {
 // Constructor using chamber id
 }
index 4de877642af12b0dadcc5b4ec005a51ba129b42c..cbb840dfa37882032fbb6c602ba6008c610b310c 100644 (file)
@@ -5,6 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliMUONChamber.h"
 
@@ -14,19 +15,20 @@ class AliMUONSegmentationTrigger ;
 class AliMUONResponseTrigger ;
 class AliMUONResponseTriggerV1 ;
 
-class AliMUONChamberTrigger:
-public AliMUONChamber {
- public:
+class AliMUONChamberTrigger : public AliMUONChamber 
+{
 public:
     AliMUONChamberTrigger();
     AliMUONChamberTrigger(Int_t id);
     virtual ~AliMUONChamberTrigger(){}
-// Cluster formation method (charge disintegration)
+    
+    // Cluster formation method (charge disintegration)
     
     virtual void   DisIntegration(Float_t eloss, Float_t tof, Float_t xhit, Float_t yhit, Float_t zhit,
                                        Int_t& nnew, Float_t newclust[6][500]);
 
   ClassDef(AliMUONChamberTrigger,1) // Muon trigger chamber class
-      };
+};
 #endif
 
 
index b61c7b4d9f23eb177c7e6a98c152035b27650788..6a4eb06c9556b6b5fc22c509eb5417caff25015a 100644 (file)
@@ -1,7 +1,22 @@
-#include "AliMUONClusterFinderAZ.h"
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+// Clusterizer class developped by Zitchenko (Dubna)
 
-#include <stdlib.h>
-#include <fcntl.h>
 #include <Riostream.h>
 #include <TROOT.h>
 #include <TCanvas.h>
@@ -13,6 +28,7 @@
 #include <TMinuit.h>
 #include <TMatrixD.h>
 
+#include "AliMUONClusterFinderAZ.h"
 #include "AliHeader.h"
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONPixel.h"
 #include "AliMC.h"
 
-// Clusterizer class developped by Zitchenko (Dubna)
-//
-//
-//
-
-
 ClassImp(AliMUONClusterFinderAZ)
  
  const Double_t AliMUONClusterFinderAZ::fgkCouplMin = 1.e-3; // threshold on coupling 
  AliMUONClusterFinderAZ* AliMUONClusterFinderAZ::fgClusterFinder = 0x0;
  TMinuit* AliMUONClusterFinderAZ::fgMinuit = 0x0;
 
-
 //_____________________________________________________________________________
-AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw=0, Int_t iReco=0)
+AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw, Int_t iReco)
   : AliMUONClusterFinderVS()
 {
 // Constructor
@@ -93,19 +102,6 @@ AliMUONClusterFinderAZ::~AliMUONClusterFinderAZ()
   */
 }
 
-//_____________________________________________________________________________
-AliMUONClusterFinderAZ&  
-AliMUONClusterFinderAZ::operator=(const AliMUONClusterFinderAZ& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  Fatal("operator=", "Not implemented.");
-    
-  return *this;  
-}    
-          
 //_____________________________________________________________________________
 void AliMUONClusterFinderAZ::FindRawClusters()
 {
@@ -2083,7 +2079,7 @@ Int_t AliMUONClusterFinderAZ::Fit(Int_t nfit, Int_t *clustFit, TObjArray **clust
 
     while (1) {
       max = !min;
-      fcn1(fNpar, gin, func0, param, 1); nCall++;
+      Fcn1(fNpar, gin, func0, param, 1); nCall++;
       //cout << " Func: " << func0 << endl;
 
       func2[max] = func0;
@@ -2092,7 +2088,7 @@ Int_t AliMUONClusterFinderAZ::Fit(Int_t nfit, Int_t *clustFit, TObjArray **clust
        delta[j] = step0[j];
        param[j] += delta[j] / 10;
        if (j > 0) param[j-1] -= delta[j-1] / 10;
-       fcn1(fNpar, gin, func1, param, 1); nCall++;
+       Fcn1(fNpar, gin, func1, param, 1); nCall++;
        deriv[max][j] = (func1 - func0) / delta[j] * 10; // first derivative
        //cout << j << " " << deriv[max][j] << endl;
        dder[j] = param0[0][j] != param0[1][j] ? (deriv[0][j] - deriv[1][j]) / 
@@ -2232,7 +2228,7 @@ Int_t AliMUONClusterFinderAZ::Fit(Int_t nfit, Int_t *clustFit, TObjArray **clust
 }  
 
 //_____________________________________________________________________________
-void AliMUONClusterFinderAZ::fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
+void AliMUONClusterFinderAZ::Fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
 {
   // Fit for one track
   AliMUONClusterFinderAZ& c = *(AliMUONClusterFinderAZ::fgClusterFinder);    
@@ -2300,7 +2296,7 @@ void AliMUONClusterFinderAZ::UpdatePads(Int_t /*nfit*/, Double_t *par)
 }  
 
 //_____________________________________________________________________________
-Bool_t AliMUONClusterFinderAZ::TestTrack(Int_t /*t*/) {
+Bool_t AliMUONClusterFinderAZ::TestTrack(Int_t /*t*/) const {
 // Test if track was user selected
   return kTRUE;
   /*
@@ -2493,3 +2489,17 @@ void AliMUONClusterFinderAZ::FindCluster(Int_t *localMax, Int_t iMax)
 
   delete [] used; used = 0;
 }
+
+//_____________________________________________________________________________
+AliMUONClusterFinderAZ&  
+AliMUONClusterFinderAZ::operator=(const AliMUONClusterFinderAZ& rhs)
+{
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
+}    
+          
index ba6eb5103cb10e93470f23c81381fa84dad50651..706ed3052331d7e8393fb517c036edebaf66c36c 100644 (file)
@@ -3,28 +3,30 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <TROOT.h>
+/* $Id$ */
+// Revision of includes 07/05/2004
+
+#include "AliMUONClusterFinderVS.h"
+
 class TH2F;
 class TH2D;
 class TClonesArray;
-class AliSegmentation;
-class AliMUONResponse;
 class TMinuit;
 class TMatrixD;
-class AliMUONPixel;
-#include "AliMUONClusterFinderVS.h"
-
-//class AliMUONClusterFinderAZ : public TObject {
-class AliMUONClusterFinderAZ : public AliMUONClusterFinderVS {
 
- public:
+class AliSegmentation;
+class AliMUONResponse;
+class AliMUONPixel;
 
-  AliMUONClusterFinderAZ(Bool_t draw, Int_t iReco);// Constructor
+class AliMUONClusterFinderAZ : public AliMUONClusterFinderVS 
+{
+public:
+  AliMUONClusterFinderAZ(Bool_t draw = 0, Int_t iReco = 0);// Constructor
   virtual ~AliMUONClusterFinderAZ(); // Destructor
 
   void     FindRawClusters(); // the same interface as for old cluster finder
   void     EventLoop(Int_t nev, Int_t ch); // first event 
-  Bool_t   TestTrack(Int_t t); // test if track was selected
+  Bool_t   TestTrack(Int_t t) const; // test if track was selected
  
 protected:
   AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
@@ -84,7 +86,7 @@ protected:
   void  FlagLocalMax(TH2D *hist, Int_t i, Int_t j, Int_t *isLocalMax); // flag local max
   void  FindCluster(Int_t *localMax, Int_t iMax); // find cluster around local max
   // This function is used for fitting
-  void  fcn1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
+  void  Fcn1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
 
   ClassDef(AliMUONClusterFinderAZ,0) // cluster finder in MUON arm of ALICE
 };
index b02a92e06da36f6ea1facd6bba51f5435472b131..6c600ae1ca11e941be79a1d36650b2d30e2da8b9 100644 (file)
@@ -15,6 +15,9 @@
 
 /* $Id$ */
 
+#include <TMinuit.h> 
+#include <TF1.h>
+
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONDigit.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONResponse.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONHitMapA1.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-
-#include <TTree.h>
-#include <TCanvas.h>
-#include <TH1.h>
-#include <TPad.h>
-#include <TGraph.h> 
-#include <TPostScript.h> 
-#include <TMinuit.h> 
-#include <TF1.h>
-
-#include <stdio.h>
-#include <Riostream.h>
 
 //_____________________________________________________________________
 // This function is minimized in the double-Mathieson fit
@@ -47,6 +36,7 @@ void fcnCombiS2(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t if
 ClassImp(AliMUONClusterFinderVS)
 
 AliMUONClusterFinderVS::AliMUONClusterFinderVS()
+  : TObject()
 {
 // Default constructor
     fInput=AliMUONClusterInput::Instance();
@@ -64,8 +54,6 @@ AliMUONClusterFinderVS::AliMUONClusterFinderVS()
     } 
     fRawClusters = new TClonesArray("AliMUONRawCluster",1000);
     fNRawClusters = 0;
-
-
 }
  //____________________________________________________________________________
 AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
@@ -80,8 +68,9 @@ AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
 
 AliMUONClusterFinderVS::AliMUONClusterFinderVS(const AliMUONClusterFinderVS & clusterFinder):TObject(clusterFinder)
 {
-// Dummy copy Constructor
-    ;
+// Protected copy constructor
+
+  Fatal("AliMUONClusterFinderAZModule", "Not implemented.");
 }
 //____________________________________________________________________________
 void AliMUONClusterFinderVS::ResetRawClusters()
@@ -2094,7 +2083,7 @@ void AliMUONClusterFinderVS::AddRawCluster(const AliMUONRawCluster& c)
        fprintf(stderr,"\nfNRawClusters %d\n",fNRawClusters);
 }
 
-Bool_t AliMUONClusterFinderVS::TestTrack(Int_t t) {
+Bool_t AliMUONClusterFinderVS::TestTrack(Int_t t) const {
 // Test if track was user selected
     if (fTrack[0]==-1 || fTrack[1]==-1) {
        return kTRUE;
@@ -2106,10 +2095,15 @@ Bool_t AliMUONClusterFinderVS::TestTrack(Int_t t) {
 }
 
 AliMUONClusterFinderVS& AliMUONClusterFinderVS
-::operator = (const AliMUONClusterFinderVS& /*rhs*/)
+::operator = (const AliMUONClusterFinderVS& rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
 
index 4b0c89c4e4aa4cc61c2fdc50bcf6298a8d532e24..ffa68abb9dd1e78d44b65b4250fdae227e1d4122 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 ////////////////////////////////////////////////
 //  MUON Cluster Finder Class                 //
 
 #include <TObject.h>
 
+class TClonesArray;
+
 class AliMUONClusterInput;
 class AliMUONHitMapA1;
 class AliMUONResponse;
 class AliSegmentation;
-class TClonesArray;
 class AliMUONRawCluster;
 class AliMUONDigit;
 
@@ -24,7 +26,6 @@ class AliMUONClusterFinderVS : public TObject
 {
  public:
     AliMUONClusterFinderVS();
-    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
     virtual ~AliMUONClusterFinderVS();
 // Decluster ?
     virtual void SetDeclusterFlag(Int_t flag=1) {fDeclusterFlag =flag;}
@@ -55,9 +56,7 @@ class AliMUONClusterFinderVS : public TObject
     virtual void AddRawCluster(const AliMUONRawCluster& cluster);
 //  Set tracks for debugging    
     virtual void SetTracks(Int_t t1, Int_t t2) {fTrack[0]=t1; fTrack[1]=t2;}
-    virtual Bool_t TestTrack(Int_t t);
-//  Assignment operator
-    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
+    virtual Bool_t TestTrack(Int_t t) const;
 //  debug level
     void SetDebugLevel(Int_t level) {fDebugLevel = level;}
     void SetGhostChi2Cut(Float_t cut) {fGhostChi2Cut = cut;}
@@ -67,6 +66,10 @@ class AliMUONClusterFinderVS : public TObject
     void ResetRawClusters();
 
  protected:
+    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
+//  Assignment operator
+    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
+
     AliMUONClusterInput*    fInput;              // ! AliMUONClusterInput instance
     AliMUONHitMapA1*        fHitMap[2];          // Hit Maps for cathode 1 and 2
     AliSegmentation*        fSeg[2];             // Segmentations for cathode 1 and 2
index 9f4f1951d9ff55876f939a4958049691639df024..0b0b54ff322cd0cd7de5e89931419527d0106a0a 100644 (file)
 
 /* $Id$ */
 
+#include <TClonesArray.h>
+#include <TMinuit.h>
+
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
 #include "AliMUONClusterInput.h"
-#include "AliSegmentation.h"
 #include "AliMUONResponse.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONDigit.h"
 
-#include <TClonesArray.h>
-#include <TMinuit.h>
-
 ClassImp(AliMUONClusterInput)
 
 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0; 
 TMinuit* AliMUONClusterInput::fgMinuit = 0; 
 
-AliMUONClusterInput::AliMUONClusterInput(){
+AliMUONClusterInput::AliMUONClusterInput()
+  : TObject()
+{
   fgClusterInput = 0; 
   fgMinuit = 0; 
   fDigits[0]=0;
@@ -59,9 +60,12 @@ AliMUONClusterInput::~AliMUONClusterInput()
 // Destructor
     delete fgMinuit;
 }
+
 AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
 {
-  
+// Protected copy constructor
+
+  Fatal("AliMUONClusterInput", "Not implemented.");
 }
 
 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
@@ -212,8 +216,13 @@ Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cat
 }
 
 AliMUONClusterInput& AliMUONClusterInput
-::operator = (const AliMUONClusterInput& /*rhs*/)
+::operator = (const AliMUONClusterInput& rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
index 5806b289c595feac26d4331f0111ff3d20034716..b17e11c2da28e8785740b2dd1bbb2021d063b072 100644 (file)
@@ -3,18 +3,21 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/*$Id $*/
+/* $Id $*/
+// Revision of includes 07/05/2004
+
+#include <TObject.h>
+#include <TClonesArray.h> // needed for inline function Digit
 
 class TMinuit;
+
 class AliMUONDigit;
 class AliMUONRawCluster;
 class AliSegmentation;
 class AliMUONResponse;
 
-#include <TClonesArray.h> // needed for inline function Digit
-
-
-class AliMUONClusterInput : public TObject {
+class AliMUONClusterInput : public TObject 
+{
  public:
     virtual ~AliMUONClusterInput();
     static AliMUONClusterInput* Instance();
@@ -23,20 +26,20 @@ class AliMUONClusterInput : public TObject {
     void SetDigits(Int_t chamber, TClonesArray* dig);
     void SetCluster(AliMUONRawCluster* cluster);
 // Access functions
-    Int_t Chamber()  {return fChamber;}
-    AliMUONDigit* Digit(Int_t cath, Int_t i) {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
-    TClonesArray* Digits(Int_t cath) {return fDigits[cath];}
-    Int_t NDigits(Int_t cath) {return fNDigits[cath];}
-    AliSegmentation* Segmentation(Int_t cath)  {return fSegmentation[cath];}
-    AliMUONResponse* Response()  {return fResponse;}    
+    Int_t Chamber() const {return fChamber;}
+    AliMUONDigit* Digit(Int_t cath, Int_t i) const {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
+    TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
+    Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
+    AliSegmentation* Segmentation(Int_t cath) const {return fSegmentation[cath];}
+    AliMUONResponse* Response() const {return fResponse;}    
 // Fitting    
-    TMinuit*      Fitter() {return fgMinuit;}
+    TMinuit*      Fitter() const {return fgMinuit;}
 // Current cluster information    
-    Float_t       TotalCharge(Int_t cath) {return fChargeTot[cath];}
-    Float_t       Charge(Int_t dig, Int_t cath) {return fCharge[dig][cath];}
-    Int_t         Ix(Int_t dig, Int_t cath) {return fix[dig][cath];}
-    Int_t         Iy(Int_t dig, Int_t cath) {return fiy[dig][cath];}
-    Int_t         Nmul(Int_t cath)  {return fNmul[cath];}
+    Float_t       TotalCharge(Int_t cath) const {return fChargeTot[cath];}
+    Float_t       Charge(Int_t dig, Int_t cath) const {return fCharge[dig][cath];}
+    Int_t         Ix(Int_t dig, Int_t cath) const {return fix[dig][cath];}
+    Int_t         Iy(Int_t dig, Int_t cath) const {return fiy[dig][cath];}
+    Int_t         Nmul(Int_t cath) const {return fNmul[cath];}
 //  Helpers for Fit     
     Float_t DiscrChargeS1(Int_t i,Double_t *par);
     Float_t DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath);
index 232adb9e12549978c3f0df1909a3b91044c1eda3..4bbc81e57baccfe11727451c0b4b10c715a649f2 100644 (file)
 //
 ////////////////////////////////////
 
-#include <Riostream.h> // for cout
-#include <stdlib.h> // for exit()
-
-#include <TTree.h>
-
-#include "AliMUON.h"
 #include "AliMUONClusterReconstructor.h"
+#include "AliMUON.h"
 #include "AliMUONDigit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONData.h"
 #include "AliMUONClusterFinderVS.h"
-#include "AliMUONClusterFinderAZ.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONRawCluster.h"
 #include "AliRun.h" // for gAlice
-#include "AliConfig.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 
@@ -57,8 +50,9 @@ ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
 
 //__________________________________________________________________________
 AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
+  : TObject()
 {
-  // Default Constructor
+  // Standard Constructor
  
   fDebug           = 0;
   fNCh             = 0;
@@ -82,9 +76,23 @@ AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
 
   // getting MUON
   fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+}
 
-  return; 
+//__________________________________________________________________________
+AliMUONClusterReconstructor::AliMUONClusterReconstructor()
+  : TObject(),
+    fNCh(0),
+    fNTrackingCh(0),
+    fMUONData(0),
+    fMUON(0),
+    fChambers(0),
+    fPrintLevel(fgkDefaultPrintLevel),
+    fDebug(0),
+    fLoader(0)
+{
+  // Default Constructor
 }
+
 //____________________________________________________________________
 void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
 {
@@ -98,15 +106,25 @@ void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONCluste
   ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
 }
 //_______________________________________________________________________
-AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& Reconstructor):TObject(Reconstructor)
+AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs)
+  : TObject(rhs)
 {
-  // Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONClusterReconstructor", "Not implemented.");
 }
 
-AliMUONClusterReconstructor & AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& /*Reconstructor*/)
+//_______________________________________________________________________
+AliMUONClusterReconstructor & 
+AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& rhs)
 {
-  // Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
 //__________________________________________________________________________
index d2e841f386da78872ad51c69b2264e187ba1a046..7f29adc591a7813235c317d80e2f8dccef17b9be 100644 (file)
@@ -4,12 +4,13 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 ////////////////////////////////////
 // MUON event reconstructor in ALICE
 ////////////////////////////////////
-#include "TObjArray.h"
-#include "AliDetector.h"
+
+#include <TObject.h>
 
 class AliLoader;
 class AliMUON;
@@ -19,13 +20,11 @@ class AliMUONClusterFinderVS;
 class AliMUONData;
 
 
-class AliMUONClusterReconstructor : public TObject {
-
+class AliMUONClusterReconstructor : public TObject 
+{
  public:
   AliMUONClusterReconstructor(AliLoader* loader); // Constructor
   virtual ~AliMUONClusterReconstructor(void); // Destructor
-  AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs); // copy constructor
-  AliMUONClusterReconstructor& operator=(const AliMUONClusterReconstructor& rhs); // assignment operator
 
   // Interface with AliMUONData
   virtual void       SetTreeAddress(){};
@@ -45,6 +44,9 @@ class AliMUONClusterReconstructor : public TObject {
   void SetPrintLevel(Int_t printLevel) {fPrintLevel = printLevel;}
 
  protected:
+  AliMUONClusterReconstructor();                  // Default constructor
+  AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs); // copy constructor
+  AliMUONClusterReconstructor& operator=(const AliMUONClusterReconstructor& rhs); // assignment operator
 
  private:
   static const Int_t fgkDefaultPrintLevel;     // Default print level
index 053256caf4c023e3f623782f3b9d04e9e92ebac4..1e5e1b3ff056470a2dccd5ce82cf56447434c0de 100644 (file)
@@ -3,7 +3,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/*$Id $*/
+/* $Id $*/
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
@@ -27,9 +28,11 @@ class AliMUONConstants : public TObject {
     static Float_t  Dmax(Int_t i) {return fgDmax[i];}
     // return maximum zoom for event display
     static Int_t    MaxZoom() {return fgMaxZoom;}
- private:
-    AliMUONConstants(){}
+
+ protected:
+    AliMUONConstants() : TObject() {}
     virtual ~AliMUONConstants(){}
+
  private:
     static Int_t  fgNCh;                //  Number of Chambers    
     static Int_t  fgNTrackingCh;        //  Number of Tracking Chambers
index 2e117f348a216e5bdfaf672d6a717270ebe175b4..94c13960fc70a5518349fe32097900de58a17aa6 100644 (file)
 // Gines Martinez, Subatech,  September 2003
 //
 
-//Root includes
-#include "TNamed.h"
 //AliRoot include
-#include "AliRun.h"
-#include "AliMC.h" 
-#include "AliLoader.h" 
+//#include "AliRun.h"
+//#include "AliMC.h" 
 #include "AliMUONConstants.h"
 #include "AliMUONData.h"
 #include "AliMUONDigit.h"
@@ -35,6 +32,7 @@
 #include "AliMUONRawCluster.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTriggerTrack.h"
+
 ClassImp(AliMUONData)
  
 //_____________________________________________________________________________
@@ -188,13 +186,13 @@ void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
   new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
 }
 //_____________________________________________________________________________
-void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *Sdigits)
+void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *sdigits)
 {
   //
   // Add a MUON Sdigit to the list of SDigits of the detection plane id
   //
   TClonesArray &lSdigits = * SDigits(id) ; 
-  new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,Sdigits);
+  new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,sdigits);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
@@ -567,9 +565,9 @@ void AliMUONData::MakeBranch(Option_t* option)
        Info("MakeBranch","Branch %s is already in tree.",GetName());
        return;
       }
-      TClonesArray * Sdigits = SDigits(iDetectionPlane); 
-      branch = TreeS()->Branch(branchname, &Sdigits, kBufferSize,1);
-      //Info("MakeBranch","Making Branch %s for Sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
+      TClonesArray * sdigits = SDigits(iDetectionPlane); 
+      branch = TreeS()->Branch(branchname, &sdigits, kBufferSize,1);
+      //Info("MakeBranch","Making Branch %s for sdigits in detection plane %d\n",branchname,iDetectionPlane+1);
       }
   }
 
@@ -844,8 +842,8 @@ void AliMUONData::SetTreeAddress(Option_t* option)
       sprintf(branchname,"%sSDigits%d",GetName(),i+1);
       if (fSDigits) {
        branch = TreeS()->GetBranch(branchname);
-       TClonesArray * Sdigits = SDigits(i);
-       if (branch) branch->SetAddress( &Sdigits );
+       TClonesArray * sdigits = SDigits(i);
+       if (branch) branch->SetAddress( &sdigits );
        else Warning("SetTreeAddress","(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i);
       }
     }
index d869884cba9a8fe1be84f93f4c10ebad28e60faf..825e3e944cae6befc42b3241de57a9975bd1a0cc 100644 (file)
@@ -5,12 +5,15 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // AliMUONData
 // Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ...
 // Gines Martinez, Subatech,  September 2003
 //
 
+#include <TNamed.h>
+
 #include "AliLoader.h"
 
 class TClonesArray;
@@ -18,7 +21,6 @@ class TNamed;
 class TObjArray;
 class TTree;
 
-
 class AliMUONConstants;
 class AliMUONRawCluster;
 class AliMUONTrack;
@@ -81,15 +83,15 @@ class AliMUONData : public TNamed
     TClonesArray*  RecTracks() {return fRecTracks;}
     TClonesArray*  RecTriggerTracks() {return fRecTriggerTracks;}
 
-    void           GetTrack(Int_t it) {fLoader->TreeH()->GetEvent(it);}
-    Int_t          GetNtracks()       {return (Int_t) fLoader->TreeH()->GetEntries();}
-    void           GetCathode(Int_t ic) {fLoader->TreeD()->GetEvent(ic);}
-    void           GetCathodeS(Int_t ic) {fLoader->TreeS()->GetEvent(ic);}
-    void           GetRawClusters() {fLoader->TreeR()->GetEvent(0);}
-    void           GetTrigger() {fLoader->TreeR()->GetEvent(0);}
-    Int_t          GetSplitLevel() {return fSplitLevel;}
-    void           GetRecTracks() {fLoader->TreeT()->GetEvent(0);}
-    void           GetRecTriggerTracks() {fLoader->TreeT()->GetEvent(0);}
+    void           GetTrack(Int_t it) const  {fLoader->TreeH()->GetEvent(it);}
+    Int_t          GetNtracks() const      {return (Int_t) fLoader->TreeH()->GetEntries();}
+    void           GetCathode(Int_t ic) const {fLoader->TreeD()->GetEvent(ic);}
+    void           GetCathodeS(Int_t ic) const {fLoader->TreeS()->GetEvent(ic);}
+    void           GetRawClusters() const {fLoader->TreeR()->GetEvent(0);}
+    void           GetTrigger() const {fLoader->TreeR()->GetEvent(0);}
+    Int_t          GetSplitLevel() const {return fSplitLevel;}
+    void           GetRecTracks() const {fLoader->TreeT()->GetEvent(0);}
+    void           GetRecTriggerTracks() const {fLoader->TreeT()->GetEvent(0);}
 
     Bool_t        IsRawClusterBranchesInTree();
     Bool_t        IsTriggerBranchesInTree();
index 7acd680dd49a482cf20cc5282f9caa96b5047618..f1a10d8ba790dbc3b035e6226983951170e24634 100644 (file)
@@ -3,12 +3,16 @@
 //  email: artur@alice.phy.uct.ac.za
 
 #include <TError.h>
+#include <TParticle.h>
 
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 
 #include "AliMUONDataInterface.h"
-#include "AliMUONData.h"
+#include "AliMUONLocalTrigger.h"
+#include "AliMUONHit.h"
+#include "AliMUONDigit.h"
+#include "AliMUONRawCluster.h"
 
 
 ClassImp(AliMUONDataInterface)
index b795e4da0d883ebff9d9c9990ba00f331512c22f..8e3cf2391b9b47b81c9540d6187fe21102ba62fd 100644 (file)
@@ -1,21 +1,27 @@
 #ifndef ALI_MUON_DATA_INTERFACE_H
 #define ALI_MUON_DATA_INTERFACE_H
+/*  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Includes revised 07/05/2004
 
 // Author: Artur Szostak
 //  email: artur@alice.phy.uct.ac.za
 
 #include <TObject.h>
 #include <TString.h>
-#include <TParticle.h>
 
-#include "AliRunLoader.h"
-#include "AliLoader.h"
 #include "AliMUONData.h"
 
-#include "AliMUONHit.h"
-#include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONLocalTrigger.h"
+class TParticle;
+
+class AliRunLoader;
+class AliLoader;
+class AliMUONRawCluster;
+class AliMUONLocalTrigger;
+class AliMUONHit;
+class AliMUONDigit;
 
 
 // An easy to use interface to the MUON module data stored in TreeK, TreeH, TreeS, TreeD and TreeR
@@ -86,22 +92,22 @@ public:
        
        
        // Returns the name of the currently selected file.
-       TString CurrentFile()     { return fFilename;    };
+       TString CurrentFile() const    { return fFilename;    };
        
        // Returns the name of the currently selected folder.
-       TString CurrentFolder()   { return fFoldername;  };
+       TString CurrentFolder() const   { return fFoldername;  };
        
        // Returns the number of the currently selected event.
-       Int_t   CurrentEvent()    { return fEventnumber; };
+       Int_t   CurrentEvent() const    { return fEventnumber; };
        
        // Returns the currently selected track.
-       Int_t   CurrentTrack()    { return fTrack;       };
+       Int_t   CurrentTrack() const    { return fTrack;       };
        
        // Returns the currently selected cathode in TreeS.
-       Int_t   CurrentSCathode() { return fSCathode;    };
+       Int_t   CurrentSCathode() const { return fSCathode;    };
        
        // Returns the currently selected cathode in TreeD.
-       Int_t   CurrentDCathode() { return fCathode;     };
+       Int_t   CurrentDCathode() const { return fCathode;     };
 
 protected:
         AliMUONDataInterface(const AliMUONDataInterface& rhs);
index cde04b760a88478d4d74f73f1583e27559303b08..3fff34d4dae80ca4e2fc1b8e6d8f1e2fb11a6609 100644 (file)
@@ -36,6 +36,13 @@ ClassImp(AliMUONDigit)
     }
 }
 
+//_____________________________________________________________________________
+ AliMUONDigit::AliMUONDigit()
+   : TObject()
+{
+// Default constructor
+}
+
 //_____________________________________________________________________________
 AliMUONDigit::AliMUONDigit(Int_t *digits)
 {
index 02927930f7d632cce7a334a19850b8c52d103d1a..ef8b0eb6d02f1b1c013285d2ddbc6368ff37bd5e 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
@@ -12,7 +13,7 @@ static const Int_t kMAXTRACKS=10;
 class AliMUONDigit : public TObject {
 
  public:
-    AliMUONDigit() {}
+    AliMUONDigit();
     AliMUONDigit(const AliMUONDigit& rhs);
     AliMUONDigit(Int_t *digits);
     AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits);
index ace38608435dc8ce8b547881e8a52ee422ec8421..d0e2a49883caf4e03d76d7c9aab1d6f2403d4192 100644 (file)
 
 /* $Id$ */
 
-#include <Riostream.h>
-#include <TDirectory.h>
-#include <TPDGCode.h>
-
 #include "AliRun.h"
 #include "AliRunDigitizer.h"
 #include "AliRunLoader.h"
-#include "AliLoader.h"
 
 #include "AliMUONDigitizer.h"
 #include "AliMUONConstants.h"
 #include "AliMUONChamber.h"
 #include "AliMUONHitMapA1.h"
 #include "AliMUON.h"
+#include "AliMUONLoader.h"
 #include "AliMUONChamber.h"
 #include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
 #include "AliMUONDigitizer.h"
-#include "AliMUONHit.h"
-#include "AliMUONHitMapA1.h"
-#include "AliMUONPadHit.h"
 #include "AliMUONTransientDigit.h"
+#include "AliMUONHitMapA1.h"
+
 
 /////////////////////////////////////////////////////////////////////////////////////
 //
@@ -64,10 +58,10 @@ AliMUONDigitizer::AliMUONDigitizer() :
 // Default constructor.
 // Initializes all pointers to NULL.
 
-       runloader = NULL;
-       gime = NULL;
-       pMUON = NULL;
-       muondata = NULL;
+       fRunLoader = NULL;
+       fGime = NULL;
+       fMUON = NULL;
+       fMUONData = NULL;
 };
 
 //___________________________________________
@@ -83,10 +77,10 @@ AliMUONDigitizer::AliMUONDigitizer(AliRunDigitizer* manager) :
 // Constructor which should be used rather than the default constructor.
 // Initializes all pointers to NULL.
 
-       runloader = NULL;
-       gime = NULL;
-       pMUON = NULL;
-       muondata = NULL;
+       fRunLoader = NULL;
+       fGime = NULL;
+       fMUON = NULL;
+       fMUONData = NULL;
 };
 
 //___________________________________________
@@ -143,8 +137,8 @@ void AliMUONDigitizer::Exec(Option_t* option)
                return;
        };
 
-       if (! FetchLoaders(fManager->GetInputFolderName(0), runloader, gime) ) return;
-       if (! FetchGlobalPointers(runloader) ) return;
+       if (! FetchLoaders(fManager->GetInputFolderName(0), fRunLoader, fGime) ) return;
+       if (! FetchGlobalPointers(fRunLoader) ) return;
 
        InitArrays();
        
@@ -161,21 +155,21 @@ void AliMUONDigitizer::Exec(Option_t* option)
 
                if (inputFile != 0)
                        // If this is the first file then we already have the loaders loaded.
-                       if (! FetchLoaders(fManager->GetInputFolderName(inputFile), runloader, gime) )
+                       if (! FetchLoaders(fManager->GetInputFolderName(inputFile), fRunLoader, fGime) )
                                continue;
                else
                        // If this is not the first file then it is assumed to be background.
                        fSignal = kFALSE;
 
-               if (! InitInputData(gime) ) continue;
+               if (! InitInputData(fGime) ) continue;
                GenerateTransientDigits();
-               CleanupInputData(gime);
+               CleanupInputData(fGime);
        };
 
-       Bool_t ok = FetchLoaders(fManager->GetOutputFolderName(), runloader, gime);
-       if (ok) ok = InitOutputData(gime);
+       Bool_t ok = FetchLoaders(fManager->GetOutputFolderName(), fRunLoader, fGime);
+       if (ok) ok = InitOutputData(fGime);
        if (ok) CreateDigits();
-       if (ok) CleanupOutputData(gime);
+       if (ok) CleanupOutputData(fGime);
 
        CleanupArrays();
 };
@@ -291,13 +285,13 @@ void AliMUONDigitizer::CreateDigits()
 };
 
 //------------------------------------------------------------------------
-void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t response_charge)
+void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t responseCharge)
 {
 // Prepares the digits, track and charge arrays in preparation for a call to
 // AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
 // This method is called by CreateDigits() whenever a new digit needs to be added
 // to the output stream trees.
-// The response_charge value is used as the Signal of the new digit. 
+// The responseCharge value is used as the Signal of the new digit. 
 // The OnWriteTransientDigit method is also called just before the adding the 
 // digit to allow inheriting digitizers to be able to do some specific processing 
 // at this point. 
@@ -309,7 +303,7 @@ void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t response_charge
        digits[0] = td->PadX();
        digits[1] = td->PadY();
        digits[2] = td->Cathode() - 1;
-       digits[3] = response_charge;
+       digits[3] = responseCharge;
        digits[4] = td->Physics();
        digits[5] = td->Hit();
        
@@ -344,7 +338,7 @@ void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t response_charge
                };
        };
 
-       if (GetDebug() > 3) Info("AddDigit", "Adding digit with charge %d.", response_charge);
+       if (GetDebug() > 3) Info("AddDigit", "Adding digit with charge %d.", responseCharge);
 
        OnWriteTransientDigit(td);
        AddDigit(td->Chamber(), tracks, charges, digits);
@@ -414,14 +408,14 @@ Bool_t AliMUONDigitizer::FetchGlobalPointers(AliRunLoader* runloader)
                Error("FetchGlobalPointers", "Could not find the AliRun object in runloader 0x%X.", (void*)runloader);
                return kFALSE;
        };
-       pMUON = (AliMUON*) gAlice->GetDetector("MUON");
-       if (pMUON == NULL)
+       fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+       if (fMUON == NULL)
        {
                Error("FetchGlobalPointers", "Could not find the MUON module in runloader 0x%X.", (void*)runloader);
                return kFALSE;
        };
-       muondata = pMUON->GetMUONData();
-       if (muondata == NULL)
+       fMUONData = fMUON->GetMUONData();
+       if (fMUONData == NULL)
        {
                Error("FetchGlobalPointers", "Could not find AliMUONData object in runloader 0x%X.", (void*)runloader);
                return kFALSE;
@@ -472,7 +466,7 @@ void AliMUONDigitizer::InitArrays()
        for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) 
        {
                if (GetDebug() > 3) Info("InitArrays", "Creating hit map for chamber %d, cathode 1.", i+1);
-               AliMUONChamber* chamber = &(pMUON->Chamber(i));
+               AliMUONChamber* chamber = &(fMUON->Chamber(i));
                AliSegmentation* c1Segmentation = chamber->SegmentationModel(1); // Cathode plane 1
                fHitMap[i] = new AliMUONHitMapA1(c1Segmentation, fTDList);
                if (GetDebug() > 3) Info("InitArrays", "Creating hit map for chamber %d, cathode 2.", i+1);
@@ -503,7 +497,7 @@ void AliMUONDigitizer::CleanupArrays()
 };
 
 //------------------------------------------------------------------------
-void AliMUONDigitizer::SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr)
+void AliMUONDigitizer::SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr) const
 {
 //
 // Sort the list of tracks contributing to a given digit
index 32458513bafa49c7c5dc74daafca8f2ffb55e0a4..1bf15e6b376ec026297aec149da12ea6bd9741d5 100644 (file)
@@ -4,16 +4,18 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
+
 #include "AliDigitizer.h"
-#include "AliRunLoader.h"
-#include "AliMUONLoader.h"
-#include "AliMUONTransientDigit.h"
-#include "AliMUON.h"
-#include "AliMUONData.h"
+#include "AliMUONDigit.h"
 
 class AliRunDigitizer;
+class AliRunLoader;
 class AliMUONHitMapA1;
-
+class AliMUON;
+class AliMUONData;
+class AliMUONLoader;
+class AliMUONTransientDigit;
 
 class AliMUONDigitizer : public AliDigitizer
 {
@@ -52,7 +54,7 @@ protected:
        /* Digitizers inheriting from AliMUONDigitizer should implement this abstract method 
           so that TransientDigit objects are generated and put onto the fTDList.
           The method would be implemented as some loop over the input stream. The data can be
-          fetched from the muondata pointer. To add to the fTDList once should use code similar
+          fetched from the fMUONData pointer. To add to the fTDList once should use code similar
           to the following:
           
             TObject* source_object;  // Assume the object from which the transient digit
@@ -72,7 +74,7 @@ protected:
        // Loops over the fTDList of transient digits to write them to the output stream.
        virtual void CreateDigits();
 
-       /* Inheriting digitizers should implement this method to prepare the muondata
+       /* Inheriting digitizers should implement this method to prepare the fMUONData
           object before GenerateTransientDigits() is called. 
           If the initialization was successful then kTRUE should be returned otherwise
           kFALSE should be returned. 
@@ -84,17 +86,17 @@ protected:
         */
        virtual void CleanupInputData(AliMUONLoader* muonloader) = 0;
 
-       /* Inheriting digitizers should implement this method to prepare the muondata
+       /* Inheriting digitizers should implement this method to prepare the fMUONData
           object before CreateDigits() is called.
           If the initialization was successful then kTRUE should be returned otherwise
           kFALSE should be returned. 
         */
        virtual Bool_t InitOutputData(AliMUONLoader* muonloader) = 0;
 
-       /* When all the data is added to the muondata object and the trees need to be
+       /* When all the data is added to the fMUONData object and the trees need to be
           filled then this method is called by CreateDigits(). 
           Thus code like
-              muondata->Fill("D")
+              fMUONData->Fill("D")
           should go into this method.
         */
        virtual void FillOutputData() = 0;
@@ -122,12 +124,12 @@ protected:
        virtual void OnCreateTransientDigit(AliMUONTransientDigit* /*digit*/, TObject* /*source_object*/);
 
        /* Called by AddDigit(AliMUONTransientDigit*, Int_t) when transient digit is added to the 
-          muondata object ready for writing to the data trees.
+          fMUONData object ready for writing to the data trees.
         */ 
        virtual void OnWriteTransientDigit(AliMUONTransientDigit* digit);
        
        // Wrapper method for AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
-       void AddDigit(AliMUONTransientDigit* td, Int_t response_charge);
+       void AddDigit(AliMUONTransientDigit* td, Int_t responseCharge);
 
        // Creates a new fTDList object, and creates and fills the fHitMap arrays.
        // Note: this method assumes the array pointers are NULL when calling this method.
@@ -159,13 +161,13 @@ protected:
        Bool_t ExistTransientDigit(AliMUONTransientDigit * mTD); 
 
        // Sorts the 3 most significant tracks.    
-       void SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr);
+       void SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr) const;
 
 
-       AliRunLoader* runloader;        //! Global run loader.
-       AliMUONLoader* gime;            //! MUON specific loader.
-       AliMUON* pMUON;                 //! Pointer to MUON module.
-       AliMUONData* muondata;          //! muon data interface
+       AliRunLoader* fRunLoader;        //! Global run loader.
+       AliMUONLoader* fGime;            //! MUON specific loader.
+       AliMUON* fMUON;                 //! Pointer to MUON module.
+       AliMUONData* fMUONData;          //! muon data interface
 
        AliMUONHitMapA1 **fHitMap;      //! pointer to array of pointers to hitmaps
        TObjArray *fTDList;             //! list of AliMUONTransientDigits
index b5e01b07a25d98eb173003cdbb37327f2f960653..6649b88f7ed68afee7c5cbc6fec4c5a8a155b9ad 100644 (file)
@@ -1,26 +1,19 @@
-
-#include <Riostream.h>
-#include <TDirectory.h>
-#include <TFile.h>
-#include <TObjArray.h>
-#include <TPDGCode.h>
-#include <TTree.h> 
-#include <TMath.h>
-
-#include "AliRun.h"
-#include "AliRunDigitizer.h"
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONDigitizerv1.h"
-#include "AliMUONHit.h"
-#include "AliMUONHitMapA1.h"
-#include "AliMUONPadHit.h"
-#include "AliMUONTransientDigit.h"
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
 
 /////////////////////////////////////////////////////////////////////////////////
 //
 //
 /////////////////////////////////////////////////////////////////////////////////
 
+#include <TTree.h> 
+
+#include "AliMUON.h"
+#include "AliMUONData.h"
+#include "AliMUONLoader.h"
+#include "AliMUONChamber.h"
+#include "AliMUONConstants.h"
+#include "AliMUONDigitizerv1.h"
+#include "AliMUONHit.h"
+#include "AliMUONTransientDigit.h"
+
 ClassImp(AliMUONDigitizerv1)
 
 //___________________________________________
@@ -62,7 +66,7 @@ void AliMUONDigitizerv1::GenerateTransientDigits()
 // MakeTransientDigitsFromHit for each hit. 
 // Note: Charge correlation is applied to the tracking chambers. 
 
-       TTree* treeH = gime->TreeH();
+       TTree* treeH = fGime->TreeH();
        if (GetDebug() > 1)
                Info("GenerateTransientDigits", "Generating transient digits using treeH = 0x%X"
                        , (void*)treeH);
@@ -72,11 +76,11 @@ void AliMUONDigitizerv1::GenerateTransientDigits()
        for (Int_t itrack = 0; itrack < ntracks; itrack++) 
        {
                if (GetDebug() > 2) Info("GenerateTransientDigits", "Processing track %d...", itrack);
-               muondata->ResetHits();
+               fMUONData->ResetHits();
                treeH->GetEvent(itrack);
                //
                //  Loop over hits
-               TClonesArray* hits = muondata->Hits();
+               TClonesArray* hits = fMUONData->Hits();
                for (Int_t ihit = 0; ihit < hits->GetEntriesFast(); ihit++) 
                {
                        AliMUONHit* mHit = static_cast<AliMUONHit*>( hits->At(ihit) );
@@ -98,7 +102,7 @@ void AliMUONDigitizerv1::GenerateTransientDigits()
                        }
                        // 
                        // Inititializing Correlation
-                       AliMUONChamber& chamber = pMUON->Chamber(ichamber);
+                       AliMUONChamber& chamber = fMUON->Chamber(ichamber);
                        chamber.ChargeCorrelationInit();
                        if (ichamber < AliMUONConstants::NTrackingCh()) 
                        {
@@ -132,7 +136,7 @@ void AliMUONDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, Ali
        Float_t newdigit[6][500];  // Pad information
        Int_t nnew=0;              // Number of touched Pads per hit
        Int_t ichamber = mHit->Chamber()-1;
-       AliMUONChamber& chamber = pMUON->Chamber(ichamber);
+       AliMUONChamber& chamber = fMUON->Chamber(ichamber);
        chamber.DisIntegration(mHit->Eloss(), mHit->Age(), mHit->X(), mHit->Y(), mHit->Z(), nnew, newdigit);
 
        // Creating new TransientDigits from hit
@@ -174,7 +178,7 @@ void AliMUONDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, Ali
 void AliMUONDigitizerv1::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6])
 {
 // Derived to add digits to TreeD.
-       muondata->AddDigit(chamber, tracks, charges, digits);   
+       fMUONData->AddDigit(chamber, tracks, charges, digits);   
 };
 
 //------------------------------------------------------------------------
@@ -188,7 +192,7 @@ Int_t AliMUONDigitizerv1::GetSignalFrom(AliMUONTransientDigit* td)
        //
        //  Digit Response (noise, threshold, saturation, ...)
        Int_t q = td->Signal(); 
-       AliMUONChamber& chamber = pMUON->Chamber(td->Chamber());
+       AliMUONChamber& chamber = fMUON->Chamber(td->Chamber());
        AliMUONResponse* response = chamber.ResponseModel();
        q = response->DigitResponse(q, td);
        return q;
@@ -198,12 +202,12 @@ Int_t AliMUONDigitizerv1::GetSignalFrom(AliMUONTransientDigit* td)
 Bool_t AliMUONDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
 {
 // Derived to initialize the output digits tree TreeD, create it if necessary
-// and sets the muondata tree address to treeD.
+// and sets the fMUONData tree address to treeD.
 
        if (GetDebug() > 2)
                Info("InitOutputData", "Creating digits branch and setting the tree address.");
 
-       muondata->SetLoader(muonloader);
+       fMUONData->SetLoader(muonloader);
 
        // New branch per chamber for MUON digit in the tree of digits
        if (muonloader->TreeD() == NULL)
@@ -216,8 +220,8 @@ Bool_t AliMUONDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
                };
        };
 
-       muondata->MakeBranch("D");
-       muondata->SetTreeAddress("D");
+       fMUONData->MakeBranch("D");
+       fMUONData->SetTreeAddress("D");
        
        return kTRUE;
 };
@@ -225,11 +229,11 @@ Bool_t AliMUONDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
 //------------------------------------------------------------------------
 void AliMUONDigitizerv1::FillOutputData()
 {
-// Derived to fill TreeD and resets the digit array in muondata.
+// Derived to fill TreeD and resets the digit array in fMUONData.
 
        if (GetDebug() > 2) Info("FillOutputData", "Filling trees with digits.");
-       muondata->Fill("D");
-       muondata->ResetDigits();
+       fMUONData->Fill("D");
+       fMUONData->ResetDigits();
 };
 
 //------------------------------------------------------------------------
@@ -252,7 +256,7 @@ Bool_t AliMUONDigitizerv1::InitInputData(AliMUONLoader* muonloader)
        if (GetDebug() > 2)
                Info("InitInputData", "Loading hits in READ mode and setting the tree address.");
 
-       muondata->SetLoader(muonloader);
+       fMUONData->SetLoader(muonloader);
 
        if (muonloader->TreeH() == NULL)
        {
@@ -264,7 +268,7 @@ Bool_t AliMUONDigitizerv1::InitInputData(AliMUONLoader* muonloader)
                };
        };
 
-       muondata->SetTreeAddress("H");
+       fMUONData->SetTreeAddress("H");
        return kTRUE;
 };
 
@@ -274,7 +278,7 @@ void AliMUONDigitizerv1::CleanupInputData(AliMUONLoader* muonloader)
 // Derived to release the loaded hits and unload them.
 
        if (GetDebug() > 2) Info("CleanupInputData", "Releasing loaded hits.");
-       muondata->ResetHits();
+       fMUONData->ResetHits();
        muonloader->UnloadHits();
 };
 
index 67f84f966baa45fe0325e57adf629bfc1978bda4..89a6f75d82e5e1c55dd4c6c76570a91d0471dd1f 100644 (file)
@@ -3,6 +3,9 @@
 /* Copyright(c) 1998-2001, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
+// Revision of includes 07/05/2004
+
 // The AliMUONDigitizer procees :
 // - Addition of hits from different tracks
 // - Merging of hits from different files
 // Gines MARTINEZ Subatech Feb 2003 
 
 #include "AliMUONDigitizer.h"
+#include "AliMUONDigit.h"
+
+class AliMUONLoader;
+class AliMUONHit;
+class AliMUONTransientDigit;
 
 class AliMUONDigitizerv1 : public AliMUONDigitizer 
 {
index eb12e651890315188b46958b63cb997517aff8d6..6780262d84a0fb69ec08f729659b81788ad9f2d9 100644 (file)
@@ -1,29 +1,23 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
 
 //  Do the Digitization (Digit) from summable Digits (SDigit)
 //  Allow the merging of signal file with background file(s).
 
-#include <Riostream.h>
-#include <TDirectory.h>
-#include <TFile.h>
-#include <TObjArray.h>
-#include <TPDGCode.h>
-#include <TTree.h> 
-#include <TMath.h>
-
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONDigitizerv2.h"
-#include "AliMUONHit.h"
-#include "AliMUONHitMapA1.h"
-#include "AliMUONPadHit.h"
-#include "AliMUONTransientDigit.h"
-#include "AliRun.h"
-#include "AliRunDigitizer.h"
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-
 /////////////////////////////////////////////////////////////////////////////////
 //
 // AliMUONDigitizerv2 digitizes digits from s-digits. 
 //
 /////////////////////////////////////////////////////////////////////////////////
 
+#include "AliMUONData.h"
+#include "AliMUONLoader.h"
+#include "AliMUONConstants.h"
+#include "AliMUONDigit.h"
+#include "AliMUONDigitizerv2.h"
+#include "AliMUONTransientDigit.h"
+
 ClassImp(AliMUONDigitizerv2)
 
 //___________________________________________
@@ -70,18 +71,18 @@ void AliMUONDigitizerv2::GenerateTransientDigits()
        TClonesArray* muonSDigits;
        for (Int_t ich = 0; ich < AliMUONConstants::NCh(); ich++)  // loop over chamber
        {
-               muondata->ResetSDigits();
-               muondata->GetCathodeS(0);
-               muonSDigits = muondata->SDigits(ich); 
+               fMUONData->ResetSDigits();
+               fMUONData->GetCathodeS(0);
+               muonSDigits = fMUONData->SDigits(ich); 
                ndig = muonSDigits->GetEntriesFast();
                for (k = 0; k < ndig; k++)
                {
                        sDigit = (AliMUONDigit*) muonSDigits->UncheckedAt(k);
                        MakeTransientDigitFromSDigit(ich,sDigit);
                }
-               muondata->ResetSDigits();
-               muondata->GetCathodeS(1);
-               muonSDigits = muondata->SDigits(ich); 
+               fMUONData->ResetSDigits();
+               fMUONData->GetCathodeS(1);
+               muonSDigits = fMUONData->SDigits(ich); 
                ndig=muonSDigits->GetEntriesFast();
                for (k = 0; k < ndig; k++)
                {
@@ -137,20 +138,20 @@ void AliMUONDigitizerv2::MakeTransientDigitFromSDigit(Int_t iChamber, AliMUONDig
 void AliMUONDigitizerv2::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6])
 {
 // Override to add new digits to the digits tree TreeD.
-       muondata->AddDigit(chamber, tracks, charges, digits);   
+       fMUONData->AddDigit(chamber, tracks, charges, digits);   
 };
 
 //------------------------------------------------------------------------
 Bool_t AliMUONDigitizerv2::InitInputData(AliMUONLoader* muonloader)
 {
-// Overridden to initialize muondata to read from the s-digits tree TreeS. 
+// Overridden to initialize fMUONData to read from the s-digits tree TreeS. 
 // If the s-digits are not loaded then the muon loader is used to load the
 // s-digits into memory.
 
        if (GetDebug() > 2)
                Info("InitInputData", "Loading s-digits in READ mode and setting the tree address.");
 
-       muondata->SetLoader(muonloader);
+       fMUONData->SetLoader(muonloader);
 
        if (muonloader->TreeS() == NULL)
        {
@@ -162,7 +163,7 @@ Bool_t AliMUONDigitizerv2::InitInputData(AliMUONLoader* muonloader)
                };
        };
 
-       muondata->SetTreeAddress("S");
+       fMUONData->SetTreeAddress("S");
        return kTRUE;
 };
 
@@ -172,6 +173,6 @@ void AliMUONDigitizerv2::CleanupInputData(AliMUONLoader* muonloader)
 // Overridden to release and unload s-digits from memory.
 
        if (GetDebug() > 2) Info("CleanupInputData", "Releasing loaded s-digits.");
-       muondata->ResetSDigits();
+       fMUONData->ResetSDigits();
        muonloader->UnloadSDigits();
 };
index 5d3c8fa9629326742d25a1f28cab821128b4c0bd..f8cea04f45f4a85fc75e20feb62f351fa9f30ce8 100644 (file)
@@ -3,7 +3,13 @@
 /* Copyright(c) 1998-2001, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
+// Revision of includes 07/05/2004
+
 #include "AliMUONDigitizerv1.h"
+#include "AliMUONDigit.h"
+
+class AliMUONLoader;
 
 class AliMUONDigitizerv2 : public AliMUONDigitizerv1
 {
index 427d5a356b65481037de503cb6ba47b78b8e05d7..a651d9a6d29c6e0169fafb98e54036a35c8f4e5b 100644 (file)
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////
 
-#include <TROOT.h>
-#include <TTree.h>
 #include <TButton.h>
 #include <TColor.h>
 #include <TCanvas.h>
 #include <TView.h>
 #include <TText.h>
-#include <TPolyMarker3D.h>
 #include <TPaveLabel.h>
 #include <TPaveText.h>
-#include <TList.h>
 #include <TDiamond.h>
 #include <TNode.h>
 #include <TArc.h>
-#include <TTUBE.h>
 #include <TSlider.h>
-#include <TSliderBox.h>
-#include <TGaxis.h>
 #include <TVirtualX.h>
 #include <TMath.h>
-#include <TMatrix.h>
 #include <TGeometry.h>
-#include <X3DBuffer.h>
 #include <TMarker3DBox.h>
 
+#include "AliMUONDisplay.h"
 #include "AliRun.h"
-#include "AliDetector.h"
 #include "AliMUON.h"
-#include "AliMUONDisplay.h"
 #include "AliMUONPoints.h"
-#include "TParticle.h"
 #include "AliMUONGlobalTrigger.h"
 #include "AliHeader.h"
 
 #include "AliMUONHit.h"
-#include "AliMUONPadHit.h"
 #include "AliMUONDigit.h"
 #include "AliMUONRawCluster.h"
 
@@ -76,6 +64,7 @@ ClassImp(AliMUONDisplay)
 
 //_____________________________________________________________________________
 AliMUONDisplay::AliMUONDisplay()
+  : AliDisplay()
 {
 // Constructor
     fPoints = 0;
@@ -88,6 +77,7 @@ AliMUONDisplay::AliMUONDisplay()
 
 //_____________________________________________________________________________
 AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
+  : AliDisplay()
 {
 // Create an event display object.
 // A canvas named "edisplay" is created with a vertical size in pixels
@@ -233,10 +223,12 @@ AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
       fMUONData =0x0;
 }
 
-AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display):AliDisplay(display)
+AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display)
+  : AliDisplay(display)
 {
-// Dummy copy constructor    
-    ;
+// Protected copy constructor
+
+  Fatal("AliMUONDisplay", "Not implemented.");
 }
 
 
@@ -340,7 +332,7 @@ void AliMUONDisplay::DisplayButtons()
 }
 
 //_____________________________________________________________________________
-void AliMUONDisplay::CreateColors()
+void AliMUONDisplay::CreateColors() const
 {
 //    Create the colors palette used to display clusters
 
@@ -628,11 +620,11 @@ void AliMUONDisplay::DrawTitle(Option_t *option)
     Float_t dx   = xmax-xmin;
     Float_t dy   = ymax-ymin;
     
-    AliRunLoader * RunLoader;
+    AliRunLoader * runLoader;
     if (fLoader)
-      RunLoader = fLoader->GetRunLoader();
+      runLoader = fLoader->GetRunLoader();
     else
-      RunLoader = 0x0;
+      runLoader = 0x0;
 
 
     if (strlen(option) == 0) {
@@ -644,7 +636,7 @@ void AliMUONDisplay::DrawTitle(Option_t *option)
        title->Draw();
        char ptitle[100];
        sprintf(ptitle, "Alice event:%d Run:%d Chamber:%d Cathode:%d",
-               RunLoader->GetEventNumber(),
+               runLoader->GetEventNumber(),
                gAlice->GetHeader()->GetRun(),
                fChamber,
                fCathode);
@@ -1187,21 +1179,21 @@ void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
 //_____________________________________________________________________________
 void AliMUONDisplay::ShowNextEvent(Int_t delta)
 {
-  AliRunLoader * RunLoader;
+  AliRunLoader * runLoader;
   if (fLoader)
-    RunLoader = fLoader->GetRunLoader();
+    runLoader = fLoader->GetRunLoader();
   else
-    RunLoader = 0x0;
+    runLoader = 0x0;
     
 //  Display (current event_number + delta)
 //    delta =  1  shown next event
 //    delta = -1 show previous event
     if (delta) {
-      //RunLoader->CleanDetectors();
-      //RunLoader->CleanKinematics();
-      Int_t currentEvent = RunLoader->GetEventNumber();
+      //runLoader->CleanDetectors();
+      //runLoader->CleanKinematics();
+      Int_t currentEvent = runLoader->GetEventNumber();
       Int_t newEvent     = currentEvent + delta;
-      RunLoader->GetEvent(newEvent);
+      runLoader->GetEvent(newEvent);
       fEvent=newEvent;
     }
     LoadDigits(fChamber, fCathode);
@@ -1257,10 +1249,15 @@ void AliMUONDisplay::ResetRpoints()
     }
 }
 
-AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay &)
+AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay & rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
 
index 562f5c724be858e17ced5d7b81fa3b00ce936ed8..963aa5f542df3c71232ebc33aad8bfbeadf9bd47 100644 (file)
@@ -5,6 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 //////////////////////////////////////////////////////////////////////////
 //                                                                      //
@@ -14,9 +15,6 @@
 //                                                                      //
 //////////////////////////////////////////////////////////////////////////
 
-//#ifndef ROOT_TObject
-#include <TObject.h>
-//#endif
 #include "AliDisplay.h"
 
 class AliLoader;
@@ -28,16 +26,16 @@ class TSlider;
 class TButton;
 class TArc;
 
-class AliMUONDisplay : /*splaypublic TObject,*/ public AliDisplay {
+class AliMUONDisplay : public AliDisplay 
+{
 public:
                      AliMUONDisplay();
                      AliMUONDisplay(Int_t size, AliLoader * loader=0x0);
-                    AliMUONDisplay(const AliMUONDisplay& display);
                     
    virtual          ~AliMUONDisplay();
    virtual void      Clear(Option_t *option="");
    virtual void      DisplayButtons();
-   virtual void      CreateColors();
+   virtual void      CreateColors() const;
    virtual void      DisplayColorScale();
    virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py);
    virtual void      Draw(Option_t *option="");
@@ -49,9 +47,9 @@ public:
    virtual void      DrawView(Float_t theta, Float_t phi, Float_t psi=0);
    virtual void      DrawP(Float_t,Float_t,Float_t,Float_t,Float_t,Int_t){}
    virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py);
-   Int_t             GetZoomMode() {return fZoomMode;}
-   Int_t             GetChamber() {return fChamber;}
-   Int_t             GetCathode() {return fCathode;}
+   Int_t             GetZoomMode() const {return fZoomMode;}
+   Int_t             GetChamber() const {return fChamber;}
+   Int_t             GetCathode() const {return fCathode;}
 
    AliMUONData*      GetMUONData() {return fMUONData;}
    AliLoader*        GetLoader()  {return fLoader;}
@@ -80,7 +78,10 @@ public:
    virtual void      NextChamber(Int_t delta=1);
    virtual void      NextCathode();
            void      Trigger();
-          AliMUONDisplay& operator = (const AliMUONDisplay& rhs);
+
+protected:
+                    AliMUONDisplay(const AliMUONDisplay& display);
+   AliMUONDisplay&   operator = (const AliMUONDisplay& rhs);
           
 
 private:
index 4a372f900606ec74542e812bb42ca99f2e0a86b8..5a41a46fe8fc90a01e75c56cbb8be883fb5a95f0 100644 (file)
 //
 ////////////////////////////////////
 
-#include <Riostream.h> // for cout
-#include <stdlib.h> // for exit()
-
-#include <TTree.h>
+#include <Riostream.h>
+#include <TDirectory.h>
+#include <TFile.h>
+#include <TMatrixD.h> //AZ
 
-#include "AliMUON.h"
-//#include "AliMUONChamber.h"
 #include "AliMUONEventReconstructor.h"
+#include "AliMUON.h"
+#include "AliMUONHit.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONTriggerTrack.h"
-//#include "AliMUONTriggerConstants.h"
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONLocalTrigger.h"
 #include "AliMUONTrackHit.h"
 #include "AliMagF.h"
 #include "AliRun.h" // for gAlice
-#include "AliConfig.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliMUONTrackK.h" //AZ
-#include <TMatrixD.h> //AZ
 #include "AliMC.h"
 
 //************* Defaults parameters for reconstruction
@@ -86,6 +83,7 @@ ClassImp(AliMUONEventReconstructor) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
+  : TObject()
 {
   // Constructor for class AliMUONEventReconstructor
   SetReconstructionParametersToDefaults();
@@ -96,7 +94,7 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
   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 < kMaxMuonTrackingStations; st++) {
+  for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++) {
     fSegmentsPtr[st] = new TClonesArray("AliMUONSegment", 2000);
     fNSegments[st] = 0; // really needed or GetEntriesFast sufficient ????
   }
@@ -155,15 +153,24 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
   return;
 }
   //__________________________________________________________________________
-AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor):TObject(Reconstructor)
+AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstructor& rhs)
+  : TObject(rhs)
 {
-  // Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONEventReconstructor", "Not implemented.");
 }
 
-AliMUONEventReconstructor & AliMUONEventReconstructor::operator=(const AliMUONEventReconstructor& /*Reconstructor*/)
+AliMUONEventReconstructor & 
+AliMUONEventReconstructor::operator=(const AliMUONEventReconstructor& rhs)
 {
-  // Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
   //__________________________________________________________________________
@@ -177,7 +184,7 @@ AliMUONEventReconstructor::~AliMUONEventReconstructor(void)
 //  if (fEventTree) delete fEventTree;
   if (fRecoEvent) delete fRecoEvent;
   delete fHitsForRecPtr; // Correct destruction of everything ???? or delete [] ????
-  for (Int_t st = 0; st < kMaxMuonTrackingStations; st++)
+  for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++)
     delete fSegmentsPtr[st]; // Correct destruction of everything ????
   return;
 }
@@ -213,7 +220,7 @@ void AliMUONEventReconstructor::SetReconstructionParametersToDefaults(void)
   // Maximum distance in non bending plane
   // 5 * 0.22 just to remember the way it was made in TRACKF_STAT
   // SIGCUT*DYMAX(IZ)
-  for (Int_t st = 0; st < kMaxMuonTrackingStations; st++)
+  for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++)
     fSegmentMaxDistNonBending[st] = 5. * 0.22;
   // Maximum distance in bending plane:
   // values from TRACKF_STAT, corresponding to (J psi 20cm),
@@ -410,7 +417,7 @@ void AliMUONEventReconstructor::ResetSegments(void)
 {
   // To reset the TClonesArray of segments and the number of Segments
   // for all stations
-  for (Int_t st = 0; st < kMaxMuonTrackingStations; st++) {
+  for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++) {
     if (fSegmentsPtr[st]) fSegmentsPtr[st]->Clear();
     fNSegments[st] = 0;
   }
@@ -828,12 +835,12 @@ void AliMUONEventReconstructor::MakeSegments(void)
   ResetSegments();
   // Loop over stations
   Int_t nb = (fTrackMethod == 2) ? 3 : 0; //AZ
-  //AZ for (Int_t st = 0; st < kMaxMuonTrackingStations; st++)
-  for (Int_t st = nb; st < kMaxMuonTrackingStations; st++) //AZ
+  //AZ for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++)
+  for (Int_t st = nb; st < fgkMaxMuonTrackingStations; st++) //AZ
     MakeSegmentsPerStation(st); 
   if (fPrintLevel >= 10) {
     cout << "end of MakeSegments" << endl;
-    for (Int_t st = 0; st < kMaxMuonTrackingStations; st++) {
+    for (Int_t st = 0; st < fgkMaxMuonTrackingStations; st++) {
       cout << "station(0...): " << st
           << "  Segments: " << fNSegments[st]
           << endl;
@@ -1022,14 +1029,14 @@ Bool_t AliMUONEventReconstructor::MakeTriggerTracks(void)
     AliMUONTriggerCircuit *circuit;
     AliMUONTriggerTrack *recTriggerTrack = 0;
 
-    TTree* TR = fLoader->TreeR();
+    TTree* treeR = fLoader->TreeR();
     
     // Loading MUON subsystem
     AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
     
-    nTRentries = Int_t(TR->GetEntries());
+    nTRentries = Int_t(treeR->GetEntries());
      
-    TR->GetEvent(0); // only one entry  
+    treeR->GetEvent(0); // only one entry  
 
     if (!(fMUONData->IsTriggerBranchesInTree())) {
       cout << "Warning in AliMUONEventReconstructor::MakeTriggerTracks"
@@ -1733,7 +1740,7 @@ void AliMUONEventReconstructor::MakeTrackCandidatesK(void)
 void AliMUONEventReconstructor::FollowTracksK(void)
 {
   // Follow tracks using Kalman filter
-  Bool_t Ok;
+  Bool_t ok;
   Int_t icand, ichamBeg, ichamEnd, chamBits;
   Double_t zDipole1, zDipole2;
   AliMUONTrackK *trackK;
@@ -1787,14 +1794,14 @@ void AliMUONEventReconstructor::FollowTracksK(void)
 
     // Discard candidate which will produce the double track
     if (icand > 0) {
-      Ok = CheckCandidateK(icand,nSeeds);
-      if (!Ok) {
+      ok = CheckCandidateK(icand,nSeeds);
+      if (!ok) {
         //trackK->SetRecover(-1); // mark candidate to be removed
         //continue;
       }
     }
 
-    Ok = kTRUE;
+    ok = kTRUE;
     if (trackK->GetRecover() == 0) hit = (AliMUONHitForRec*) 
                                    trackK->GetHitOnTrack()->Last(); // last hit
     else hit = (AliMUONHitForRec*) (*trackK->GetHitOnTrack())[1]; // 2'nd hit
@@ -1803,13 +1810,13 @@ void AliMUONEventReconstructor::FollowTracksK(void)
     // Check propagation direction
     if (trackK->GetTrackDir() > 0) {
       ichamEnd = 9; // forward propagation
-      Ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
-      if (Ok) {
+      ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
+      if (ok) {
         ichamBeg = ichamEnd;
         ichamEnd = 6; // backward propagation
        // Change weight matrix and zero fChi2 for backpropagation
         trackK->StartBack();
-        Ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
+        ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
         ichamBeg = ichamEnd;
         ichamEnd = 0;
       }
@@ -1819,18 +1826,18 @@ void AliMUONEventReconstructor::FollowTracksK(void)
         ichamEnd = 6; // backward propagation
        // Change weight matrix and zero fChi2 for backpropagation
         trackK->StartBack();
-        Ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
+        ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kTRUE,zDipole1,zDipole2);
         ichamBeg = ichamEnd;
         ichamEnd = 0;
       }
     }
 
-    if (Ok) {
+    if (ok) {
       trackK->SetTrackDir(-1);
       trackK->SetBPFlag(kFALSE);
-      Ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
+      ok = trackK->KalmanFilter(ichamBeg,ichamEnd,kFALSE,zDipole1,zDipole2);
     }
-    if (Ok) trackK->SetTrackQuality(0); // compute "track quality"
+    if (ok) trackK->SetTrackQuality(0); // compute "track quality"
     else trackK->SetRecover(-1); // mark candidate to be removed
 
     // Majority 3 of 4 in first 2 stations
@@ -1855,7 +1862,7 @@ void AliMUONEventReconstructor::FollowTracksK(void)
 }
 
 //__________________________________________________________________________
-Bool_t AliMUONEventReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds)
+Bool_t AliMUONEventReconstructor::CheckCandidateK(Int_t icand, Int_t nSeeds) const
 {
   // Discards track candidate if it will produce the double track (having
   // the same seed segment hits as hits of a good track found before)
index 91b3f9bf2c7c31ab8b64b9dfa871575d46cb31b6..4507f841d827169d1c9590878beef4d7259d2946 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 ////////////////////////////////////
 // MUON event reconstructor in ALICE
@@ -27,8 +28,6 @@ class AliMUONEventReconstructor : public TObject {
  public:
   AliMUONEventReconstructor(AliLoader* loader); // default Constructor
   virtual ~AliMUONEventReconstructor(void); // Destructor
-  AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor); // copy constructor
-  AliMUONEventReconstructor& operator=(const AliMUONEventReconstructor& Reconstructor); // assignment operator
 
   // Parameters for event reconstruction: public methods
   // Get and Set, Set to defaults
@@ -98,12 +97,14 @@ class AliMUONEventReconstructor : public TObject {
   AliMUONData*  GetMUONData() {return fMUONData;}
 
  protected:
+  AliMUONEventReconstructor (const AliMUONEventReconstructor& rhs); // copy constructor
+  AliMUONEventReconstructor& operator=(const AliMUONEventReconstructor& rhs); // assignment operator
 
  private:
 
   // Constants which should be elsewhere ????
   static const Int_t fgkMaxMuonTrackingChambers = 10; // Max number of Muon tracking chambers
-  static const Int_t kMaxMuonTrackingStations = 5; // Max number of Muon tracking stations
+  static const Int_t fgkMaxMuonTrackingStations = 5; // Max number of Muon tracking stations
 
   // Defaults parameters for reconstruction
   static const Double_t fgkDefaultMinBendingMomentum;
@@ -137,8 +138,8 @@ class AliMUONEventReconstructor : public TObject {
   Double_t fMaxSigma2Distance; // maximum square distance in units of the variance (maximum chi2)
   Double_t fRMin[fgkMaxMuonTrackingChambers]; // minimum radius (cm)
   Double_t fRMax[fgkMaxMuonTrackingChambers]; // maximum radius (cm)
-  Double_t fSegmentMaxDistBending[kMaxMuonTrackingStations]; // maximum distance (cm) for segments in bending plane
-  Double_t fSegmentMaxDistNonBending[kMaxMuonTrackingStations]; // maximum distance (cm) for segments in non bending plane
+  Double_t fSegmentMaxDistBending[fgkMaxMuonTrackingStations]; // maximum distance (cm) for segments in bending plane
+  Double_t fSegmentMaxDistNonBending[fgkMaxMuonTrackingStations]; // maximum distance (cm) for segments in non bending plane
   Double_t fBendingResolution; // chamber resolution (cm) in bending plane
   Double_t fNonBendingResolution; // chamber resolution (cm) in non bending plane
   Double_t fChamberThicknessInX0; // chamber thickness in number of radiation lengths
@@ -167,8 +168,8 @@ class AliMUONEventReconstructor : public TObject {
   Int_t fIndexOfFirstHitForRecPerChamber[fgkMaxMuonTrackingChambers]; // index (0...) of first HitForRec
 
   // Segments inside a station
-  TClonesArray *fSegmentsPtr[kMaxMuonTrackingStations]; // array of pointers to the segments for each station
-  Int_t fNSegments[kMaxMuonTrackingStations]; // number of segments for each station
+  TClonesArray *fSegmentsPtr[fgkMaxMuonTrackingStations]; // array of pointers to the segments for each station
+  Int_t fNSegments[fgkMaxMuonTrackingStations]; // number of segments for each station
 
   // Reconstructed tracks
   TClonesArray *fRecTracksPtr; // pointer to array of reconstructed tracks
@@ -226,7 +227,7 @@ class AliMUONEventReconstructor : public TObject {
   void FollowTracksK(void);
   void RemoveDoubleTracksK(void);
   void GoToVertex(void);
-  Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds);
+  Bool_t CheckCandidateK(Int_t icand, Int_t nSeeds) const;
 
   ClassDef(AliMUONEventReconstructor, 0) // MUON event reconstructor in ALICE
     };
index ba79a686daaae4653c8ae83fb9de58ffb8abbc7b..c4d117fa293bdebb844f1be9e69503d9ef08910f 100644 (file)
 #include "AliMUONChamber.h"
 #include "AliMUONResponseV0.h"
 #include "AliMUONResponseTrigger.h"
-#include "AliMUONSegmentationV0.h"
 #include "AliMUONSegmentationV01.h"
 #include "AliMUONSegmentationV02.h"
-#include "AliMUONSegmentationV04.h"
-#include "AliMUONSegmentationV05.h"
 #include "AliMUONSegmentationSlat.h"
 #include "AliMUONSegmentationSlatN.h"
-#include "AliMUONSegmentationTrigger.h"
 #include "AliMUONSegmentationTriggerX.h"
 #include "AliMUONSegmentationTriggerY.h"
 
@@ -52,10 +48,11 @@ AliMUONFactory::AliMUONFactory(const AliMUONFactory& rhs)
 {
 // Protected copy constructor
 
-  Fatal("AliMUONFactoryModule", "Not implemented.");
+  Fatal("AliMUONFactory", "Not implemented.");
 }
 
 //__________________________________________________________________________
+
 AliMUONFactory::~AliMUONFactory()
 {
 //
index 2fc81523de40d102765ac6d4f7fe26e558573abd..8f825ed8e7427b8758d62b3f56efe417e0fbfbb4 100644 (file)
@@ -4,12 +4,13 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 ////////////////////////////////////////////////////////////
 //  Factory for muon chambers, segmentations and response //
 ////////////////////////////////////////////////////////////
-#include "AliDetector.h"
-// #include "AliMUONTriggerCircuit.h" // cp
+
+#include <TObject.h>
 
 class AliMUON;
 class AliMUONResponseV0;
index 9108d54ee7091f08d3a5615bf1d2bd21913e5071..821fd261f63b7ab0684bf830347840e008998724 100644 (file)
@@ -1,3 +1,18 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
 // $Id$
 //
 // Class AliMUONGeometryConstituent
index 678cb8ba9644461d15198a77314425b92b105dbd..0c0b220a5160d051035df92689ef2bb44738fa27 100644 (file)
@@ -1,4 +1,8 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONGeometryConstituent
 // --------------------------------
@@ -29,18 +33,20 @@ class AliMUONGeometryConstituent : public TNamed
                         const TGeoRotation& rotation,
                         Int_t npar, Double_t* param);
     AliMUONGeometryConstituent();
-    AliMUONGeometryConstituent(const AliMUONGeometryConstituent& rhs);
     virtual ~AliMUONGeometryConstituent();
 
-    // operators  
-    AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
-  
     // get methods
     Int_t                  GetCopyNo() const;  
     Int_t                  GetNpar() const;
     Double_t*              GetParam() const;
     const TGeoCombiTrans*  GetTransformation() const;
 
+  protected:
+    AliMUONGeometryConstituent(const AliMUONGeometryConstituent& rhs);
+
+    // operators  
+    AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
+
   private:
     Int_t            fCopyNo;        // copy number
     Int_t            fNpar;          // number of shape parameters
index 65ee19be981560c4cbfa0df69ced5b305d35c919..169b321f5042513693f141149f8e1831bc037fc9 100644 (file)
@@ -1,3 +1,18 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
 // $Id$
 //
 // Class AliMUONGeometryEnvelope
index 9a2d843bd967c67e2817d02d9569bcc78477f24d..923f114115ab0678f53893f6d9a89452619c3179 100644 (file)
@@ -1,4 +1,8 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONGeometryEnvelope
 // -----------------------------
@@ -24,11 +28,7 @@ class AliMUONGeometryEnvelope : public TNamed
     AliMUONGeometryEnvelope(const TString& name, Int_t copyNo,
                             const char* only); 
     AliMUONGeometryEnvelope();
-    AliMUONGeometryEnvelope(const AliMUONGeometryEnvelope& rhs);
     virtual ~AliMUONGeometryEnvelope();
-
-    // operators  
-    AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
   
     // methods
     void  AddConstituent(const TString& name, Int_t copyNo); 
@@ -58,6 +58,12 @@ class AliMUONGeometryEnvelope : public TNamed
     const TGeoCombiTrans*  GetTransformation() const;
     const TObjArray*       GetConstituents() const;
 
+  protected:
+    AliMUONGeometryEnvelope(const AliMUONGeometryEnvelope& rhs);
+
+    // operators  
+    AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
+
   private:
     Bool_t           fIsVirtual;     // true if envelope is not represented
                                      // by a real volume
index f7a307b480bb156325d07304ea5c70dcaef871e6..f11b4cb9cd458ea3cbdb15d3e302b04a5511601f 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-
-*/
+/* $Id$ */
 
 #include "AliMUONGlobalTrigger.h"
 
 ClassImp(AliMUONGlobalTrigger);
 //----------------------------------------------------------------------
 AliMUONGlobalTrigger::AliMUONGlobalTrigger()
+  : TObject()
 {
 // constructor 
   fSinglePlusLpt = 0;
@@ -45,56 +44,60 @@ AliMUONGlobalTrigger::AliMUONGlobalTrigger()
   fPairLikeApt   = 0;
 }
 //----------------------------------------------------------------------
-AliMUONGlobalTrigger::AliMUONGlobalTrigger(const AliMUONGlobalTrigger& MUONGlobalTrig):TObject(MUONGlobalTrig)
+AliMUONGlobalTrigger::AliMUONGlobalTrigger(const AliMUONGlobalTrigger& theMUONGlobalTrig)
+  : TObject(theMUONGlobalTrig)
 {
 // copy constructor
-  fSinglePlusLpt  = MUONGlobalTrig.fSinglePlusLpt;
-  fSinglePlusHpt  = MUONGlobalTrig.fSinglePlusHpt;
-  fSinglePlusApt  = MUONGlobalTrig.fSinglePlusApt;
+  fSinglePlusLpt  = theMUONGlobalTrig.fSinglePlusLpt;
+  fSinglePlusHpt  = theMUONGlobalTrig.fSinglePlusHpt;
+  fSinglePlusApt  = theMUONGlobalTrig.fSinglePlusApt;
   
-  fSingleMinusLpt = MUONGlobalTrig.fSingleMinusLpt;
-  fSingleMinusHpt = MUONGlobalTrig.fSingleMinusHpt;
-  fSingleMinusApt = MUONGlobalTrig.fSingleMinusApt;
+  fSingleMinusLpt = theMUONGlobalTrig.fSingleMinusLpt;
+  fSingleMinusHpt = theMUONGlobalTrig.fSingleMinusHpt;
+  fSingleMinusApt = theMUONGlobalTrig.fSingleMinusApt;
   
-  fSingleUndefLpt = MUONGlobalTrig.fSingleUndefLpt;
-  fSingleUndefHpt = MUONGlobalTrig.fSingleUndefHpt;
-  fSingleUndefApt = MUONGlobalTrig.fSingleUndefApt;
+  fSingleUndefLpt = theMUONGlobalTrig.fSingleUndefLpt;
+  fSingleUndefHpt = theMUONGlobalTrig.fSingleUndefHpt;
+  fSingleUndefApt = theMUONGlobalTrig.fSingleUndefApt;
   
-  fPairUnlikeLpt  = MUONGlobalTrig.fPairUnlikeLpt;
-  fPairUnlikeHpt  = MUONGlobalTrig.fPairUnlikeHpt;
-  fPairUnlikeApt  = MUONGlobalTrig.fPairUnlikeApt;
+  fPairUnlikeLpt  = theMUONGlobalTrig.fPairUnlikeLpt;
+  fPairUnlikeHpt  = theMUONGlobalTrig.fPairUnlikeHpt;
+  fPairUnlikeApt  = theMUONGlobalTrig.fPairUnlikeApt;
   
-  fPairLikeLpt    = MUONGlobalTrig.fPairLikeLpt;
-  fPairLikeHpt    = MUONGlobalTrig.fPairLikeHpt;
-  fPairLikeApt    = MUONGlobalTrig.fPairLikeApt;
+  fPairLikeLpt    = theMUONGlobalTrig.fPairLikeLpt;
+  fPairLikeHpt    = theMUONGlobalTrig.fPairLikeHpt;
+  fPairLikeApt    = theMUONGlobalTrig.fPairLikeApt;
 }
 
 //----------------------------------------------------------------------
-AliMUONGlobalTrigger& AliMUONGlobalTrigger::operator=(const AliMUONGlobalTrigger& MUONGlobalTrig)
+AliMUONGlobalTrigger& AliMUONGlobalTrigger::operator=(const AliMUONGlobalTrigger& theMUONGlobalTrig)
 {
 // equal operator (useful for non-pointer member in TClonesArray)
-  if (this == &MUONGlobalTrig)
+  if (this == &theMUONGlobalTrig)
     return *this;
+    
+  // base class assignement
+  TObject::operator=(theMUONGlobalTrig);
 
-  fSinglePlusLpt  = MUONGlobalTrig.fSinglePlusLpt;
-  fSinglePlusHpt  = MUONGlobalTrig.fSinglePlusHpt;
-  fSinglePlusApt  = MUONGlobalTrig.fSinglePlusApt;
+  fSinglePlusLpt  = theMUONGlobalTrig.fSinglePlusLpt;
+  fSinglePlusHpt  = theMUONGlobalTrig.fSinglePlusHpt;
+  fSinglePlusApt  = theMUONGlobalTrig.fSinglePlusApt;
   
-  fSingleMinusLpt = MUONGlobalTrig.fSingleMinusLpt;
-  fSingleMinusHpt = MUONGlobalTrig.fSingleMinusHpt;
-  fSingleMinusApt = MUONGlobalTrig.fSingleMinusApt;
+  fSingleMinusLpt = theMUONGlobalTrig.fSingleMinusLpt;
+  fSingleMinusHpt = theMUONGlobalTrig.fSingleMinusHpt;
+  fSingleMinusApt = theMUONGlobalTrig.fSingleMinusApt;
   
-  fSingleUndefLpt = MUONGlobalTrig.fSingleUndefLpt;
-  fSingleUndefHpt = MUONGlobalTrig.fSingleUndefHpt;
-  fSingleUndefApt = MUONGlobalTrig.fSingleUndefApt;
+  fSingleUndefLpt = theMUONGlobalTrig.fSingleUndefLpt;
+  fSingleUndefHpt = theMUONGlobalTrig.fSingleUndefHpt;
+  fSingleUndefApt = theMUONGlobalTrig.fSingleUndefApt;
   
-  fPairUnlikeLpt  = MUONGlobalTrig.fPairUnlikeLpt;
-  fPairUnlikeHpt  = MUONGlobalTrig.fPairUnlikeHpt;
-  fPairUnlikeApt  = MUONGlobalTrig.fPairUnlikeApt;
+  fPairUnlikeLpt  = theMUONGlobalTrig.fPairUnlikeLpt;
+  fPairUnlikeHpt  = theMUONGlobalTrig.fPairUnlikeHpt;
+  fPairUnlikeApt  = theMUONGlobalTrig.fPairUnlikeApt;
   
-  fPairLikeLpt    = MUONGlobalTrig.fPairLikeLpt;
-  fPairLikeHpt    = MUONGlobalTrig.fPairLikeHpt;
-  fPairLikeApt    = MUONGlobalTrig.fPairLikeApt;
+  fPairLikeLpt    = theMUONGlobalTrig.fPairLikeLpt;
+  fPairLikeHpt    = theMUONGlobalTrig.fPairLikeHpt;
+  fPairLikeApt    = theMUONGlobalTrig.fPairLikeApt;
 
   return *this;
 }
index 1d97174b2d9e39f37b390cac150496c21eb32a24..e117a681c16d22d7cbf6cc9d3623d072c7fa63b8 100644 (file)
@@ -4,7 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/*    */
+/* $Id$ */
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
index 9c7149b455ef316d2f55f187a55ba1c6f05a52a2..b4182227457bd7592360d31ca545c944b4f8e02d 100644 (file)
 // Incident fTheta and fPhi angle with respect of the wire plane of the chamber.
 //
 
-#include "TMath.h"
+#include <TMath.h>
+
 #include "AliMUONHit.h"
 
 ClassImp(AliMUONHit)
  
+//___________________________________________
+AliMUONHit::AliMUONHit()
+  : AliHit() 
+{
+// Default constructor
+}
+
 //___________________________________________
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
        AliHit(shunt, track)
index 9784aa64b46e643ba8b6564d20d851fb4f2401c0..b70073c543dd060094e1e3a86553cd14d5445f54 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // MUON classe for MonteCarlo Hits, inherited from AliHit for the 
 // In addition to the ALiHit data member fX, fY, fZ and fTrack, AliMUONHit contains some info about the particle crossing the chamber:
@@ -21,7 +22,7 @@ class AliMUONHit : public AliHit {
 
  public:
     
-    AliMUONHit() {}
+    AliMUONHit();
     AliMUONHit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
     AliMUONHit(Int_t fIshunt, Int_t track, Int_t iChamber, Int_t idpart, Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, Float_t theta, Float_t phi, Float_t length, Float_t destep);
     AliMUONHit(Int_t fIshunt, Int_t track, Int_t iChamber, Int_t idpart, 
index 5f98fad7a4a6df4f658c2c551bb57f294c3d161d..1537a7d2463601c3a825fcbca46742a34761b65b 100644 (file)
 //__________________________________________________________________________
 
 #include "AliMUONHitForRec.h" 
-#include "AliMUONTrackParam.h" 
 #include "AliMUONRawCluster.h"
 #include "AliMUONHit.h"
 
 ClassImp(AliMUONHitForRec) // Class implementation in ROOT context
 
   //__________________________________________________________________________
-AliMUONHitForRec::AliMUONHitForRec(AliMUONHit* Ghit)
+AliMUONHitForRec::AliMUONHitForRec()
+  : TObject()
+{
+ // Default Constructor
+    fFirstTrackHitPtr = 0;
+    fLastTrackHitPtr = 0;
+}
+
+  //__________________________________________________________________________
+AliMUONHitForRec::AliMUONHitForRec(AliMUONHit* theGhit)
+  : TObject()
 {
   // Constructor for AliMUONHitForRec from a GEANT hit.
   // Fills the bending, non bending, and Z coordinates,
   // which are taken from the coordinates of the GEANT hit,
   // the track number (GEANT and not TH),
   // and the chamber number (0...).
-  fBendingCoor = Ghit->Y();
-  fNonBendingCoor = Ghit->X();
-  fZ = Ghit->Z();
-  // fTrack = Ghit->fTrack; ?????????
-  fChamberNumber = Ghit->Chamber() - 1;
+  fBendingCoor = theGhit->Y();
+  fNonBendingCoor = theGhit->X();
+  fZ = theGhit->Z();
+  // fTrack = theGhit->fTrack; ?????????
+  fChamberNumber = theGhit->Chamber() - 1;
   // other fields will be updated in
   // AliMUONEventReconstructor::NewHitForRecFromGEANT,
   // except the following ones
@@ -67,12 +77,13 @@ AliMUONHitForRec::AliMUONHitForRec(AliMUONHit* Ghit)
 // }
 
   //__________________________________________________________________________
-AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* RawCluster)
+AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* theRawCluster)
+  : TObject()
 {
   // Constructor for AliMUONHitForRec from a raw cluster.
   // Fills the bending and non bending coordinates.
-  fNonBendingCoor = RawCluster->GetX(0);
-  fBendingCoor = RawCluster->GetY(0);
+  fNonBendingCoor = theRawCluster->GetX(0);
+  fBendingCoor = theRawCluster->GetY(0);
   // other fields will be updated in
   // AliMUONEventReconstructor::AddHitsForRecFromRawClusters,
   // except the following ones
@@ -85,15 +96,25 @@ AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* RawCluster)
   return;
 }
 
-AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& MUONHitForRec):TObject(MUONHitForRec)
+  //__________________________________________________________________________
+AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& rhs)
+  : TObject(rhs)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONHitForRec", "Not implemented.");
 }
 
-AliMUONHitForRec & AliMUONHitForRec::operator=(const AliMUONHitForRec& /*MUONHitForRec*/)
+  //__________________________________________________________________________
+AliMUONHitForRec & AliMUONHitForRec::operator=(const AliMUONHitForRec& rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
   //__________________________________________________________________________
 /*AZ
@@ -119,10 +140,10 @@ Int_t AliMUONHitForRec::Compare(const TObject* Hit) const
 }
 
   //__________________________________________________________________________
-Double_t AliMUONHitForRec::NormalizedChi2WithHitForRec(AliMUONHitForRec* HitForRec, Double_t Sigma2Cut)
+Double_t AliMUONHitForRec::NormalizedChi2WithHitForRec(AliMUONHitForRec* hitForRec, Double_t Sigma2Cut) const
 {
-  // Calculate the normalized Chi2 between the current HitForRec (this)
-  // and the HitForRec pointed to by "HitForRec",
+  // Calculate the normalized Chi2 between the current hitForRec (this)
+  // and the hitForRec pointed to by "hitForRec",
   // i.e. the square deviations between the coordinates,
   // in both the bending and the non bending plane,
   // divided by the variance of the same quantities and by "Sigma2Cut".
@@ -134,15 +155,15 @@ Double_t AliMUONHitForRec::NormalizedChi2WithHitForRec(AliMUONHitForRec* HitForR
   chi2 = 0.0;
   chi2Max = 3.0;
   // coordinate in bending plane
-  diff = this->fBendingCoor - HitForRec->fBendingCoor;
+  diff = fBendingCoor - hitForRec->fBendingCoor;
   normDiff = diff * diff /
-    (this->fBendingReso2 + HitForRec->fBendingReso2) / Sigma2Cut;
+    (fBendingReso2 + hitForRec->fBendingReso2) / Sigma2Cut;
   if (normDiff > 1.0) return chi2Max;
   chi2 = chi2 + normDiff;
   // coordinate in non bending plane
-  diff = this->fNonBendingCoor - HitForRec->fNonBendingCoor;
+  diff = fNonBendingCoor - hitForRec->fNonBendingCoor;
   normDiff = diff * diff /
-    (this->fNonBendingReso2 + HitForRec->fNonBendingReso2) / Sigma2Cut;
+    (fNonBendingReso2 + hitForRec->fNonBendingReso2) / Sigma2Cut;
   if (normDiff > 1.0) return chi2Max;
   chi2 = chi2 + normDiff;
   return chi2;
index e7cdd4239b5b8ea39e40019a7fbd07b5d04c7953..73759cac7b74cc394f8b92c3b01431a802b491d6 100644 (file)
@@ -4,8 +4,9 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
-#include <TROOT.h>
+#include <TObject.h>
 
 class AliMUONHit;
 class AliMUONRawCluster;
@@ -14,57 +15,53 @@ class AliMUONTrackParam;
 
 class AliMUONHitForRec : public TObject {
  public:
-  AliMUONHitForRec(){
-    // Constructor
-    fFirstTrackHitPtr = 0;
-    fLastTrackHitPtr = 0;
-  } // Constructor
-  virtual ~AliMUONHitForRec(){
-    // Destructor
-    ;} // Destructor
-  AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
-  AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
+  AliMUONHitForRec(); // Constructor
+  virtual ~AliMUONHitForRec(){} // Destructor
   AliMUONHitForRec(AliMUONHit* mHit); // Constructor from GEANT hit
-  AliMUONHitForRec(AliMUONRawCluster* RawCluster); // Constructor from raw cluster
+  AliMUONHitForRec(AliMUONRawCluster* theRawCluster); // Constructor from raw cluster
 
   // Inline functions for Get and Set
-  Double_t GetBendingCoor(void) { return fBendingCoor;}
+  Double_t GetBendingCoor(void) const { return fBendingCoor;}
   void SetBendingCoor(Double_t BendingCoor) { fBendingCoor = BendingCoor;}
-  Double_t GetNonBendingCoor(void) { return fNonBendingCoor;}
+  Double_t GetNonBendingCoor(void) const { return fNonBendingCoor;}
   void SetNonBendingCoor(Double_t NonBendingCoor) { fNonBendingCoor = NonBendingCoor;}
-  Double_t GetZ(void) { return fZ;}
+  Double_t GetZ(void) const { return fZ;}
   void SetZ(Double_t Z) { fZ = Z;}
-  Double_t GetBendingReso2(void) { return fBendingReso2;}
+  Double_t GetBendingReso2(void) const { return fBendingReso2;}
   void SetBendingReso2(Double_t BendingReso2) { fBendingReso2 = BendingReso2;}
-  Double_t GetNonBendingReso2(void) { return fNonBendingReso2;}
+  Double_t GetNonBendingReso2(void) const { return fNonBendingReso2;}
   void SetNonBendingReso2(Double_t NonBendingReso2) { fNonBendingReso2 = NonBendingReso2;}
-  Int_t GetChamberNumber(void) { return fChamberNumber;}
+  Int_t GetChamberNumber(void) const { return fChamberNumber;}
   void SetChamberNumber(Int_t ChamberNumber) { fChamberNumber = ChamberNumber;}
-  Int_t GetHitNumber(void) { return fHitNumber;}
+  Int_t GetHitNumber(void) const { return fHitNumber;}
   void SetHitNumber(Int_t HitNumber) { fHitNumber = HitNumber;}
-  Int_t GetTHTrack(void) { return fTHTrack;}
+  Int_t GetTHTrack(void) const { return fTHTrack;}
   void SetTHTrack(Int_t THTrack) { fTHTrack = THTrack;}
-  Int_t GetGeantSignal(void) { return fGeantSignal;}
+  Int_t GetGeantSignal(void) const { return fGeantSignal;}
   void SetGeantSignal(Int_t GeantSignal) { fGeantSignal = GeantSignal;}
-  Int_t GetIndexOfFirstSegment(void) { return fIndexOfFirstSegment;}
+  Int_t GetIndexOfFirstSegment(void) const { return fIndexOfFirstSegment;}
   void SetIndexOfFirstSegment(Int_t IndexOfFirstSegment) { fIndexOfFirstSegment = IndexOfFirstSegment;}
-  Int_t GetNSegments(void) { return fNSegments;}
+  Int_t GetNSegments(void) const { return fNSegments;}
   void SetNSegments(Int_t NSegments) { fNSegments = NSegments;}
-  AliMUONTrackHit* GetFirstTrackHitPtr(void) { return fFirstTrackHitPtr;}
+  AliMUONTrackHit* GetFirstTrackHitPtr(void) const { return fFirstTrackHitPtr;}
   void SetFirstTrackHitPtr(AliMUONTrackHit* FirstTrackHitPtr) { fFirstTrackHitPtr = FirstTrackHitPtr;}
-  AliMUONTrackHit* GetLastTrackHitPtr(void) { return fLastTrackHitPtr;}
+  AliMUONTrackHit* GetLastTrackHitPtr(void) const { return fLastTrackHitPtr;}
   void SetLastTrackHitPtr(AliMUONTrackHit* LastTrackHitPtr) { fLastTrackHitPtr = LastTrackHitPtr;}
-  Int_t GetNTrackHits(void) { return fNTrackHits;}
+  Int_t GetNTrackHits(void) const { return fNTrackHits;}
   void SetNTrackHits(Int_t NTrackHits) { fNTrackHits = NTrackHits;}
 
 
-  Double_t NormalizedChi2WithHitForRec(AliMUONHitForRec* Hit, Double_t Sigma2Cut);
+  Double_t NormalizedChi2WithHitForRec(AliMUONHitForRec* Hit, Double_t Sigma2Cut) const;
 /*   void UpdateFromChamberTrackParam(AliMUONTrackParam *TrackParam, Double_t MCSfactor); */
 
   // What is necessary for sorting TClonesArray's; sufficient too ????
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* HitForRec) const; // "Compare" function for sorting
+
  protected:
+  AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
+  AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
+
  private:
   Double_t fBendingCoor; // coordinate (cm) in bending plane
   Double_t fNonBendingCoor; // coordinate (cm) in non bending plane
index 9573067de43d4e61b378e49ae4c634c659e82d2d..1e8ad685a4d96d30a840cd0b2cf04e53762b7dfe 100644 (file)
 
 /* $Id$ */
 
+#include <TObjArray.h>
+#include <TMath.h>
+
 #include "AliMUONHitMapA1.h"
 #include "AliSegmentation.h"
-#include "AliMUONResponse.h"
 #include "AliMUONDigit.h"
 
-#include <TObjArray.h>
-#include <TMath.h>
-
 ClassImp(AliMUONHitMapA1)
 
-    AliMUONHitMapA1::AliMUONHitMapA1()
+AliMUONHitMapA1::AliMUONHitMapA1()
+  : AliHitMap()
 {
     // Default constructor
     fNpx          = 0;
@@ -37,6 +37,7 @@ ClassImp(AliMUONHitMapA1)
 }
 
 AliMUONHitMapA1::AliMUONHitMapA1(AliSegmentation *seg, TObjArray *dig)
+  : AliHitMap()
 {
 // Constructor
     fNpx  = seg->Npx()+1;
@@ -48,10 +49,12 @@ AliMUONHitMapA1::AliMUONHitMapA1(AliSegmentation *seg, TObjArray *dig)
     Clear();
 }
 
-AliMUONHitMapA1::AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap):AliHitMap(hitMap)
+AliMUONHitMapA1::AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap)
+  : AliHitMap(hitMap)
 {
-// Dummy copy constructor
-    ;
+// Protected copy constructor
+
+  Fatal("AliMUONHitMapA1", "Not implemented.");
 }
 
  
@@ -155,10 +158,15 @@ FlagType AliMUONHitMapA1::TestHit(Int_t ix, Int_t iy)
     }
 }
 
-AliMUONHitMapA1 & AliMUONHitMapA1::operator = (const AliMUONHitMapA1 & /*rhs*/
+AliMUONHitMapA1 & AliMUONHitMapA1::operator = (const AliMUONHitMapA1 & rhs
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
 
index 7d108c031288e634e6a44a316e6377df4f856b09..ba55a88c8d09baf9cf42dc629d87c9a4e520a9b1 100644 (file)
@@ -5,22 +5,21 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliHitMap.h"
-class AliSegmentation;
-class TObjArray;
 
+class TObjArray;
 
+class AliSegmentation;
 
-class AliMUONHitMapA1 :
-public AliHitMap 
+class AliMUONHitMapA1 : public AliHitMap 
 {
  public:
     AliMUONHitMapA1();
     AliMUONHitMapA1(AliSegmentation *seg, TObjArray *dig);
-    AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap);
-    
     virtual ~AliMUONHitMapA1();
+
     // Fill hits from list of digits into hit map
     virtual  void  FillHits();
     // Clear the hit map
@@ -39,6 +38,9 @@ public AliHitMap
     virtual  Bool_t ValidateHit(Int_t ix, Int_t iy);
     // Test hit status
     virtual FlagType TestHit(Int_t ix, Int_t iy);
+
+ protected:
+    AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap);
     // Assignment operator
     AliMUONHitMapA1& operator = (const AliMUONHitMapA1& rhs);
     
index bbea2603169fa336e410749278035f397060a41c..c3f00bec8a431daf7b86fdaf6778b508b41e2f0e 100644 (file)
@@ -17,6 +17,7 @@
  **************************************************************************/
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliLoader.h"
 
index c041e367a98f7f5d3b8e0d4d1b3fcb28b606fec7..5a3449b0441d1b2009c2f7424c72842b7146599c 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-
-*/
+/* $Id$ */
 
 #include "AliMUONLocalTrigger.h"
 
 ClassImp(AliMUONLocalTrigger);
 //----------------------------------------------------------------------
 AliMUONLocalTrigger::AliMUONLocalTrigger()
+  : TObject()
 {
 // constructor
   fLoCircuit = 0;
@@ -33,31 +32,35 @@ AliMUONLocalTrigger::AliMUONLocalTrigger()
   fLoApt     = 0;
 }
 //----------------------------------------------------------------------
-AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& MUONLocalTrig):TObject(MUONLocalTrig)
+AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocalTrig)
+  : TObject(theMUONLocalTrig)
 {
 // copy constructor (useful for TClonesArray)
-  fLoCircuit = MUONLocalTrig.fLoCircuit;
-  fLoStripX  = MUONLocalTrig.fLoStripX;         
-  fLoDev     = MUONLocalTrig.fLoDev;           
-  fLoStripY  = MUONLocalTrig.fLoStripY;           
-  fLoLpt     = MUONLocalTrig.fLoLpt;
-  fLoHpt     = MUONLocalTrig.fLoHpt;
-  fLoApt     = MUONLocalTrig.fLoApt;
+  fLoCircuit = theMUONLocalTrig.fLoCircuit;
+  fLoStripX  = theMUONLocalTrig.fLoStripX;         
+  fLoDev     = theMUONLocalTrig.fLoDev;           
+  fLoStripY  = theMUONLocalTrig.fLoStripY;           
+  fLoLpt     = theMUONLocalTrig.fLoLpt;
+  fLoHpt     = theMUONLocalTrig.fLoHpt;
+  fLoApt     = theMUONLocalTrig.fLoApt;
 }
 //----------------------------------------------------------------------
-AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& MUONLocalTrig)
+AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
 {
 // equal operator (useful for non-pointer member in TClonesArray)
-  if (this == &MUONLocalTrig)
+  if (this == &theMUONLocalTrig)
     return *this;
 
-  fLoCircuit = MUONLocalTrig.fLoCircuit;
-  fLoStripX  = MUONLocalTrig.fLoStripX;         
-  fLoDev     = MUONLocalTrig.fLoDev;           
-  fLoStripY  = MUONLocalTrig.fLoStripY;           
-  fLoLpt     = MUONLocalTrig.fLoLpt;
-  fLoHpt     = MUONLocalTrig.fLoHpt;
-  fLoApt     = MUONLocalTrig.fLoApt;
+  // base class assignement
+  TObject::operator=(theMUONLocalTrig);
+
+  fLoCircuit = theMUONLocalTrig.fLoCircuit;
+  fLoStripX  = theMUONLocalTrig.fLoStripX;         
+  fLoDev     = theMUONLocalTrig.fLoDev;           
+  fLoStripY  = theMUONLocalTrig.fLoStripY;           
+  fLoLpt     = theMUONLocalTrig.fLoLpt;
+  fLoHpt     = theMUONLocalTrig.fLoHpt;
+  fLoApt     = theMUONLocalTrig.fLoApt;
 
   return *this;
 }
index 842eeceb0bcbe5f20a56595feedb24a3e386a6cc..7c16ff3f6b3be9125753e92cc9d05680e9d38262 100644 (file)
@@ -4,7 +4,8 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/*    */
+/* $Id$ */
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
index 01601f60073e0f6de08e51a4bc57d9a2ce3aa06f..1993a03148d73c80753a66d11e5e3b2379fa8144 100644 (file)
 
 /* $Id$ */
 
-#include <Riostream.h> 
-#include <TTree.h> 
 #include <TObjArray.h>
 #include <TFile.h>
-#include <TDirectory.h>
-#include <TPDGCode.h>
+#include <TError.h>
+//#include <TTree.h> 
+//#include <TDirectory.h>
 
-#include "AliHitMap.h"
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONHit.h"
-#include "AliMUONHitMapA1.h"
 #include "AliMUONMerger.h"
+#include "AliMUON.h"
 #include "AliMUONPadHit.h"
 #include "AliMUONTransientDigit.h"
-#include "AliRun.h"
+#include "AliHitMap.h"
+//#include "AliMUONChamber.h"
+//#include "AliMUONConstants.h"
+//#include "AliMUONHit.h"
+//#include "AliMUONHitMapA1.h"
+//#include "AliRun.h"
 
 ClassImp(AliMUONMerger)
 
@@ -428,7 +426,7 @@ void AliMUONMerger::Digitise()
 
 
 
-void AliMUONMerger::SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr)
+void AliMUONMerger::SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr) const
 {
   //
   // Sort the list of tracks contributing to a given digit
index e15551d7939cb52225e80c52eddb2d16996db93e..4594bbb1b7b69699e4216ae1721a1c7e41a17d7b 100644 (file)
@@ -4,9 +4,9 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-// #include "AliMerger.h"
-// #include "AliMergable.h"
+class TTree;
 
 class AliMUONPadHit;
 class AliHitMap;
@@ -48,7 +48,7 @@ class AliMUONMerger {
  private:    
     // Open the bgr file
     TFile *InitBgr();
-    void SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr);
+    void SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr) const;
     
  private:
     TTree *fTrH1;                   //! Hits Tree for background event
index 0b4b3ac4c5bd5583af1c0af1fdb6f6412c7cd253..8d9c1343fbed99ab0d66ec593d1df6c75bc9518a 100644 (file)
 
 ClassImp(AliMUONPadHit)
  
+//___________________________________________
+AliMUONPadHit::AliMUONPadHit()
+  :  TObject(),
+     fHitNumber(0),
+     fCathode(0),
+     fQ(0),
+     fPadX(0),
+     fPadY(0),
+     fQpad(0),
+     fRSec(0)   
+{
+// Default constructor
+}
+
 //___________________________________________
 AliMUONPadHit::AliMUONPadHit(Int_t *clhits)
+  : TObject()
 {
 // Constructor
    fHitNumber=clhits[0];
index 202d027f0f514f532a2ad91f8e265effcc7439c3..360474ae4d5d95b4e7fd357057e1ade8497aa550 100644 (file)
@@ -4,18 +4,17 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
-
 class AliMUONPadHit : public TObject {
  
 public:
-   AliMUONPadHit() {
-      fHitNumber=fQ=fPadX=fPadY=fQpad=fRSec=0;   
-}
+   AliMUONPadHit();
    AliMUONPadHit(Int_t *clhits);
    virtual ~AliMUONPadHit() {;}
+
    Int_t   HitNumber() const {return fHitNumber;}
    Int_t   Cathode()   const {return fCathode;}
    Int_t   Q()         const {return fQ;}
index 69fb91a08ff063bc4fd41589b87b3f6af9e2fb4a..79bd6b40a3932d4ce09bc19ef7335fc205a60ffd 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
 #include "AliMUONPixel.h"
 
 ClassImp(AliMUONPixel) // Class implementation in ROOT context
 
+//_____________________________________________________________________________
+AliMUONPixel::AliMUONPixel()
+  : TObject()
+{
+// Default constructor
+} 
+
 //_____________________________________________________________________________
 AliMUONPixel::AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge)
+  : TObject()
 {
   // Constructor
   fXY[0] = xc; fXY[1] = yc; fSize[0] = wx; fSize[1] = wy; fCharge = charge;
index ef4dddd04ed4286b07c4ad384289c525e7f6bf22..c3c5f0a6878d9daa76a2bc619a8eca0adfbb7b7a 100644 (file)
@@ -3,15 +3,16 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <TROOT.h>
-class TObjArray;
+/* $Id$ */
+// Revision of includes 07/05/2004
+
+#include <TObject.h>
 
 class AliMUONPixel : public TObject {
 
  public:
 
-  AliMUONPixel(){
-    ;} // Default constructor
+  AliMUONPixel();
   AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge); // constructor
   virtual ~AliMUONPixel(); // Destructor
 
index 157bc3a3ebcc14b64898c4501e7e4b4f02eb2ab9..e13c891a74aec19dfb4849a7ef220e71e4d5a204 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "AliMUONPoints.h"
-#include "AliMUONDisplay.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliMUONResponse.h"
-#include "AliMUONHit.h"
-#include "AliMUONPadHit.h"
-#include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
-
-
 #include <TROOT.h>
-#include <TTree.h>
 #include <TPolyMarker3D.h>
 #include <TMatrix.h>
-#include <TPad.h>
 #include <TVirtualPad.h>
-#include <TPolyLine3D.h>
 #include <TPaveText.h>
-#include <TView.h>
-#include <TMath.h>
 #include <TMarker3DBox.h>
  
+#include "AliMUONPoints.h"
+#include "AliMUONDisplay.h"
+#include "AliRun.h"
+#include "AliMUON.h"
+#include "AliMUONHit.h"
+#include "AliMUONDigit.h"
+
 ClassImp(AliMUONPoints)
 
 //_____________________________________________________________________________
 AliMUONPoints::AliMUONPoints()
+  : AliPoints()
 {
   //
   // Default constructor
@@ -81,9 +72,13 @@ AliMUONPoints::AliMUONPoints(Int_t npoints)
   fMatrix = 0;
 }
 
-AliMUONPoints::AliMUONPoints(const AliMUONPoints& points):AliPoints(points)
+//_____________________________________________________________________________
+AliMUONPoints::AliMUONPoints(const AliMUONPoints& points)
+  : AliPoints(points)
 {
-// Copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONPoints", "Not implemented.");
 }
         
 //_____________________________________________________________________________
@@ -102,7 +97,7 @@ AliMUONPoints::~AliMUONPoints()
 }
 
 //_____________________________________________________________________________
-void AliMUONPoints::DumpHit()
+void AliMUONPoints::DumpHit() const
 {
   //
   //   Dump hit corresponding to this point
@@ -112,7 +107,7 @@ void AliMUONPoints::DumpHit()
 }
 
 //_____________________________________________________________________________
-void AliMUONPoints::DumpDigit()
+void AliMUONPoints::DumpDigit() const
 {
   //
   //   Dump digit corresponding to this point
@@ -191,13 +186,13 @@ void AliMUONPoints::InspectDigit()
 }
 
 //_____________________________________________________________________________
-Int_t AliMUONPoints::GetTrackIndex()
+Int_t AliMUONPoints::GetTrackIndex() const
 {
   //
   //   Dump digit corresponding to this point
   //
 
-  this->Inspect();
+  Inspect();
   /*
   if (fDigitIndex != 0) {
     Int_t ncol=this->fMatrix->GetNcols();
@@ -246,7 +241,13 @@ AliMUONDigit *AliMUONPoints::GetDigit() const
 }
 //_____________________________________________________________________________
 
-AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& /*rhs*/)
+AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& rhs)
 {
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
index 5862d7d5bac6cdedd7184239f292bc186f617255..a320b57ec67681af49b0422f2e45ef80acfb14d6 100644 (file)
@@ -5,40 +5,43 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-class AliMUONDigit;
-class AliMUONHit;
+#include "AliPoints.h"
 
 class TMatrix;
 class TMarker3DBox;
 
-#include "AliPoints.h"
+class AliMUONDigit;
+class AliMUONHit;
 
-class AliMUONPoints : public AliPoints {
-    public:
+class AliMUONPoints : public AliPoints 
+{
+public:
   AliMUONPoints();
   AliMUONPoints(Int_t npoints);
-  AliMUONPoints(const AliMUONPoints& points);  
   virtual ~AliMUONPoints();
 
-  Int_t                 GetHitIndex() {return fHitIndex;}
-  Int_t                 GetTrackIndex(); // *MENU*
-  Int_t                 GetDigitIndex() {return fDigitIndex;}
-  TMarker3DBox         *GetMarker(Int_t i) {return fMarker[i];}
+  Int_t                 GetHitIndex() const {return fHitIndex;}
+  Int_t                 GetTrackIndex() const; // *MENU*
+  Int_t                 GetDigitIndex() const {return fDigitIndex;}
+  TMarker3DBox         *GetMarker(Int_t i) const {return fMarker[i];}
   AliMUONHit           *GetHit() const;
   AliMUONDigit         *GetDigit() const;
   virtual void          InspectHit(); // *MENU*
-  virtual void          DumpHit(); // *MENU*
+  virtual void          DumpHit() const; // *MENU*
   virtual void          InspectDigit(); // *MENU*
-  virtual void          DumpDigit(); // *MENU*
+  virtual void          DumpDigit() const; // *MENU*
   virtual void          SetHitIndex(Int_t hitindex) {fHitIndex = hitindex;}
   virtual void          SetTrackIndex(Int_t trackindex) {fTrackIndex = trackindex;}
   virtual void          SetDigitIndex(Int_t digitindex) {fDigitIndex = digitindex;}
   virtual void          Set3DMarker(Int_t i,TMarker3DBox *marker) {fMarker[i] = marker;}
   virtual void          SetMatrix(TMatrix *matrix) {fMatrix = matrix;}
-  AliMUONPoints& operator = (const AliMUONPoints& rhs);
   
 protected:
+  AliMUONPoints(const AliMUONPoints& points);  
+  AliMUONPoints& operator = (const AliMUONPoints& rhs);
+
    Int_t            fHitIndex;         // Link to hit number 
    Int_t            fTrackIndex;       // Link to track number 
    Int_t            fDigitIndex;       // Link to digit 
index 558c9c347c171a66d00d1eb026964197a8bb44fe..612f7e4ffa31552b708e5665e7836904b8ff027c 100644 (file)
 //
 //
 
-#include "AliMUONRawCluster.h"
 #include <TArrayF.h>
 
+#include "AliMUONRawCluster.h"
+
 ClassImp(AliMUONRawCluster);
 
 
-AliMUONRawCluster::AliMUONRawCluster() {
+AliMUONRawCluster::AliMUONRawCluster() 
+  : TObject()
+{
 // Constructor
     fTracks[0]=fTracks[1]=fTracks[2]=-1; 
     for (int j=0;j<2;j++) {
index f7ff918be297a38be7a279c7f5088624b105e440..84b71a0470cfa7e73cc706d1d18f27008ba0d943 100644 (file)
@@ -5,17 +5,18 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Class for the MUON RecPoint
 // It contains the propeorties of the physics cluters found in the tracking chambers
 // RawCluster contains also the information from the both cathode of the chambers.
 
 
-class TArrayF;
-
 #include <TObject.h>
 #include <TMath.h> // because of inline funtion GetRadius
 
+class TArrayF;
+
 class AliMUONRawCluster : public TObject {
 
 public:
index b0f2bd84c697ecae3da8b5b6b611dd946433ff96..41a4ff94436d37245a171d27576d1d9651a55b95 100644 (file)
 //                                                                  //
 //////////////////////////////////////////////////////////////////////
 
-#include <Riostream.h>
-
 #include <TROOT.h>
+#include <TApplication.h>
+#include <TFile.h>
+#include <TPolyLine3D.h>
+#include <TParticle.h>
+#include <TTree.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TCanvas.h>
+#include <TProfile.h>
 #include <TFolder.h>
 #include <TClonesArray.h>
-#include <TGeometry.h>
 #include <TSlider.h>
 #include <TGeometry.h>
 #include <TView.h>
+#include <Riostream.h>
 
-#include <AliRun.h>
-#include <AliConfig.h>
-#include <AliHeader.h>
-#include <AliPoints.h>
+#include "AliRun.h"
+#include "AliDetector.h"
+#include "AliConfig.h"
+#include "AliHeader.h"
+#include "AliPoints.h"
+#include "AliMC.h"
 
 #include "AliMUONRecoDisplay.h"
 #include "AliMUONRecoEvent.h"
 #include "AliMUONRecoTrack.h"
-#include "AliMC.h"
+#include "AliMUONHit.h"
 
 ClassImp(AliMUONRecoDisplay)
 
 //-------------------------------------------------------------------
 AliMUONRecoDisplay::AliMUONRecoDisplay(Int_t nevent)
-                  :AliDisplay(750)
+  AliDisplay(750)
 {
 //************ Constructor of the reco. event display**********
    // get reconstructed event from file
@@ -467,7 +476,7 @@ void AliMUONRecoDisplay::ShowNextEvent(Int_t delta)
    if (gROOT->GetListOfCanvases()->FindObject("xy")) XYPlot();
 }
 //-------------------------------------------------------------------
-Bool_t AliMUONRecoDisplay::IsReconstructible(Int_t track)
+Bool_t AliMUONRecoDisplay::IsReconstructible(Int_t track) const
 {
 // true if at least three hits in first 2 stations, 3 in last 2 stations
 // and one in station 3
@@ -816,5 +825,3 @@ void AliMUONRecoDisplay::PolyLineInfo(TClonesArray *line3Dlist)
       }
    }
 }
-
-
index f4904135d0a8d357581c4f5f05958052c49998db..daac88466031afc58c1a18ae7e8b200555bc4427 100644 (file)
@@ -4,26 +4,19 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 // Authors : M.Gheata, A.Gheata 09/10/00
 
-#include <TApplication.h>
-#include <TROOT.h>
-#include <TFile.h>
-#include <TPolyLine3D.h>
-#include <TParticle.h>
-#include <AliDisplay.h>
-#include <TTree.h>
-#include <TH1.h>
-#include <TH2.h>
-#include <TCanvas.h>
-#include <TProfile.h>
-#include <AliDetector.h>
-#include "AliMUONHit.h"
+#include "AliDisplay.h"
+
+class TTree;
+class TFile;
+class TClonesArray;
 
 class AliMUONRecoEvent;
 
-class AliMUONRecoDisplay:public AliDisplay 
+class AliMUONRecoDisplay : public AliDisplay 
 {
   public:
     AliMUONRecoDisplay(Int_t nevent=0);
@@ -50,7 +43,7 @@ class AliMUONRecoDisplay:public AliDisplay
     Int_t              GetBestMatch(Int_t indr, Float_t tolerance=3.0);
     TClonesArray*      MakePolyLines3D(TClonesArray *tracklist);
     void               MapEvent(Int_t nevent);
-    Bool_t             IsReconstructible(Int_t track);
+    Bool_t             IsReconstructible(Int_t track) const;
     //data members
     Int_t              fEvent;                   // current event number
     AliMUONRecoEvent  *fEvGen;                   // Geant event
index 5a9125df65ddfee28d60d7302e607cf5ed12fca2..eebef1ac97ed3ef594de81c4dd1e073a0308a1d6 100644 (file)
 ////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h>
-#include <AliRun.h>
 #include <TClonesArray.h>
-#include <TClass.h>
-
-#include <TFile.h>
 #include <TMatrixD.h>
-#include <TParticle.h>
 
 #include "AliMUONRecoEvent.h"
 #include "AliMUONRecoTrack.h"
@@ -57,6 +52,7 @@
 #include "AliMUONTrackParam.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONTrackHit.h"
+#include "AliRun.h"
 #include "AliHeader.h"
 
 ClassImp(AliMUONRecoEvent)
index cdfba1a08f9d2406d7ef59e011afcc61b3b03755..92d17699e905a067c8fa533ab6b40102dde70f64 100644 (file)
@@ -5,17 +5,15 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
-
+// Revision of includes 07/05/2004
 
 // Authors : M.Gheata, A.Gheata 09/10/00
 
 #include <TObject.h>
-#include <TFile.h>
-#include <TParticle.h>
-#include <AliDetector.h>
-#include "AliMUONHit.h"
-class AliMUONEventReconstructor;
 
+class TClonesArray;
+
+class AliMUONEventReconstructor;
 class AliMUONRecoTrack;
 
 /////////////////////////////////////////////////////////////////////
index 8487dc6db1269445a09be60134f7e634ca573e53..3b34ab06985a2112f30965bb26435a427b7fbd55 100644 (file)
 ////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h>
-#include <AliRun.h>
-#include <TClonesArray.h>
-#include <TClass.h>
-
-#include <TFile.h>
-#include <TMatrixD.h>
-#include <TParticle.h>
 
 #include "AliMUONRecoTrack.h"
-#include "AliMUONEventReconstructor.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackK.h"
-#include "AliMUONTrackParam.h"
-#include "AliMUONHitForRec.h"
-#include "AliMUONTrackHit.h"
-#include "AliHeader.h"
 
 ClassImp(AliMUONRecoTrack)
 
 //-------------------------------------------------------------------
 AliMUONRecoTrack::AliMUONRecoTrack(Bool_t active)
+  : TObject()
 {
 //Constructor of AliMUONRecoTrack
    fSign  = 0;
index 0f3312e699fbfd7757244b03530d4419cc5983a0..5121b8b46b873d6328ea7b88386c39291159daa1 100644 (file)
 // Authors : M.Gheata, A.Gheata 09/10/00
 
 #include <TObject.h>
-//#include <TFile.h>
-//#include <TParticle.h>
-//#include <AliDetector.h>
-//#include "AliMUONHit.h"
-//class AliMUONEventReconstructor;
+#include <TMath.h>
 
 ////////////////////////////////////////////////////////////////////
 //                                                                //
@@ -24,7 +20,7 @@
 //                                                                //
 ////////////////////////////////////////////////////////////////////
 
-class AliMUONRecoTrack:public TObject 
+class AliMUONRecoTrack : public TObject 
 {
   public:
     AliMUONRecoTrack() { }
@@ -36,7 +32,7 @@ class AliMUONRecoTrack:public TObject
     const Double_t GetPosX(Int_t chamber) const {return fPosX[chamber];};
     const Double_t GetPosY(Int_t chamber) const {return fPosY[chamber];};
     const Double_t GetPosZ(Int_t chamber) const {return fPosZ[chamber];};
-    const Double_t GetVertexPos() { return fZvr;};
+    const Double_t GetVertexPos() const { return fZvr;};
     const Double_t P() {return TMath::Sqrt(fPr[0]*fPr[0] + fPr[1]*fPr[1] + fPr[2]*fPr[2]);};
     const Double_t Phi();
     void           SetChi2r(Double_t chi) { fChi2r = chi;};
index ca567a52f248cdffe45ec603caf8f5a2196c7c22..55de97350e7000bf1d44e80cc2d565f883bfd9a6 100644 (file)
 #include "AliMUONReconstHit.h"
 
 ClassImp(AliMUONReconstHit)
-//___________________________________________
+
+//_____________________________________________________________________________
+AliMUONReconstHit::AliMUONReconstHit() 
+  : TObject()
+{
+// Default constructor
+
+  fCorrelIndex[0]=fCorrelIndex[1]=fCorrelIndex[2]=fCorrelIndex[3]=0;
+  fX[0]=fX[1]=fX[2]=fX[3]=0; fY[0]=fY[1]=fY[2]=fY[3]=0; 
+}
+
 //_____________________________________________________________________________
 AliMUONReconstHit::AliMUONReconstHit(Int_t *idx, Float_t *x, Float_t *y)
+  : TObject()
 {
     //
     // Creates a MUON correlation object
index 8ffd4cd72fd342dff8e87564dff802caccfa82e9..4749cde7c81f13f8d09ea78c976e54f02a6afc4d 100644 (file)
@@ -5,16 +5,14 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include <TObject.h>
 
 class AliMUONReconstHit : public TObject 
 {
   public:
-    AliMUONReconstHit() {
-       fCorrelIndex[0]=fCorrelIndex[1]=fCorrelIndex[2]=fCorrelIndex[3]=0;
-       fX[0]=fX[1]=fX[2]=fX[3]=0; fY[0]=fY[1]=fY[2]=fY[3]=0; 
-    }
+    AliMUONReconstHit();
     AliMUONReconstHit(Int_t *idx, Float_t *x, Float_t *y);
     virtual ~AliMUONReconstHit() {}
    
index 339686d74aa4e5702232a1abbc2a7f11ad7ddb25..c32ab8bafbb43724d4324aefff151b15831edb0d 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 #include <TParticle.h>
-#include "TArrayF.h"
+#include <TArrayF.h>
+
 #include "AliRunLoader.h"
-#include "AliRun.h"
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
 #include "AliESD.h"
+
 #include "AliMUONData.h"
 #include "AliMUONEventReconstructor.h"
 #include "AliMUONClusterReconstructor.h"
@@ -41,6 +42,7 @@
 ClassImp(AliMUONReconstructor)
 //_____________________________________________________________________________
 AliMUONReconstructor::AliMUONReconstructor()
+  : AliReconstructor()
 {
 }
 //_____________________________________________________________________________
@@ -67,9 +69,9 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
 
   for (Int_t i = 0; i < 10; i++) {
-    AliMUONClusterFinderVS *RecModel = new AliMUONClusterFinderVS();
-    RecModel->SetGhostChi2Cut(10);
-    recoCluster->SetReconstructionModel(i,RecModel);
+    AliMUONClusterFinderVS *recModel = new AliMUONClusterFinderVS();
+    recModel->SetGhostChi2Cut(10);
+    recoCluster->SetReconstructionModel(i,recModel);
   } 
 
   loader->LoadDigits("READ");
@@ -190,7 +192,7 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
     }
   }
   // setting ESD MUON class
-  AliESDMuonTrack* ESDTrack = new  AliESDMuonTrack() ;
+  AliESDMuonTrack* theESDTrack = new  AliESDMuonTrack() ;
 
   //-------------------- trigger tracks-------------
   Long_t trigPat = 0;
@@ -235,20 +237,20 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
     chi2MatchTrigger = recTrack->GetChi2MatchTrigger();
 
     // setting data member of ESD MUON
-    ESDTrack->SetInverseBendingMomentum(inverseBendingMomentum);
-    ESDTrack->SetThetaX(TMath::ATan(nonBendingSlope));
-    ESDTrack->SetThetaY(TMath::ATan(bendingSlope));
-    ESDTrack->SetZ(vertex[2]);
-    ESDTrack->SetBendingCoor(vertex[1]); // calculate vertex at ESD or Tracking level ?
-    ESDTrack->SetNonBendingCoor(vertex[0]);
-    ESDTrack->SetChi2(fitFmin);
-    ESDTrack->SetNHit(nTrackHits);
-    ESDTrack->SetMatchTrigger(matchTrigger);
-    ESDTrack->SetChi2MatchTrigger(chi2MatchTrigger);
+    theESDTrack->SetInverseBendingMomentum(inverseBendingMomentum);
+    theESDTrack->SetThetaX(TMath::ATan(nonBendingSlope));
+    theESDTrack->SetThetaY(TMath::ATan(bendingSlope));
+    theESDTrack->SetZ(vertex[2]);
+    theESDTrack->SetBendingCoor(vertex[1]); // calculate vertex at ESD or Tracking level ?
+    theESDTrack->SetNonBendingCoor(vertex[0]);
+    theESDTrack->SetChi2(fitFmin);
+    theESDTrack->SetNHit(nTrackHits);
+    theESDTrack->SetMatchTrigger(matchTrigger);
+    theESDTrack->SetChi2MatchTrigger(chi2MatchTrigger);
 
     // storing ESD MUON Track into ESD Event 
     if (nRecTracks != 0)  
-      esd->AddMuonTrack(ESDTrack);
+      esd->AddMuonTrack(theESDTrack);
   } // end loop tracks
 
   // add global trigger pattern
@@ -263,7 +265,7 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
   loader->UnloadTracks(); 
   if (!header)
     runLoader->UnloadKinematics();
-  delete ESDTrack;
+  delete theESDTrack;
   delete muonData;
   // delete particle;
 }
index ce554a861125f0918ca4491d9a74f11b6fc1c573..a7772fc3020c8d26e252794b8e9cad9b19eaa28c 100644 (file)
@@ -4,10 +4,12 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliReconstructor.h"
 
-class AliMUONReconstructor: public AliReconstructor {
+class AliMUONReconstructor: public AliReconstructor 
+{
   public:
     AliMUONReconstructor();
     virtual ~AliMUONReconstructor();
index d17a80695ece9b7859a33ac596f1886ffcc26dcc..190922c0d8b2cbd3d996d76a3ff54a9f313963de 100644 (file)
 
 ClassImp(AliMUONResponse)
 
+AliMUONResponse::AliMUONResponse()
+  : TObject()
+{
+// Default constructor
+}
+
+
+AliMUONResponse::~AliMUONResponse()
+{
+// Destructor
+}
+
index 7ec1b45dcdb18bec7589555404be7001096e0e9e..a7ed4a97b6d8825bce9f66c9d4914c1b3ada45ca 100644 (file)
@@ -4,33 +4,37 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-#include "TObject.h"
+#include <TObject.h>
 
 class TF1;
 class AliSegmentation;
 class AliMUONTransientDigit;
 
-class AliMUONResponse :
-public TObject {
+class AliMUONResponse : public TObject 
+{
  public:
+    AliMUONResponse();
+    virtual ~AliMUONResponse();
     //
     // Configuration methods
     //
     // Set number of sigmas over which cluster disintegration is performed
     virtual void    SetSigmaIntegration(Float_t p1)           =0;
     // Get number of sigmas over which cluster disintegration is performed
-    virtual Float_t SigmaIntegration()                        =0;
+    virtual Float_t SigmaIntegration() const                  =0;
     // Set single electron pulse height (ADCcounts/e)
     virtual void    SetChargeSlope(Float_t p1)                =0;
     // Get single electron pulse height (ADCcounts/e)
-    virtual Float_t ChargeSlope()                             =0;
+    virtual Float_t ChargeSlope() const                       =0;
     // Set sigmas of the charge spread function
     virtual void    SetChargeSpread(Float_t p1, Float_t p2)   =0;
     // Get sigma_X of the charge spread function
-    virtual Float_t ChargeSpreadX()                           =0;
+    virtual Float_t ChargeSpreadX() const                     =0;
     // Get sigma_Y of the charge spread function
-    virtual Float_t ChargeSpreadY()                           =0;
+    virtual Float_t ChargeSpreadY() const                     =0;
     // Set maximum Adc-count value
     virtual void    SetMaxAdc(Int_t p1)                       =0;
     // Set saturation value
@@ -38,19 +42,19 @@ public TObject {
     // Set zero suppression threshold
     virtual void    SetZeroSuppression(Int_t val)             =0;
     // Get maximum Adc-count value
-    virtual Int_t MaxAdc()                                    =0;
+    virtual Int_t MaxAdc() const                              =0;
     // Get saturation value
-    virtual Int_t Saturation()                                =0;
+    virtual Int_t Saturation() const                          =0;
     // Get maximum zero suppression threshold
-    virtual Int_t ZeroSuppression()                           =0;
+    virtual Int_t ZeroSuppression() const                     =0;
     // Set anode cathode Pitch
     virtual void    SetPitch(Float_t)                         =0;
     // Get anode cathode Pitch
-    virtual Float_t Pitch()                                   =0;
+    virtual Float_t Pitch() const                             =0;
     // Set the charge correlation
     virtual void SetChargeCorrel(Float_t correl)              =0;
     // Get the charge correlation
-    virtual Float_t ChargeCorrel()                            =0;
+    virtual Float_t ChargeCorrel() const                      =0;
     //  
     // Chamber response methods
     // Pulse height from scored quantity (eloss)
index 405c253f78cf933c66aefd08c797a83e09024a4f..5a899c67bb1442d7ff646e3a1a60a5bff2b2f829 100644 (file)
 
 /* $Id$ */
 
+//#include <TMath.h>
+//#include <TRandom.h>
+//#include <Riostream.h> 
+
 #include "AliMUONResponseTrigger.h"
-#include "AliSegmentation.h"
-#include <TMath.h>
-#include <TRandom.h>
-#include <Riostream.h> 
+//#include "AliSegmentation.h"
 
 ClassImp(AliMUONResponseTrigger)
 
+//------------------------------------------------------------------   
+AliMUONResponseTrigger::AliMUONResponseTrigger()
+  : AliMUONResponseV0()
+{
+// Default constructor
+};
+
 //------------------------------------------------------------------   
 Int_t AliMUONResponseTrigger::SetGenerCluster(){
 // nothing to be done except return 0
index 14bbe0663376de763f0524b1fc7ed0a508ce38a8..e7a17c0c2fd9f7d89dc81deb00d77de5e9bbef7e 100644 (file)
@@ -4,13 +4,14 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliMUONResponseV0.h"
 
-class AliMUONResponseTrigger : 
-public AliMUONResponseV0 {
+class AliMUONResponseTrigger : public AliMUONResponseV0 
+{
  public:
-  AliMUONResponseTrigger(){};
+  AliMUONResponseTrigger();
   virtual ~AliMUONResponseTrigger(){} 
 
   virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where);
index 798e0873eb8863724ca6199cb33dcbbbe43143df..aa65cf243e9bdc39d2969f3b5f26603c82b8253e 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
+/* $Id$ */
 
-*/
+#include <TMath.h>
+#include <TRandom.h>
 
 #include "AliMUONResponseTriggerV1.h"
 #include "AliSegmentation.h"
-#include <TMath.h>
-#include <TRandom.h>
-#include <Riostream.h> 
 
 ClassImp(AliMUONResponseTriggerV1)
 
 //------------------------------------------------------------------   
-AliMUONResponseTriggerV1::AliMUONResponseTriggerV1(){
+AliMUONResponseTriggerV1::AliMUONResponseTriggerV1()
+  : AliMUONResponseTrigger() 
+{
 // default constructor 
   Float_t hv=9.2;
   SetParameters(hv);
 }
 
 //------------------------------------------------------------------   
-AliMUONResponseTriggerV1::AliMUONResponseTriggerV1(Float_t hv){
+AliMUONResponseTriggerV1::AliMUONResponseTriggerV1(Float_t hv)
+  : AliMUONResponseTrigger() 
+{
 // Constructor 
   SetParameters(hv);
 }
index 2eb3cc6170146abead17eff753badbd633f2be2a..887268ce320c7b27c371e6a9b78489a8b08aaf7e 100644 (file)
@@ -3,6 +3,9 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                                */
 
+/* $Id$ */
+// Revision of includes 07/05/2004
+
 #include "AliMUONResponseTrigger.h"
 
 class AliMUONResponseTriggerV1 : public AliMUONResponseTrigger 
index 4abf2a271d5a5c40ca9087b3cb9246606c8ec35a..089d2e5d752fce7cf2c4a527ca5abc3f6d348c09 100644 (file)
 
 /* $Id$ */
 
-#include "AliMUONResponseV0.h"
-#include "AliSegmentation.h"
 #include <TMath.h>
 #include <TRandom.h>
 
+#include "AliMUONResponseV0.h"
+#include "AliSegmentation.h"
 
 ClassImp(AliMUONResponseV0)
        
+//__________________________________________________________________________
+AliMUONResponseV0::AliMUONResponseV0()
+  : AliMUONResponse() 
+{
+// Default constructor
+
+  fChargeCorrel = 0;
+}
+
   //__________________________________________________________________________
 void AliMUONResponseV0::SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3)
 {
index 4addf18281a997dc48bdfc61534c5b5050c4a07c..517f8fed7f0795fa38aad76e6c8e3b1c58d2e3ee 100644 (file)
@@ -4,13 +4,14 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliMUONResponse.h"
 
-class AliMUONResponseV0 : 
-public AliMUONResponse {
+class AliMUONResponseV0 : public AliMUONResponse 
+{
  public:
-    AliMUONResponseV0(){fChargeCorrel = 0;} // by default
+    AliMUONResponseV0();
     virtual ~AliMUONResponseV0(){}
     //
     // Configuration methods
@@ -18,18 +19,18 @@ public AliMUONResponse {
     // Set number of sigmas over which cluster didintegration is performed
     virtual void    SetSigmaIntegration(Float_t p1) {fSigmaIntegration=p1;}
     // Get number of sigmas over which cluster didintegration is performed   
-    virtual Float_t SigmaIntegration() {return fSigmaIntegration;}    
+    virtual Float_t SigmaIntegration() const {return fSigmaIntegration;}    
     // Set single electron pulse height (ADCcounts/e)
     virtual void    SetChargeSlope(Float_t p1) {fChargeSlope=p1;}
     // Get Set single electron pulse height (ADCcounts/e)
-    virtual Float_t ChargeSlope()      {return fChargeSlope;}
+    virtual Float_t ChargeSlope() const     {return fChargeSlope;}
     // Set sigmas of the charge spread function
     virtual void    SetChargeSpread(Float_t p1, Float_t p2)
        {fChargeSpreadX=p1; fChargeSpreadY=p2;}
     // Get sigma_X of the charge spread function
-    virtual Float_t ChargeSpreadX()    {return fChargeSpreadX;}
+    virtual Float_t ChargeSpreadX() const    {return fChargeSpreadX;}
     // Get sigma_Y of the charge spread function
-    virtual Float_t ChargeSpreadY()    {return fChargeSpreadY;}        
+    virtual Float_t ChargeSpreadY() const    {return fChargeSpreadY;}        
     // Set maximum Adc-count value
     virtual void    SetMaxAdc(Int_t p1) {fMaxAdc=p1;}
     // Set saturation value
@@ -37,20 +38,20 @@ public AliMUONResponse {
     // Set zero suppression threshold
     virtual void    SetZeroSuppression(Int_t p1) {fZeroSuppression=p1;}
     // Get maximum Adc-count value   
-    virtual Int_t   MaxAdc()           {return fMaxAdc;}
+    virtual Int_t   MaxAdc() const          {return fMaxAdc;}
     // Get saturation value   
-    virtual Int_t   Saturation()           {return fSaturation;}
+    virtual Int_t   Saturation() const      {return fSaturation;}
 
     // Get zero suppression threshold
-    virtual Int_t   ZeroSuppression() {return fZeroSuppression;}
+    virtual Int_t   ZeroSuppression() const {return fZeroSuppression;}
     // Set anode cathode Pitch
-    virtual Float_t Pitch()            {return fPitch;}
+    virtual Float_t Pitch() const           {return fPitch;}
     // Get anode cathode Pitch
     virtual void    SetPitch(Float_t p1) {fPitch=p1;};
     // Set the charge correlation
     virtual void SetChargeCorrel(Float_t correl){fChargeCorrel = correl;}
     // Get the charge correlation
-    virtual Float_t ChargeCorrel(){return fChargeCorrel;}
+    virtual Float_t ChargeCorrel() const {return fChargeCorrel;}
     // Set Mathieson parameters
     // Mathieson \sqrt{Kx3} and derived Kx2 and Kx4
     virtual void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
index 2b885a87faf5e11fc648477f730209fe9a272529..ece2293e79acf30fdd50dd86008564190487a7c6 100644 (file)
@@ -1,25 +1,19 @@
-
-#include <Riostream.h>
-#include <TDirectory.h>
-#include <TFile.h>
-#include <TObjArray.h>
-#include <TPDGCode.h>
-#include <TTree.h> 
-#include <TMath.h>
-
-#include "AliRun.h"
-#include "AliRunLoader.h"
-#include "AliLoader.h"
-
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONSDigitizerv1.h"
-#include "AliMUONHit.h"
-#include "AliMUONHitMapA1.h"
-#include "AliMUONPadHit.h"
-#include "AliMUONTransientDigit.h"
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
 
 /////////////////////////////////////////////////////////////////////////////////
 //
 //
 /////////////////////////////////////////////////////////////////////////////////
 
+#include "AliMUONSDigitizerv1.h"
+#include "AliMUONLoader.h"
+#include "AliMUONData.h"
+#include "AliMUONDigit.h"
+#include "AliMUONTransientDigit.h"
+
 ClassImp(AliMUONSDigitizerv1)
 
 //___________________________________________
-AliMUONSDigitizerv1::AliMUONSDigitizerv1() : AliMUONDigitizerv1()
+AliMUONSDigitizerv1::AliMUONSDigitizerv1() 
+  : AliMUONDigitizerv1()
 {
        // Default ctor - don't use it
 }
 
 //___________________________________________
-AliMUONSDigitizerv1::AliMUONSDigitizerv1(AliRunDigitizer* manager) : AliMUONDigitizerv1(manager)
+AliMUONSDigitizerv1::AliMUONSDigitizerv1(AliRunDigitizer* manager) 
+  : AliMUONDigitizerv1(manager)
 {
        // ctor which should be used
 }
@@ -56,7 +58,7 @@ void AliMUONSDigitizerv1::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_
 {
 // Derived to write to the s-digit tree TreeS.
 
-       muondata->AddSDigit(chamber, tracks, charges, digits);   
+       fMUONData->AddSDigit(chamber, tracks, charges, digits);   
 };
 
 //------------------------------------------------------------------------
@@ -76,7 +78,7 @@ Bool_t AliMUONSDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
        if (GetDebug() > 2)
                Info("InitOutputData", "Creating s-digits branch and setting the tree address.");
 
-       muondata->SetLoader(muonloader);
+       fMUONData->SetLoader(muonloader);
 
        // New branch per chamber for MUON digit in the tree of digits
        if (muonloader->TreeS() == NULL)
@@ -89,8 +91,8 @@ Bool_t AliMUONSDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
                };
        };
 
-       muondata->MakeBranch("S");
-       muondata->SetTreeAddress("S");
+       fMUONData->MakeBranch("S");
+       fMUONData->SetTreeAddress("S");
        
        return kTRUE;
 };
@@ -101,8 +103,8 @@ void AliMUONSDigitizerv1::FillOutputData()
 // Overridden to fill TreeS rather than TreeD.
 
        if (GetDebug() > 2) Info("FillOutputData", "Filling trees with s-digits.");
-       muondata->Fill("S");
-       muondata->ResetSDigits();
+       fMUONData->Fill("S");
+       fMUONData->ResetSDigits();
 };
 
 //------------------------------------------------------------------------
@@ -112,6 +114,6 @@ void AliMUONSDigitizerv1::CleanupOutputData(AliMUONLoader* muonloader)
 
        if (GetDebug() > 2) Info("CleanupOutputData", "Writing s-digits and releasing pointers.");
        muonloader->WriteSDigits("OVERWRITE");
-       muondata->ResetSDigits();
+       fMUONData->ResetSDigits();
        muonloader->UnloadSDigits();
 };
index 4b421764dce13cf88e624bee85c6c0770bf408f2..63e51117a50c78b5bf4ed2e15c9ac31f50476d80 100644 (file)
@@ -1,5 +1,10 @@
 #ifndef ALIMUONSDIGITIZERV1_H
 #define ALIMUONSDIGITIZERV1_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Revision of includes 07/05/2004
 
 // The AliMUONSDigitizer produces
 // SDigits from Hits 
index 7609edc587b8aaf8ec1610e1354dcd240baacad4..a4f1a89587b33ac1a918019b699f9e19adacb7b5 100644 (file)
 //
 ///////////////////////////////////////////////////////////
 
+#include "AliMUONSegment.h" 
 #include "AliMUON.h"
 #include "AliMUONChamber.h" 
 #include "AliMUONHitForRec.h" 
-#include "AliMUONSegment.h" 
 #include "AliMUONTrackParam.h" 
 #include "AliRun.h" // for gAlice
 
@@ -37,6 +37,7 @@ ClassImp(AliMUONSegment) // Class implementation in ROOT context
 
   //__________________________________________________________________________
 AliMUONSegment::AliMUONSegment()
+  : TObject()
 {
   // Default constructor
   fHitForRecPtr1 = 0; // pointer to HitForRec in first chamber
@@ -62,6 +63,7 @@ AliMUONSegment::AliMUONSegment()
 
   //__________________________________________________________________________
 AliMUONSegment::AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2)
+  : TObject()
 {
   // Constructor for AliMUONSegment from two HitForRec's,
   // one, in the first chamber of the station, pointed to by "Hit1",
@@ -97,15 +99,23 @@ AliMUONSegment::AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2)
   return;
 }
 
-AliMUONSegment::AliMUONSegment (const AliMUONSegment& MUONSegment):TObject(MUONSegment)
+AliMUONSegment::AliMUONSegment (const AliMUONSegment& theMUONSegment)
+  : TObject(theMUONSegment)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONSegment", "Not implemented.");
 }
 
-AliMUONSegment & AliMUONSegment::operator=(const AliMUONSegment& /*MUONSegment*/)
+AliMUONSegment & AliMUONSegment::operator=(const AliMUONSegment& rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
   //__________________________________________________________________________
@@ -123,7 +133,7 @@ Int_t AliMUONSegment::Compare(const TObject* Segment) const
 }
 
   //__________________________________________________________________________
-Double_t AliMUONSegment::NormalizedChi2WithSegment(AliMUONSegment* Segment, Double_t Sigma2Cut)
+Double_t AliMUONSegment::NormalizedChi2WithSegment(AliMUONSegment* Segment, Double_t Sigma2Cut) const
 {
   // Calculate the normalized Chi2 between the current Segment (this)
   // and the Segment pointed to by "Segment",
@@ -165,7 +175,7 @@ Double_t AliMUONSegment::NormalizedChi2WithSegment(AliMUONSegment* Segment, Doub
 }
 
   //__________________________________________________________________________
-AliMUONSegment* AliMUONSegment::CreateSegmentFromLinearExtrapToStation (Int_t Station, Double_t MCSfactor)
+AliMUONSegment* AliMUONSegment::CreateSegmentFromLinearExtrapToStation (Int_t Station, Double_t MCSfactor) const
 {
   // Extrapolates linearly the current Segment (this) to station (0..) "Station".
   // Multiple Coulomb scattering calculated from "MCSfactor"
@@ -209,7 +219,7 @@ AliMUONSegment* AliMUONSegment::CreateSegmentFromLinearExtrapToStation (Int_t St
 }
 
   //__________________________________________________________________________
-AliMUONHitForRec* AliMUONSegment::CreateHitForRecFromLinearExtrapToChamber (Int_t Chamber, Double_t MCSfactor)
+AliMUONHitForRec* AliMUONSegment::CreateHitForRecFromLinearExtrapToChamber (Int_t Chamber, Double_t MCSfactor) const
 {
   // Extrapolates linearly the current Segment (this) to chamber(0..) "Chamber".
   // Multiple Coulomb scattering calculated from "MCSfactor"
index 6a84125559c506a33b6a683804afa7a3c3685bda..e9120243b62b7a7b10090e8ba3f351cab043e6b4 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 ///////////////////////////////////////////////////////////
 // Segment for reconstruction in ALICE dimuon  spectrometer
 class AliMUONHitForRec;
 class AliMUONTrackParam;
 
-class AliMUONSegment : public TObject {
+class AliMUONSegment : public TObject 
+{
  public:
   AliMUONSegment(); // default constructor
-  virtual ~AliMUONSegment(){
-    // Destructor
-    ;} // Destructor
-  AliMUONSegment (const AliMUONSegment& AliMUONSegment); // copy constructor
-  AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
+  virtual ~AliMUONSegment(){} // Destructor
   AliMUONSegment(AliMUONHitForRec* Hit1, AliMUONHitForRec* Hit2); // Constructor from two HitForRec's
 
   // Inline functions for Get and Set
@@ -43,15 +41,19 @@ class AliMUONSegment : public TObject {
   Bool_t GetInTrack(void) const {return fInTrack;}
   void SetInTrack(Bool_t InTrack) {fInTrack = InTrack;}
 
-  AliMUONSegment* CreateSegmentFromLinearExtrapToStation (Int_t Station, Double_t MCSfactor);
-  Double_t NormalizedChi2WithSegment(AliMUONSegment* Segment, Double_t Sigma2Cut);
-  AliMUONHitForRec* CreateHitForRecFromLinearExtrapToChamber (Int_t Chamber, Double_t MCSfactor);
+  AliMUONSegment* CreateSegmentFromLinearExtrapToStation (Int_t Station, Double_t MCSfactor) const;
+  Double_t NormalizedChi2WithSegment(AliMUONSegment* Segment, Double_t Sigma2Cut) const;
+  AliMUONHitForRec* CreateHitForRecFromLinearExtrapToChamber (Int_t Chamber, Double_t MCSfactor) const;
   void UpdateFromStationTrackParam(AliMUONTrackParam *TrackParam, Double_t MCSfactor, Double_t Dz1, Double_t Dz2, Double_t Dz3, Int_t Station, Double_t InverseMomentum);
 
   // What is necessary for sorting TClonesArray's; sufficient too ????
   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
@@ -74,6 +76,6 @@ class AliMUONSegment : public TObject {
   Bool_t fInTrack; // TRUE if segment belongs to one track
   
   ClassDef(AliMUONSegment, 1) // Segment for reconstruction in ALICE dimuon spectrometer
-    };
+};
        
 #endif
index 6986364bb94e7536a3b5ac786b80d503a8f2c2df..a561bb1803bd80f1fdcb10bd10c8ad50bf173c3d 100644 (file)
 
 /* $Id$ */
 
+#include <TArrayI.h>
+#include <TObjArray.h>
+#include <TMath.h>
+#include <TBRIK.h>
+#include <TNode.h>
+#include <TGeometry.h>
+
 #include "AliMUONSegmentationSlat.h"
 #include "AliMUONSegmentationSlatModule.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
-#include "TArrayI.h"
-#include "TObjArray.h"
 #include "AliRun.h"
-#include <TMath.h>
-#include <TBRIK.h>
-#include <TNode.h>
-#include <TGeometry.h>
-#include <Riostream.h>
 
 //___________________________________________
 ClassImp(AliMUONSegmentationSlat)
@@ -191,7 +191,7 @@ void AliMUONSegmentationSlat::GlobalToLocal(
 }
 
 void AliMUONSegmentationSlat::GlobalToLocal(
-    Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal)
+    Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const
 {
 //
 // Perform global to local transformation for pad coordinates
@@ -206,18 +206,16 @@ void AliMUONSegmentationSlat::GlobalToLocal(
     for (Int_t i=0; i<fNSlats; i++) {
        iytemp-=Slat(i)->Npy();
        
-       
        if (iytemp <= 0) break;
        iylocal = iytemp;
        index=i+1;
     }
-
     ixlocal=TMath::Abs(ix);
     islat=index;
 }
 
 void AliMUONSegmentationSlat::
-LocalToGlobal(Int_t islat, Float_t  xlocal, Float_t  ylocal, Float_t  &x, Float_t  &y, Float_t &z)
+LocalToGlobal(Int_t islat, Float_t  xlocal, Float_t  ylocal, Float_t  &x, Float_t  &y, Float_t &z) const
 {
 // Transform from local to global space coordinates
 //
@@ -237,8 +235,8 @@ LocalToGlobal(Int_t islat, Float_t  xlocal, Float_t  ylocal, Float_t  &x, Float_
 }
 
 
-void AliMUONSegmentationSlat::LocalToGlobal(
-    Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy)
+void AliMUONSegmentationSlat::LocalToGlobal (
+    Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const
 {
 // Transform from local to global pad coordinates
 //
@@ -432,11 +430,12 @@ Int_t  AliMUONSegmentationSlat::Ix()
     Int_t ixl,iyl,ix,iy;
     ixl=fCurrentSlat->Ix();
     iyl=fCurrentSlat->Iy();
-    
     LocalToGlobal(fSlatIndex, ixl, iyl, ix, iy);
+
     Int_t ixc, iyc, isc;
     Float_t xc, yc;
     GlobalToLocal(ix, iy, isc, ixc, iyc);
+    
     Slat(isc)->GetPadC(ixc,iyc,xc,yc);
     return ix;
 }
@@ -567,7 +566,7 @@ AliMUONSegmentationSlatModule*  AliMUONSegmentationSlat::Slat(Int_t index) const
 
 
 AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::
-CreateSlatModule()
+CreateSlatModule() const
 {
     // Factory method for slat module
     return new AliMUONSegmentationSlatModule(4);
index a12dbe6c11cc56aff87ee24b4c7da4a1796d2317..c2dc9e21cfbe946dc9cd830eaab9aa559ccb2df2 100644 (file)
@@ -4,6 +4,8 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
+
 /////////////////////////////////////////////////////
 //  Segmentation classes for slat modules          //
 //  to be used with AluMUONSegmentationSlat        //
 
 class TArrayI;
 class TObjArray;
+
 class AliMUONSegmentationSlatModule;
 class AliMUONChamber;
 
-
-class AliMUONSegmentationSlat :
-public AliSegmentation {
+class AliMUONSegmentationSlat : public AliSegmentation 
+{
  public:
     AliMUONSegmentationSlat();
     AliMUONSegmentationSlat(Int_t nsec);    
@@ -133,16 +135,16 @@ public AliSegmentation {
     virtual void GlobalToLocal(
        Float_t x, Float_t y, Float_t z,  Int_t &islat, Float_t &xlocal, Float_t &ylocal);
     virtual void GlobalToLocal(
-       Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal);
+       Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const;
 
-    virtual void LocalToGlobal(
-        Int_t islat, Float_t xlocal, Float_t ylocal, Float_t &x, Float_t  &y, Float_t &z);
-    virtual void LocalToGlobal(
-        Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy);
+    virtual void LocalToGlobal (
+        Int_t islat, Float_t xlocal, Float_t ylocal, Float_t &x, Float_t  &y, Float_t &z) const; 
+    virtual void LocalToGlobal (
+        Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const;
     virtual void SetSymmetry(Int_t   ix);
     virtual void SetSymmetry(Float_t  x);
    // Factory method for associated slat module class  
-    virtual AliMUONSegmentationSlatModule* CreateSlatModule();
+    virtual AliMUONSegmentationSlatModule* CreateSlatModule() const;
     
  protected:
 
index 195e50a48bb788f3324e3863ca55c7e70fab8f9e..7988c2cfab8a5904d9fffb51ec0411fd1eb89ce1 100644 (file)
 //  to be used with AluMUONSegmentationSlat        //
 /////////////////////////////////////////////////////
 
+#include <TArrayI.h>
+#include <TArrayF.h>
 
 #include "AliMUONSegmentationSlatModule.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include <TMath.h>
-#include <Riostream.h>
-
-#include "AliMUONSegmentationV01.h"
 
 //___________________________________________
 ClassImp(AliMUONSegmentationSlatModule)
index 5e78b5e3b08d5bd7a745e9e70e9cb25c1e668bb2..e80a168968447cad410b7719634d13792bd8aac8 100644 (file)
@@ -4,20 +4,20 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation classes for slat modules          //
 //  to be used with AluMUONSegmentationSlat        //
 /////////////////////////////////////////////////////
 
+#include  "AliMUONSegmentationV0.h"
+
 class TArrayF;
 class TArrayI;
-class TObjArray;
-
-#include  "AliMUONSegmentationV0.h"
 
-class AliMUONSegmentationSlatModule :
-public AliMUONSegmentationV0 {
+class AliMUONSegmentationSlatModule : public AliMUONSegmentationV0 
+{
  public:
     AliMUONSegmentationSlatModule();
     AliMUONSegmentationSlatModule(Int_t nsec);
index 89f6287609c5513e8c8915bb9f0f066ef24281c9..5165795c4eb62a60a51f839aa777fb1948a3fa29 100644 (file)
 /////////////////////////////////////////////////////
 
 
-#include "AliMUONSegmentationSlatModuleN.h"
-#include <TMath.h>
-#include <Riostream.h>
+#include <TArrayI.h>
+#include <TArrayF.h>
 
-#include "AliMUONSegmentationV01.h"
+#include "AliMUONSegmentationSlatModuleN.h"
 
 //___________________________________________
 ClassImp(AliMUONSegmentationSlatModuleN)
 
 AliMUONSegmentationSlatModuleN::AliMUONSegmentationSlatModuleN() 
+  : AliMUONSegmentationSlatModule()
 {
 // Default constructor
 }
index 711d1306eda4614af06bbdfbd8aba709f8ecd278..fb9d9b9f5d9926450e9b97174e32142ab7a21aa0 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation classes for slat modules          //
@@ -12,8 +13,8 @@
 
 #include "AliMUONSegmentationSlatModule.h"
 
-class  AliMUONSegmentationSlatModuleN :
-public AliMUONSegmentationSlatModule {
+class  AliMUONSegmentationSlatModuleN : public AliMUONSegmentationSlatModule 
+{
  public:
     AliMUONSegmentationSlatModuleN();
     AliMUONSegmentationSlatModuleN(Int_t nsec);
index cb70cebb0fd972e5a8974aa14c50a3f12a87bd21..6d9697bef1ec81e1b1b21cd54cf3a55fe4bba715 100644 (file)
 
 /* $Id$ */
 
+#include <TArrayI.h>
+#include <TMath.h>
+
 #include "AliMUONSegmentationSlatN.h"
 #include "AliMUONSegmentationSlatModuleN.h"
-#include "TArrayI.h"
-#include "TArrayF.h"
-#include "TObjArray.h"
-#include <TMath.h>
-#include <Riostream.h>
 
 //___________________________________________
 ClassImp(AliMUONSegmentationSlatN);
 
 AliMUONSegmentationSlatN::AliMUONSegmentationSlatN()
+  : AliMUONSegmentationSlat()
 {
 // Default constructor
 }
@@ -61,7 +60,7 @@ Float_t AliMUONSegmentationSlatN::Dpy(Int_t isec) const
 
 
 void AliMUONSegmentationSlatN::GlobalToLocal(
-    Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal)
+    Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const
 {
 //
 // Perform local to global transformation for pad coordinates
@@ -88,7 +87,7 @@ void AliMUONSegmentationSlatN::GlobalToLocal(
 }
 
 void AliMUONSegmentationSlatN::LocalToGlobal(
-    Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy)
+    Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const
 {
 // Local to global transformation for pad coordinates
     
@@ -131,7 +130,7 @@ GetPadI(Float_t x, Float_t y, Float_t z, Int_t &ix, Int_t &iy)
 }
 
 AliMUONSegmentationSlatModule* AliMUONSegmentationSlatN::
-CreateSlatModule()
+CreateSlatModule() const
 {
     // Factory method for slat module
     return new AliMUONSegmentationSlatModuleN(4);
index b216f8e15fc10f4fc0508789025a4896b187c879..d7dbcb95f19dc772a00fb6f7337ba73606c5678f 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation classes for slat modules          //
 
 #include "AliMUONSegmentationSlat.h"
 
-class TArrayF;
-class TList;
-class AliMUONSegmentationSlatModuleN;
+//class TArrayF;
+//class TList;
+//class AliMUONSegmentationSlatModuleN;
 
 
-class  AliMUONSegmentationSlatN :
-public AliMUONSegmentationSlat {
+class  AliMUONSegmentationSlatN : public AliMUONSegmentationSlat 
+{
  public:
     AliMUONSegmentationSlatN();
     AliMUONSegmentationSlatN(Int_t nsec);
@@ -39,11 +40,11 @@ public AliMUONSegmentationSlat {
     //
     // Class specific methods
     virtual void GlobalToLocal(
-       Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal);
+       Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const;
     virtual void LocalToGlobal(
-        Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy);
+        Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const;
     // Factory method for associated slat module class
-     AliMUONSegmentationSlatModule* CreateSlatModule();
+     AliMUONSegmentationSlatModule* CreateSlatModule() const;
  private:
     ClassDef(AliMUONSegmentationSlatN,1) // Segmentation for Muon Chamber built from Slat Modules
        
index 14abdb30ee716e7c4a819d4e9911bae5294bd283..082a1ce72b747fbb4c0d15b6f614fd682a03e45c 100644 (file)
 
 /* $Id$ */
 
+#include <TMath.h>
+//#include <TRandom.h>
+//#include <TArc.h>
+//#include <Riostream.h>
+
 #include "AliMUONSegmentationTrigger.h"
 #include "AliMUONTriggerConstants.h"
 #include "AliRun.h"
 #include "AliMUON.h"
-#include <TMath.h>
-#include <TRandom.h>
-#include <TArc.h>
 #include "AliMUONChamber.h"
-#include <Riostream.h>
 
 ClassImp(AliMUONSegmentationTrigger)
 
+//------------------------------------------------------------------
+AliMUONSegmentationTrigger::AliMUONSegmentationTrigger()
+  : AliMUONSegmentationV0()
+{
+// Constructor
+
+  fChamber=0;
+}
+
 //------------------------------------------------------------------
 void AliMUONSegmentationTrigger::Init(Int_t chamber)
 {
index 8bba797041072f9ad09a3f077d396163d9816904..84b13c904ff4b25b89e12a804542f7b78e0bb152 100644 (file)
@@ -5,17 +5,21 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-#include "AliMUONSegmentationV0.h"
-class AliMUONChamber;
 //----------------------------------------------
 //
 // Chamber segmentation virtual base class
 //
-class AliMUONSegmentationTrigger :
-public AliMUONSegmentationV0 {
+
+#include "AliMUONSegmentationV0.h"
+
+class AliMUONChamber;
+
+class AliMUONSegmentationTrigger : public AliMUONSegmentationV0 
+{
  public:
-    AliMUONSegmentationTrigger(){fChamber=0;}
+    AliMUONSegmentationTrigger();
     virtual ~AliMUONSegmentationTrigger(){}  
     virtual void Init(Int_t chamber);         // Initialization
     Int_t ModuleNumber(Int_t imodule);  // returns module number of ModuleId
index b5973b85b4b4ec2df9cc226b5683dfcab2fb49aa..1b033bfd1376fdc9c94451121208393594ad1c61 100644 (file)
 #include "AliMUON.h"
 #include "AliMUONSegmentationTriggerX.h"
 #include "AliMUONTriggerConstants.h"
-#include "TMath.h"
-#include "TRandom.h"
-#include "TArc.h"
 #include "AliMUONChamber.h"
 #include "AliRun.h"  // gAlice
-#include <Riostream.h> 
+
 ClassImp(AliMUONSegmentationTriggerX)
 
 //------------------------------------------------------------------
index 747c938f95c73e37493a1aa72f8711d8d6ccf269..46cc3b0ab2dd63c547bddfb12d35c938fa917c84 100644 (file)
@@ -5,16 +5,19 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-#include "AliMUONSegmentationTrigger.h"
-
-class AliMUONChamber;
 //----------------------------------------------
 //
 // Chamber segmentation virtual base class
 //
-class AliMUONSegmentationTriggerX :
-public AliMUONSegmentationTrigger {
+
+#include "AliMUONSegmentationTrigger.h"
+
+class AliMUONChamber;
+
+class AliMUONSegmentationTriggerX : public AliMUONSegmentationTrigger 
+{
  public:
   AliMUONSegmentationTriggerX(){}
   virtual ~AliMUONSegmentationTriggerX(){}
index bee410846c81b7e0561b10873b8825e25935ffbe..92e8e8a36cc010a8679232c24b4596c80e9f4fae 100644 (file)
 
 /* $Id$ */
 
+#include <TMath.h>
+
 #include "AliMUONSegmentationTriggerY.h"
 #include "AliMUONTriggerConstants.h"
-#include "TMath.h"
-#include "TRandom.h"
-#include "TArc.h"
-#include "AliMUONChamber.h"
 #include "AliMUON.h"
 #include "AliRun.h"
-#include <Riostream.h> 
+
 ClassImp(AliMUONSegmentationTriggerY)
 
+//------------------------------------------------------------------
+AliMUONSegmentationTriggerY::AliMUONSegmentationTriggerY()
+  : AliMUONSegmentationTrigger()
+{
+// Constructor
+}
+
 //------------------------------------------------------------------
 void AliMUONSegmentationTriggerY::Init(Int_t chamber)
 {
index fba16978954cebf909a82490535a418d1492f6a1..bf62710ae96a73e2bff3cab7ce9f8aff5f9ce53d 100644 (file)
@@ -4,19 +4,21 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
-
-#include "AliMUONSegmentationTrigger.h"
-
-class AliMUONChamber;
 //----------------------------------------------
 //
 // Chamber segmentation virtual base class
 //
-class AliMUONSegmentationTriggerY :
-public AliMUONSegmentationTrigger {
+
+#include "AliMUONSegmentationTrigger.h"
+
+class AliMUONChamber;
+
+class AliMUONSegmentationTriggerY : public AliMUONSegmentationTrigger 
+{
  public:
-  AliMUONSegmentationTriggerY(){}
+  AliMUONSegmentationTriggerY();
   virtual ~AliMUONSegmentationTriggerY(){}
   // Transform from pad to real coordinates
   virtual void    GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy);
index 1f44f23035a8ac2afcc55a8325971df4bef2ee0d..bafb319418f1d2e1dd5b17b295a7c615f4c22d9b 100644 (file)
 
 /* $Id$ */
 
+#include <TArc.h>
+#include <TMath.h>
+
 #include "AliMUONSegmentationV0.h"
-#include "TArc.h"
-#include "TMath.h"
 #include "AliMUONChamber.h"
 #include "AliRun.h"
 #include "AliMUON.h"
 
 ClassImp(AliMUONSegmentationV0)
-  AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation):AliSegmentation(segmentation)
+
+AliMUONSegmentationV0::AliMUONSegmentationV0()
+  : AliSegmentation()
 {
-  // Dummy copy constructor
+  fCorr=0;
+  fChamber=0;
+}
+
+AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation)
+  : AliSegmentation(segmentation)
+{
+// Protected copy constructor
+
+  Fatal("AliMUONSegmentationV0", "Not implemented.");
 }
 
     void AliMUONSegmentationV0::Init(Int_t  chamber)
@@ -312,8 +324,14 @@ void AliMUONSegmentationV0::Draw(const char *) const
     circle->Draw();
 }
 
-AliMUONSegmentationV0& AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & /*rhs*/)
+AliMUONSegmentationV0& 
+AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
index 517338e55a460e0d86c523fbd250974efa283491..f1b634ce33f707051f937f15daef5b456a7cabc0 100644 (file)
@@ -4,23 +4,24 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
+
+//----------------------------------------------
+//
+// Chamber segmentation for homogeneously segmented circular chamber
+//
 
 #include "AliSegmentation.h"
 
 class AliMUONChamber;
 class TF1;
 
-//----------------------------------------------
-//
-// Chamber segmentation for homogeneously segmented circular chamber
-//
-class AliMUONSegmentationV0 :
-public AliSegmentation {
+class AliMUONSegmentationV0 : public AliSegmentation 
+{
  public:
-    AliMUONSegmentationV0(){fCorr=0;fChamber=0;}
-    AliMUONSegmentationV0(const AliMUONSegmentationV0 & segmentation);
-    
+    AliMUONSegmentationV0();
     virtual ~AliMUONSegmentationV0(){}
+
     // Set Chamber Segmentation Parameters
     //
     // Pad size Dx*Dy 
@@ -107,11 +108,14 @@ dummy);
     virtual void SetCorrFunc(Int_t dum, TF1* func);
     // Get the correction Function
     virtual TF1* CorrFunc(Int_t) const {return fCorr;}
-    // assignment operator
-    AliMUONSegmentationV0& operator=(const AliMUONSegmentationV0& rhs);
     
     ClassDef(AliMUONSegmentationV0,1) //Class for homogeneous segmentation
-       protected:
+  
+  protected:
+    AliMUONSegmentationV0(const AliMUONSegmentationV0 & segmentation);
+    // assignment operator
+    AliMUONSegmentationV0& operator=(const AliMUONSegmentationV0& rhs);
+
     //
     // Implementation of the segmentation class:
     // Version 0 models rectangular pads with the same dimensions all
index 94da57b1fb80c56450e2fb0fb0a2bcc32e0eeaf4..ad4f8ff31dadae028db1885c694e958548bb6975 100644 (file)
@@ -27,7 +27,6 @@
 #include <TF1.h> 
 #include <TVector3.h> 
 #include <TObjArray.h>
-#include <Riostream.h>
 
 #include "AliMUONSegmentationV01.h"
 #include "AliMUON.h"
 #include "AliRun.h"
 
 
+
 //___________________________________________
 ClassImp(AliMUONSegmentationV01)
 
-  AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation):AliMUONSegmentationV0(segmentation)
+AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
+  : AliMUONSegmentationV0(segmentation)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONSegmentationV01", "Not implemented.");
 }
 
 AliMUONSegmentationV01::AliMUONSegmentationV01() 
+  : AliMUONSegmentationV0()
 {
 // Default constructor
     fRSec = 0;
@@ -54,6 +58,7 @@ AliMUONSegmentationV01::AliMUONSegmentationV01()
 }
 
 AliMUONSegmentationV01::AliMUONSegmentationV01(Int_t nsec) 
+  : AliMUONSegmentationV0()
 {
 //  Non default constructor
 
@@ -193,6 +198,7 @@ void AliMUONSegmentationV01::Init(Int_t chamber)
     fId=chamber;
 }
 
+//______________________________________________________________________
 Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
 {
 // Returns sector number for given pad position
@@ -208,6 +214,7 @@ Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
     }
     return isec;
 }
+
 //______________________________________________________________________
 void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
 {
@@ -354,7 +361,7 @@ void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Fl
     fIx=fIxmin;
     fIy=fIymin;
     GetPadC(fIx,fIy,fX,fY);
-    
+
     // added 
     if (fSector == -1) {
       fSector=Sector(fIx,fIy);
@@ -659,10 +666,15 @@ TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
     return (TF1*) fCorrA->At(isec);
 }
 
-AliMUONSegmentationV01& AliMUONSegmentationV01::operator 
-=(const AliMUONSegmentationV01 & /*rhs*/)
+AliMUONSegmentationV01& 
+AliMUONSegmentationV01::operator =(const AliMUONSegmentationV01 & rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
index 7d030bd859fddf6c6d9e1fa84b4b57e5e210281a..5094bac57b45b7e2f0cd1202086f8d00992f7f21 100644 (file)
@@ -5,25 +5,26 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation and Response classes version 01   //
 /////////////////////////////////////////////////////
-class AliMUON;
-class TObjArray;
+
+#include <TArrayF.h>  // needed for CINT
+#include <TArrayI.h>  // needed for CINT
 
 #include "AliMUONSegmentationV0.h"
-#include "TArrayI.h" // because the object, and not the pointer,
-#include "TArrayF.h" // belongs to the class
 
+class TObjArray;
 
-class AliMUONSegmentationV01 :
-public AliMUONSegmentationV0 {
+class AliMUON;
+
+class AliMUONSegmentationV01 : public AliMUONSegmentationV0 
+{
  public:
     AliMUONSegmentationV01();
     AliMUONSegmentationV01(Int_t nsec);
-    AliMUONSegmentationV01(const AliMUONSegmentationV01 & segmentation);
-    
     virtual ~AliMUONSegmentationV01();
     
     //    
@@ -89,10 +90,13 @@ public AliMUONSegmentationV0 {
     virtual void SetCorrFunc(Int_t dum, TF1* func);
     // Get the correction function
     virtual TF1* CorrFunc(Int_t iZone) const;
+    ClassDef(AliMUONSegmentationV01,1) // Segmentation approximating circular zones with different pad size
+
+  protected:
+    AliMUONSegmentationV01(const AliMUONSegmentationV01 & segmentation);
     // assignment operator
     AliMUONSegmentationV01& operator=(const AliMUONSegmentationV01& rhs);
-    ClassDef(AliMUONSegmentationV01,1) // Segmentation approximating circular zones with different pad size
- protected:
+
     //  Geometry
     //
     Int_t       fNsec;           // Number of sectors
index 7e2264ab54f65e12df5547ef5d90d383582ec4cb..de31b6d314d96ef367e54dc04c66a27e7e87cc0e 100644 (file)
 //  Segmentation and Response classes version 02   //
 /////////////////////////////////////////////////////
 
+#include <TArrayF.h>
 
 #include "AliMUONSegmentationV02.h"
-#include "Riostream.h"
 
 //___________________________________________
 ClassImp(AliMUONSegmentationV02)
 
     
-AliMUONSegmentationV02::AliMUONSegmentationV02(Int_t nsec): 
-    AliMUONSegmentationV01(nsec) 
+AliMUONSegmentationV02::AliMUONSegmentationV02()
+  : AliMUONSegmentationV01() 
+{
+// Default constructor
+}
+
+AliMUONSegmentationV02::AliMUONSegmentationV02(Int_t nsec) 
+  : AliMUONSegmentationV01(nsec) 
 {
 // Non default constructor
 }
index e7c6d9fc98fb5164dc82284f08c6ff873754d70c..001b841b50dd2379be1cc06b834822462416c1a4 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation and Response classes version 02   //
 
 #include "AliMUONSegmentationV01.h"
 
-class AliMUONSegmentationV02 :
-public AliMUONSegmentationV01 {
+class AliMUONSegmentationV02 : public AliMUONSegmentationV01 
+{
  public:
-    AliMUONSegmentationV02(){}
+    AliMUONSegmentationV02();
     AliMUONSegmentationV02(Int_t nsec);
     
     virtual ~AliMUONSegmentationV02(){}
index 1a08ccb55600d1a4f54b6a854979f4cea2373dc6..707604bf57a364a5b6e9801b946adf6ba18484e2 100644 (file)
 //  Segmentation and Response classes version 04   //
 /////////////////////////////////////////////////////
 
+#include <TMath.h>
+#include <TArrayF.h>
 
 #include "AliMUONSegmentationV04.h"
 #include "AliMUONChamber.h"
 #include "AliMUON.h"
 #include "AliRun.h"
 
-#include <TMath.h>
-
 //___________________________________________
 ClassImp(AliMUONSegmentationV04)
 
 
+AliMUONSegmentationV04::AliMUONSegmentationV04()
+  : AliMUONSegmentationV01()
+{
+// Constructor
+}
+
 void AliMUONSegmentationV04::Init(Int_t chamber)
 {
 
index 45f1ebe0c0af5da8507665c9bd4a4fae3c055655..6c7bb7fe4e3bdb4d5409b2dc0a295a6a51e48336 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation and Response classes version 04   //
  
 #include "AliMUONSegmentationV01.h"
 
-class AliMUONSegmentationV04 :
-public AliMUONSegmentationV01 {
+class AliMUONSegmentationV04 : public AliMUONSegmentationV01 
+{
  public:
-    AliMUONSegmentationV04(){}
+    AliMUONSegmentationV04();
     virtual ~AliMUONSegmentationV04(){}
     // Initialisation
     virtual void Init(Int_t chamber);
index e29df14c3d7755d6e03d9c79028ee5b99b3dbcab..8f5de897aca05e8b3deb47f580e981fe09cb1e8e 100644 (file)
 //  Segmentation and Response classes version 05   //
 /////////////////////////////////////////////////////
 
+#include <TMath.h>
+#include <TArrayF.h>
 
 #include "AliMUONSegmentationV05.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
 #include "AliRun.h"
 
-#include <TMath.h>
 //___________________________________________
 ClassImp(AliMUONSegmentationV05)
 
 
+AliMUONSegmentationV05::AliMUONSegmentationV05()
+  : AliMUONSegmentationV02()
+{
+// Constructor
+}
+
 void AliMUONSegmentationV05::Init(Int_t chamber)
 {
 //
index ef8e4059efb39585af3918dc2592d7c737b32eeb..38dad9b5386e7c30f6e65236f84e34c6e6bddb30 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 /////////////////////////////////////////////////////
 //  Segmentation                      version 05   //
  
 #include "AliMUONSegmentationV02.h"
 
-class AliMUONSegmentationV05 :
-public AliMUONSegmentationV02 {
+class AliMUONSegmentationV05 : public AliMUONSegmentationV02 
+{
  public:
-    AliMUONSegmentationV05(){}
+    AliMUONSegmentationV05();
     virtual ~AliMUONSegmentationV05(){}
     // Initialisation
     virtual void Init(Int_t chamber);
index 9f7e36007a70fc58a2d42181fabb922dc0e86464..b9c67664c448bb5fb3c3d5cdb6bcf96cde0636d3 100644 (file)
@@ -20,6 +20,7 @@
 /////////////////////////////////////////////////////////
 
 #include <TMath.h>
+
 #include "AliMUONChamber.h"
 #include "AliMUONSegmentationV1.h"
 #include "AliRun.h"
 //___________________________________________
 ClassImp(AliMUONSegmentationV1)
 
-  AliMUONSegmentationV1::AliMUONSegmentationV1(const AliMUONSegmentationV1& segmentation):AliSegmentation(segmentation)
+AliMUONSegmentationV1::AliMUONSegmentationV1(const AliMUONSegmentationV1& segmentation)
+  : AliSegmentation(segmentation)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONSegmentationV1", "Not implemented.");
 }
 
 
 AliMUONSegmentationV1::AliMUONSegmentationV1()
-
+  : AliSegmentation()
 {
   // initizalize the class with default settings
     fNzone=1;
@@ -249,7 +253,7 @@ Int_t AliMUONSegmentationV1::MorePads()
     }
 }
 
-Int_t AliMUONSegmentationV1::IsParallel2(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::IsParallel2(Int_t iX, Int_t iY) const
 {
 // test if the pad is read in parallel for zone 2
 // iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
@@ -266,7 +270,7 @@ Int_t AliMUONSegmentationV1::IsParallel2(Int_t iX, Int_t iY)
     return (iX%6)/3+1;
 }
 
-Int_t AliMUONSegmentationV1::IsParallel3(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::IsParallel3(Int_t iX, Int_t iY) const
 {
 // test if the pad is read in parallel for zone 3
 // iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
@@ -283,7 +287,7 @@ Int_t AliMUONSegmentationV1::IsParallel3(Int_t iX, Int_t iY)
     return (iX%9)/3+1 - (iY%3==2 && iX%3==0);
 }
 
-Int_t AliMUONSegmentationV1::NParallel2(Int_t /*iX*/, Int_t iY)
+Int_t AliMUONSegmentationV1::NParallel2(Int_t /*iX*/, Int_t iY) const
 {
 // returns the number of pads connected in parallel for zone 2
 // iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
@@ -298,7 +302,7 @@ Int_t AliMUONSegmentationV1::NParallel2(Int_t /*iX*/, Int_t iY)
     return 2;
 }
 
-Int_t AliMUONSegmentationV1::NParallel3(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::NParallel3(Int_t iX, Int_t iY) const
 {
 // test if the pad is read in parallel for zone 3
 // iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
@@ -539,8 +543,14 @@ void AliMUONSegmentationV1::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) con
     y[0]=x[0];
 }
 
-AliMUONSegmentationV1& AliMUONSegmentationV1::operator =(const AliMUONSegmentationV1 & /*rhs*/)
+AliMUONSegmentationV1& 
+AliMUONSegmentationV1::operator =(const AliMUONSegmentationV1 & rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
index c38163415a49bdfd1110c5f377e8107b6dca28c3..c424ba8460c5e39a93fefd67e3226a9110ef6211 100644 (file)
@@ -4,14 +4,14 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 #include "AliSegmentation.h"
 
-class AliMUONSegmentationV1 :
-public AliSegmentation {
+class AliMUONSegmentationV1 : public AliSegmentation 
+{
  public:
     AliMUONSegmentationV1();
-    AliMUONSegmentationV1(const AliMUONSegmentationV1 & segmentation);
     virtual ~AliMUONSegmentationV1(){}
     //    
     // Set Chamber Segmentation Parameters
@@ -102,11 +102,11 @@ public AliSegmentation {
     virtual Int_t Sector(Int_t /*ix*/, Int_t /*iy*/)   {return 1;}
     virtual Int_t Sector(Float_t /*x*/, Float_t /*y*/) {return 1;}
     // Position of pad in perellel read-out
-    virtual Int_t IsParallel2(Int_t iX, Int_t iY);
-    virtual Int_t IsParallel3(Int_t iX, Int_t iY);
+    virtual Int_t IsParallel2(Int_t iX, Int_t iY) const;
+    virtual Int_t IsParallel3(Int_t iX, Int_t iY) const;
     // Number of pads read in parallel
-    virtual Int_t NParallel2(Int_t iX, Int_t iY);
-    virtual Int_t NParallel3(Int_t iX, Int_t iY);
+    virtual Int_t NParallel2(Int_t iX, Int_t iY) const;
+    virtual Int_t NParallel3(Int_t iX, Int_t iY) const;
     //
     // Number of pads read in parallel and offset to add to x
     virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
@@ -131,9 +131,12 @@ public AliSegmentation {
     // Get the correction function
     virtual TF1* CorrFunc(Int_t) const {return fCorr;}
     //
-    AliMUONSegmentationV1& operator=(const AliMUONSegmentationV1& rhs);
     ClassDef(AliMUONSegmentationV1,1) // Implementation of the Lyon type chamber segmentation with parallel read-out
- protected:
+
+  protected:
+    AliMUONSegmentationV1(const AliMUONSegmentationV1 & segmentation);
+    AliMUONSegmentationV1& operator=(const AliMUONSegmentationV1& rhs);
+
     //
     // Implementation of the segmentation data
     // Version This models rectangular pads with the same dimensions all
index 694e4abb74115d90a0467262e4ae9303352c3056..0bc13d2f237599339c957abbac55c147a39bcc61 100644 (file)
 //   * Float_t slat_length
 //   * Float_t slat_number or Float_t slat_position
 
-
-
 #include <TVirtualMC.h>
 #include <TGeoMatrix.h>
-#include "AliRun.h"
+#include <Riostream.h>
 
 #include "AliMUONSlatGeometryBuilder.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
 #include "AliMUONChamberGeometry.h"
+#include "AliRun.h"
 
 ClassImp(AliMUONSlatGeometryBuilder)
 
-Int_t   ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq);
-
-
+//Int_t   ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq);
 
 //______________________________________________________________________________
 AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder(AliMUON* muon)
- : AliMUONVGeometryBuilder(&muon->Chamber(4), &muon->Chamber(5), &muon->Chamber(6), &muon->Chamber(7), &muon->Chamber(8), &muon->Chamber(9)),
-//  : AliMUONVGeometryBuilder(&muon->Chamber(4), &muon->Chamber(5)),
+ : AliMUONVGeometryBuilder(&muon->Chamber(4), &muon->Chamber(5), 
+                           &muon->Chamber(6), &muon->Chamber(7), 
+                          &muon->Chamber(8), &muon->Chamber(9)),
    fMUON(muon)
 {
 // Standard constructor
index 4ad975019faf7a09af6bc56bb40155afcb5db55b..f208d05bc589787a2cf85bb1e575b71cebf261b3 100644 (file)
@@ -1,4 +1,8 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONSlatGeometryBuilder
 // -----------------------------
@@ -18,17 +22,19 @@ class AliMUONSlatGeometryBuilder : public AliMUONVGeometryBuilder
 {
   public:
     AliMUONSlatGeometryBuilder(AliMUON* muon);
-    AliMUONSlatGeometryBuilder(const AliMUONSlatGeometryBuilder& rhs);
     AliMUONSlatGeometryBuilder();
     virtual ~AliMUONSlatGeometryBuilder();
 
-    // operators  
-    AliMUONSlatGeometryBuilder& operator = (const AliMUONSlatGeometryBuilder& rhs);
-  
     // methods
     virtual void CreateGeometry();
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
+
+  protected:
+    AliMUONSlatGeometryBuilder(const AliMUONSlatGeometryBuilder& rhs);
+
+    // operators  
+    AliMUONSlatGeometryBuilder& operator = (const AliMUONSlatGeometryBuilder& rhs);
     
   private:
     Int_t  ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq) const;
index 81ee2eecb58aec0692ce06c074b45c3255910729..89b256b6d69f219caf4e935825e0028a9ad1a71e 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index 4dc85fced51291380c72f23f4fe99dd9545b3304..08bb7a8123454f97588d4185bdfb54dd9dcf5f3b 100644 (file)
@@ -27,9 +27,8 @@
 // a range of gassiplex/MANAS numbers, in a given range of MANU addresses
 // Included in AliRoot 2003/01/28
 
-#include "AliMpPad.h"
-
 #include "AliMUONSt1ElectronicElement.h"
+#include "AliMpPad.h"
 
 ClassImp(AliMUONSt1ElectronicElement);
 
index 512bbd5660ed0a6865d7e22ebca8842c862ce966..b5cfa4715f7b5b0501551c9b99a3cfa58c675a94 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index b6e6a5f7532a1c272ba64661a6657a1dafbfa3c2..66916fc01cc15882a56d17a3495c1e865baf77e8 100644 (file)
@@ -39,6 +39,8 @@ AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder()
 AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs)
   : AliMUONVGeometryBuilder(rhs)
 {
+// Protected copy constructor
+
   Fatal("Copy constructor", 
         "Copy constructor is not implemented.");
 }
@@ -52,6 +54,8 @@ AliMUONSt1GeometryBuilder::~AliMUONSt1GeometryBuilder() {
 AliMUONSt1GeometryBuilder& 
 AliMUONSt1GeometryBuilder::operator = (const AliMUONSt1GeometryBuilder& rhs) 
 {
+// Protected assignement operator
+
   // check assignement to self
   if (this == &rhs) return *this;
 
index 9f7e1a95b56d428d8b198f6691cd67bfd39b7c39..b8d8edb80c43b5097ea18717728acdf1bdc5e9c0 100644 (file)
@@ -2,6 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONSt1GeometryBuilder
 // -----------------------------
@@ -21,18 +22,20 @@ class AliMUONSt1GeometryBuilder : public AliMUONVGeometryBuilder
 {
   public:
     AliMUONSt1GeometryBuilder(AliMUON* muon);
-    AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs);
     AliMUONSt1GeometryBuilder();
     virtual ~AliMUONSt1GeometryBuilder();
-
-    // operators  
-    AliMUONSt1GeometryBuilder& operator = (const AliMUONSt1GeometryBuilder& rhs);
   
     // methods
     virtual void CreateGeometry();
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
     
+  protected:
+    AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs);
+
+    // operators  
+    AliMUONSt1GeometryBuilder& operator = (const AliMUONSt1GeometryBuilder& rhs);
+    
   private:
      AliMUON*  fMUON; // the MUON detector class 
         
index fd24d67ecb788e0ae11cc33bc5a91227fd37ee69..e3baf1c8f3c389a13db787bf6f38c07bec5d5ee6 100644 (file)
@@ -52,7 +52,6 @@
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
 #include "AliMUONChamberGeometry.h"
-#include "AliMUONConstants.h"
 #include "AliRun.h"
 #include "AliMagF.h"
 
index 696e0c3d5e29a32f64bc94318d4c17f138577c51..a135b24fe1a8f4b182f52f6a5ba6b465883c7d44 100644 (file)
@@ -2,6 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONSt1GeometryBuilderV2
 // ---------------------------------
 #ifndef ALI_MUON_ST1_GEOMETRY_BUILDER_V2_H
 #define ALI_MUON_ST1_GEOMETRY_BUILDER_V2_H
 
-//#include "AliMUONSt1Containers.h"
 #include "AliMUONSt1Types.h"
-
-/*
-#ifdef ST1_WITH_STL
-  #include <map>
-  #ifdef __HP_aCC
-    using std::map;
-  #endif
-#endif
-
-#ifdef ST1_WITH_ROOT
-  #include "TExMap.h"
-#endif
-*/
 #include "AliMUONVGeometryBuilder.h"
 
 //typedef Float_t GReal_t; // for AliGeant3
@@ -56,16 +43,6 @@ class AliMUONSt1GeometryBuilderV2 : public AliMUONVGeometryBuilder
     AliMUONSt1GeometryBuilderV2& operator = (const AliMUONSt1GeometryBuilderV2& rhs);    
  
   private:
-    // Typedefs
-    //
-/*
-#ifdef ST1_WITH_STL
-    typedef map<Int_t , AliMUONSt1SpecialMotif> SpecialMap;
-#endif
-#ifdef ST1_WITH_ROOT
-    typedef  TExMap  SpecialMap;
-#endif
-*/
     // Constants
     //
     static const GReal_t fgkHzPadPlane;    // Pad plane
index 199339e705df085b3cfe2eadf739ec15583f8e4a..d182a306d4b0d4cc9daf02911ab842faa0ad068e 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index dacd2e07210c19346b91f4069508ce488a45ef58..631d9ff5c64cd008ea81ff2198e51840467c8af7 100644 (file)
@@ -5,6 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
@@ -35,9 +36,8 @@ class AliMUONSt1ResponseParameter;
 
 class AliMUONSt1Response : public AliMUONResponseV0 
 {
-public:
+  public:
     AliMUONSt1Response(Int_t chamber=1);
-    AliMUONSt1Response(const AliMUONSt1Response& rhs);
     virtual ~AliMUONSt1Response();
     
     //
@@ -51,15 +51,17 @@ public:
     virtual Int_t DigitResponse(Int_t digit,AliMUONTransientDigit* where);
     void PrintStatistics() const;
 
+  protected:
+    AliMUONSt1Response(const AliMUONSt1Response& rhs);
+
+    // operators
+    AliMUONSt1Response& operator=(const AliMUONSt1Response & rhs);
 
-private:
+  private:
     // typedefs
     typedef map<string, AliMUONSt1ResponseParameter*> ParamsMap;
     typedef map<string, TList*>  ListMap;
 
-    // operators
-    AliMUONSt1Response& operator=(const AliMUONSt1Response & rhs);
-
     // private methods
     AliMpZone* FindZone(AliMpSector* sector,Int_t posId) const; // to be moved in AliMpSector::
     void ReadFiles();
index e3c79bbffb8bac6d1fc0aec97b5711dca1766bdc..d86cda8253e6221ca3f1ff89919da21e3da08e5e 100644 (file)
@@ -5,6 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index 053ae90fcf2cd37982e3b6a81a8e06a856576517..0a12c628632918d418369bf2cd71c56fc3ad9625 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index 07e231cdced7c847f5829325e82d7c9b782ffd9f..b1c10046d70b3480cd8273faa1771d7097279140 100644 (file)
@@ -108,7 +108,8 @@ AliMUONSt1Segmentation::AliMUONSt1Segmentation()
 }
 
 //______________________________________________________________________________
-AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs) :AliSegmentation(rhs)
+AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs) 
+  : AliSegmentation(rhs)
 {
 // Copy constructor
   Fatal("Copy constructor", 
index fad0e4ebf291524cb3563221d4595015a85da46b..dc766b3ac2784fa1c043dcbda032c049555e2429 100644 (file)
@@ -5,6 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
@@ -30,7 +31,6 @@ class AliMUONSt1Segmentation : public AliSegmentation
 {
   public:
     AliMUONSt1Segmentation(const AliMpPlaneType planeType);
-    AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs);
     AliMUONSt1Segmentation();
     
     virtual ~AliMUONSt1Segmentation();
@@ -134,10 +134,13 @@ class AliMUONSt1Segmentation : public AliSegmentation
     virtual TF1* CorrFunc(Int_t isec)  const;
                    // Get the correction Function
  
-  private:
+  protected:
+    AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs);
+  
     // operators
     AliMUONSt1Segmentation& operator=(const AliMUONSt1Segmentation & rhs);
 
+  private:
     // methods
     void UpdateCurrentPadValues(const AliMpPad& pad);
   
index 7336b82db7107c198c95d0253e688d027ce148d5..1cd2e0490faf8196c278b4aa86b8aed78a78d4a5 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /* $Id$ */
+// Revision of includes 07/05/2004
 
 // Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
 //
index 8dbe54333cd75abbcd582a5739deb55394e19b12..75631c08dbb73550b93ee4fb29c203171eb063b0 100644 (file)
@@ -1,3 +1,18 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
 // $Id$
 //
 // Class AliMUONSt2GeometryBuilder
@@ -39,6 +54,8 @@ AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder()
 AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder(const AliMUONSt2GeometryBuilder& rhs)
   : AliMUONVGeometryBuilder(rhs)
 {
+// Protected copy constructor
+
   Fatal("Copy constructor", 
         "Copy constructor is not implemented.");
 }
@@ -52,6 +69,8 @@ AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder() {
 AliMUONSt2GeometryBuilder& 
 AliMUONSt2GeometryBuilder::operator = (const AliMUONSt2GeometryBuilder& rhs) 
 {
+// Protected assignement operator
+
   // check assignement to self
   if (this == &rhs) return *this;
 
index 018953701e3625290ba07f0d1a83986d9e61f2fb..985220ab26a2d71875497fb087f7c5e924572ea0 100644 (file)
@@ -1,4 +1,8 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
 // $Id$
+// Revision of includes 07/05/2004
 //
 // Class AliMUONSt2GeometryBuilder
 // -----------------------------
@@ -17,18 +21,20 @@ class AliMUONSt2GeometryBuilder : public AliMUONVGeometryBuilder
 {
   public:
     AliMUONSt2GeometryBuilder(AliMUON* muon);
-    AliMUONSt2GeometryBuilder(const AliMUONSt2GeometryBuilder& rhs);
     AliMUONSt2GeometryBuilder();
     virtual ~AliMUONSt2GeometryBuilder();
-
-    // operators  
-    AliMUONSt2GeometryBuilder& operator = (const AliMUONSt2GeometryBuilder& rhs);
   
     // methods
     virtual void CreateGeometry();
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
     
+  protected:
+    AliMUONSt2GeometryBuilder(const AliMUONSt2GeometryBuilder& rhs);
+
+    // operators  
+    AliMUONSt2GeometryBuilder& operator = (const AliMUONSt2GeometryBuilder& rhs);
+    
   private:
      AliMUON*  fMUON; // the MUON detector class 
         
index 69a2e9f055c56126b1ed74b4b13e355194fd5ee0..54f370a9fff51732b293f73c780874a136b9fbe2 100644 (file)
 //
 ///////////////////////////////////////////////////
 
-#include <Riostream.h> // for cout
 #include <stdlib.h> // for exit()
 
-#include <TClonesArray.h>
+#include <Riostream.h> // for cout
 #include <TMath.h>
 #include <TMatrixD.h>
 #include <TObjArray.h>
@@ -55,7 +54,8 @@ ClassImp(AliMUONTrack) // Class implementation in ROOT context
 TVirtualFitter* AliMUONTrack::fgFitter = NULL; 
 
   //__________________________________________________________________________
-AliMUONTrack::AliMUONTrack() 
+AliMUONTrack::AliMUONTrack()
+  : TObject() 
 {
   // Default constructor
   fgFitter = 0;
@@ -66,6 +66,7 @@ AliMUONTrack::AliMUONTrack()
 
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegment, AliMUONEventReconstructor* EventReconstructor)
+  : TObject()
 {
   // Constructor from two Segment's
   fEventReconstructor = EventReconstructor; // link back to EventReconstructor
@@ -89,6 +90,7 @@ AliMUONTrack::AliMUONTrack(AliMUONSegment* BegSegment, AliMUONSegment* EndSegmen
 
   //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack(AliMUONSegment* Segment, AliMUONHitForRec* HitForRec, AliMUONEventReconstructor* EventReconstructor)
+  : TObject()
 {
   // Constructor from one Segment and one HitForRec
   fEventReconstructor = EventReconstructor; // link back to EventReconstructor
@@ -127,38 +129,51 @@ AliMUONTrack::~AliMUONTrack()
 }
 
   //__________________________________________________________________________
-AliMUONTrack::AliMUONTrack (const AliMUONTrack& MUONTrack):TObject(MUONTrack)
+AliMUONTrack::AliMUONTrack (const AliMUONTrack& theMUONTrack)
+  :  TObject(theMUONTrack)
 {
-  fEventReconstructor = new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor); // is it right ?
-  fTrackParamAtVertex = MUONTrack.fTrackParamAtVertex;
-  fTrackHitsPtr     =  new TObjArray(*MUONTrack.fTrackHitsPtr);  // is it right ?
-  fTrackParamAtHit  =  new TClonesArray(*MUONTrack.fTrackParamAtHit);
-  fNTrackHits       =  MUONTrack.fNTrackHits;
-  fFitMCS           =  MUONTrack.fFitMCS;
-  fFitNParam        =  MUONTrack.fFitNParam;
-  fFitFMin          =  MUONTrack.fFitFMin;
-  fFitStart         =  MUONTrack.fFitStart;
-  fMatchTrigger     =  MUONTrack.fMatchTrigger;
-  fChi2MatchTrigger =  MUONTrack.fChi2MatchTrigger;
+  //fEventReconstructor = new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor);
+                               // is it right ?
+                              // NO, because it would use dummy copy constructor
+                              // and AliMUONTrack is not the owner of its EventReconstructor 
+  fEventReconstructor = theMUONTrack.fEventReconstructor;
+  fTrackParamAtVertex = theMUONTrack.fTrackParamAtVertex;
+  fTrackHitsPtr     =  new TObjArray(*theMUONTrack.fTrackHitsPtr);  // is it right ?
+  fTrackParamAtHit  =  new TClonesArray(*theMUONTrack.fTrackParamAtHit);
+  fNTrackHits       =  theMUONTrack.fNTrackHits;
+  fFitMCS           =  theMUONTrack.fFitMCS;
+  fFitNParam        =  theMUONTrack.fFitNParam;
+  fFitFMin          =  theMUONTrack.fFitFMin;
+  fFitStart         =  theMUONTrack.fFitStart;
+  fMatchTrigger     =  theMUONTrack.fMatchTrigger;
+  fChi2MatchTrigger =  theMUONTrack.fChi2MatchTrigger;
 }
 
   //__________________________________________________________________________
-AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& MUONTrack)
+AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& theMUONTrack)
 {
-  if (this == &MUONTrack)
+
+  // check assignement to self
+  if (this == &theMUONTrack)
     return *this;
 
-  fEventReconstructor =  new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor); // is it right ?
-  fTrackParamAtVertex =  MUONTrack.fTrackParamAtVertex;
-  fTrackHitsPtr       =  new TObjArray(*MUONTrack.fTrackHitsPtr); // is it right ?
-  fTrackParamAtHit    =  new TClonesArray(*MUONTrack.fTrackParamAtHit);
-  fNTrackHits         =  MUONTrack.fNTrackHits;
-  fFitMCS             =  MUONTrack.fFitMCS;
-  fFitNParam          =  MUONTrack.fFitNParam;
-  fFitFMin            =  MUONTrack.fFitFMin;
-  fFitStart           =  MUONTrack.fFitStart;
-  fMatchTrigger       =  MUONTrack.fMatchTrigger;
-  fChi2MatchTrigger   =  MUONTrack.fChi2MatchTrigger;
+  // base class assignement
+  TObject::operator=(theMUONTrack);
+
+  // fEventReconstructor =  new AliMUONEventReconstructor(*MUONTrack.fEventReconstructor); // is it right ?
+                               // is it right ? NO because it would use dummy copy constructor
+  fEventReconstructor =  theMUONTrack.fEventReconstructor;
+  fTrackParamAtVertex =  theMUONTrack.fTrackParamAtVertex;
+  fTrackHitsPtr       =  new TObjArray(*theMUONTrack.fTrackHitsPtr); // is it right ?
+  fTrackParamAtHit    =  new TClonesArray(*theMUONTrack.fTrackParamAtHit);
+  fNTrackHits         =  theMUONTrack.fNTrackHits;
+  fFitMCS             =  theMUONTrack.fFitMCS;
+  fFitNParam          =  theMUONTrack.fFitNParam;
+  fFitFMin            =  theMUONTrack.fFitFMin;
+  fFitStart           =  theMUONTrack.fFitStart;
+  fMatchTrigger       =  theMUONTrack.fMatchTrigger;
+  fChi2MatchTrigger   =  theMUONTrack.fChi2MatchTrigger;
+
   return *this;
 }
 
@@ -267,7 +282,7 @@ void AliMUONTrack::RecursiveDump(void) const
 }
 
   //__________________________________________________________________________
-Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track)
+Int_t AliMUONTrack::HitsInCommon(AliMUONTrack* Track) const
 {
   // Returns the number of hits in common
   // between the current track ("this")
index be351d7c16ea374e3806d64a5174f5696d1ab4a3..593f984fa24283dfde8cc0ad9cf619e474c6bcbe 100644 (file)
@@ -4,24 +4,28 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
+
 
 ///////////////////////////////////////////////////
 // Reconstructed track in ALICE dimuon spectrometer
 ///////////////////////////////////////////////////
 
+#include <TClonesArray.h>
+
 #include "AliMUONTrackParam.h" // object belongs to the class
 
 //const Int_t kMaxTrackingChamber=10;
         // not used
 
 class TObjArray;
-class TClonesArray;
 class TVirtualFitter;
 class AliMUONEventReconstructor;
 class AliMUONHitForRec;
 class AliMUONSegment;
 
-class AliMUONTrack : public TObject {
+class AliMUONTrack : public TObject 
+{
  public:
   AliMUONTrack(); // Default constructor
   virtual ~AliMUONTrack(); // Destructor
@@ -59,7 +63,7 @@ class AliMUONTrack : public TObject {
   void AddSegment(AliMUONSegment* Segment); // Add Segment
   void AddHitForRec(AliMUONHitForRec* HitForRec); // Add HitForRec
   void SetTrackParamAtHit(Int_t indexHit, AliMUONTrackParam *TrackParam) const;
-  Int_t HitsInCommon(AliMUONTrack* Track);
+  Int_t HitsInCommon(AliMUONTrack* Track) const;
   void MatchTriggerTrack(TClonesArray* TriggerTrackArray);
 
   static TVirtualFitter* Fitter(void) {return fgFitter;}
index 2ff7cdb78205846e3e41c4eb1d637803761d59b5..e8ae95bd5a21e57c22d678f47e72af3a26f82019 100644 (file)
 //
 ///////////////////////////////////////////////////////
 
-#include "AliMUONHitForRec.h" 
 #include "AliMUONTrackHit.h" 
+#include "AliMUONHitForRec.h" 
 
 ClassImp(AliMUONTrackHit) // Class implementation in ROOT context
 
+  //__________________________________________________________________________
+AliMUONTrackHit::AliMUONTrackHit()
+  : TObject()
+{
+  // Default constructor
+  fHitForRecPtr = 0;
+  fNextTrackHitWithSameHitForRec = 0;
+  fPrevTrackHitWithSameHitForRec = 0;
+}
+
   //__________________________________________________________________________
 AliMUONTrackHit::AliMUONTrackHit(AliMUONHitForRec* Hit)
 {
@@ -50,16 +60,24 @@ AliMUONTrackHit::AliMUONTrackHit(AliMUONHitForRec* Hit)
 }
 
   //__________________________________________________________________________
-AliMUONTrackHit::AliMUONTrackHit (const AliMUONTrackHit& MUONTrackHit):TObject(MUONTrackHit)
+AliMUONTrackHit::AliMUONTrackHit (const AliMUONTrackHit& theMUONTrackHit)
+  : TObject(theMUONTrackHit)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONTrackHit", "Not implemented.");
 }
 
   //__________________________________________________________________________
-AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& /*MUONTrackHit*/)
+AliMUONTrackHit & AliMUONTrackHit::operator=(const AliMUONTrackHit& rhs)
 {
-// Dummy assignment operator
-    return *this;
+// Protected assignement operator
+
+  if (this == &rhs) return *this;
+
+  Fatal("operator=", "Not implemented.");
+    
+  return *this;  
 }
 
 
index f623deed5331c11406e704cbeb70e3d178a81748..e9669cb8ff764a1dda9462b939a09afa95abcff9 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 ///////////////////////////////////////////////////////
 // Reconstructed track hit in ALICE dimuon spectrometer
 
 class AliMUONHitForRec;
 
-class AliMUONTrackHit : public TObject {
+class AliMUONTrackHit : public TObject 
+{
  public:
-  AliMUONTrackHit(){
-    // Constructor
-    fHitForRecPtr = 0;
-    fNextTrackHitWithSameHitForRec = 0;
-    fPrevTrackHitWithSameHitForRec = 0;
-  } // Constructor
+  AliMUONTrackHit(); // Constructor
   virtual ~AliMUONTrackHit(); // Destructor
-  AliMUONTrackHit (const AliMUONTrackHit& AliMUONTrackHit); // copy constructor
-  AliMUONTrackHit& operator=(const AliMUONTrackHit& AliMUONTrackHit); // assignment operator
   AliMUONTrackHit(AliMUONHitForRec* Hit); // Constructor from one HitForRec
 
   // Inline functions for Get and Set
@@ -39,6 +34,9 @@ class AliMUONTrackHit : public TObject {
   Int_t Compare(const TObject* TrackHit) const; // "Compare" function for sorting
 
  protected:
+  AliMUONTrackHit (const AliMUONTrackHit& AliMUONTrackHit); // copy constructor
+  AliMUONTrackHit& operator=(const AliMUONTrackHit& AliMUONTrackHit); // assignment operator
+
  private:
   void SetNextTrackHitWithSameHitForRec(AliMUONTrackHit *Next) {fNextTrackHitWithSameHitForRec = Next;}
   void SetPrevTrackHitWithSameHitForRec(AliMUONTrackHit *Prev) {fPrevTrackHitWithSameHitForRec = Prev;}
index a5e46afa3c73acbd48f87f323f41ba35e6327a26..84b06e5b14149f3bb87df706b6df77820ccd5e6a 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-#include "AliMUONTrackK.h"
+#include <stdlib.h> // for exit()
 
 #include <Riostream.h>
 #include <TClonesArray.h>
-#include <TArrayD.h>
 #include <TMatrixD.h>
-#include <stdlib.h> // for exit()
 
+#include "AliMUONTrackK.h"
 #include "AliCallf77.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
@@ -30,7 +29,7 @@
 #include "AliMUONRawCluster.h"
 #include "AliMUONTrackParam.h"
 #include "AliRun.h"
-#include "AliMagF.h"
+//#include "AliMagF.h"
 
 const Int_t AliMUONTrackK::fgkSize = 5;
 const Int_t AliMUONTrackK::fgkNSigma = 4; 
@@ -82,6 +81,7 @@ TClonesArray* AliMUONTrackK::fgHitForRec = NULL;
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK()
+  : TObject()
 {
   // Default constructor
 
@@ -104,6 +104,7 @@ AliMUONTrackK::AliMUONTrackK()
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClonesArray *hitForRec)
+  : TObject()
 {
   // Constructor
 
@@ -127,6 +128,7 @@ AliMUONTrackK::AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClo
 
   //__________________________________________________________________________
 AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
+  : TObject()
 {
   // Constructor from a segment
   Double_t dX, dY, dZ;
@@ -217,9 +219,12 @@ AliMUONTrackK::~AliMUONTrackK()
 }
 
   //__________________________________________________________________________
-AliMUONTrackK::AliMUONTrackK (const AliMUONTrackK& source):TObject(source)
+AliMUONTrackK::AliMUONTrackK (const AliMUONTrackK& source)
+  : TObject(source)
 {
-// Dummy copy constructor
+// Protected copy constructor
+
+  Fatal("AliMUONTrackK", "Not implemented.");
 }
 
   //__________________________________________________________________________
@@ -228,6 +233,10 @@ AliMUONTrackK & AliMUONTrackK::operator=(const AliMUONTrackK& source)
   // Assignment operator
   // Members
   if(&source == this) return *this;
+
+  // base class assignement
+  TObject::operator=(source);
+
   fStartSegment = source.fStartSegment;
   fNTrackHits = source.fNTrackHits;
   fChi2 = source.fChi2;
@@ -652,8 +661,8 @@ void AliMUONTrackK::WeightPropagation(Double_t zEnd)
   Int_t i, j;
   Double_t dPar;
 
-  TMatrixD Jacob(fgkSize,fgkSize);
-  Jacob = 0;
+  TMatrixD jacob(fgkSize,fgkSize);
+  jacob = 0;
 
   // Save initial and propagated parameters
   TMatrixD trackPar0 = *fTrackPar;
@@ -681,23 +690,23 @@ void AliMUONTrackK::WeightPropagation(Double_t zEnd)
     (*fTrackPar)(i,0) += dPar;
     ParPropagation(zEnd);
     for (j=0; j<fgkSize; j++) {
-      Jacob(j,i) = ((*fTrackParNew)(j,0)-trackPar0(j,0))/dPar;
+      jacob(j,i) = ((*fTrackParNew)(j,0)-trackPar0(j,0))/dPar;
     }
   }
 
-  //Jacob->Print();
+  //jacob->Print();
   //trackParNew0.Print();
-  //TMatrixD par1(Jacob,TMatrixD::kMult,trackPar0); //
+  //TMatrixD par1(jacob,TMatrixD::kMult,trackPar0); //
   //par1.Print();
   /*
-  if (Jacob.Determinant() != 0) {
-    //  Jacob.Invert();
+  if (jacob.Determinant() != 0) {
+    //  jacob.Invert();
   } else {
-    cout << " ***** Warning in WeightPropagation: Determinant Jacob=0:" << endl;
+    cout << " ***** Warning in WeightPropagation: Determinant jacob=0:" << endl;
   }
   */
-  TMatrixD weight1(*fWeight,TMatrixD::kMult,Jacob); // WD
-  *fWeight = TMatrixD(Jacob,TMatrixD::kTransposeMult,weight1); // DtWD
+  TMatrixD weight1(*fWeight,TMatrixD::kMult,jacob); // WD
+  *fWeight = TMatrixD(jacob,TMatrixD::kTransposeMult,weight1); // DtWD
   //fWeight->Print();
 
   // Restore initial and propagated parameters
@@ -714,12 +723,12 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
   // Picks up point within a window for the chamber No ichamb 
   // Split the track if there are more than 1 hit
   Int_t ihit, nRecTracks;
-  Double_t WindowB, WindowNonB, dChi2Tmp=0, dChi2, y, x, savePosition=0;
+  Double_t windowB, windowNonB, dChi2Tmp=0, dChi2, y, x, savePosition=0;
   TClonesArray *trackPtr;
   AliMUONHitForRec *hit, *hitLoop;
   AliMUONTrackK *trackK;
 
-  Bool_t Ok = kFALSE;
+  Bool_t ok = kFALSE;
   //sigmaB = fgEventReconstructor->GetBendingResolution(); // bending resolution
   //sigmaNonB = fgEventReconstructor->GetNonBendingResolution(); // non-bending resolution
   *fCovariance = *fWeight;
@@ -733,8 +742,8 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
   } else {
     cout << " ***** Warning in FindPoint: Determinant fCovariance=0:" << endl;
   }
-  //WindowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+sigmaB*sigmaB);
-  //WindowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+sigmaNonB*sigmaNonB);
+  //windowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+sigmaB*sigmaB);
+  //windowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+sigmaNonB*sigmaNonB);
   // Loop over all hits and take hits from the chamber
   TMatrixD pointWeight(fgkSize,fgkSize);
   TMatrixD saveWeight = pointWeight;
@@ -770,10 +779,10 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
        }
        y = hit->GetBendingCoor();
        x = hit->GetNonBendingCoor();
-       WindowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+hit->GetBendingReso2());
-       WindowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+hit->GetNonBendingReso2());
-       if (TMath::Abs((*fTrackParNew)(0,0)-y) <= WindowB &&
-           TMath::Abs((*fTrackParNew)(1,0)-x) <= WindowNonB) {
+       windowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+hit->GetBendingReso2());
+       windowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+hit->GetNonBendingReso2());
+       if (TMath::Abs((*fTrackParNew)(0,0)-y) <= windowB &&
+           TMath::Abs((*fTrackParNew)(1,0)-x) <= windowNonB) {
          // Vector of measurements and covariance matrix
          point.Zero();
          point(0,0) = y;
@@ -782,7 +791,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
          pointWeight(1,1) = 1/hit->GetNonBendingReso2();
          TryPoint(point,pointWeight,trackPar,dChi2);
          if (TMath::Abs(1./(trackPar)(4,0)) < fgEventReconstructor->GetMinBendingMomentum()) continue; // p < p_min - next hit
-         Ok = kTRUE;
+         ok = kTRUE;
          nHitsOK++;
          //if (nHitsOK > -1) {
          if (nHitsOK == 1) {
@@ -839,7 +848,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
       }
     } else break; // different chamber
   } // for (ihit=currIndx;
-  if (Ok) {
+  if (ok) {
     *fTrackPar = trackParTmp;
     *fWeight = saveWeight;
     *fWeight += pointWeightTmp; 
@@ -847,7 +856,7 @@ Bool_t AliMUONTrackK::FindPoint(Int_t ichamb, Double_t zEnd, Int_t currIndx, Int
     // Restore members
     fPosition = savePosition;
   }
-  return Ok;
+  return ok;
 }
 
   //__________________________________________________________________________
@@ -995,7 +1004,7 @@ Int_t AliMUONTrackK::Compare(const TObject* trackK) const
 }
 
   //__________________________________________________________________________
-Bool_t AliMUONTrackK::KeepTrack(AliMUONTrackK* track0)
+Bool_t AliMUONTrackK::KeepTrack(AliMUONTrackK* track0) const
 {
   // Check whether or not to keep current track 
   // (keep, if it has less than half of common hits with track0)
@@ -1112,7 +1121,7 @@ void AliMUONTrackK::GoToVertex(void)
   // R > 1
   // R < 1
 
-  Double_t dZ, r0Norm, X0, deltaP, dChi2, pTotal, pOld;
+  Double_t dZ, r0Norm, x0, deltaP, dChi2, pTotal, pOld;
   AliMUONHitForRec *hit;
   AliMUONRawCluster *clus;
   TClonesArray *rawclusters;
@@ -1132,9 +1141,9 @@ void AliMUONTrackK::GoToVertex(void)
     ParPropagation(zPos[i]);
     WeightPropagation(zPos[i]);
     dZ = TMath::Abs (fPositionNew-fPosition);
-    if (r0Norm > 1) X0 = x01[i];
-    else X0 = x02[i];
-    MSLine(dZ,X0); // multiple scattering in the medium (linear approximation)
+    if (r0Norm > 1) x0 = x01[i];
+    else x0 = x02[i];
+    MSLine(dZ,x0); // multiple scattering in the medium (linear approximation)
     fPosition = fPositionNew;
     *fTrackPar = *fTrackParNew; 
     r0Norm = (*fTrackPar)(0,0)*(*fTrackPar)(0,0) + 
@@ -1259,7 +1268,7 @@ void AliMUONTrackK::GoToVertex(void)
 }
 
   //__________________________________________________________________________
-void AliMUONTrackK::MSLine(Double_t dZ, Double_t X0)
+void AliMUONTrackK::MSLine(Double_t dZ, Double_t x0)
 {
   // Adds multiple scattering in a thick layer for linear propagation
 
@@ -1274,7 +1283,7 @@ void AliMUONTrackK::MSLine(Double_t dZ, Double_t X0)
   Double_t step = TMath::Abs(dZ)/cosAlph/cosBeta; // step length
 
   // Projected scattering angle
-  Double_t theta0 = 0.0136/velo/momentum/TMath::Sqrt(X0)*(1+0.038*TMath::Log(step/X0)); 
+  Double_t theta0 = 0.0136/velo/momentum/TMath::Sqrt(x0)*(1+0.038*TMath::Log(step/x0)); 
   Double_t theta02 = theta0*theta0;
   Double_t dl2 = step*step/2*theta02;
   Double_t dl3 = dl2*step*2/3;
index 188fa4206d60e9b450e6110683f4a69debff38bf..8eea8e2252b1a83dbc46075054add0410950fba3 100644 (file)
@@ -3,11 +3,15 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <TROOT.h>
-class TArrayD;
+/*$Id$*/
+// Revision of includes 07/05/2004
+
+#include <TObject.h>
+
 class TMatrixD;
 class AliMUONEventReconstructor;
 class TClonesArray;
+class TObjArray;
 class AliMUONSegment;
 class AliMUON;
 class AliMUONHitForRec;
@@ -18,8 +22,6 @@ class AliMUONTrackK : public TObject {
 
   AliMUONTrackK(); // Default constructor
   virtual ~AliMUONTrackK(); // Destructor
-  AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
-  AliMUONTrackK& operator=(const AliMUONTrackK& source); // assignment operator
 
   //AliMUONTrackK(const AliMUONEventReconstructor *EventReconstructor, const AliMUONHitForRec *hitForRec); // Constructor
   AliMUONTrackK(AliMUONEventReconstructor *EventReconstructor, TClonesArray *hitForRec); // Constructor
@@ -42,7 +44,7 @@ class AliMUONTrackK : public TObject {
   Bool_t KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back, Double_t zDipole1, Double_t zDipole2); // Kalman filter
   void StartBack(void); // start backpropagator
   void SetTrackQuality(Int_t iChi2); // compute track quality or Chi2
-  Bool_t KeepTrack(AliMUONTrackK* track0); // keep or discard track 
+  Bool_t KeepTrack(AliMUONTrackK* track0) const; // keep or discard track 
   void Kill(void); // kill track candidate
   void Branson(void); // Branson correction
   void GoToZ(Double_t zEnd); // propagate track to given Z
@@ -56,6 +58,9 @@ class AliMUONTrackK : public TObject {
 
  protected:
 
+  AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
+  AliMUONTrackK& operator=(const AliMUONTrackK& source); // assignment operator
+
  private:
  
   static Int_t fgNOfPoints; // number of points in event
index a64ed48ae9e192c03c922ca98ddb48f0dd2b74cf..f05505a548a08fc87459aa4d9a6f244306812120 100644 (file)
@@ -70,31 +70,50 @@ extern "C" {
     Field[0] = b[0]; Field[1] = b[1]; Field[2] = b[2];
   }
 }
+
   //_________________________________________________________________________
+AliMUONTrackParam::AliMUONTrackParam()
+  : TObject()
+{
+// Constructor
 
-AliMUONTrackParam& AliMUONTrackParam::operator=(const AliMUONTrackParam& MUONTrackParam)
+  fInverseBendingMomentum = 0;
+  fBendingSlope = 0;
+  fNonBendingSlope = 0;
+  fZ = 0;
+  fBendingCoor = 0;
+  fNonBendingCoor = 0;
+}
+
+  //_________________________________________________________________________
+AliMUONTrackParam& 
+AliMUONTrackParam::operator=(const AliMUONTrackParam& theMUONTrackParam)
 {
-  if (this == &MUONTrackParam)
+  if (this == &theMUONTrackParam)
     return *this;
 
-  fInverseBendingMomentum =  MUONTrackParam.fInverseBendingMomentum; 
-  fBendingSlope           =  MUONTrackParam.fBendingSlope; 
-  fNonBendingSlope        =  MUONTrackParam.fNonBendingSlope; 
-  fZ                      =  MUONTrackParam.fZ; 
-  fBendingCoor            =  MUONTrackParam.fBendingCoor; 
-  fNonBendingCoor         =  MUONTrackParam.fNonBendingCoor;
+  // base class assignement
+  TObject::operator=(theMUONTrackParam);
+
+  fInverseBendingMomentum =  theMUONTrackParam.fInverseBendingMomentum; 
+  fBendingSlope           =  theMUONTrackParam.fBendingSlope; 
+  fNonBendingSlope        =  theMUONTrackParam.fNonBendingSlope; 
+  fZ                      =  theMUONTrackParam.fZ; 
+  fBendingCoor            =  theMUONTrackParam.fBendingCoor; 
+  fNonBendingCoor         =  theMUONTrackParam.fNonBendingCoor;
 
   return *this;
 }
   //_________________________________________________________________________
-AliMUONTrackParam::AliMUONTrackParam(const AliMUONTrackParam& MUONTrackParam):TObject(MUONTrackParam)
+AliMUONTrackParam::AliMUONTrackParam(const AliMUONTrackParam& theMUONTrackParam)
+  : TObject(theMUONTrackParam)
 {
-  fInverseBendingMomentum =  MUONTrackParam.fInverseBendingMomentum; 
-  fBendingSlope           =  MUONTrackParam.fBendingSlope; 
-  fNonBendingSlope        =  MUONTrackParam.fNonBendingSlope; 
-  fZ                      =  MUONTrackParam.fZ; 
-  fBendingCoor            =  MUONTrackParam.fBendingCoor; 
-  fNonBendingCoor         =  MUONTrackParam.fNonBendingCoor;
+  fInverseBendingMomentum =  theMUONTrackParam.fInverseBendingMomentum; 
+  fBendingSlope           =  theMUONTrackParam.fBendingSlope; 
+  fNonBendingSlope        =  theMUONTrackParam.fNonBendingSlope; 
+  fZ                      =  theMUONTrackParam.fZ; 
+  fBendingCoor            =  theMUONTrackParam.fBendingCoor; 
+  fNonBendingCoor         =  theMUONTrackParam.fNonBendingCoor;
 }
 
   //__________________________________________________________________________
index 689400b5bdd60f8a5e0d8e53887a4479fa4bbcf1..ce09432017befe585e7ef3e6ae33c9d11e1026d5 100644 (file)
@@ -4,6 +4,7 @@
  * See cxx source for full Copyright notice                               */
 
 /*$Id$*/
+// Revision of includes 07/05/2004
 
 ///////////////////////////////////////////////////
 // Track parameters in ALICE dimuon spectrometer
 
 #include <TObject.h>
 
-class AliMUONTrackParam : public TObject {
+class AliMUONTrackParam : public TObject 
+{
  public:
-  AliMUONTrackParam(){
-    fInverseBendingMomentum = 0;
-    fBendingSlope = 0;
-    fNonBendingSlope = 0;
-    fZ = 0;
-    fBendingCoor = 0;
-    fNonBendingCoor = 0;
-    // Constructor
-  } // Constructor
+  AliMUONTrackParam(); // Constructor
   virtual ~AliMUONTrackParam(){} // Destructor
   
   AliMUONTrackParam(const AliMUONTrackParam& rhs);// copy constructor (should be added per default !)
index 9586d67ed7d0752e1fed7a9f3ff273df6a6d1577..865d817789b8ab199c1741e1979da5d93c66bedd 100644 (file)
 
 /*