Coding convention violations
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Apr 2004 13:29:10 +0000 (13:29 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Apr 2004 13:29:10 +0000 (13:29 +0000)
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterInput.cxx
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRawCluster.h
MUON/AliMUONTrackK.cxx

index 958c208..0a5f35e 100644 (file)
 //
 //
 //
-// This function is used for fitting
-void fcn1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
+
 
 ClassImp(AliMUONClusterFinderAZ)
 
-AliMUONClusterFinderAZ* AliMUONClusterFinderAZ::fgClusterFinder = NULL;
-TMinuit* AliMUONClusterFinderAZ::fgMinuit = NULL; 
 
 //_____________________________________________________________________________
 AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw=0, Int_t iReco=0)
@@ -57,6 +54,8 @@ AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw=0, Int_t iReco=0)
   fNextCathode = kFALSE; 
   fColPad = 0;
   */
+  fgClusterFinder = NULL;
+  fgMinuit = NULL;
 }
 
 //_____________________________________________________________________________
@@ -2206,7 +2205,7 @@ Int_t AliMUONClusterFinderAZ::Fit(Int_t nfit, Int_t *clustFit, TObjArray **clust
 }  
 
 //_____________________________________________________________________________
-void 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);    
@@ -2304,8 +2303,8 @@ void AliMUONClusterFinderAZ::AddRawCluster(Double_t x, Double_t y, Double_t fmin
     cnew.SetY(cath, y);
     cnew.SetZ(cath, fZpad);
     cnew.SetCharge(cath, 100);
-    cnew.fPeakSignal[cath] = 20;
-    cnew.fMultiplicity[cath] = 5;
+    cnew.SetPeakSignal(cath,20);
+    cnew.SetMultiplicity(cath, 5);
     cnew.fNcluster[cath] = 1;
     cnew.fChi2[cath] = fmin; //0.1;
     /*
index 08857c5..f397c3e 100644 (file)
@@ -26,62 +26,67 @@ class AliMUONClusterFinderAZ : public AliMUONClusterFinderVS {
   AliMUONClusterFinderAZ(Bool_t draw, Int_t iReco);// 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
+  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
 
-  static AliMUONClusterFinderAZ* fgClusterFinder;
-
-  Int_t fnPads[2]; // ! number of pads in the cluster on 2 cathodes
-  Float_t fXyq[6][kDim]; // ! pad information
-  Int_t fPadIJ[2][kDim]; // ! pad information
-  AliSegmentation *fSegmentation[2]; // ! segmentation
-  AliMUONResponse *fResponse; // ! response
-  Float_t fZpad; // ! z-coordinate of the hit
-  Int_t fNpar; // ! number of fit parameters
-  Double_t fQtot; // ! total cluster charge
-  Int_t fReco; // ! =1 if run reco with writing to TreeR
+  static   AliMUONClusterFinderAZ* fgClusterFinder;
+protected:
 
- protected:
 
  private:
-  static TMinuit* fgMinuit; // ! Fitter
-  Bool_t fUsed[2][kDim]; // ! flags for used pads
-  TH2F *fHist[4]; // ! histograms
+
+  Int_t      fnPads[2];        // ! number of pads in the cluster on 2 cathodes
+  Float_t    fXyq[6][kDim];    // ! pad information
+  Int_t      fPadIJ[2][kDim];  // ! pad information
+  AliSegmentation *fSegmentation[2]; // ! segmentation
+  AliMUONResponse *fResponse;// ! response
+  Float_t    fZpad;            // ! z-coordinate of the hit
+  Int_t      fNpar;            // ! number of fit parameters
+  Double_t   fQtot;            // ! total cluster charge
+  Int_t      fReco;            // ! =1 if run reco with writing to TreeR 
+
+  static     TMinuit* fgMinuit; // ! Fitter
+  Bool_t     fUsed[2][kDim]; // ! flags for used pads
+  TH2F*      fHist[4]; // ! histograms
   TClonesArray *fMuonDigits; // ! pointer to digits
-  Bool_t fDraw; // ! draw flag
-  Int_t fnMu; // number of muons passing thru the selected area
-  Double_t fxyMu[2][7]; // ! muon information
-  TObjArray *fPixArray; // collection of pixels
+  Bool_t     fDraw; // ! draw flag
+  Int_t      fnMu; // number of muons passing thru the selected area
+  Double_t   fxyMu[2][7]; // ! muon information
+  TObjArrayfPixArray; // collection of pixels
 
   // Functions
 
-  void ModifyHistos(void); // modify histograms
-  void AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
+  void   ModifyHistos(void); // modify histograms
+  void   AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
   Bool_t Overlap(Int_t cath, TObject *dig); // check if the pad from one cathode overlaps with a pad in the cluster on the other cathode
   Bool_t Overlap(Float_t *xy1, Int_t iPad, Float_t *xy12, Int_t iSkip); // check if pads xy1 and iPad overlap and return overlap area
   Bool_t CheckPrecluster(Int_t *nShown); // check precluster to simplify it (if possible)
-  void BuildPixArray(); // build array of pixels
-  void AjustPixel(Float_t width, Int_t ixy); // ajust size of small pixels
-  void AjustPixel(Float_t wxmin, Float_t wymin); // ajust size of large pixels
+  void   BuildPixArray(); // build array of pixels
+  void   AjustPixel(Float_t width, Int_t ixy); // ajust size of small pixels
+  void   AjustPixel(Float_t wxmin, Float_t wymin); // ajust size of large pixels
   Bool_t MainLoop(); // repeat MLEM algorithm until pixels become sufficiently small
-  void Mlem(Double_t *coef, Double_t *probi); // use MLEM for cluster finding
-  void FindCOG(TH2D *mlem, Double_t *xyc); // find COG position around maximum bin
-  Int_t FindNearest(AliMUONPixel *pixPtr0); // find nearest neighbouring pixel to the given one
-  void Split(TH2D *mlem, Double_t *coef); // steering function for pixels
-  void AddBin(TH2D *mlem, Int_t ic, Int_t jc, Int_t mode, Bool_t* used, TObjArray *pix); // add a bin to the cluster
+  void   Mlem(Double_t *coef, Double_t *probi); // use MLEM for cluster finding
+  void   FindCOG(TH2D *mlem, Double_t *xyc); // find COG position around maximum bin
+  Int_t  FindNearest(AliMUONPixel *pixPtr0); // find nearest neighbouring pixel to the given one
+  void   Split(TH2D *mlem, Double_t *coef); // steering function for pixels
+  void   AddBin(TH2D *mlem, Int_t ic, Int_t jc, Int_t mode, Bool_t* used, TObjArray *pix); // add a bin to the cluster
   TObject* BinToPix(TH2D *mlem, Int_t jc, Int_t ic); // hist. bin-to-pixel
-  void AddCluster(Int_t ic, Int_t nclust, TMatrixD *aijcluclu, Bool_t *used, Int_t *clustNumb, Int_t &nCoupled); // add a cluster to the group of coupled clusters
+  void   AddCluster(Int_t ic, Int_t nclust, TMatrixD *aijcluclu, Bool_t *used, Int_t *clustNumb, Int_t &nCoupled); // add a cluster to the group of coupled clusters
   Double_t MinGroupCoupl(Int_t nCoupled, Int_t *clustNumb, TMatrixD *aijcluclu, Int_t *minGroup); // find group of cluster with min. coupling to others
-  Int_t SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *clustNumb, Int_t *clustFit, TMatrixD *aijcluclu); //select pads for fit
-  void Merge(Int_t nForFit, Int_t nCoupled, Int_t *clustNumb, Int_t *clustFit, TObjArray **clusters, TMatrixD *aijcluclu, TMatrixD *aijclupad); // merge clusters
-  Int_t Fit(Int_t nfit, Int_t *clustFit, TObjArray **clusters, Double_t *parOk); // do the fitting 
-  void UpdatePads(Int_t nfit, Double_t *par); // subtract fitted charges from pads
-  void AddRawCluster(Double_t x, Double_t y, Double_t fmin); // add new raw cluster
+  Int_t  SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *clustNumb, Int_t *clustFit, TMatrixD *aijcluclu); //select pads for fit
+  void   Merge(Int_t nForFit, Int_t nCoupled, Int_t *clustNumb, Int_t *clustFit, TObjArray **clusters, TMatrixD *aijcluclu, TMatrixD *aijclupad); // merge clusters
+  Int_t  Fit(Int_t nfit, Int_t *clustFit, TObjArray **clusters, Double_t *parOk); // do the fitting 
+  void  UpdatePads(Int_t nfit, Double_t *par); // subtract fitted charges from pads
+  void  AddRawCluster(Double_t x, Double_t y, Double_t fmin); // add new raw cluster
   Int_t FindLocalMaxima(Int_t *localMax, Double_t *maxVal); // find local maxima 
-  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
+  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);
 
   ClassDef(AliMUONClusterFinderAZ,0) // cluster finder in MUON arm of ALICE
     };
index de14d14..9416f5f 100644 (file)
@@ -104,8 +104,8 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
 
     fInput->SetCluster(c);
 
-    fMul[0]=c->fMultiplicity[0];
-    fMul[1]=c->fMultiplicity[1];
+    fMul[0]=c->GetMultiplicity(0);
+    fMul[1]=c->GetMultiplicity(1);
 
 //
 //  dump digit information into arrays
@@ -455,16 +455,16 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                                cnew.SetY(cath, Float_t(ym[ico][0]));
                                cnew.SetZ(cath, fZPlane);
                                
-                               cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+                               cnew.SetMultiplicity(cath,c->GetMultiplicity(cath));
                                for (i=0; i<fMul[cath]; i++) {
                                    cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
                                    fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
                                }
                                fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
-                               fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+                               fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
                                FillCluster(&cnew,cath);
                            } 
-                           cnew.fClusterType=cnew.PhysicsContribution();
+                           cnew.SetClusterType(cnew.PhysicsContribution());
                            AddRawCluster(cnew);
                            fNPeaks++;
                        }
@@ -739,16 +739,16 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                        cnew.SetX(cath, Float_t(xm[ico][1]));
                        cnew.SetY(cath, Float_t(ym[ico][0]));
                        cnew.SetZ(cath, fZPlane);
-                       cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+                       cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
                        for (i=0; i<fMul[cath]; i++) {
                            cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
                            fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
                        }
                        fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
-                       fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+                       fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
                        FillCluster(&cnew,cath);
                    } 
-                   cnew.fClusterType=cnew.PhysicsContribution();
+                   cnew.SetClusterType(cnew.PhysicsContribution());
                    AddRawCluster(cnew);
                    fNPeaks++;
                }
@@ -877,16 +877,16 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                        cnew.SetX(cath, Float_t(xm[ico][1]));
                        cnew.SetY(cath, Float_t(ym[ico][0]));
                        cnew.SetZ(cath, fZPlane);
-                       cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+                       cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
                        for (i=0; i<fMul[cath]; i++) {
                            cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
                            fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
                        }
                        fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
-                       fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+                       fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
                        FillCluster(&cnew,cath);
                    } 
-                   cnew.fClusterType=cnew.PhysicsContribution();
+                   cnew.SetClusterType(cnew.PhysicsContribution());
                    AddRawCluster(cnew);
                    fNPeaks++;
                }
@@ -953,14 +953,14 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                    cnew.SetX(cath, Float_t(xm[ico][1]));
                    cnew.SetY(cath, Float_t(ym[ico][0]));
                    cnew.SetZ(cath, fZPlane);
-                   cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+                   cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
                    for (i=0; i<fMul[cath]; i++) {
                        cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
                        fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
                    }
                    FillCluster(&cnew,cath);
                } 
-               cnew.fClusterType=cnew.PhysicsContribution();
+               cnew.SetClusterType(cnew.PhysicsContribution());
                AddRawCluster(cnew);
                fNPeaks++;
            }
@@ -1188,9 +1188,9 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
     Int_t  ix, iy;
     
     if (cath==1) {
-       c->fPeakSignal[cath]=c->fPeakSignal[0]; 
+       c->SetPeakSignal(cath,c->GetPeakSignal(0));     
     } else {
-       c->fPeakSignal[cath]=0;
+       c->SetPeakSignal(cath,0);
     }
     
     
@@ -1201,8 +1201,8 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
     }
 
     if (fDebugLevel)
-       fprintf(stderr,"\n fPeakSignal %d\n",c->fPeakSignal[cath]);
-    for (Int_t i=0; i<c->fMultiplicity[cath]; i++)
+       fprintf(stderr,"\n fPeakSignal %d\n",c->GetPeakSignal(cath));
+    for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
     {
        dig= fInput->Digit(cath,c->fIndexMap[i][cath]);
        ix=dig->PadX()+c->fOffsetMap[i][cath];
@@ -1218,13 +1218,13 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
 //
 // 
        if (fDebugLevel>1)
-           fprintf(stderr,"q %d c->fPeakSignal[cath] %d\n",q,c->fPeakSignal[cath]);
+           fprintf(stderr,"q %d c->fPeakSignal[cath] %d\n",q,c->GetPeakSignal(cath));
 // peak signal and track list
-       if (q>c->fPeakSignal[cath]) {
-           c->fPeakSignal[cath]=q;
-           c->fTracks[0]=dig->Hit();
-           c->fTracks[1]=dig->Track(0);
-           c->fTracks[2]=dig->Track(1);
+       if (q>c->GetPeakSignal(cath)) {
+           c->SetPeakSignal(cath, q);
+           c->SetTrack(0,dig->Hit());
+           c->SetTrack(1,dig->Track(0));
+           c->SetTrack(2,dig->Track(1));
 //         fprintf(stderr," c->fTracks[0] %d c->fTracks[1] %d\n",dig->fHit,dig->fTracks[0]);
        }
 //
@@ -1277,7 +1277,7 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t cath)
     Float_t xpad, ypad, zpad;
     Float_t dx, dy, dr;
 
-    for (Int_t i=0; i<c->fMultiplicity[cath]; i++)
+    for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
     {
        dig = fInput->Digit(cath,c->fIndexMap[i][cath]);
        fSeg[cath]->
@@ -1298,10 +1298,10 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t cath)
            } else if (dig->Physics() == 0) {
                c->fPhysicsMap[i]=0;
            } else  c->fPhysicsMap[i]=1;
-           c->fPeakSignal[cath]=q;
-           c->fTracks[0]=dig->Hit();
-           c->fTracks[1]=dig->Track(0);
-           c->fTracks[2]=dig->Track(1);
+           c->SetPeakSignal(cath,q);
+           c->SetTrack(0,dig->Hit());
+           c->SetTrack(1,dig->Track(0));
+           c->SetTrack(2,dig->Track(1));
            if (fDebugLevel)
                fprintf(stderr," c->fTracks[0] %d c->fTracks[1] %d\n",dig->Hit(),
                    dig->Track(0));
@@ -1330,17 +1330,17 @@ void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONR
     Int_t theX=dig->PadX();
     Int_t theY=dig->PadY(); 
    
-    if (q > TMath::Abs(c.fPeakSignal[0]) && q > TMath::Abs(c.fPeakSignal[1])) {
-       c.fPeakSignal[cath]=q;
-       c.fTracks[0]=dig->Hit();
-       c.fTracks[1]=dig->Track(0);
-       c.fTracks[2]=dig->Track(1);
+    if (q > TMath::Abs(c.GetPeakSignal(0)) && q > TMath::Abs(c.GetPeakSignal(1))) {
+       c.SetPeakSignal(cath,q);
+       c.SetTrack(0,dig->Hit());
+       c.SetTrack(1,dig->Track(0));
+       c.SetTrack(2,dig->Track(1));
     }
 
 //
 //  Make sure that list of digits is ordered 
 // 
-    Int_t mu=c.fMultiplicity[cath];
+    Int_t mu=c.GetMultiplicity(cath);
     c.fIndexMap[mu][cath]=idx;
     
     if (dig->Physics() >= dig->Signal()) {
@@ -1367,10 +1367,10 @@ void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONR
        }
     }
 
-    c.fMultiplicity[cath]++;
-    if (c.fMultiplicity[cath] >= 50 ) {
-       printf("FindCluster - multiplicity >50  %d \n",c.fMultiplicity[0]);
-       c.fMultiplicity[cath]=49;
+    c.SetMultiplicity(cath, c.GetMultiplicity(cath)+1);
+    if (c.GetMultiplicity(cath) >= 50 ) {
+       printf("FindCluster - multiplicity >50  %d \n",c.GetMultiplicity(0));
+       c.SetMultiplicity(cath, 49);
     }
 
 // Prepare center of gravity calculation
@@ -1488,12 +1488,12 @@ void AliMUONClusterFinderVS::FindRawClusters()
            if (fDebugLevel)
                fprintf(stderr,"\n CATHODE %d CLUSTER %d\n",cath,ncls);
            AliMUONRawCluster c;
-           c.fMultiplicity[0]=0;
-           c.fMultiplicity[1]=0;
-           c.fPeakSignal[cath]=dig->Signal();
-           c.fTracks[0]=dig->Hit();
-           c.fTracks[1]=dig->Track(0);
-           c.fTracks[2]=dig->Track(1);
+           c.SetMultiplicity(0, 0);
+           c.SetMultiplicity(1, 0);
+           c.SetPeakSignal(cath,dig->Signal());
+           c.SetTrack(0, dig->Hit());
+           c.SetTrack(1, dig->Track(0));
+           c.SetTrack(2, dig->Track(1));
            // tag the beginning of cluster list in a raw cluster
            c.fNcluster[0]=-1;
            Float_t xcu, ycu;
@@ -1522,15 +1522,15 @@ void AliMUONClusterFinderVS::FindRawClusters()
 
            if (fDebugLevel) {
                fprintf(stderr,"\n Cathode 1 multiplicite %d X(CG) %f Y(CG) %f\n",
-                       c.fMultiplicity[0],c.GetX(0),c.GetY(0));
+                       c.GetMultiplicity(0),c.GetX(0),c.GetY(0));
                fprintf(stderr," Cathode 2 multiplicite %d X(CG) %f Y(CG) %f\n",
-                       c.fMultiplicity[1],c.GetX(1),c.GetY(1));
+                       c.GetMultiplicity(1),c.GetX(1),c.GetY(1));
            }
 //      Analyse cluster and decluster if necessary
 //     
        ncls++;
        c.fNcluster[1]=fNRawClusters;
-       c.fClusterType=c.PhysicsContribution();
+       c.SetClusterType(c.PhysicsContribution());
 
        fNPeaks=0;
 //
@@ -1539,14 +1539,15 @@ void AliMUONClusterFinderVS::FindRawClusters()
 //
 //      reset Cluster object
        { // begin local scope
-           for (int k=0;k<c.fMultiplicity[0];k++) c.fIndexMap[k][0]=0;
+           for (int k=0;k<c.GetMultiplicity(0);k++) c.fIndexMap[k][0]=0;
        } // end local scope
 
        { // begin local scope
-           for (int k=0;k<c.fMultiplicity[1];k++) c.fIndexMap[k][1]=0;
+           for (int k=0;k<c.GetMultiplicity(1);k++) c.fIndexMap[k][1]=0;
        } // end local scope
        
-       c.fMultiplicity[0]=c.fMultiplicity[0]=0;
+       c.SetMultiplicity(0,0);
+       c.SetMultiplicity(1,0);
 
        
        } // end loop ndig
@@ -1960,7 +1961,7 @@ void AliMUONClusterFinderVS::Split(AliMUONRawCluster* c)
                cnew.fNcluster[0]=fNPeaks;
                cnew.fNcluster[1]=0;
            }
-           cnew.fMultiplicity[cath]=0;
+           cnew.SetMultiplicity(cath,0);
            cnew.SetX(cath, Float_t(fXFit[j]));
            cnew.SetY(cath, Float_t(fYFit[j]));
            cnew.SetZ(cath, fZPlane);
@@ -1971,18 +1972,18 @@ void AliMUONClusterFinderVS::Split(AliMUONRawCluster* c)
            }
            fSeg[cath]->SetHit(fXFit[j],fYFit[j],fZPlane);
            for (i=0; i<fMul[cath]; i++) {
-               cnew.fIndexMap[cnew.fMultiplicity[cath]][cath]=
+               cnew.fIndexMap[cnew.GetMultiplicity(cath)][cath]=
                    c->fIndexMap[i][cath];
                fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
                Float_t q1=fInput->Response()->IntXY(fSeg[cath]);
                cnew.fContMap[i][cath]
                    =(q1*Float_t(cnew.GetCharge(cath)))/Float_t(fQ[i][cath]);
-               cnew.fMultiplicity[cath]++;
+               cnew.SetMultiplicity(cath, cnew.GetMultiplicity(cath)+1 );
            }
            FillCluster(&cnew,0,cath);
        } // cathode loop
        
-       cnew.fClusterType=cnew.PhysicsContribution();
+       cnew.SetClusterType(cnew.PhysicsContribution());
        if (cnew.GetCharge(0)>0 && cnew.GetCharge(1)>0) AddRawCluster(cnew);
        fNPeaks++;
     }
index 92c3e33..115b7fa 100644 (file)
@@ -108,8 +108,8 @@ void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
     Float_t qtot;
     Int_t   i, cath, ix, iy;
     AliMUONDigit* digit;
-    fNmul[0]=cluster->fMultiplicity[0];
-    fNmul[1]=cluster->fMultiplicity[1];
+    fNmul[0]=cluster->GetMultiplicity(0);
+    fNmul[1]=cluster->GetMultiplicity(1);
     //PH printf("\n %p %p ", fDigits[0], fDigits[1]);
     
     for (cath=0; cath<2; cath++) {
index 843e2f3..d11a3d1 100644 (file)
@@ -237,6 +237,30 @@ Float_t AliMUONRawCluster::GetZ(Int_t i) const
   if (i==0 || i==1) return fZ[i];
   else  return 99999.;
 }
+//____________________________________________________
+Int_t AliMUONRawCluster::GetTrack(Int_t i) const 
+{
+  if (i==0 || i==1 || i==2) return fTracks[i];
+  else  return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetPeakSignal(Int_t i) const 
+{
+  if (i==0 || i==1 ) return fPeakSignal[i];
+  else  return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetMultiplicity(Int_t i) const 
+{
+  if (i==0 || i==1 ) return fMultiplicity[i];
+  else  return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetClusterType() const 
+{
+  return fClusterType;
+}
+
 //____________________________________________________
 Int_t AliMUONRawCluster::SetCharge(Int_t i, Int_t Q)
 {
@@ -273,3 +297,36 @@ Int_t AliMUONRawCluster::SetZ(Int_t i, Float_t Z)
   }
   else return 0;
 }
+//____________________________________________________
+Int_t AliMUONRawCluster::SetTrack(Int_t i, Int_t track)
+{
+  if (i==0 || i==1 || i==2) {
+    fTracks[i]=track;
+    return 1;
+  }
+  else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetPeakSignal(Int_t i, Int_t peaksignal)
+{
+  if (i==0 || i==1 ) {
+    fPeakSignal[i]=peaksignal;
+    return 1;
+  }
+  else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetMultiplicity(Int_t i, Int_t mul)
+{
+  if (i==0 || i==1 ) {
+    fMultiplicity[i]=mul;
+    return 1;
+  }
+  else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetClusterType(Int_t type)
+{
+  fClusterType=type;
+  return 1;
+}
index 70546dc..d10d916 100644 (file)
@@ -38,35 +38,41 @@ public:
    Float_t      GetX(Int_t i) const;
    Float_t      GetY(Int_t i) const;
    Float_t      GetZ(Int_t i) const;
+   Int_t        GetTrack(Int_t i) const;
+   Int_t        GetPeakSignal(Int_t i) const;
+   Int_t        GetMultiplicity(Int_t i) const;
+   Int_t        GetClusterType() const;
 
    Int_t        SetCharge(Int_t i,Int_t Q);
    Int_t        SetX(Int_t i, Float_t X);
    Int_t        SetY(Int_t i, Float_t Y);
    Int_t        SetZ(Int_t i, Float_t Z);
+   Int_t        SetTrack(Int_t i, Int_t track);
+   Int_t        SetPeakSignal(Int_t i, Int_t peaksignal);
+   Int_t        SetMultiplicity(Int_t i, Int_t mul);
+   Int_t        SetClusterType(Int_t type);
 
-private:
-   Int_t       fQ[2]  ;           // Q of cluster (in ADC counts)     
-   Float_t     fX[2]  ;           // X of cluster
-   Float_t     fY[2]  ;           // Y of cluster
-   Float_t     fZ[2]  ;           // Z of cluster
-
-public:
-   Int_t       fTracks[3];        //labels of overlapped tracks
-   Int_t       fPeakSignal[2];    // Peak signal 
    Int_t       fIndexMap[50][2];  // indeces of digits
    Int_t       fOffsetMap[50][2]; // Emmanuel special
    Float_t     fContMap[50][2];   // Contribution from digit
    Int_t       fPhysicsMap[50];   // Distinguish signal and background contr.
-   Int_t       fMultiplicity[2];  // Cluster multiplicity
    Int_t       fNcluster[2];      // Number of clusters
-   Int_t       fClusterType;      // Cluster type
    Float_t     fChi2[2];          // Chi**2 of fit
    Int_t       fGhost;            // 0 if not a ghost or ghost problem solved
                                   // >0 if ghost problem remains because
                                   // 1 both (true and ghost) satify 
                                   //   charge chi2 compatibility
                                   // 2 none give satisfactory chi2
-
+private:
+   Int_t       fQ[2]  ;           // Q of cluster (in ADC counts)     
+   Float_t     fX[2]  ;           // X of cluster
+   Float_t     fY[2]  ;           // Y of cluster
+   Float_t     fZ[2]  ;           // Z of cluster
+   Int_t       fTracks[3];        //labels of overlapped tracks
+   Int_t       fPeakSignal[2];    // Peak signal 
+   Int_t       fMultiplicity[2];  // Cluster multiplicity
+   Int_t       fClusterType;      // Cluster type
 
    ClassDef(AliMUONRawCluster,1)  //Cluster class for MUON
 };
index ad5d474..3612dcb 100644 (file)
@@ -186,8 +186,8 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
       hit1 = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i]);
       rawclusters = fgMUON->GetMUONData()->RawClusters(hit1->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit1->GetHitNumber());
-      cout << clus->fTracks[1]-1;
-      if (clus->fTracks[2] != 0) cout << " " << clus->fTracks[2]-1;
+      cout << clus->GetTrack(1)-1;
+      if (clus->GetTrack(2) != 0) cout << " " << clus->GetTrack(2)-1;
       if (i == 0) cout << " <--> ";
     }
     cout << endl;
@@ -1219,7 +1219,7 @@ void AliMUONTrackK::GoToVertex(void)
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
       rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
-      printf ("%4d", clus->fTracks[1] - 1); 
+      printf ("%4d", clus->GetTrack(1) - 1); 
       //cout << clus->fTracks[1] - 1 << " ";
     }
     cout << endl;
@@ -1227,7 +1227,7 @@ void AliMUONTrackK::GoToVertex(void)
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
       rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
-      if (clus->fTracks[2] != 0) printf ("%4d", clus->fTracks[2] - 1);
+      if (clus->GetTrack(2) != 0) printf ("%4d", clus->GetTrack(2) - 1);
       else printf ("%4s", "   ");
       //if (clus->fTracks[2] != 0) cout << clus->fTracks[2] - 1 << " ";
     }