Removing obsoleted classes (Laurent)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 21:09:29 +0000 (21:09 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 21:09:29 +0000 (21:09 +0000)
56 files changed:
MUON/AliMUONClusterDrawAZ.cxx [deleted file]
MUON/AliMUONClusterDrawAZ.h [deleted file]
MUON/AliMUONClusterFinderVS.cxx [deleted file]
MUON/AliMUONClusterFinderVS.h [deleted file]
MUON/AliMUONClusterInput.cxx [deleted file]
MUON/AliMUONClusterInput.h [deleted file]
MUON/AliMUONData.cxx [deleted file]
MUON/AliMUONData.h [deleted file]
MUON/AliMUONDataDigitIterator.cxx [deleted file]
MUON/AliMUONDataDigitIterator.h [deleted file]
MUON/AliMUONDataIterator.cxx [deleted file]
MUON/AliMUONDataIterator.h [deleted file]
MUON/AliMUONDetElement.cxx [deleted file]
MUON/AliMUONDetElement.h [deleted file]
MUON/AliMUONDigitMapA1.cxx [deleted file]
MUON/AliMUONDigitMapA1.h [deleted file]
MUON/AliMUONDisplay.cxx [deleted file]
MUON/AliMUONDisplay.h [deleted file]
MUON/AliMUONEventRecoCombi.cxx [deleted file]
MUON/AliMUONEventRecoCombi.h [deleted file]
MUON/AliMUONGeometrySegmentation.cxx [deleted file]
MUON/AliMUONGeometrySegmentation.h [deleted file]
MUON/AliMUONHitMapA1.cxx [deleted file]
MUON/AliMUONHitMapA1.h [deleted file]
MUON/AliMUONPoints.cxx [deleted file]
MUON/AliMUONPoints.h [deleted file]
MUON/AliMUONRecData.cxx [deleted file]
MUON/AliMUONRecData.h [deleted file]
MUON/AliMUONRecLoader.cxx [deleted file]
MUON/AliMUONRecLoader.h [deleted file]
MUON/AliMUONSegFactory.cxx [deleted file]
MUON/AliMUONSegFactory.h [deleted file]
MUON/AliMUONSegmentation.cxx [deleted file]
MUON/AliMUONSegmentation.h [deleted file]
MUON/AliMUONSimData.cxx [deleted file]
MUON/AliMUONSimData.h [deleted file]
MUON/AliMUONSimLoader.cxx [deleted file]
MUON/AliMUONSimLoader.h [deleted file]
MUON/AliMUONSt12QuadrantSegmentation.cxx [deleted file]
MUON/AliMUONSt12QuadrantSegmentation.h [deleted file]
MUON/AliMUONSt345SlatSegmentation.cxx [deleted file]
MUON/AliMUONSt345SlatSegmentation.h [deleted file]
MUON/AliMUONStopwatchGroupElement.h [new file with mode: 0644]
MUON/AliMUONTriggerSegmentation.cxx [deleted file]
MUON/AliMUONTriggerSegmentation.h [deleted file]
MUON/AliMUONV1DStore.cxx [deleted file]
MUON/AliMUONV1DStore.h [deleted file]
MUON/AliMUONV2DStore.cxx [deleted file]
MUON/AliMUONV2DStore.h [deleted file]
MUON/AliMUONVDataIterator.cxx [deleted file]
MUON/AliMUONVDataIterator.h [deleted file]
MUON/AliMUONVGeometryDESegmentation.cxx [deleted file]
MUON/AliMUONVGeometryDESegmentation.h [deleted file]
MUON/Doxyfile
MUON/Doxymain.h [new file with mode: 0644]
MUON/MUONCDB.h [deleted file]

diff --git a/MUON/AliMUONClusterDrawAZ.cxx b/MUON/AliMUONClusterDrawAZ.cxx
deleted file mode 100644 (file)
index 3576c5d..0000000
+++ /dev/null
@@ -1,741 +0,0 @@
-/**************************************************************************
- * 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 AliMUONClusterDrawAZ
-// -------------------------------------
-// Cluster drawing for AZ cluster finder 
-// Author: Alexander Zinchenko, JINR Dubna
-
-#include <stdlib.h>
-#include <Riostream.h>
-#include <TROOT.h>
-#include <TCanvas.h>
-#include <TLine.h>
-#include <TH2.h>
-#include <TView.h>
-#include <TStyle.h>
-
-#include "AliMUONClusterDrawAZ.h"
-#include "AliMUONClusterFinderAZ.h"
-#include "AliMUONGeometryModuleTransformer.h"
-#include "AliMUONGeometrySegmentation.h"
-#include "AliHeader.h"
-#include "AliRun.h"
-#include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONClusterInput.h"
-#include "AliMUONPixel.h"
-#include "AliMUONRecLoader.h"
-#include "AliMUONRecData.h"
-#include "AliLog.h"
-
-ClassImp(AliMUONClusterDrawAZ)
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ::AliMUONClusterDrawAZ()
-  : TObject(),
-    fData(0x0),
-    fFind(0x0),
-    fnMu(0),
-    fEvent(0),
-    fChamber(0),
-    fidDE(0),
-    fDebug(0),
-    fModif(0)
-{
-/// Default constructor
-  for (Int_t i=0; i<4; i++) fHist[i] = NULL;
-}
-
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ::AliMUONClusterDrawAZ(AliMUONClusterFinderAZ *clusFinder)
-  : TObject(),
-    fData(0x0),
-    fFind(clusFinder),
-    fnMu(0),
-    fEvent(0),
-    fChamber(0),
-    fidDE(0),
-    fDebug(1),
-    fModif(0)
-{
-/// Constructor
-  for (Int_t i=0; i<4; i++) fHist[i] = NULL;
-  Init();
-}
-
-//_____________________________________________________________________________
-AliMUONClusterDrawAZ::~AliMUONClusterDrawAZ()
-{
-/// Destructor
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::Init()
-{
-/// Initialization
-
-  TCanvas *c1 = new TCanvas("c1","Clusters",0,0,600,700);
-  //c1->SetFillColor(10);
-  c1->Divide(1,2);
-  new TCanvas("c2","Mlem",700,0,600,350);
-
-  // Get pointer to Alice detectors
-  //AliMUON *muon  = (AliMUON*) gAlice->GetModule("MUON");
-  //if (!muon) return;
-  //Loaders
-  AliRunLoader *rl = AliRunLoader::GetRunLoader();
-  AliLoader *gime = rl->GetLoader("MUONLoader");
-  fData = ((AliMUONRecLoader*)gime)->GetMUONData();
-
-  // gime->LoadHits("READ"); 
-  gime->LoadRecPoints("READ"); 
-}
-
-//_____________________________________________________________________________
-Bool_t AliMUONClusterDrawAZ::FindEvCh(Int_t nev, Int_t ch)
-{
-/// Find requested event and chamber (skip the ones before the selected)
-
-  if (nev < fEvent) return kFALSE;
-  else if (nev == fEvent) {
-    if (ch < fChamber) return kFALSE;
-    if (AliMUONClusterInput::Instance()->DetElemId() < fidDE) return kFALSE;
-  }
-  fEvent = nev;
-  fChamber = ch;
-  fidDE = AliMUONClusterInput::Instance()->DetElemId();
-  return kTRUE;
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::DrawCluster()
-{
-/// Draw preclusters
-
-  TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
-
-  cout << " nev         " << fEvent << endl;
-    
-  char hName[4];
-  for (Int_t cath = 0; cath < 2; cath++) {
-    // Build histograms
-    //if (fHist[cath*2]) {fHist[cath*2]->Delete(); fHist[cath*2] = 0;}
-    //if (fHist[cath*2+1]) {fHist[cath*2+1]->Delete(); fHist[cath*2+1] = 0;}
-    if (fHist[cath*2]) fHist[cath*2] = 0;
-    if (fHist[cath*2+1]) fHist[cath*2+1] = 0;
-    if (fFind->GetNPads(cath) == 0) continue; // cluster on one cathode only
-    Float_t wxMin = 999, wxMax = 0, wyMin = 999, wyMax = 0; 
-    Int_t minDx = 0, maxDx = 0, minDy = 0, maxDy = 0;
-    for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
-      if (fFind->GetIJ(0,i) != cath) continue;
-      if (fFind->GetXyq(3,i) < wxMin) { wxMin = fFind->GetXyq(3,i); minDx = i; }
-      if (fFind->GetXyq(3,i) > wxMax) { wxMax = fFind->GetXyq(3,i); maxDx = i; }
-      if (fFind->GetXyq(4,i) < wyMin) { wyMin = fFind->GetXyq(4,i); minDy = i; }
-      if (fFind->GetXyq(4,i) > wyMax) { wyMax = fFind->GetXyq(4,i); maxDy = i; }
-    }
-    cout << minDx << " " << maxDx << " " << minDy << " " << maxDy << endl;
-    Int_t nx, ny, padSize;
-    Float_t xmin = 9999, xmax = -9999, ymin = 9999, ymax = -9999;
-    if (TMath::Nint(fFind->GetXyq(3,minDx)*1000) == TMath::Nint(fFind->GetXyq(3,maxDx)*1000) &&
-       TMath::Nint(fFind->GetXyq(4,minDy)*1000) == TMath::Nint(fFind->GetXyq(4,maxDy)*1000)) {
-      // the same segmentation
-      cout << " Same" << endl;
-      cout << fFind->GetXyq(3,minDx) << " " << fFind->GetXyq(3,maxDx) << " " 
-          << fFind->GetXyq(4,minDy) << " " << fFind->GetXyq(4,maxDy) << endl;
-      for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
-       if (fFind->GetIJ(0,i) != cath) continue;
-       if (fFind->GetXyq(0,i) < xmin) xmin = fFind->GetXyq(0,i);
-       if (fFind->GetXyq(0,i) > xmax) xmax = fFind->GetXyq(0,i);
-       if (fFind->GetXyq(1,i) < ymin) ymin = fFind->GetXyq(1,i);
-       if (fFind->GetXyq(1,i) > ymax) ymax = fFind->GetXyq(1,i);
-      }
-      xmin -= fFind->GetXyq(3,minDx); xmax += fFind->GetXyq(3,minDx);
-      ymin -= fFind->GetXyq(4,minDy); ymax += fFind->GetXyq(4,minDy);
-      nx = TMath::Nint ((xmax-xmin)/wxMin/2);
-      ny = TMath::Nint ((ymax-ymin)/wyMin/2);
-      cout << xmin << " " << xmax << " " << nx << " " << ymin << " " << ymax << " " << ny << endl;
-      sprintf(hName,"h%d",cath*2);
-      fHist[cath*2] = new TH2D(hName,"cluster",nx,xmin,xmax,ny,ymin,ymax);
-      for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
-       if (fFind->GetIJ(0,i) != cath) continue;
-       fHist[cath*2]->Fill(fFind->GetXyq(0,i),fFind->GetXyq(1,i),fFind->GetXyq(2,i));
-      }
-    } else {
-      // different segmentation in the cluster
-      cout << " Different" << endl;
-      cout << fFind->GetXyq(3,minDx) << " " << fFind->GetXyq(3,maxDx) << " " 
-          << fFind->GetXyq(4,minDy) << " " << fFind->GetXyq(4,maxDy) << endl;
-      Int_t nOK = 0;
-      Int_t indx, locMin, locMax;
-      if (TMath::Nint(fFind->GetXyq(3,minDx)*1000) != TMath::Nint(fFind->GetXyq(3,maxDx)*1000)) {
-       // different segmentation along x
-       indx = 0;
-       locMin = minDx;
-       locMax = maxDx;
-      } else {
-       // different segmentation along y
-       indx = 1;
-       locMin = minDy;
-       locMax = maxDy;
-      }
-      Int_t loc = locMin;
-      for (Int_t i = 0; i < 2; i++) {
-       // loop over different pad sizes
-       if (i > 0) loc = locMax;
-       padSize = TMath::Nint(fFind->GetXyq(indx+3,loc)*1000);
-       xmin = 9999; xmax = -9999; ymin = 9999; ymax = -9999;
-       for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
-         if (fFind->GetIJ(0,j) != cath) continue;
-         if (TMath::Nint(fFind->GetXyq(indx+3,j)*1000) != padSize) continue;
-         nOK++;
-         xmin = TMath::Min (xmin,fFind->GetXyq(0,j));
-         xmax = TMath::Max (xmax,fFind->GetXyq(0,j));
-         ymin = TMath::Min (ymin,fFind->GetXyq(1,j));
-         ymax = TMath::Max (ymax,fFind->GetXyq(1,j));
-       }
-       xmin -= fFind->GetXyq(3,loc); xmax += fFind->GetXyq(3,loc);
-       ymin -= fFind->GetXyq(4,loc); ymax += fFind->GetXyq(4,loc);
-       nx = TMath::Nint ((xmax-xmin)/fFind->GetXyq(3,loc)/2);
-       ny = TMath::Nint ((ymax-ymin)/fFind->GetXyq(4,loc)/2);
-       sprintf(hName,"h%d",cath*2+i);
-       fHist[cath*2+i] = new TH2D(hName,"cluster",nx,xmin,xmax,ny,ymin,ymax);
-       for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
-         if (fFind->GetIJ(0,j) != cath) continue;
-         if (TMath::Nint(fFind->GetXyq(indx+3,j)*1000) != padSize) continue;
-         fHist[cath*2+i]->Fill(fFind->GetXyq(0,j),fFind->GetXyq(1,j),fFind->GetXyq(2,j));
-       }
-      } // for (Int_t i=0;
-      if (nOK != fFind->GetNPads(cath)) cout << " *** Too many segmentations: nPads, nOK " 
-                                            << fFind->GetNPads(cath) << " " << nOK << endl;
-    } // if (TMath::Nint(fFind->GetXyq(3,minDx)*1000)
-  } // for (Int_t cath = 0;
-       
-  // Draw histograms and coordinates
-  //TH2D *hFake = 0x0;
-  TH2D *hFake = (TH2D*) gROOT->FindObject("hFake");
-  if (hFake) hFake->Delete();
-  if (fModif) {
-    // This part works only after a modification of THistPainter::PaintLego(Option_t *) 
-    // in ROOT
-    Double_t xmin = 9999, ymin = 9999, xmax = -9999, ymax = -9999, aMax = -1;
-    for (Int_t i = 0; i < 4; i++) {
-      if (!fHist[i]) continue;
-      xmin = TMath::Min (xmin, fHist[i]->GetXaxis()->GetXmin());
-      xmax = TMath::Max (xmax, fHist[i]->GetXaxis()->GetXmax());
-      ymin = TMath::Min (ymin, fHist[i]->GetYaxis()->GetXmin());
-      ymax = TMath::Max (ymax, fHist[i]->GetYaxis()->GetXmax());
-      aMax = TMath:: Max (aMax, fHist[i]->GetMaximum());
-    }
-    //if (c1->FindObject("hFake")) delete c1->FindObject("hFake");
-    hFake = new TH2D ("hFake", "hFake", 1, xmin, xmax, 1, ymin, ymax);
-    hFake->SetMaximum(aMax);
-    hFake->SetNdivisions(505,"Z");
-    hFake->SetStats(kFALSE);
-  }
-
-  TObject *stats = 0x0;
-  for (Int_t cath = 0; cath < 2; cath++) {
-    if (cath == 0) ModifyHistos();
-    if (fFind->GetNPads(cath) == 0) continue; // cluster on one cathode only
-    c1->cd(cath+1);
-    gPad->SetTheta(55);
-    gPad->SetPhi(30);
-    if (fModif) {
-      if (fHist[cath*2]) { 
-       fHist[cath*2]->Draw();
-       gPad->Update();
-       stats = fHist[cath*2]->GetListOfFunctions()->FindObject("stats");
-      }
-      hFake->Draw("legoFb");
-    }
-
-    Double_t x, y, x0, y0, r1 = 999, r2 = 0;
-    if (fHist[cath*2+1]) {
-      // 
-      x0 = fHist[cath*2]->GetXaxis()->GetXmin() - 1000*TMath::Cos(30*TMath::Pi()/180);
-      y0 = fHist[cath*2]->GetYaxis()->GetXmin() - 1000*TMath::Sin(30*TMath::Pi()/180);
-      r1 = 0;
-      Int_t ihist=cath*2;
-      for (Int_t iy = 1; iy <= fHist[ihist]->GetNbinsY(); iy++) {
-       y = fHist[ihist]->GetYaxis()->GetBinCenter(iy) 
-         + fHist[ihist]->GetYaxis()->GetBinWidth(iy);
-       for (Int_t ix = 1; ix <= fHist[ihist]->GetNbinsX(); ix++) {
-         if (fHist[ihist]->GetCellContent(ix,iy) > 0.1) {
-           x = fHist[ihist]->GetXaxis()->GetBinCenter(ix)
-             + fHist[ihist]->GetXaxis()->GetBinWidth(ix);
-           r1 = TMath::Max (r1,TMath::Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0)));
-         }
-       }
-      }
-      ihist = cath*2 + 1 ;
-      for (Int_t iy = 1; iy <= fHist[ihist]->GetNbinsY(); iy++) {
-       y = fHist[ihist]->GetYaxis()->GetBinCenter(iy)
-         + fHist[ihist]->GetYaxis()->GetBinWidth(iy);
-       for (Int_t ix = 1; ix <= fHist[ihist]->GetNbinsX(); ix++) {
-         if (fHist[ihist]->GetCellContent(ix,iy) > 0.1) {
-           x = fHist[ihist]->GetXaxis()->GetBinCenter(ix)
-             + fHist[ihist]->GetXaxis()->GetBinWidth(ix);
-           r2 = TMath::Max (r2,TMath::Sqrt((x-x0)*(x-x0)+(y-y0)*(y-y0)));
-         }
-       }
-      }
-      cout << r1 << " " << r2 << endl;
-    } // if (fHist[cath*2+1])
-    if (r1 > r2) {
-      if (fModif) fHist[cath*2]->Draw("lego1FbSame");
-      else fHist[cath*2]->Draw("lego1Fb");
-      // Draw background contaminated charges
-      //TH2D *hBkg = GetBackground(cath*2);
-      //if (hBkg) hBkg->Draw("lego1FbBbSameAxis");
-      if (fHist[cath*2+1]) fHist[cath*2+1]->Draw("lego1SameAxisBbFb");
-    } else {
-      if (fModif) fHist[cath*2+1]->Draw("lego1FbSame");
-      else fHist[cath*2+1]->Draw("lego1Fb");
-      fHist[cath*2]->Draw("lego1SameAxisFbBb");
-    }
-    c1->Update();
-    if (fModif) stats->Draw();
-  } // for (Int_t cath = 0;
-
-  // Draw simulated and reconstructed hits 
-  // DrawHits();
-}
-/*
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::DrawHits()
-{
-/// Draw simulated and reconstructed hits 
-
-  TView *view[2] = { 0x0, 0x0 };
-  Double_t p1[3]={0}, p2[3], xNDC[6], xl, yl, zl;
-  TLine *line[199] = {0};
-  TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
-  if (c1) {
-    c1->cd(1);
-    view[0] = c1->Pad()->GetView();
-    c1->cd(2);
-    view[1] = c1->Pad()->GetView();
-  }
-  fData->SetTreeAddress("H RC");
-
-  TH2D *hist = fHist[0] ? fHist[0] : fHist[2];
-  p2[2] = hist->GetMaximum();
-
-  // Draw simulated hits
-  cout << " *** Simulated hits *** " << endl;
-  Int_t ntracks = 0;
-  if (fData->TreeH()) ntracks = (Int_t) fData->GetNtracks();
-  fnMu = 0;
-  Int_t ix, iy, iok, nLine = 0;
-  TClonesArray *hits = NULL;
-  for (Int_t i = 0; i < ntracks; i++) {
-    fData->GetTrack(i);
-    hits = fData->Hits();
-    Int_t nhits = (Int_t) hits->GetEntriesFast();
-    AliMUONHit* mHit;
-    for (Int_t ihit = 0; ihit < nhits; ihit++) {
-      mHit = (AliMUONHit*) hits->UncheckedAt(ihit);
-      if (mHit->Chamber() != fChamber+1) continue;  // chamber number
-      if (mHit->DetElemId() != fidDE) continue;  // det. elem. Id
-      AliMUONClusterInput::Instance()->Segmentation2(0)->GetTransformer()->
-                        Global2Local(fidDE, mHit->X(), mHit->Y(), mHit->Z(), xl, yl, zl);
-      //if (TMath::Abs(zl-fFind->GetZpad()) > 1) continue; // different slat
-      p2[0] = p1[0] = xl;        // x-pos of hit
-      p2[1] = p1[1] = yl;        // y-pos
-      if (p1[0] < hist->GetXaxis()->GetXmin() || 
-         p1[0] > hist->GetXaxis()->GetXmax()) continue;
-      if (p1[1] < hist->GetYaxis()->GetXmin() || 
-         p1[1] > hist->GetYaxis()->GetXmax()) continue;
-      // Check if track comes thru pads with signal
-      iok = 0;
-      for (Int_t ihist = 0; ihist < 4; ihist++) {
-       if (!fHist[ihist]) continue;
-       ix = fHist[ihist]->GetXaxis()->FindBin(p1[0]);
-       iy = fHist[ihist]->GetYaxis()->FindBin(p1[1]);
-       if (fHist[ihist]->GetCellContent(ix,iy) > 0.5) {iok = 1; break;}
-      }
-      if (!iok) continue;
-      gStyle->SetLineColor(1);
-      if (TMath::Abs((Int_t)mHit->Particle()) == 13) {
-       gStyle->SetLineColor(4);
-       if (fnMu < 2) {
-         fxyMu[fnMu][0] = p1[0];
-         fxyMu[fnMu++][1] = p1[1];
-       }
-      }            
-      printf(" Local coord.:  X=%10.4f, Y=%10.4f\n",p1[0],p1[1]);
-      printf(" Global coord.: X=%10.4f, Y=%10.4f, Z=%10.4f\n",mHit->X(),mHit->Y(),mHit->Z());
-      if (view[0] || view[1]) {
-       // Take into account track angles
-       p2[0] += mHit->Tlength() * TMath::Sin(mHit->Theta()/180*TMath::Pi()) 
-                                * TMath::Cos(mHit->Phi()/180*TMath::Pi()) / 2;
-       p2[1] += mHit->Tlength() * TMath::Sin(mHit->Theta()/180*TMath::Pi()) 
-                                * TMath::Sin(mHit->Phi()/180*TMath::Pi()) / 2;
-       for (Int_t ipad = 1; ipad < 3; ipad++) {
-         c1->cd(ipad);
-         if (!view[ipad-1]) continue;
-         view[ipad-1]->WCtoNDC(p1, &xNDC[0]);
-         view[ipad-1]->WCtoNDC(p2, &xNDC[3]);
-         //c1->DrawLine(xpad[0],xpad[1],xpad[3],xpad[4]);
-         line[nLine] = new TLine(xNDC[0],xNDC[1],xNDC[3],xNDC[4]);
-         line[nLine++]->Draw();
-       }
-      }
-    } // for (Int_t ihit = 0; ihit < nhits;
-  } // for (Int_t i = 0; i < ntracks;
-  fData->ResetHits();
-
-  // Draw reconstructed coordinates
-  if (fData->TreeR()) fData->GetRawClusters();
-  TClonesArray *rawclust = fData->RawClusters(fChamber);
-  AliMUONRawCluster *mRaw;
-  gStyle->SetLineColor(3);
-  cout << " *** Reconstructed hits *** " << endl;
-  if (rawclust) {
-    for (Int_t i = 0; i < rawclust ->GetEntriesFast(); i++) {
-      mRaw = (AliMUONRawCluster*)rawclust ->UncheckedAt(i);
-      AliMUONClusterInput::Instance()->Segmentation2(0)->GetTransformer()->
-                   Global2Local(fidDE, mRaw->GetX(0), mRaw->GetY(0), mRaw->GetZ(0), xl, yl, zl);
-      if (TMath::Abs(zl-fFind->GetZpad()) > 1) continue; // different slat
-      p2[0] = p1[0] = xl;        // x-pos of hit
-      p2[1] = p1[1] = yl;        // y-pos
-      if (p1[0] < hist->GetXaxis()->GetXmin() || 
-         p1[0] > hist->GetXaxis()->GetXmax()) continue;
-      if (p1[1] < hist->GetYaxis()->GetXmin() || 
-         p1[1] > hist->GetYaxis()->GetXmax()) continue;
-
-       //treeD->GetEvent(cath);
-       //cout << mRaw->fMultiplicity[0] << mRaw->fMultiplicity[1] << endl;
-       //for (Int_t j=0; j<mRaw->fMultiplicity[cath]; j++) {
-       //Int_t digit = mRaw->fIndexMap[j][cath];
-       //cout << ((AliMUONDigit*)fMuonDigits->UncheckedAt(digit))->Signal() << endl;
-       //}
-
-      // Check if track comes thru pads with signal
-      iok = 0;
-      for (Int_t ihist = 0; ihist < 4; ihist++) {
-       if (!fHist[ihist]) continue;
-       ix = fHist[ihist]->GetXaxis()->FindBin(p1[0]);
-       iy = fHist[ihist]->GetYaxis()->FindBin(p1[1]);
-       if (fHist[ihist]->GetCellContent(ix,iy) > 0.5) {iok = 1; break;}
-      }
-      if (!iok) continue;
-      printf(" Local coord.:  X=%10.4f, Y=%10.4f\n",p1[0],p1[1]);
-      printf(" Global coord.: X=%10.4f, Y=%10.4f, Z=%10.4f\n",mRaw->GetX(0),mRaw->GetY(0),mRaw->GetZ(0));
-      if (view[0] || view[1]) {
-       for (Int_t ipad = 1; ipad < 3; ipad++) {
-         c1->cd(ipad);
-         if (!view[ipad-1]) continue;
-         view[ipad-1]->WCtoNDC(p1, &xNDC[0]);
-         view[ipad-1]->WCtoNDC(p2, &xNDC[3]);
-         line[nLine] = new TLine(xNDC[0],xNDC[1],xNDC[3],xNDC[4]);
-         line[nLine++]->Draw();
-       }
-      }
-    } // for (Int_t i = 0; i < rawclust ->GetEntries();
-  } // if (rawclust)
-  if (fData->TreeR()) fData->ResetRawClusters();
-  c1->Update();
-}
-*/
-//_____________________________________________________________________________
-Int_t AliMUONClusterDrawAZ::Next()
-{
-/// What to do next?
-
-  // File
-  FILE *lun = 0;
-  //lun = fopen("pull.dat","w");
-
-  for (Int_t i = 0; i < fnMu; i++) {
-    // Check again if muon comes thru the used pads (due to extra splitting)
-    for (Int_t j = 0; j < fFind->GetNPads(0)+fFind->GetNPads(1); j++) {
-      if (TMath::Abs(fxyMu[i][0]-fFind->GetXyq(0,j))<fFind->GetXyq(3,j) && 
-         TMath::Abs(fxyMu[i][1]-fFind->GetXyq(1,j))<fFind->GetXyq(4,j)) {
-       if (fDebug) printf("%12.3e %12.3e %12.3e %12.3e\n",fxyMu[i][2],fxyMu[i][3],fxyMu[i][4],fxyMu[i][5]);
-       if (lun) fprintf(lun,"%4d %2d %12.3e %12.3e %12.3e %12.3e\n",fEvent,fChamber,fxyMu[i][2],fxyMu[i][3],fxyMu[i][4],fxyMu[i][5]);
-       break;
-      }
-    }
-  } // for (Int_t i=0; i<fnMu;
-
-  // What's next?
-  char command[8];
-  cout << " What is next? " << endl;
-  command[0] = ' '; 
-  gets(command);
-  if (command[0] == 'n' || command[0] == 'N') { fEvent++; fChamber = fidDE = 0; } // next event
-  else if (command[0] == 'q' || command[0] == 'Q') { if (lun) fclose(lun); } // exit display 
-  else if (command[0] == 'c' || command[0] == 'C') sscanf(command+1,"%d",&fChamber); // new chamber
-  else if (command[0] == 'e' || command[0] == 'E') { sscanf(command+1,"%d",&fEvent); fChamber = fidDE = 0; } // new event
-  else if (command[0] == 'd' || command[0] == 'D') { sscanf(command+1,"%d",&fidDE); fChamber = fidDE / 100 - 1; } // new DetElem.
-  else return 1; // Next precluster
-  return 0;
-}
-
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::ModifyHistos(void)
-{
-/// Modify histograms to bring them to (approximately) the same size
-
-  Int_t nhist = 0;
-  Float_t hlim[4][4], hbin[4][4]; // first index - xmin, xmax, ymin, ymax
-
-  Float_t binMin[4] = {999,999,999,999};
-
-  for (Int_t i = 0; i < 4; i++) {
-    if (!fHist[i]) {
-      hlim[0][i] = hlim[2][i] = 999;
-      hlim[1][i] = hlim[3][i] = -999;
-      continue;
-    }
-    hlim[0][i] = fHist[i]->GetXaxis()->GetXmin(); // xmin
-    hlim[1][i] = fHist[i]->GetXaxis()->GetXmax(); // xmax
-    hlim[2][i] = fHist[i]->GetYaxis()->GetXmin(); // ymin
-    hlim[3][i] = fHist[i]->GetYaxis()->GetXmax(); // ymax
-    hbin[0][i] = hbin[1][i] = fHist[i]->GetXaxis()->GetBinWidth(1);
-    hbin[2][i] = hbin[3][i] = fHist[i]->GetYaxis()->GetBinWidth(1);
-    binMin[0] = TMath::Min(binMin[0],hbin[0][i]);
-    binMin[2] = TMath::Min(binMin[2],hbin[2][i]);
-    nhist++;
-  }
-  binMin[1] = binMin[0];
-  binMin[3] = binMin[2];
-  cout << " Nhist: " << nhist << endl;
-
-  // Adjust histo limits for cathode with different segmentation
-  for (Int_t i = 0; i < 4; i+=2) {
-    if (!fHist[i+1]) continue;
-    Int_t imin, imax, i1 = i + 1;
-    for (Int_t lim = 0; lim < 4; lim++) {
-      while (1) {
-       if (hlim[lim][i] < hlim[lim][i1]) {
-         imin = i;
-         imax = i1;
-       } else {
-         imin = i1;
-         imax = i;
-       }
-       if (TMath::Abs(hlim[lim][imin]-hlim[lim][imax])<0.01*binMin[lim]) break;
-       if (lim == 0 || lim == 2) {
-         // find lower limit
-         hlim[lim][imax] -= hbin[lim][imax];
-       } else {
-         // find upper limit
-         hlim[lim][imin] += hbin[lim][imin];
-       }
-      } // while (1)
-    }
-  }
-    
-
-  Int_t imnmx = 0, nExtra = 0;
-  for (Int_t lim = 0; lim < 4; lim++) {
-    if (lim == 0 || lim == 2) imnmx = TMath::LocMin(4,hlim[lim]); // find lower limit
-    else imnmx = TMath::LocMax(4,hlim[lim]); // find upper limit
-
-    // Adjust histogram limit
-    for (Int_t i = 0; i < 4; i++) {
-      if (!fHist[i]) continue;
-      nExtra = TMath::Nint ((hlim[lim][imnmx]-hlim[lim][i]) / hbin[lim][i]);
-      hlim[lim][i] += nExtra * hbin[lim][i];
-    }
-  }
-    
-  // Rebuild histograms 
-  TH2D *hist = 0;
-  Int_t nx, ny;
-  Double_t x, y, cont, cmax=0;
-  char hName[4];
-  for (Int_t ihist = 0; ihist < 4; ihist++) {
-    if (!fHist[ihist]) continue;
-    nx = TMath::Nint((hlim[1][ihist]-hlim[0][ihist])/hbin[0][ihist]);
-    ny = TMath::Nint((hlim[3][ihist]-hlim[2][ihist])/hbin[2][ihist]);
-    cout << ihist << " " << hlim[0][ihist] << " " << hlim[1][ihist] << " " << nx;
-    cout << " " << hlim[2][ihist] << " " << hlim[3][ihist] << " " << ny << endl;
-    sprintf(hName,"hh%d",ihist);
-    hist =  new TH2D(hName,"hist",nx,hlim[0][ihist],hlim[1][ihist],ny,hlim[2][ihist],hlim[3][ihist]);
-    for (Int_t i=1; i<=fHist[ihist]->GetNbinsX(); i++) {
-      x = fHist[ihist]->GetXaxis()->GetBinCenter(i);
-      for (Int_t j=1; j<=fHist[ihist]->GetNbinsY(); j++) {
-       y = fHist[ihist]->GetYaxis()->GetBinCenter(j);
-       cont = fHist[ihist]->GetCellContent(i,j);
-       hist->Fill(x,y,cont);
-      }
-    }
-    cmax = TMath::Max (cmax,hist->GetMaximum());
-    sprintf(hName,"%s%d",fHist[ihist]->GetName(),ihist);
-    fHist[ihist]->Delete();
-    fHist[ihist] = new TH2D(*hist);
-    fHist[ihist]->SetName(hName);
-    fHist[ihist]->SetNdivisions(505,"Z");
-    hist->Delete(); 
-  }
-  if (fDebug) printf("%f \n",cmax);
-
-  for (Int_t ihist = 0; ihist < 4; ihist++) {
-    if (!fHist[ihist]) continue;
-    fHist[ihist]->SetMaximum(cmax);
-    fHist[ihist]->SetMinimum(0);
-  }
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::AdjustHist(Double_t *xylim, const AliMUONPixel *pixPtr)
-{
-/// Adjust histogram limits for pixel drawing
-
-  Float_t xypads[4];
-  if (fHist[0]) {
-    xypads[0] = fHist[0]->GetXaxis()->GetXmin();
-    xypads[1] = -fHist[0]->GetXaxis()->GetXmax();
-    xypads[2] = fHist[0]->GetYaxis()->GetXmin();
-    xypads[3] = -fHist[0]->GetYaxis()->GetXmax();
-    for (Int_t i = 0; i < 4; i++) {
-      while(1) {
-       if (xylim[i] < xypads[i]) break;
-       xylim[i] -= 2*pixPtr->Size(i/2);
-      }
-    }
-  } 
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::DrawHist(const char* canvas, TH2D *hist)
-{
-/// Draw histogram in given canvas 
-
-  Int_t ix = 0;
-  //((TCanvas*)gROOT->FindObject("c2"))->cd();
-  ((TCanvas*)gROOT->FindObject(canvas))->cd();
-  gPad->SetTheta(55);
-  gPad->SetPhi(30);
-  hist->Draw("lego1Fb");
-  gPad->Update();
-  //gets((char*)&ix);
-  if (fnMu) gets((char*)&ix);
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::FillMuon(Int_t nfit, const Double_t *parOk, const Double_t *errOk)
-{
-/// Fill muon information
-
-  Int_t indx, imax;
-  Double_t cmax, rad;
-  for (Int_t i = 0; i < fnMu; i++) {
-    cmax = fxyMu[i][6];
-    for (Int_t j = 0; j < nfit; j++) {
-      indx = j<2 ? j*2 : j*2+1;  
-      rad = (fxyMu[i][0]-parOk[indx])*(fxyMu[i][0]-parOk[indx]) +
-            (fxyMu[i][1]-parOk[indx+1])*(fxyMu[i][1]-parOk[indx+1]);
-      if (rad < cmax) {
-       cmax = rad; 
-       imax = indx;
-       fxyMu[i][6] = cmax;
-       fxyMu[i][2] = parOk[imax] - fxyMu[i][0];
-       fxyMu[i][4] = parOk[imax+1] - fxyMu[i][1];
-       fxyMu[i][3] = errOk[imax];
-       fxyMu[i][5] = errOk[imax+1];
-      }
-    }      
-  }
-}
-
-//_____________________________________________________________________________
-void AliMUONClusterDrawAZ::UpdateCluster(Int_t npad)
-{
-/// Update cluster after removing non-overlapped pads
-
-  Int_t cath = 0, ix = 0, iy = 0;
-  cout << " Update cluster " << endl;
-  gets((char*)&ix);
-  for (Int_t i = 0; i < npad; i++) {
-    if (TMath::Nint (fFind->GetXyq(2,i)) != -2) continue;
-    cath = fFind->GetIJ(0,i);
-    for (Int_t j = 0; j < 2; j++) {
-      Int_t ihist = cath * 2 + j;
-      if (!fHist[ihist]) continue;
-      ix = fHist[ihist]->GetXaxis()->FindBin(fFind->GetXyq(0,i));
-      iy = fHist[ihist]->GetYaxis()->FindBin(fFind->GetXyq(1,i));
-      Double_t cont = fHist[ihist]->GetCellContent(ix, iy);
-      if (cont < 0.1) continue;
-      fHist[ihist]->Fill(fFind->GetXyq(0,i), fFind->GetXyq(1,i), -cont);
-    }
-  }
-  TCanvas *c1 = (TCanvas*) gROOT->GetListOfCanvases()->FindObject("c1");
-  if (c1) {
-    c1->cd(1);
-    gPad->Modified();
-    gPad->Update();
-    c1->cd(2);
-    gPad->Modified();
-    gPad->Update();
-  }  
-}
-
-//_____________________________________________________________________________
-TH2D* AliMUONClusterDrawAZ::GetBackground(Int_t iHist)
-{
-/// Build histogram with pads from the cluster contaminated by the background
-
-  //return 0x0;
-  Int_t cath = iHist / 2;
-  Double_t xmin = fHist[iHist]->GetXaxis()->GetXmin();
-  Double_t xmax = fHist[iHist]->GetXaxis()->GetXmax();
-  Double_t ymin = fHist[iHist]->GetYaxis()->GetXmin();
-  Double_t ymax = fHist[iHist]->GetYaxis()->GetXmax();
-  
-  // Create histogram
-  char hName[4];
-  sprintf(hName,"Bkg%1d",iHist);
-  TH2D *hist = (TH2D*) gROOT->FindObject(hName);
-  if (hist) hist->Delete();
-  hist = (TH2D*) fHist[iHist]->Clone(hName);
-  hist->Reset();
-
-  // Loop over pads
-  Int_t digit = 0, iok = 0, ix = 0, iy = 0; 
-  AliMUONDigit *mdig = 0x0;
-  Double_t cont = 0, x = 0, y = 0; 
-  for (Int_t i = 0; i < fFind->GetNPads(0)+fFind->GetNPads(1); i++) {
-    if (fFind->GetIJ(0,i) != cath) continue;
-    x = fFind->GetXyq(0,i);
-    y = fFind->GetXyq(1,i);
-    if (x < xmin || x > xmax) continue;
-    if (y < ymin || y > ymax) continue;
-    digit = fFind->GetIJ(4,i);
-    if (digit >= 0) mdig = AliMUONClusterInput::Instance()->Digit(cath, digit);
-    else mdig = AliMUONClusterInput::Instance()->Digit(TMath::Even(cath), -digit-1);
-    if (mdig->Track(1) >= 0 || mdig->Track(0) >= 10000000) {
-      ix = fHist[iHist]->GetXaxis()->FindBin(x);
-      iy = fHist[iHist]->GetYaxis()->FindBin(y);
-      cont = fHist[iHist]->GetCellContent(ix, iy);
-      hist->Fill(x, y, cont);
-      iok = 1;
-    }
-  }
-  if (iok) { 
-    hist->SetFillColor(5); 
-    hist->SetMaximum(fHist[iHist]->GetMaximum());
-    return hist; 
-  }
-  return 0x0;
-}
diff --git a/MUON/AliMUONClusterDrawAZ.h b/MUON/AliMUONClusterDrawAZ.h
deleted file mode 100644 (file)
index 8c3f030..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef ALIMUONCLUSTERDRAWAZ_H
-#define ALIMUONCLUSTERDRAWAZ_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-/// \ingroup rec
-/// \class AliMUONClusterDrawAZ
-/// \brief Cluster drawing object for AZ cluster finder in MUON arm of ALICE
-///
-/// \author Alexander Zinchenko, JINR Dubna
-
-#include "AliMUONClusterDrawAZ.h"
-
-class TH2D;
-class AliMUONRecData;
-class AliMUONPixel;
-class AliMUONClusterFinderAZ;
-
-class AliMUONClusterDrawAZ : public TObject 
-{
-public:
-  AliMUONClusterDrawAZ(); // default constructor
-  AliMUONClusterDrawAZ(AliMUONClusterFinderAZ *clusFinder); // Constructor
-  virtual ~AliMUONClusterDrawAZ(); // Destructor
-
-  void     DrawCluster(); // draw precluster
-  void     AdjustHist(Double_t *xylim, const AliMUONPixel *pixPtr);
-  void     DrawHist(const char* canvas, TH2D *hist); // draw histogram in canvas
-  Int_t    Next(); // commands for drawing
-  Bool_t   FindEvCh(Int_t nev, Int_t ch); // find requested event and chamber
-  void     FillMuon(Int_t nfit, const Double_t *parOk, const Double_t *errOk); // fill muon info
-  void     ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } ///< reset muons
-  void     UpdateCluster(Int_t npad); // update cluster after removing non-overlapped pads
-
-private:
-  AliMUONRecData *fData; //!<  pointer to muon data container
-  AliMUONClusterFinderAZ* fFind; //!<  pointer to ClusterFinder
-  TH2D*      fHist[4]; //!<  histograms
-  Int_t      fnMu; //!<  number of muons passing thru the selected area
-  Double_t   fxyMu[2][7]; //!<  muon information
-  Int_t      fEvent; //!<  current event
-  Int_t      fChamber; //!<  current chamber
-  Int_t      fidDE; //!<  current Det. Elem.
-  Int_t      fDebug; //!<  debug level
-  Int_t      fModif; //!<  modification flag (modified ROOT)
-
-  // Functions
-
-  /// Not implemented
-  AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
-  /// Not implemented
-  AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
-
-  void   Init(); // initialization
-  void   ModifyHistos(); // modify histograms
-  // void   DrawHits(); // draw simulated and reconstructed hits
-  TH2D*  GetBackground(Int_t iHist); // build histogram with bkg. contaminated pads
-
-ClassDef(AliMUONClusterDrawAZ,0) // cluster drawing for MUON arm of ALICE
-};
-
-#endif
diff --git a/MUON/AliMUONClusterFinderVS.cxx b/MUON/AliMUONClusterFinderVS.cxx
deleted file mode 100644 (file)
index 883d3c3..0000000
+++ /dev/null
@@ -1,2102 +0,0 @@
-/**************************************************************************
- * 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 AliMUONClusterFinderVS
-// -------------------------------
-// Class for clustering and reconstruction of space points
-// (Not used by default)
-
-#include "AliMUONClusterFinderVS.h"
-#include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONGeometrySegmentation.h"
-#include "AliMUONMathieson.h"
-#include "AliMUONClusterInput.h"
-#include "AliMUONDigitMapA1.h"
-
-#include "AliLog.h"
-
-#include <TMinuit.h> 
-#include <TF1.h>
-#include <TMinuit.h> 
-#include <Riostream.h>
-
-
-//_____________________________________________________________________
-// This function is minimized in the double-Mathieson fit
-void fcnS2(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
-void fcnS1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
-void fcnCombiS1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
-void fcnCombiS2(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
-
-/// \cond CLASSIMP
-ClassImp(AliMUONClusterFinderVS)
-/// \endcond
-
-AliMUONClusterFinderVS::AliMUONClusterFinderVS()
-  : TObject(),
-    fInput(AliMUONClusterInput::Instance()),
-    fDeclusterFlag(0),
-    fClusterSize(0),
-    fNperMax(0),
-    fGhostChi2Cut(1e6),
-    fNPeaks(0),
-    fNRawClusters(0),
-    fRawClusters(0x0),
-    fZPlane(0.),
-    fSector(0),
-    fFitStat(0),
-    fEvtNumber(0)
-{
-/// Default constructor
-    fDigitMap[0] = 0;
-    fDigitMap[1] = 0;
-    fTrack[0]=fTrack[1]=-1;
-    fSeg2[0]    = 0;
-    fSeg2[1]    = 0;
-
-    for(Int_t i=0; i<100; i++) {
-      for (Int_t j=0; j<2; j++) {
-        fDig[i][j] = 0;
-      }
-    } 
-    fRawClusters = new TClonesArray("AliMUONRawCluster",1000);
-}
- //____________________________________________________________________________
-AliMUONClusterFinderVS::~AliMUONClusterFinderVS()
-{
-/// Destructor
-
-  // Reset tracks information
-   fNRawClusters = 0;
-   if (fRawClusters) {
-     fRawClusters->Delete();
-     delete fRawClusters;
-   }
-}
-
-//____________________________________________________________________________
-void AliMUONClusterFinderVS::ResetRawClusters()
-{
-/// Reset tracks information
-  fNRawClusters = 0;
-  if (fRawClusters) fRawClusters->Clear();
-}
-//____________________________________________________________________________
-void AliMUONClusterFinderVS::Decluster(AliMUONRawCluster *cluster)
-{
-/// Decluster by local maxima
-    SplitByLocalMaxima(cluster);
-}
-//____________________________________________________________________________
-void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
-{
-/// Split complex cluster by local maxima 
-    Int_t cath, i;
-
-    fInput->SetCluster(c);
-
-    fMul[0]=c->GetMultiplicity(0);
-    fMul[1]=c->GetMultiplicity(1);
-
-//
-//  dump digit information into arrays
-//
-
-    Float_t qtot;
-    
-    for (cath=0; cath<2; cath++) {
-      qtot=0;
-
-      for (i=0; i<fMul[cath]; i++) {
-       // pointer to digit
-       fDig[i][cath]=fInput->Digit(cath, c->GetIndex(i, cath));
-       // pad coordinates
-       fIx[i][cath]= fDig[i][cath]->PadX();
-       fIy[i][cath]= fDig[i][cath]->PadY();
-       // pad charge
-       fQ[i][cath] = fDig[i][cath]->Signal();
-       // pad centre coordinates
-         fSeg2[cath]->
-           GetPadC(fInput->DetElemId(), fIx[i][cath], fIy[i][cath], fX[i][cath], fY[i][cath], fZ[i][cath]);
-      } // loop over cluster digits
-
-    }  // loop over cathodes
-
-
-    FindLocalMaxima(c);
-
-//
-//  Initialise and perform mathieson fits
-    Float_t chi2, oldchi2;
-//  ++++++++++++++++++*************+++++++++++++++++++++
-//  (1) No more than one local maximum per cathode plane 
-//  +++++++++++++++++++++++++++++++*************++++++++
-    if ((fNLocal[0]==1 && (fNLocal[1]==0 ||  fNLocal[1]==1)) || 
-       (fNLocal[0]==0 && fNLocal[1]==1)) {
-// Perform combined single Mathieson fit
-// Initial values for coordinates (x,y) 
-
-       // One local maximum on cathodes 1 and 2 (X->cathode 2, Y->cathode 1)
-       if (fNLocal[0]==1 &&  fNLocal[1]==1) {
-           fXInit[0]=c->GetX(1);
-           fYInit[0]=c->GetY(0);
-           // One local maximum on cathode 1 (X,Y->cathode 1)
-       } else if (fNLocal[0]==1) {
-           fXInit[0]=c->GetX(0);
-           fYInit[0]=c->GetY(0);
-           // One local maximum on cathode 2  (X,Y->cathode 2)
-       } else {
-           fXInit[0]=c->GetX(1);
-           fYInit[0]=c->GetY(1);
-       }
-       AliDebug(1,"cas (1) CombiSingleMathiesonFit(c)");
-       chi2=CombiSingleMathiesonFit(c);
-//     Int_t ndf = fgNbins[0]+fgNbins[1]-2;
-//     Float_t prob = TMath::Prob(Double_t(chi2),ndf);
-//     prob1->Fill(prob);
-//     chi2_1->Fill(chi2);
-       oldchi2=chi2;
-       AliDebug(1,Form(" chi2 %f ",chi2));        
-
-       c->SetX(0, fXFit[0]);
-       c->SetY(0, fYFit[0]);
-
-       c->SetX(1,fXFit[0]);
-       c->SetY(1,fYFit[0]);
-       c->SetChi2(0,chi2);
-       c->SetChi2(1,chi2);
-        // Force on anod
-
-       c->SetX(0, fSeg2[0]->GetAnod(fInput->DetElemId(), c->GetX(0)));
-       c->SetX(1, fSeg2[1]->GetAnod(fInput->DetElemId(), c->GetX(1)));
-
-       //      c->SetDetElemId(fInput->DetElemId());
-       // If reasonable chi^2 add result to the list of rawclusters
-       if (chi2 < 0.3) {
-           AddRawCluster(*c);
-           // If not try combined double Mathieson Fit
-       } else {
-               AliDebug(1," MAUVAIS CHI2 !!!\n");
-           if (fNLocal[0]==1 &&  fNLocal[1]==1) {
-               fXInit[0]=fX[fIndLocal[0][1]][1];
-               fYInit[0]=fY[fIndLocal[0][0]][0];
-               fXInit[1]=fX[fIndLocal[0][1]][1];
-               fYInit[1]=fY[fIndLocal[0][0]][0];
-           } else if (fNLocal[0]==1) {
-               fXInit[0]=fX[fIndLocal[0][0]][0];
-               fYInit[0]=fY[fIndLocal[0][0]][0];
-               fXInit[1]=fX[fIndLocal[0][0]][0];
-               fYInit[1]=fY[fIndLocal[0][0]][0];
-           } else {
-               fXInit[0]=fX[fIndLocal[0][1]][1];
-               fYInit[0]=fY[fIndLocal[0][1]][1];
-               fXInit[1]=fX[fIndLocal[0][1]][1];
-               fYInit[1]=fY[fIndLocal[0][1]][1];
-           }
-           
-//  Initial value for charge ratios
-           fQrInit[0]=0.5;
-           fQrInit[1]=0.5;
-           AliDebug(1,"\n cas (1) CombiDoubleMathiesonFit(c)\n");
-           chi2=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi2);
-           
-// Was this any better ??
-           AliDebug(1,Form(" Old and new chi2 %f %f ", oldchi2, chi2));
-           if (fFitStat!=0 && chi2>0 && (2.*chi2 < oldchi2)) {
-             AliDebug(1,"Split");
-               // Split cluster into two according to fit result
-               Split(c);
-           } else {
-             AliDebug(1,"Do not Split");
-               // Don't split
-             AddRawCluster(*c);
-           }
-       }
-
-//  +++++++++++++++++++++++++++++++++++++++
-//  (2) Two local maxima per cathode plane 
-//  +++++++++++++++++++++++++++++++++++++++
-    } else if (fNLocal[0]==2 &&  fNLocal[1]==2) {
-//
-//  Let's look for ghosts first 
-
-       Float_t xm[4][2], ym[4][2];
-       Float_t dpx, dpy, dx, dy;
-       Int_t ixm[4][2], iym[4][2];
-       Int_t isec, im1, im2, ico;
-//
-//  Form the 2x2 combinations
-//  0-0, 0-1, 1-0, 1-1 
-        ico=0;
-       for (im1=0; im1<2; im1++) {
-           for (im2=0; im2<2; im2++) {     
-               xm[ico][0]=fX[fIndLocal[im1][0]][0];
-               ym[ico][0]=fY[fIndLocal[im1][0]][0];
-               xm[ico][1]=fX[fIndLocal[im2][1]][1];
-               ym[ico][1]=fY[fIndLocal[im2][1]][1];
-
-               ixm[ico][0]=fIx[fIndLocal[im1][0]][0];
-               iym[ico][0]=fIy[fIndLocal[im1][0]][0];
-               ixm[ico][1]=fIx[fIndLocal[im2][1]][1];
-               iym[ico][1]=fIy[fIndLocal[im2][1]][1];
-               ico++;
-           }
-       }
-// ico = 0 : first local maximum on cathodes 1 and 2
-// ico = 1 : fisrt local maximum on cathode 1 and second on cathode 2
-// ico = 2 : second local maximum on cathode 1 and first on cathode 1
-// ico = 3 : second local maximum on cathodes 1 and 2
-
-// Analyse the combinations and keep those that are possible !
-// For each combination check consistency in x and y   
-       Int_t   iacc;
-       Bool_t  accepted[4];
-       Float_t dr[4] = {1.e4, 1.e4, 1.e4, 1.e4};
-       iacc=0;
-
-// In case of staggering maxima are displaced by exactly half the pad-size in y. 
-// We have to take into account the numerical precision in the consistency check;      
-       Float_t eps = 1.e-5;
-//
-       for (ico=0; ico<4; ico++) {
-           accepted[ico]=kFALSE;
-// cathode one: x-coordinate
-           isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-           dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-          
-           dx=TMath::Abs(xm[ico][0]-xm[ico][1]);
-// cathode two: y-coordinate
-
-           isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-           dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           
-           dy=TMath::Abs(ym[ico][0]-ym[ico][1]);
-           AliDebug(2,Form("\n %i %f %f %f %f %f %f \n", ico, ym[ico][0], ym[ico][1], dy, dpy, dx, dpx ));
-           if ((dx <= dpx) && (dy <= dpy+eps)) {
-               // consistent
-               accepted[ico]=kTRUE;
-               dr[ico] = TMath::Sqrt(dx*dx+dy*dy);
-               iacc++;
-           } else {
-               // reject
-               accepted[ico]=kFALSE;
-           }
-       }
-       AliDebug(1,Form("\n iacc= %d:\n", iacc));
-       if (iacc == 3) {
-           if (accepted[0] && accepted[1]) {
-               if (dr[0] >= dr[1]) {
-                   accepted[0]=kFALSE;
-               } else {
-                   accepted[1]=kFALSE;
-               }
-           }
-
-           if (accepted[2] && accepted[3]) {
-               if (dr[2] >= dr[3]) {
-                   accepted[2]=kFALSE;
-               } else {
-                   accepted[3]=kFALSE;
-               }
-           }
-/*         
-// eliminate one candidate
-           Float_t drmax = 0;
-           Int_t icobad = -1;
-
-           for (ico=0; ico<4; ico++) {
-               if (accepted[ico] && dr[ico] > drmax) {
-                   icobad = ico;
-                   drmax  = dr[ico];
-               }
-           }
-           
-           accepted[icobad] = kFALSE;
-*/
-           iacc = 2;
-       }
-       
-       
-       AliDebug(1,Form("\n iacc= %d:\n", iacc));
-       if (iacc==2) {
-               AliDebug(1,"\n iacc=2: No problem ! \n");
-       } else if (iacc==4) {
-               AliDebug(1,"\n iacc=4: Ok, but ghost problem !!! \n");
-       } else if (iacc==0) {
-               AliDebug(1,"\n iacc=0: I don't know what to do with this !!!!!!!!! \n");
-       }
-
-//  Initial value for charge ratios
-       fQrInit[0]=Float_t(fQ[fIndLocal[0][0]][0])/
-           Float_t(fQ[fIndLocal[0][0]][0]+fQ[fIndLocal[1][0]][0]);
-       fQrInit[1]=Float_t(fQ[fIndLocal[0][1]][1])/
-           Float_t(fQ[fIndLocal[0][1]][1]+fQ[fIndLocal[1][1]][1]);
-       
-// ******* iacc = 0 *******
-// No combinations found between the 2 cathodes
-// We keep the center of gravity of the cluster
-       if (iacc==0) {
-         AddRawCluster(*c);
-       }
-
-// ******* iacc = 1 *******
-// Only one combination found between the 2 cathodes
-       if (iacc==1) {
-// Initial values for the 2 maxima (x,y)
-
-// 1 maximum is initialised with the maximum of the combination found (X->cathode 2, Y->cathode 1)
-// 1 maximum is initialised with the other maximum of the first cathode  
-           if (accepted[0]){
-               AliDebug(1,"ico=0");
-               fXInit[0]=xm[0][1];
-               fYInit[0]=ym[0][0];
-               fXInit[1]=xm[3][0];
-               fYInit[1]=ym[3][0];
-           } else if (accepted[1]){
-               AliDebug(1,"ico=1");
-               fXInit[0]=xm[1][1];
-               fYInit[0]=ym[1][0];
-               fXInit[1]=xm[2][0];
-               fYInit[1]=ym[2][0];
-           } else if (accepted[2]){
-               AliDebug(1,"ico=2");
-               fXInit[0]=xm[2][1];
-               fYInit[0]=ym[2][0];
-               fXInit[1]=xm[1][0];
-               fYInit[1]=ym[1][0];
-           } else if (accepted[3]){
-               AliDebug(1,"ico=3");
-               fXInit[0]=xm[3][1];
-               fYInit[0]=ym[3][0];
-               fXInit[1]=xm[0][0];
-               fYInit[1]=ym[0][0];
-           }
-               AliDebug(1,"cas (2) CombiDoubleMathiesonFit(c)");
-           chi2=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi2);
-           AliDebug(1,Form(" chi2 %f\n",chi2));
-
-// If reasonable chi^2 add result to the list of rawclusters
-           if (chi2<10) {
-               Split(c);
-
-           } else {
-// 1 maximum is initialised with the maximum of the combination found (X->cathode 2, Y->cathode 1)
-// 1 maximum is initialised with the other maximum of the second cathode  
-               if (accepted[0]){
-                       AliDebug(1,"ico=0");
-                   fXInit[0]=xm[0][1];
-                   fYInit[0]=ym[0][0];
-                   fXInit[1]=xm[3][1];
-                   fYInit[1]=ym[3][1];
-               } else if (accepted[1]){
-                       AliDebug(1,"ico=1");
-                   fXInit[0]=xm[1][1];
-                   fYInit[0]=ym[1][0];
-                   fXInit[1]=xm[2][1];
-                   fYInit[1]=ym[2][1];
-               } else if (accepted[2]){
-                       AliDebug(1,"ico=2");
-                   fXInit[0]=xm[2][1];
-                   fYInit[0]=ym[2][0];
-                   fXInit[1]=xm[1][1];
-                   fYInit[1]=ym[1][1];
-               } else if (accepted[3]){
-                       AliDebug(1,"ico=3");
-                   fXInit[0]=xm[3][1];
-                   fYInit[0]=ym[3][0];
-                   fXInit[1]=xm[0][1];
-                   fYInit[1]=ym[0][1];
-               }
-               AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
-               chi2=CombiDoubleMathiesonFit(c);
-//             Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//             Float_t prob = TMath::Prob(chi2,ndf);
-//             prob2->Fill(prob);
-//             chi2_2->Fill(chi2);
-               AliDebug(1,Form(" chi2 %f\n",chi2));
-
-// If reasonable chi^2 add result to the list of rawclusters
-               if (chi2<10) {
-                   Split(c);
-               } else {
-//We keep only the combination found (X->cathode 2, Y->cathode 1)
-                   for (Int_t ico=0; ico<2; ico++) {
-                       if (accepted[ico]) {
-                           AliMUONRawCluster cnew;
-                           Int_t cath;    
-                           for (cath=0; cath<2; cath++) {
-                               cnew.SetX(cath, Float_t(xm[ico][1]));
-                               cnew.SetY(cath, Float_t(ym[ico][0]));
-                               cnew.SetZ(cath, fZPlane);
-                               cnew.SetMultiplicity(cath,c->GetMultiplicity(cath));
-                               for (i=0; i<fMul[cath]; i++) {
-                                 cnew.SetIndex(i, cath, c->GetIndex(i,cath));
-                                 fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
-                               }
-                               AliDebug(1,Form("\nRawCluster %d cath %d\n",ico,cath));
-                               AliDebug(1,Form("mult_av %d\n",c->GetMultiplicity(cath)));
-                               FillCluster(&cnew,cath);
-                           } 
-                           cnew.SetClusterType(cnew.PhysicsContribution());
-                           AddRawCluster(cnew);
-                           fNPeaks++;
-                       }
-                   }
-               }
-           }
-       }
-       
-// ******* iacc = 2 *******
-// Two combinations found between the 2 cathodes
-       if (iacc==2) {
-// Was the same maximum taken twice
-           if ((accepted[0]&&accepted[1]) || (accepted[2]&&accepted[3])) {
-               AliDebug(1,"\n Maximum taken twice !!!\n");
-
-// Have a try !! with that
-               if (accepted[0]&&accepted[3]) {
-                   fXInit[0]=xm[0][1];
-                   fYInit[0]=ym[0][0];
-                   fXInit[1]=xm[1][1];
-                   fYInit[1]=ym[1][0];
-               } else {
-                   fXInit[0]=xm[2][1];
-                   fYInit[0]=ym[2][0];
-                   fXInit[1]=xm[3][1];
-                   fYInit[1]=ym[3][0];
-               }
-               AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
-               chi2=CombiDoubleMathiesonFit(c);
-//                 Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//                 Float_t prob = TMath::Prob(chi2,ndf);
-//                 prob2->Fill(prob);
-//                 chi2_2->Fill(chi2);
-               Split(c);
-               
-           } else {
-// No ghosts ! No Problems ! -  Perform one fit only !
-               if (accepted[0]&&accepted[3]) {
-                   fXInit[0]=xm[0][1];
-                   fYInit[0]=ym[0][0];
-                   fXInit[1]=xm[3][1];
-                   fYInit[1]=ym[3][0];
-               } else {
-                   fXInit[0]=xm[1][1];
-                   fYInit[0]=ym[1][0];
-                   fXInit[1]=xm[2][1];
-                   fYInit[1]=ym[2][0];
-               }
-               AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
-               chi2=CombiDoubleMathiesonFit(c);
-//                 Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//                 Float_t prob = TMath::Prob(chi2,ndf);
-//                 prob2->Fill(prob);
-//                 chi2_2->Fill(chi2);
-               AliDebug(1,Form(" chi2 %f\n",chi2));
-               Split(c);
-           }
-           
-// ******* iacc = 4 *******
-// Four combinations found between the 2 cathodes
-// Ghost !!
-       } else if (iacc==4) {
-// Perform fits for the two possibilities !!   
-// Accept if charges are compatible on both cathodes
-// If none are compatible, keep everything
-           fXInit[0]=xm[0][1];
-           fYInit[0]=ym[0][0];
-           fXInit[1]=xm[3][1];
-           fYInit[1]=ym[3][0];
-           AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
-           chi2=CombiDoubleMathiesonFit(c);
-//             Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//             Float_t prob = TMath::Prob(chi2,ndf);
-//             prob2->Fill(prob);
-//             chi2_2->Fill(chi2);
-           AliDebug(1,Form(" chi2 %f\n",chi2));
-           // store results of fit and postpone decision
-           Double_t sXFit[2],sYFit[2],sQrFit[2];
-           Float_t sChi2[2];
-           for (Int_t i=0;i<2;i++) {
-               sXFit[i]=fXFit[i];
-               sYFit[i]=fYFit[i];
-               sQrFit[i]=fQrFit[i];
-               sChi2[i]=fChi2[i];
-           }
-           fXInit[0]=xm[1][1];
-           fYInit[0]=ym[1][0];
-           fXInit[1]=xm[2][1];
-           fYInit[1]=ym[2][0];
-           AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
-           chi2=CombiDoubleMathiesonFit(c);
-//             ndf = fgNbins[0]+fgNbins[1]-6;
-//             prob = TMath::Prob(chi2,ndf);
-//             prob2->Fill(prob);
-//             chi2_2->Fill(chi2);
-           AliDebug(1,Form(" chi2 %f\n",chi2));
-           // We have all informations to perform the decision
-           // Compute the chi2 for the 2 possibilities
-           Float_t chi2fi,chi2si,chi2f,chi2s;
-
-           chi2f = (TMath::Log(fInput->TotalCharge(0)*fQrFit[0]
-                 /  (fInput->TotalCharge(1)*fQrFit[1]) )
-                 / fInput->ChargeCorrel() );
-           chi2f *=chi2f;
-           chi2fi = (TMath::Log(fInput->TotalCharge(0)*(1-fQrFit[0])
-                 /  (fInput->TotalCharge(1)*(1-fQrFit[1])) )
-                 / fInput->ChargeCorrel() );
-           chi2f += chi2fi*chi2fi;
-
-           chi2s = (TMath::Log(fInput->TotalCharge(0)*sQrFit[0]
-                 /  (fInput->TotalCharge(1)*sQrFit[1]) )
-                 / fInput->ChargeCorrel() );
-           chi2s *=chi2s;
-           chi2si = (TMath::Log(fInput->TotalCharge(0)*(1-sQrFit[0])
-                 /  (fInput->TotalCharge(1)*(1-sQrFit[1])) )
-                 / fInput->ChargeCorrel() );
-           chi2s += chi2si*chi2si;
-
-           // usefull to store the charge matching chi2 in the cluster
-           // fChi2[0]=sChi2[1]=chi2f;
-           // fChi2[1]=sChi2[0]=chi2s;
-
-           if (chi2f<=fGhostChi2Cut && chi2s<=fGhostChi2Cut)
-               c->SetGhost(1);
-           if   (chi2f>fGhostChi2Cut && chi2s>fGhostChi2Cut) {
-               // we keep the ghost
-               c->SetGhost(2);
-               chi2s=-1;
-               chi2f=-1;
-           }
-           if (chi2f<=fGhostChi2Cut)
-               Split(c);
-           if (chi2s<=fGhostChi2Cut) {
-               // retreive saved values
-               for (Int_t i=0;i<2;i++) {
-                   fXFit[i]=sXFit[i];
-                   fYFit[i]=sYFit[i];
-                   fQrFit[i]=sQrFit[i];
-                   fChi2[i]=sChi2[i];
-               }
-               Split(c);
-           }
-           c->SetGhost(0);
-       }
-
-    } else if (fNLocal[0]==2 &&  fNLocal[1]==1) {
-//  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//  (3) Two local maxima on cathode 1 and one maximum on cathode 2 
-//  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//
-       Float_t xm[4][2], ym[4][2];
-       Float_t dpx, dpy, dx, dy;
-       Int_t ixm[4][2], iym[4][2];
-       Int_t isec, im1, ico;
-//
-//  Form the 2x2 combinations
-//  0-0, 0-1, 1-0, 1-1 
-        ico=0;
-       for (im1=0; im1<2; im1++) {
-           xm[ico][0]=fX[fIndLocal[im1][0]][0];
-           ym[ico][0]=fY[fIndLocal[im1][0]][0];
-           xm[ico][1]=fX[fIndLocal[0][1]][1];
-           ym[ico][1]=fY[fIndLocal[0][1]][1];
-           
-           ixm[ico][0]=fIx[fIndLocal[im1][0]][0];
-           iym[ico][0]=fIy[fIndLocal[im1][0]][0];
-           ixm[ico][1]=fIx[fIndLocal[0][1]][1];
-           iym[ico][1]=fIy[fIndLocal[0][1]][1];
-           ico++;
-       }
-// ico = 0 : first local maximum on cathodes 1 and 2
-// ico = 1 : second local maximum on cathode 1 and first on cathode 2
-
-// Analyse the combinations and keep those that are possible !
-// For each combination check consistency in x and y   
-       Int_t iacc;
-       Bool_t accepted[4];
-       iacc=0;
-       // In case of staggering maxima are displaced by exactly half the pad-size in y. 
-        // We have to take into account the numerical precision in the consistency check;
-       
-       Float_t eps = 1.e-5;
-
-       for (ico=0; ico<2; ico++) {
-           isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-           dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           
-           dx=TMath::Abs(xm[ico][0]-xm[ico][1]);
-           isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-           dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-          
-           dy=TMath::Abs(ym[ico][0]-ym[ico][1]);
-           AliDebug(2,Form("\n %i %f %f %f %f \n", ico, ym[ico][0], ym[ico][1], dy, dpy ));
-           if ((dx <= dpx) && (dy <= dpy+eps)) {
-               // consistent
-               accepted[ico]=kTRUE;
-               iacc++;
-           } else {
-               // reject
-               accepted[ico]=kFALSE;
-           }
-       }
-       
-       Float_t chi21 = 100;
-       Float_t chi22 = 100;
-       Float_t chi23 = 100;
-
-       //  Initial value for charge ratios
-       fQrInit[0]=Float_t(fQ[fIndLocal[0][0]][0])/
-           Float_t(fQ[fIndLocal[0][0]][0]+fQ[fIndLocal[1][0]][0]);
-       fQrInit[1]=fQrInit[0];
-       
-       if (accepted[0] && accepted[1]) {
-           
-           fXInit[0]=0.5*(xm[0][1]+xm[0][0]);
-           fYInit[0]=ym[0][0];
-           fXInit[1]=0.5*(xm[0][1]+xm[1][0]);
-           fYInit[1]=ym[1][0];
-           fQrInit[0]=0.5;
-           fQrInit[1]=0.5;
-           chi23=CombiDoubleMathiesonFit(c);
-           if (chi23<10) {
-               Split(c);
-               Float_t yst;
-               yst = fYFit[0];
-               fYFit[0] = fYFit[1];
-               fYFit[1] = yst;
-               Split(c);
-           }
-       } else if (accepted[0]) {
-           fXInit[0]=xm[0][1];
-           fYInit[0]=ym[0][0];
-           fXInit[1]=xm[1][0];
-           fYInit[1]=ym[1][0];
-           chi21=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi21);
-           AliDebug(1,Form(" chi2 %f\n",chi21));
-           if (chi21<10) Split(c);
-       } else if (accepted[1]) {
-           fXInit[0]=xm[1][1];
-           fYInit[0]=ym[1][0];
-           fXInit[1]=xm[0][0];
-           fYInit[1]=ym[0][0];
-           chi22=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi22);
-           AliDebug(1,Form(" chi2 %f\n",chi22));
-           if (chi22<10) Split(c);
-       }
-
-       if (chi21 > 10 && chi22 > 10 && chi23 > 10) {
-// We keep only the combination found (X->cathode 2, Y->cathode 1)
-           for (Int_t ico=0; ico<2; ico++) {
-               if (accepted[ico]) {
-                   AliMUONRawCluster cnew;
-                   Int_t cath;    
-                   for (cath=0; cath<2; cath++) {
-                       cnew.SetX(cath, Float_t(xm[ico][1]));
-                       cnew.SetY(cath, Float_t(ym[ico][0]));
-                       cnew.SetZ(cath, fZPlane);
-                       cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
-                       for (i=0; i<fMul[cath]; i++) {
-                           cnew.SetIndex(i, cath, c->GetIndex(i, cath));
-                           fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
-
-                       }
-                       AliDebug(1,Form("\nRawCluster %d cath %d\n",ico,cath));
-                       AliDebug(1,Form("mult_av %d\n",c->GetMultiplicity(cath)));
-                       
-                       FillCluster(&cnew,cath);
-                   } 
-                   cnew.SetClusterType(cnew.PhysicsContribution());
-                   AddRawCluster(cnew);
-                   fNPeaks++;
-               }
-           }
-       }
-       
-//  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//  (3') One local maximum on cathode 1 and two maxima on cathode 2 
-//  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    } else if (fNLocal[0]==1 && fNLocal[1]==2) {
-       Float_t xm[4][2], ym[4][2];
-       Float_t dpx, dpy, dx, dy;
-       Int_t ixm[4][2], iym[4][2];
-       Int_t isec, im1, ico;
-//
-//  Form the 2x2 combinations
-//  0-0, 0-1, 1-0, 1-1 
-        ico=0;
-       for (im1=0; im1<2; im1++) {
-           xm[ico][0]=fX[fIndLocal[0][0]][0];
-           ym[ico][0]=fY[fIndLocal[0][0]][0];
-           xm[ico][1]=fX[fIndLocal[im1][1]][1];
-           ym[ico][1]=fY[fIndLocal[im1][1]][1];
-           
-           ixm[ico][0]=fIx[fIndLocal[0][0]][0];
-           iym[ico][0]=fIy[fIndLocal[0][0]][0];
-           ixm[ico][1]=fIx[fIndLocal[im1][1]][1];
-           iym[ico][1]=fIy[fIndLocal[im1][1]][1];
-           ico++;
-       }
-// ico = 0 : first local maximum on cathodes 1 and 2
-// ico = 1 : first local maximum on cathode 1 and second on cathode 2
-
-// Analyse the combinations and keep those that are possible !
-// For each combination check consistency in x and y   
-       Int_t iacc;
-       Bool_t accepted[4];
-       iacc=0;
-        // In case of staggering maxima are displaced by exactly half the pad-size in y. 
-        // We have to take into account the numerical precision in the consistency check;      
-       Float_t eps = 1.e-5;
-
-       
-       for (ico=0; ico<2; ico++) {
-           accepted[ico]=kFALSE;
-           isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-           dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-          
-           dx=TMath::Abs(xm[ico][0]-xm[ico][1]);
-           isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-           dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           
-           dy=TMath::Abs(ym[ico][0]-ym[ico][1]);
-           AliDebug(1,Form("\n %i %f %f %f %f \n", ico, ym[ico][0], ym[ico][1], dy, dpy ));
-           if ((dx <= dpx) && (dy <= dpy+eps)) {
-               // consistent
-               accepted[ico]=kTRUE;
-               AliDebug(1,Form("ico %d\n",ico));
-               iacc++;
-           } else {
-               // reject
-               accepted[ico]=kFALSE;
-           }
-       }
-
-       Float_t chi21 = 100;
-       Float_t chi22 = 100;
-       Float_t chi23 = 100;
-
-       fQrInit[1]=Float_t(fQ[fIndLocal[0][1]][1])/
-           Float_t(fQ[fIndLocal[0][1]][1]+fQ[fIndLocal[1][1]][1]);
-       
-       fQrInit[0]=fQrInit[1];
-
-       
-       if (accepted[0] && accepted[1]) {
-           fXInit[0]=xm[0][1];
-           fYInit[0]=0.5*(ym[0][0]+ym[0][1]);
-           fXInit[1]=xm[1][1];
-           fYInit[1]=0.5*(ym[0][0]+ym[1][1]);
-           fQrInit[0]=0.5;
-           fQrInit[1]=0.5;
-           chi23=CombiDoubleMathiesonFit(c);
-           if (chi23<10) {
-               Split(c);
-               Float_t yst;
-               yst = fYFit[0];
-               fYFit[0] = fYFit[1];
-               fYFit[1] = yst;
-               Split(c);
-           }
-       } else if (accepted[0]) {
-           fXInit[0]=xm[0][0];
-           fYInit[0]=ym[0][1];
-           fXInit[1]=xm[1][1];
-           fYInit[1]=ym[1][1];
-           chi21=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi21);
-           AliDebug(1,Form(" chi2 %f\n",chi21));
-           if (chi21<10) Split(c);
-       } else if (accepted[1]) {
-           fXInit[0]=xm[1][0];
-           fYInit[0]=ym[1][1];
-           fXInit[1]=xm[0][1];
-           fYInit[1]=ym[0][1];
-           chi22=CombiDoubleMathiesonFit(c);
-//         Int_t ndf = fgNbins[0]+fgNbins[1]-6;
-//         Float_t prob = TMath::Prob(chi2,ndf);
-//         prob2->Fill(prob);
-//         chi2_2->Fill(chi22);
-           AliDebug(1,Form(" chi2 %f\n",chi22));
-           if (chi22<10) Split(c);
-       }
-
-       if (chi21 > 10 && chi22 > 10 && chi23 > 10) {
-//We keep only the combination found (X->cathode 2, Y->cathode 1)
-           for (Int_t ico=0; ico<2; ico++) {
-               if (accepted[ico]) {
-                   AliMUONRawCluster cnew;
-                   Int_t cath;    
-                   for (cath=0; cath<2; cath++) {
-                       cnew.SetX(cath, Float_t(xm[ico][1]));
-                       cnew.SetY(cath, Float_t(ym[ico][0]));
-                       cnew.SetZ(cath, fZPlane);
-                       cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
-                       for (i=0; i<fMul[cath]; i++) {
-                         cnew.SetIndex(i, cath, c->GetIndex(i, cath));
-                         fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
-                       }
-                       AliDebug(1,Form("\nRawCluster %d cath %d\n",ico,cath));
-                       AliDebug(1,Form("mult_av %d\n",c->GetMultiplicity(cath)));
-                       FillCluster(&cnew,cath);
-                   } 
-                   cnew.SetClusterType(cnew.PhysicsContribution());
-                   AddRawCluster(cnew);
-                   fNPeaks++;
-               }
-           }
-       }
-
-//  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//  (4) At least three local maxima on cathode 1 or on cathode 2 
-//  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    } else if (fNLocal[0]>2 || fNLocal[1]>2) {
-       Int_t param = fNLocal[0]*fNLocal[1];
-       Int_t ii;
-
-       Float_t ** xm = new Float_t * [param];
-       for (ii=0; ii<param; ii++) xm[ii]=new Float_t [2];
-       Float_t ** ym = new Float_t * [param];
-       for (ii=0; ii<param; ii++) ym[ii]=new Float_t [2];
-       Int_t ** ixm = new Int_t * [param];
-       for (ii=0; ii<param; ii++) ixm[ii]=new Int_t [2];
-       Int_t ** iym = new Int_t * [param];
-       for (ii=0; ii<param; ii++) iym[ii]=new Int_t [2];
-       
-       Int_t isec, ico;
-       Float_t dpx, dpy, dx, dy;
-
-        ico=0;
-       for (Int_t im1=0; im1<fNLocal[0]; im1++) {
-           for (Int_t im2=0; im2<fNLocal[1]; im2++) {
-               xm[ico][0]=fX[fIndLocal[im1][0]][0];
-               ym[ico][0]=fY[fIndLocal[im1][0]][0];
-               xm[ico][1]=fX[fIndLocal[im2][1]][1];
-               ym[ico][1]=fY[fIndLocal[im2][1]][1];
-
-               ixm[ico][0]=fIx[fIndLocal[im1][0]][0];
-               iym[ico][0]=fIy[fIndLocal[im1][0]][0];
-               ixm[ico][1]=fIx[fIndLocal[im2][1]][1];
-               iym[ico][1]=fIy[fIndLocal[im2][1]][1];
-               ico++;
-           }
-       }
-       
-       Int_t nIco = ico;
-       AliDebug(1,Form("nIco %d\n",nIco));
-       for (ico=0; ico<nIco; ico++) {
-           AliDebug(1,Form("ico = %d\n",ico));
-           isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-           dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           
-           dx=TMath::Abs(xm[ico][0]-xm[ico][1]);
-           isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-           dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           
-           dy=TMath::Abs(ym[ico][0]-ym[ico][1]);
-               AliDebug(1,Form("dx %f dpx %f dy %f dpy %f\n",dx,dpx,dy,dpy));
-               AliDebug(1,Form("  X %f Y %f\n",xm[ico][1],ym[ico][0]));
-           if ((dx <= dpx) && (dy <= dpy)) {
-                       AliDebug(1,"ok\n");
-               Int_t cath;    
-               AliMUONRawCluster cnew;
-               for (cath=0; cath<2; cath++) {
-                   cnew.SetX(cath, Float_t(xm[ico][1]));
-                   cnew.SetY(cath, Float_t(ym[ico][0]));
-                   cnew.SetZ(cath, fZPlane);
-                   cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
-                   for (i=0; i<fMul[cath]; i++) {
-                       cnew.SetIndex(i, cath, c->GetIndex(i, cath));
-                       fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
-                   }
-                   FillCluster(&cnew,cath);
-               } 
-               cnew.SetClusterType(cnew.PhysicsContribution());
-               //              cnew.SetDetElemId(fInput->DetElemId());
-               AddRawCluster(cnew);
-               fNPeaks++;
-           }
-       }
-       delete [] xm;
-       delete [] ym;
-       delete [] ixm;
-       delete [] iym;
-    }
-}
-
-void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
-{
-/// Find all local maxima of a cluster
-    AliDebug(1,"\n Find Local maxima  !");
-    
-    AliMUONDigit* digt;
-    
-    Int_t cath, cath1; // loops over cathodes
-    Int_t i;           // loops over digits
-    Int_t j;           // loops over cathodes
-//
-//  Find local maxima
-//
-//  counters for number of local maxima
-    fNLocal[0]=fNLocal[1]=0;
-//  flags digits as local maximum
-    Bool_t isLocal[100][2];
-    for (i=0; i<100;i++) {
-       isLocal[i][0]=isLocal[i][1]=kFALSE;
-    }
-//  number of next neighbours and arrays to store them 
-    Int_t nn;
-    Int_t x[10], y[10];
-    // loop over cathodes
-    for (cath=0; cath<2; cath++) {
-      // loop over cluster digits
-      for (i=0; i<fMul[cath]; i++) {
-       // get neighbours for that digit and assume that it is local maximum
-       Int_t isec;
-       Float_t a0;
-
-       fSeg2[cath]->Neighbours(fInput->DetElemId(), fIx[i][cath], fIy[i][cath], &nn, x, y);
-         
-       isLocal[i][cath]=kTRUE;
-       isec = fSeg2[cath]->Sector(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
-       a0   = fSeg2[cath]->Dpx(fInput->DetElemId(), isec)*fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-       
-       // loop over next neighbours, if at least one neighbour has higher charger assumption
-       // digit is not local maximum 
-       for (j=0; j<nn; j++) {
-         if (fDigitMap[cath]->TestHit(x[j], y[j])==kEmpty) continue;
-         digt=(AliMUONDigit*) fDigitMap[cath]->GetHit(x[j], y[j]);
-         Float_t a1;
-         isec=fSeg2[cath]->Sector(fInput->DetElemId(), x[j], y[j]);
-         a1 = fSeg2[cath]->Dpx(fInput->DetElemId(),isec)*fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-        
-         if (digt->Signal()/a1 > fQ[i][cath]/a0) {
-           isLocal[i][cath]=kFALSE;
-           break;
-           //
-           // handle special case of neighbouring pads with equal signal
-         } else if (digt->Signal() == fQ[i][cath]) {
-           if (fNLocal[cath]>0) {
-             for (Int_t k=0; k<fNLocal[cath]; k++) {
-               if (x[j]==fIx[fIndLocal[k][cath]][cath] 
-                   && y[j]==fIy[fIndLocal[k][cath]][cath])
-                 {
-                   isLocal[i][cath]=kFALSE;
-                 } 
-             } // loop over local maxima
-           } // are there already local maxima
-         } // same charge ? 
-       } // loop over next neighbours
-       if (isLocal[i][cath]) {
-         fIndLocal[fNLocal[cath]][cath]=i;
-         fNLocal[cath]++;
-       } 
-      } // loop over all digits
-    } // loop over cathodes
-
-    AliDebug(1,Form("\n Found %d %d %d %d local Maxima\n",
-              fNLocal[0], fNLocal[1], fMul[0], fMul[1]));
-       AliDebug(1,Form("\n Cathode 1 local Maxima %d Multiplicite %d\n",fNLocal[0], fMul[0]));
-       AliDebug(1,Form(" Cathode 2 local Maxima %d Multiplicite %d\n",fNLocal[1], fMul[1]));
-    Int_t ix, iy, isec;
-    Float_t dpx, dpy;
-    
-    
-    if (fNLocal[1]==2 &&  (fNLocal[0]==1 || fNLocal[0]==0)) {
-       Int_t iback=fNLocal[0];
-       
-//  Two local maxima on cathode 2 and one maximum on cathode 1 
-//  Look for local maxima considering up and down neighbours on the 1st cathode only
-//
-//  Loop over cluster digits
-       cath=0;
-       cath1=1;
-       
-       for (i=0; i<fMul[cath]; i++) {
-         isec=fSeg2[cath]->Sector(fInput->DetElemId(), fIx[i][cath],fIy[i][cath]);
-         dpy=fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-         dpx=fSeg2[cath]->Dpx(fInput->DetElemId(), isec);
-         
-           if (isLocal[i][cath]) continue;
-// Pad position should be consistent with position of local maxima on the opposite cathode
-           if ((TMath::Abs(fX[i][cath]-fX[fIndLocal[0][cath1]][cath1]) > dpx/2.) && 
-               (TMath::Abs(fX[i][cath]-fX[fIndLocal[1][cath1]][cath1]) > dpx/2.))
-               continue;
-
-// get neighbours for that digit and assume that it is local maximum       
-           isLocal[i][cath]=kTRUE;
-// compare signal to that on the two neighbours on the left and on the right
-// iNN counts the number of neighbours with signal, it should be 1 or 2
-           Int_t iNN=0;
-
-
-           for (fSeg2[cath]->FirstPad(fInput->DetElemId(), fX[i][cath], fY[i][cath], fZPlane, 0., dpy);
-                  fSeg2[cath]->MorePads(fInput->DetElemId());
-                  fSeg2[cath]->NextPad(fInput->DetElemId()))
-               {
-                 ix = fSeg2[cath]->Ix();
-                 iy = fSeg2[cath]->Iy();
-                 // skip the current pad
-                 if (iy == fIy[i][cath]) continue;
-               
-                 if (fDigitMap[cath]->TestHit(ix, iy)!=kEmpty) {
-                   iNN++;
-                   digt=(AliMUONDigit*) fDigitMap[cath]->GetHit(ix,iy);
-                   if (digt->Signal() > fQ[i][cath]) isLocal[i][cath]=kFALSE;
-                 }
-               } // Loop over pad neighbours in y
-           
-           if (isLocal[i][cath] && iNN>0) {
-               fIndLocal[fNLocal[cath]][cath]=i;
-               fNLocal[cath]++;
-           } 
-       } // loop over all digits
-// if one additional maximum has been found we are happy 
-// if more maxima have been found restore the previous situation
-       AliDebug(1,Form("\n New search gives %d local maxima for cathode 1 \n",
-                   fNLocal[0]));
-       AliDebug(1,Form("                  %d local maxima for cathode 2 \n",
-                   fNLocal[1]));
-       if (fNLocal[cath]>2) {
-           fNLocal[cath]=iback;
-       }
-       
-    } // 1,2 local maxima
-    
-    if (fNLocal[0]==2 &&  (fNLocal[1]==1 || fNLocal[1]==0)) {
-       Int_t iback=fNLocal[1];
-       
-//  Two local maxima on cathode 1 and one maximum on cathode 2 
-//  Look for local maxima considering left and right neighbours on the 2nd cathode only
-       cath=1;
-       Int_t cath1 = 0;
-       Float_t eps = 1.e-5;
-       
-//
-//  Loop over cluster digits
-       for (i=0; i<fMul[cath]; i++) {
-           isec=fSeg2[cath]->Sector(fInput->DetElemId(), fIx[i][cath],fIy[i][cath]);
-           dpx=fSeg2[cath]->Dpx(fInput->DetElemId(), isec);
-           dpy=fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-         
-       
-           if (isLocal[i][cath]) continue;
-// Pad position should be consistent with position of local maxima on the opposite cathode
-           if ((TMath::Abs(fY[i][cath]-fY[fIndLocal[0][cath1]][cath1]) > dpy/2.+eps) && 
-               (TMath::Abs(fY[i][cath]-fY[fIndLocal[1][cath1]][cath1]) > dpy/2.+eps))
-               continue;
-           
-//
-// get neighbours for that digit and assume that it is local maximum       
-           isLocal[i][cath]=kTRUE;
-// compare signal to that on the two neighbours on the left and on the right
-
-// iNN counts the number of neighbours with signal, it should be 1 or 2
-           Int_t iNN=0;
-           for (fSeg2[cath]->FirstPad(fInput->DetElemId(), fX[i][cath], fY[i][cath], fZPlane, dpx, 0.);
-                  fSeg2[cath]->MorePads(fInput->DetElemId());
-                  fSeg2[cath]->NextPad(fInput->DetElemId()))
-               {
-
-                 ix = fSeg2[cath]->Ix();
-                 iy = fSeg2[cath]->Iy();
-
-                 // skip the current pad
-                 if (ix == fIx[i][cath]) continue;
-               
-                 if (fDigitMap[cath]->TestHit(ix, iy)!=kEmpty) {
-                   iNN++;
-                   digt=(AliMUONDigit*) fDigitMap[cath]->GetHit(ix,iy);
-                   if (digt->Signal() > fQ[i][cath]) isLocal[i][cath]=kFALSE;
-                 }
-               } // Loop over pad neighbours in x
-           
-           if (isLocal[i][cath] && iNN>0) {
-               fIndLocal[fNLocal[cath]][cath]=i;
-               fNLocal[cath]++;
-           } 
-       } // loop over all digits
-// if one additional maximum has been found we are happy 
-// if more maxima have been found restore the previous situation
-       AliDebug(1,Form("\n New search gives %d local maxima for cathode 1 \n",fNLocal[0]));
-       AliDebug(1,Form("\n                  %d local maxima for cathode 2 \n",fNLocal[1]));
-       AliDebug(1,Form("\n New search gives %d %d \n",fNLocal[0],fNLocal[1]));
-       if (fNLocal[cath]>2) {
-           fNLocal[cath]=iback;
-       }
-    } // 2,1 local maxima
-}
-
-
-void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_t cath) 
-{
-///  Completes cluster information starting from list of digits
-
-  AliMUONDigit* dig;
-  Float_t x, y, z;
-  Int_t  ix, iy;
-  
-  if (cath==1) {
-    c->SetPeakSignal(cath,c->GetPeakSignal(0));        
-  } else {
-    c->SetPeakSignal(cath,0);
-  }
-  
-  
-  if (flag) {
-    c->SetX(cath,0.);
-    c->SetY(cath,0.);
-    c->SetCharge(cath,0);
-  }
-  
-  AliDebug(1,Form("\n fPeakSignal %d\n",c->GetPeakSignal(cath)));
-  for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
-    {
-      dig= fInput->Digit(cath,c->GetIndex(i,cath));
-      ix=dig->PadX()+c->GetOffset(i,cath);
-      iy=dig->PadY();
-      Float_t q=dig->Signal();
-      if (!flag) q *= c->GetContrib(i,cath);
-      //       fprintf(stderr,"q %d c->fPeakSignal[ %d ] %d\n",q,cath,c->fPeakSignal[cath]);
-      if (dig->Physics() >= dig->Signal()) {
-       c->SetPhysics(i,2);
-      } else if (dig->Physics() == 0) {
-       c->SetPhysics(i,0);
-      } else  c->SetPhysics(i,1);
-      //
-      // 
-      AliDebug(2,Form("q %d c->fPeakSignal[cath] %d\n",q,c->GetPeakSignal(cath)));
-      // peak signal and track list
-      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]);
-      }
-      //
-      if (flag) {
-       fSeg2[cath]->GetPadC(fInput->DetElemId(), ix, iy, x, y, z);
-       
-       c->AddX(cath, q*x);
-       c->AddY(cath, q*y);
-       c->AddCharge(cath, q);
-      }
-    } // loop over digits
-  AliDebug(1," fin du cluster c\n");
-  
-  
-  if (flag) {
-    c->SetX(cath, c->GetX(cath)/c->GetCharge(cath));
-    // Force on anod
-    c->SetX(cath, fSeg2[cath]->GetAnod(fInput->DetElemId(), c->GetX(cath)));
-    c->SetY(cath, c->GetY(cath)/c->GetCharge(cath)); 
-    //
-    //  apply correction to the coordinate along the anode wire
-    //
-    x=c->GetX(cath);   
-    y=c->GetY(cath);
-    TF1* cogCorr;
-    Int_t isec;
-    fSeg2[cath]->GetPadI(fInput->DetElemId(), x, y, fZPlane, ix, iy);
-    fSeg2[cath]->GetPadC(fInput->DetElemId(), ix, iy, x, y, z);
-    isec=fSeg2[cath]->Sector(fInput->DetElemId(), ix,iy);
-    cogCorr = fSeg2[cath]->CorrFunc(fInput->DetElemId(), isec-1);
-    
-    
-    if (cogCorr) {
-      Float_t yOnPad;
-      yOnPad=(c->GetY(cath)-y)/fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-      
-      c->SetY(cath, c->GetY(cath)-cogCorr->Eval(yOnPad, 0, 0));
-      // slat ID from digit
-      
-    }
-  }
-}
-
-void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t cath) 
-{
-///  Completes cluster information starting from list of digits
-
-  static Float_t dr0;
-  
-  AliMUONDigit* dig;
-  
-  if (cath==0) {
-    dr0 = 10000;
-  }
-  
-  Float_t xpad, ypad, zpad;
-  Float_t dx, dy, dr;
-  
-  for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
-    {
-      dig = fInput->Digit(cath,c->GetIndex(i,cath));
-      fSeg2[cath]->
-         GetPadC(fInput->DetElemId(),dig->PadX(),dig->PadY(),xpad,ypad, zpad);
-      AliDebug(1,Form("x %f y %f cx %f cy %f\n",xpad,ypad,c->GetX(0),c->GetY(0)));
-      dx = xpad - c->GetX(0);
-      dy = ypad - c->GetY(0);
-      dr = TMath::Sqrt(dx*dx+dy*dy);
-      
-      if (dr < dr0) {
-       dr0 = dr;
-       AliDebug(1,Form(" dr %f\n",dr));
-       Float_t q=dig->Signal();
-       if (dig->Physics() >= dig->Signal()) {
-         c->SetPhysics(i,2);
-       } else if (dig->Physics() == 0) {
-         c->SetPhysics(i,0);
-       } else  c->SetPhysics(i,1);
-       c->SetPeakSignal(cath,q);
-       c->SetTrack(0,dig->Hit());
-       c->SetTrack(1,dig->Track(0));
-       c->SetTrack(2,dig->Track(1));
-       
-       AliDebug(1,Form(" c->fTracks[0] %d c->fTracks[1] %d\n",dig->Hit(),
-                       dig->Track(0)));
-      }
-      //
-    } // loop over digits
-  
-  //  apply correction to the coordinate along the anode wire
-  // Force on anod
-    c->SetX(cath,fSeg2[cath]->GetAnod(fInput->DetElemId(), c->GetX(cath)));
-}
-
-void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONRawCluster &c)
-{
-///  Find a super cluster on both cathodes
-///  Add i,j as element of the cluster
-    
-    Int_t idx = fDigitMap[cath]->GetHitIndex(i,j);
-    AliMUONDigit* dig = (AliMUONDigit*) fDigitMap[cath]->GetHit(i,j);
-    Float_t q=dig->Signal();
-    Int_t theX=dig->PadX();
-    Int_t theY=dig->PadY(); 
-   
-    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.GetMultiplicity(cath);
-    c.SetIndex(mu, cath, idx);
-    
-    if (dig->Physics() >= dig->Signal()) {
-        c.SetPhysics(mu,2);
-    } else if (dig->Physics() == 0) {
-        c.SetPhysics(mu,0);
-    } else  c.SetPhysics(mu,1);
-
-    
-    if (mu > 0) {
-       for (Int_t ind = mu-1; ind >= 0; ind--) {
-           Int_t ist=c.GetIndex(ind,cath);
-           Float_t ql=fInput->Digit(cath, ist)->Signal();
-           Int_t ix=fInput->Digit(cath, ist)->PadX();
-           Int_t iy=fInput->Digit(cath, ist)->PadY();
-           
-           if (q>ql || (q==ql && theX > ix && theY < iy)) {
-               c.SetIndex(ind, cath, idx);
-               c.SetIndex(ind+1, cath, ist);
-           } else {
-               
-               break;
-           }
-       }
-    }
-
-    c.SetMultiplicity(cath, c.GetMultiplicity(cath)+1);
-    if (c.GetMultiplicity(cath) >= 50 ) {
-      AliDebug(1,Form("FindCluster - multiplicity >50  %d \n",c.GetMultiplicity(0)));
-       c.SetMultiplicity(cath, 49);
-    }
-
-// Prepare center of gravity calculation
-    Float_t x, y, z;
-    fSeg2[cath]->GetPadC(fInput->DetElemId(), i, j, x, y, z);
-    c.AddX(cath,q*x);
-    c.AddY(cath,q*y);
-    c.AddCharge(cath,q);
-//
-// Flag hit as "taken"  
-    fDigitMap[cath]->FlagHit(i,j);
-//
-//  Now look recursively for all neighbours and pad hit on opposite cathode
-//
-//  Loop over neighbours
-    Int_t ix,iy;
-    ix=iy=0;
-    Int_t nn;
-    Int_t xList[10], yList[10];
-    fSeg2[cath]->Neighbours(fInput->DetElemId(), i,j,&nn,xList,yList);
-    for (Int_t in=0; in<nn; in++) {
-       ix=xList[in];
-       iy=yList[in];
-       
-       if (fDigitMap[cath]->TestHit(ix,iy)==kUnused) {
-           AliDebug(2,Form("\n Neighbours %d %d %d", cath, ix, iy));
-           FindCluster(ix, iy, cath, c);
-       }
-       
-   }
-    Int_t nOpp=0;
-    Int_t iXopp[50], iYopp[50];
-    
-//  Neighbours on opposite cathode 
-//  Take into account that several pads can overlap with the present pad
-    Int_t isec;
-    isec=fSeg2[cath]->Sector(fInput->DetElemId(), i,j);    
-
-    Int_t iop;
-    Float_t dx, dy;
-  
-    if (cath==0) {
-      iop = 1;
-      dx  = (fSeg2[cath]->Dpx(fInput->DetElemId(), isec))/2.;
-      dy  = 0.;
-    } else {
-      iop = 0;
-      dx  = 0.;
-      dy  = (fSeg2[cath]->Dpy(fInput->DetElemId(), isec))/2;
-    }
-   
-
-    
-    // loop over pad neighbours on opposite cathode
-    for (fSeg2[iop]->FirstPad(fInput->DetElemId(), x, y, fZPlane, dx, dy);
-        fSeg2[iop]->MorePads(fInput->DetElemId());
-        fSeg2[iop]->NextPad(fInput->DetElemId()))
-      {
-       
-       ix = fSeg2[iop]->Ix(); iy = fSeg2[iop]->Iy();
-       AliDebug(2,Form("\n ix, iy: %f %f %f %d %d %d", x,y,z,ix, iy, fSector));
-       if (fDigitMap[iop]->TestHit(ix,iy)==kUnused){
-         iXopp[nOpp]=ix;
-         iYopp[nOpp++]=iy;
-         AliDebug(2,Form("\n Opposite %d %d %d", iop, ix, iy));
-       }
-       
-      } // Loop over pad neighbours
-    //  This had to go outside the loop since recursive calls inside the iterator are not possible
-    //
-    Int_t jopp;
-    for (jopp=0; jopp<nOpp; jopp++) {
-      if (fDigitMap[iop]->TestHit(iXopp[jopp],iYopp[jopp]) == kUnused) 
-       FindCluster(iXopp[jopp], iYopp[jopp], iop, c);
-    }
-
-}
-
-//_____________________________________________________________________________
-
-void AliMUONClusterFinderVS::FindRawClusters()
-{
-/// MUON cluster finder from digits -- finds neighbours on both cathodes and 
-/// fills the tree with raw clusters
-
-    ResetRawClusters();
-//  Return if no input datad available
-    if (!fInput->NDigits(0) && !fInput->NDigits(1)) return;
-
-    fSeg2[0] = fInput->Segmentation2(0);
-    fSeg2[1] = fInput->Segmentation2(1);
-    
-    Int_t detElemId = fInput->DetElemId();
-    
-    Int_t npx0  = fSeg2[0]->Npx(detElemId)+1;
-    Int_t npy0  = fSeg2[0]->Npy(detElemId)+1;
-    fDigitMap[0]  = new AliMUONDigitMapA1(detElemId, npx0, npy0);
-
-    Int_t npx1  = fSeg2[0]->Npx(detElemId)+1;
-    Int_t npy1  = fSeg2[0]->Npy(detElemId)+1;
-    fDigitMap[1]  = new AliMUONDigitMapA1(detElemId, npx1, npy1);
-    
-    AliMUONDigit *dig;
-
-    Int_t ndig, cath;
-    Int_t nskip=0;
-    Int_t ncls=0;
-
-    fDigitMap[0]->FillHits(fInput->Digits(0));
-    fDigitMap[1]->FillHits(fInput->Digits(1));
-//
-//  Outer Loop over Cathodes
-    for (cath = 0; cath < 2; cath++) {
-      
-       for (ndig=0; ndig<fInput->NDigits(cath); ndig++) {
-         dig = fInput->Digit(cath, ndig);
-         Int_t padx = dig->PadX();
-         Int_t pady = dig->PadY();
-         if (fDigitMap[cath]->TestHit(padx,pady)==kUsed ||fDigitMap[0]->TestHit(padx,pady)==kEmpty) {
-           nskip++;
-           continue;
-         }
-         AliDebug(1,Form("\n CATHODE %d CLUSTER %d\n",cath,ncls));
-         AliMUONRawCluster clus;
-         clus.SetMultiplicity(0, 0);
-         clus.SetMultiplicity(1, 0);
-         clus.SetPeakSignal(cath,dig->Signal());
-         clus.SetTrack(0, dig->Hit());
-         clus.SetTrack(1, dig->Track(0));
-         clus.SetTrack(2, dig->Track(1));
-         
-         AliDebug(1,Form("idDE %d Padx %d Pady %d", fInput->DetElemId(), padx, pady));
-         
-         // tag the beginning of cluster list in a raw cluster
-         clus.SetNcluster(0,-1);
-         Float_t xcu, ycu;
-         fSeg2[cath]->GetPadC(fInput->DetElemId(), padx, pady, xcu, ycu, fZPlane);
-         fSector= fSeg2[cath]->Sector(fInput->DetElemId(), padx, pady)/100;
-         
-         
-         
-         
-         FindCluster(padx,pady,cath,clus);
-         //^^^^^^^^^^^^^^^^^^^^^^^^
-         // center of gravity
-         if (clus.GetX(0)!=0.) clus.SetX(0, clus.GetX(0)/clus.GetCharge(0)); // clus.fX[0] /= clus.fQ[0];
-         
-         // Force on anod
-         clus.SetX(0,fSeg2[0]->GetAnod(fInput->DetElemId(), clus.GetX(0)));
-         if (clus.GetY(0)!=0.) clus.SetY(0, clus.GetY(0)/clus.GetCharge(0)); // clus.fY[0] /= clus.fQ[0];
-         
-         if(clus.GetCharge(1)!=0.) clus.SetX(1, clus.GetX(1)/clus.GetCharge(1));  // clus.fX[1] /= clus.fQ[1];
-         
-         // Force on anod
-         clus.SetX(1, fSeg2[0]->GetAnod(fInput->DetElemId(),clus.GetX(1)));
-         if(clus.GetCharge(1)!=0.) clus.SetY(1, clus.GetY(1)/clus.GetCharge(1));// clus.fY[1] /= clus.fQ[1];
-         
-         clus.SetZ(0, fZPlane);
-         clus.SetZ(1, fZPlane);            
-         
-         AliDebug(1,Form("\n Cathode 1 multiplicite %d X(CG) %f Y(CG) %f\n",
-                         clus.GetMultiplicity(0),clus.GetX(0),clus.GetY(0)));
-         AliDebug(1,Form(" Cathode 2 multiplicite %d X(CG) %f Y(CG) %f\n",
-                         clus.GetMultiplicity(1),clus.GetX(1),clus.GetY(1)));
-         //      Analyse cluster and decluster if necessary
-         //    
-         ncls++;
-         clus.SetNcluster(1,fNRawClusters);
-         clus.SetClusterType(clus.PhysicsContribution());
-         
-         fNPeaks=0;
-         //
-         //
-         Decluster(&clus);
-         //
-         //      reset Cluster object
-         { // begin local scope
-           for (int k=0;k<clus.GetMultiplicity(0);k++) clus.SetIndex(k, 0, 0);
-         } // end local scope
-         
-         { // begin local scope
-           for (int k=0;k<clus.GetMultiplicity(1);k++) clus.SetIndex(k, 1, 0);
-         } // end local scope
-         
-         clus.SetMultiplicity(0,0);
-         clus.SetMultiplicity(1,0);
-         
-       
-       } // end loop ndig
-    } // end loop cathodes
-    delete fDigitMap[0];
-    delete fDigitMap[1];
-}
-
-Float_t AliMUONClusterFinderVS::SingleMathiesonFit(AliMUONRawCluster *c, Int_t cath)
-{
-/// Performs a single Mathieson fit on one cathode
-
-    Double_t arglist[20];
-    Int_t ierflag=0;
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());
-    
-    clusterInput.Fitter()->SetFCN(fcnS1);
-    clusterInput.Fitter()->mninit(2,10,7);
-    clusterInput.Fitter()->SetPrintLevel(-1 + AliLog::GetGlobalDebugLevel());
-    arglist[0]=-1;
-    clusterInput.Fitter()->mnexcm("SET NOW", arglist, 0, ierflag);
-// Set starting values 
-    static Double_t vstart[2];
-    vstart[0]=c->GetX(1);
-    vstart[1]=c->GetY(0);
-    
-    
-// lower and upper limits
-    static Double_t lower[2], upper[2];
-    Int_t ix,iy, isec;
-    fSeg2[cath]->GetPadI(fInput->DetElemId(), c->GetX(cath), c->GetY(cath), fZPlane, ix, iy);
-    isec=fSeg2[cath]->Sector(fInput->DetElemId(), ix, iy);
-
-    lower[0]=vstart[0]-fSeg2[cath]->Dpx(fInput->DetElemId(), isec)/2;
-    lower[1]=vstart[1]-fSeg2[cath]->Dpy(fInput->DetElemId(), isec)/2;
-    
-    upper[0]=lower[0]+fSeg2[cath]->Dpx(fInput->DetElemId(), isec);
-    upper[1]=lower[1]+fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-    
-
-// step sizes
-    static Double_t step[2]={0.0005, 0.0005};
-    
-    clusterInput.Fitter()->mnparm(0,"x1",vstart[0],step[0],lower[0],upper[0],ierflag);
-    clusterInput.Fitter()->mnparm(1,"y1",vstart[1],step[1],lower[1],upper[1],ierflag);
-// ready for minimisation      
-    arglist[0]= -1;
-    arglist[1]= 0;
-    
-    clusterInput.Fitter()->mnexcm("SET NOGR", arglist, 0, ierflag);
-    clusterInput.Fitter()->mnexcm("MIGRAD", arglist, 0, ierflag);
-    //    clusterInput.Fitter()->mnexcm("EXIT" , arglist, 0, ierflag);
-    Double_t fmin, fedm, errdef;
-    Int_t   npari, nparx, istat;
-      
-    clusterInput.Fitter()->mnstat(fmin, fedm, errdef, npari, nparx, istat);  
-    fFitStat=istat;
-    
-// Print results
-// Get fitted parameters
-    Double_t xrec, yrec;
-    TString chname;
-    Double_t epxz, b1, b2;
-    Int_t ierflg;
-    clusterInput.Fitter()->mnpout(0, chname, xrec, epxz, b1, b2, ierflg);      
-    clusterInput.Fitter()->mnpout(1, chname, yrec, epxz, b1, b2, ierflg);      
-    fXFit[cath]=xrec;
-    fYFit[cath]=yrec;
-    return fmin;
-}
-
-Float_t AliMUONClusterFinderVS::CombiSingleMathiesonFit(AliMUONRawCluster * /*c*/)
-{
-/// Perform combined Mathieson fit on both cathode planes
-
-    Double_t arglist[20];
-    Int_t ierflag=0;
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());
-    clusterInput.Fitter()->SetFCN(fcnCombiS1);
-    clusterInput.Fitter()->mninit(2,10,7);
-    clusterInput.Fitter()->SetPrintLevel(-1 + AliLog::GetGlobalDebugLevel());
-    arglist[0]=-1;
-    clusterInput.Fitter()->mnexcm("SET NOW", arglist, 0, ierflag);
-    static Double_t vstart[2];
-    vstart[0]=fXInit[0];
-    vstart[1]=fYInit[0];
-    
-    
-// lower and upper limits
-    static Float_t lower[2], upper[2];
-    Int_t ix,iy,isec;
-    Float_t dpy, dpx;
-
-    fSeg2[0]->GetPadI(fInput->DetElemId(), fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg2[0]->Sector(fInput->DetElemId(), ix, iy);
-    dpy=fSeg2[0]->Dpy(fInput->DetElemId(), isec);
-    fSeg2[1]->GetPadI(fInput->DetElemId(), fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg2[1]->Sector(fInput->DetElemId(), ix, iy);
-    dpx=fSeg2[1]->Dpx(fInput->DetElemId(), isec);
-      
-    Int_t icount;
-    Float_t xdum, ydum, zdum;
-
-//  Find save upper and lower limits    
-    
-    icount = 0;
-    for (fSeg2[1]->FirstPad(fInput->DetElemId(),fXInit[0], fYInit[0], fZPlane, dpx, 0.); 
-        fSeg2[1]->MorePads(fInput->DetElemId()); 
-        fSeg2[1]->NextPad(fInput->DetElemId()))
-       {
-         ix=fSeg2[1]->Ix(); iy=fSeg2[1]->Iy();
-         fSeg2[1]->GetPadC(fInput->DetElemId(), ix,iy, upper[0], ydum, zdum);  
-         if (icount ==0) lower[0]=upper[0];
-         icount++;
-       }
-    
-    if (lower[0]>upper[0]) {xdum=lower[0]; lower[0]=upper[0]; upper[0]=xdum;}
-       
-    icount=0;
-    AliDebug(1,Form("\n single y %f %f", fXInit[0], fYInit[0]));
-    
-    for (fSeg2[0]->FirstPad(fInput->DetElemId(), fXInit[0], fYInit[0], fZPlane, 0., dpy); 
-        fSeg2[0]->MorePads(fInput->DetElemId()); 
-        fSeg2[0]->NextPad(fInput->DetElemId()))
-       {
-         ix=fSeg2[0]->Ix(); iy=fSeg2[0]->Iy();
-         fSeg2[0]->GetPadC(fInput->DetElemId(), ix,iy,xdum,upper[1],zdum);     
-         if (icount ==0) lower[1]=upper[1];
-         icount++;
-         AliDebug(1,Form("\n upper lower %d %f %f", icount, upper[1], lower[1]));
-       }
-    
-    if (lower[1]>upper[1]) {xdum=lower[1]; lower[1]=upper[1]; upper[1]=xdum;}
-
-// step sizes
-    static Double_t step[2]={0.00001, 0.0001};
-    
-    clusterInput.Fitter()->mnparm(0,"x1",vstart[0],step[0],lower[0],upper[0],ierflag);
-    clusterInput.Fitter()->mnparm(1,"y1",vstart[1],step[1],lower[1],upper[1],ierflag);
-// ready for minimisation      
-    arglist[0]= -1;
-    arglist[1]= 0;
-    
-    clusterInput.Fitter()->mnexcm("SET NOGR", arglist, 0, ierflag);
-    clusterInput.Fitter()->mnexcm("MIGRAD", arglist, 0, ierflag);
-    //    clusterInput.Fitter()->mnexcm("EXIT" , arglist, 0, ierflag);
-    Double_t fmin, fedm, errdef;
-    Int_t   npari, nparx, istat;
-      
-    clusterInput.Fitter()->mnstat(fmin, fedm, errdef, npari, nparx, istat);  
-    fFitStat=istat;
-    
-// Print results
-// Get fitted parameters
-    Double_t xrec, yrec;
-    TString chname;
-    Double_t epxz, b1, b2;
-    Int_t ierflg;
-    clusterInput.Fitter()->mnpout(0, chname, xrec, epxz, b1, b2, ierflg);      
-    clusterInput.Fitter()->mnpout(1, chname, yrec, epxz, b1, b2, ierflg);      
-    fXFit[0]=xrec;
-    fYFit[0]=yrec;
-    return fmin;
-}
-
-Bool_t AliMUONClusterFinderVS::DoubleMathiesonFit(AliMUONRawCluster * /*c*/, Int_t cath)
-{
-/// Performs a double Mathieson fit on one cathode 
-
-//
-//  Initialise global variables for fit
-    Double_t arglist[20];
-    Int_t ierflag=0;
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());
-    clusterInput.Fitter()->SetFCN(fcnS2);
-    clusterInput.Fitter()->mninit(5,10,7);
-    clusterInput.Fitter()->SetPrintLevel(-1 + AliLog::GetGlobalDebugLevel());
-    arglist[0]=-1;
-    clusterInput.Fitter()->mnexcm("SET NOW", arglist, 0, ierflag);
-// Set starting values 
-    static Double_t vstart[5];
-    vstart[0]=fX[fIndLocal[0][cath]][cath];
-    vstart[1]=fY[fIndLocal[0][cath]][cath];    
-    vstart[2]=fX[fIndLocal[1][cath]][cath];
-    vstart[3]=fY[fIndLocal[1][cath]][cath];    
-    vstart[4]=Float_t(fQ[fIndLocal[0][cath]][cath])/
-       Float_t(fQ[fIndLocal[0][cath]][cath]+fQ[fIndLocal[1][cath]][cath]);
-// lower and upper limits
-    static Float_t lower[5], upper[5];
-    Int_t isec;
-
-    isec=fSeg2[cath]->Sector(fInput->DetElemId(),fIx[fIndLocal[0][cath]][cath], 
-                            fIy[fIndLocal[0][cath]][cath]);
-    lower[0]=vstart[0]-fSeg2[cath]->Dpx(fInput->DetElemId(),isec);
-    lower[1]=vstart[1]-fSeg2[cath]->Dpy(fInput->DetElemId(),isec);
-    
-    upper[0]=lower[0]+2.*fSeg2[cath]->Dpx(fInput->DetElemId(),isec);
-    upper[1]=lower[1]+2.*fSeg2[cath]->Dpy(fInput->DetElemId(),isec);
-    
-    isec=fSeg2[cath]->Sector(fInput->DetElemId(),fIx[fIndLocal[1][cath]][cath], 
-                            fIy[fIndLocal[1][cath]][cath]);
-    lower[2]=vstart[2]-fSeg2[cath]->Dpx(fInput->DetElemId(),isec)/2;
-    lower[3]=vstart[3]-fSeg2[cath]->Dpy(fInput->DetElemId(),isec)/2;
-    
-    upper[2]=lower[2]+fSeg2[cath]->Dpx(fInput->DetElemId(),isec);
-    upper[1]=lower[1]+2.*fSeg2[cath]->Dpy(fInput->DetElemId(),isec);
-
-    
-
-    lower[4]=0.;
-    upper[4]=1.;
-// step sizes
-    static Double_t step[5]={0.0005, 0.0005, 0.0005, 0.0005, 0.0001};
-    
-    clusterInput.Fitter()->mnparm(0,"x1",vstart[0],step[0],lower[0],upper[0],ierflag);
-    clusterInput.Fitter()->mnparm(1,"y1",vstart[1],step[1],lower[1],upper[1],ierflag);
-    clusterInput.Fitter()->mnparm(2,"x2",vstart[2],step[2],lower[2],upper[2],ierflag);
-    clusterInput.Fitter()->mnparm(3,"y2",vstart[3],step[3],lower[3],upper[3],ierflag);
-    clusterInput.Fitter()->mnparm(4,"a0",vstart[4],step[4],lower[4],upper[4],ierflag);
-// ready for minimisation      
-    arglist[0]= -1;
-    arglist[1]= 0;
-    
-    clusterInput.Fitter()->mnexcm("SET NOGR", arglist, 0, ierflag);
-    clusterInput.Fitter()->mnexcm("MIGRAD", arglist, 0, ierflag);
-    //    clusterInput.Fitter()->mnexcm("EXIT" , arglist, 0, ierflag);
-// Get fitted parameters
-    Double_t xrec[2], yrec[2], qfrac;
-    TString chname;
-    Double_t epxz, b1, b2;
-    Int_t ierflg;
-    clusterInput.Fitter()->mnpout(0, chname, xrec[0], epxz, b1, b2, ierflg);   
-    clusterInput.Fitter()->mnpout(1, chname, yrec[0], epxz, b1, b2, ierflg);   
-    clusterInput.Fitter()->mnpout(2, chname, xrec[1], epxz, b1, b2, ierflg);   
-    clusterInput.Fitter()->mnpout(3, chname, yrec[1], epxz, b1, b2, ierflg);   
-    clusterInput.Fitter()->mnpout(4, chname, qfrac,   epxz, b1, b2, ierflg);   
-
-    Double_t fmin, fedm, errdef;
-    Int_t   npari, nparx, istat;
-      
-    clusterInput.Fitter()->mnstat(fmin, fedm, errdef, npari, nparx, istat);  
-    fFitStat=istat;
-    return kTRUE;
-}
-
-Float_t AliMUONClusterFinderVS::CombiDoubleMathiesonFit(AliMUONRawCluster * /*c*/)
-{
-/// Perform combined double Mathieson fit on both cathode planes
-
-    Double_t arglist[20];
-    Int_t ierflag=0;
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());
-    clusterInput.Fitter()->SetFCN(fcnCombiS2);
-    clusterInput.Fitter()->mninit(6,10,7);
-    clusterInput.Fitter()->SetPrintLevel(-1 + AliLog::GetGlobalDebugLevel());
-    arglist[0]=-1;
-    clusterInput.Fitter()->mnexcm("SET NOW", arglist, 0, ierflag);
-// Set starting values 
-    static Double_t vstart[6];
-    vstart[0]=fXInit[0];
-    vstart[1]=fYInit[0];
-    vstart[2]=fXInit[1];
-    vstart[3]=fYInit[1];
-    vstart[4]=fQrInit[0];
-    vstart[5]=fQrInit[1];
-// lower and upper limits
-    static Float_t lower[6], upper[6];
-    Int_t ix,iy,isec;
-    Float_t dpx, dpy;
-
-    fSeg2[1]->GetPadI(fInput->DetElemId(),fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg2[1]->Sector(fInput->DetElemId(),ix, iy);
-    dpx=fSeg2[1]->Dpx(fInput->DetElemId(), isec);
-
-    fSeg2[0]->GetPadI(fInput->DetElemId(), fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg2[0]->Sector(fInput->DetElemId(), ix, iy);
-    dpy=fSeg2[0]->Dpy(fInput->DetElemId(), isec);
-
-  
-
-    Int_t icount;
-    Float_t xdum, ydum, zdum;
-    AliDebug(1,Form("\n Cluster Finder: %f %f %f %f  ", fXInit[0], fXInit[1],fYInit[0], fYInit[1] ));
-
-    //  Find save upper and lower limits    
-    icount = 0;
-    
-    for (fSeg2[1]->FirstPad(fInput->DetElemId(),fXInit[0], fYInit[0], fZPlane, dpx, 0.); 
-        fSeg2[1]->MorePads(fInput->DetElemId()); 
-        fSeg2[1]->NextPad(fInput->DetElemId()))
-      {
-       ix=fSeg2[1]->Ix(); iy=fSeg2[1]->Iy();
-       //      if (fDigitMap[1]->TestHit(ix, iy) == kEmpty) continue;
-       fSeg2[1]->GetPadC(fInput->DetElemId(),ix,iy,upper[0],ydum,zdum);        
-       if (icount ==0) lower[0]=upper[0];
-       icount++;
-      }
-    if (lower[0]>upper[0]) {xdum=lower[0]; lower[0]=upper[0]; upper[0]=xdum;}    
-    //    vstart[0] = 0.5*(lower[0]+upper[0]);
-
-    
-    icount=0;
-    
-    for (fSeg2[0]->FirstPad(fInput->DetElemId(),fXInit[0], fYInit[0], fZPlane, 0., dpy); 
-        fSeg2[0]->MorePads(fInput->DetElemId()); 
-        fSeg2[0]->NextPad(fInput->DetElemId()))
-      {
-       ix=fSeg2[0]->Ix(); iy=fSeg2[0]->Iy();
-       //      if (fDigitMap[0]->TestHit(ix, iy) == kEmpty) continue;
-       fSeg2[0]->GetPadC(fInput->DetElemId(),ix,iy,xdum,upper[1],zdum);        
-       if (icount ==0) lower[1]=upper[1];
-       icount++;
-      }
-    
-    if (lower[1]>upper[1]) {xdum=lower[1]; lower[1]=upper[1]; upper[1]=xdum;}    
-    //     vstart[1] = 0.5*(lower[1]+upper[1]);
-
-
-    fSeg2[1]->GetPadI(fInput->DetElemId(),fXInit[1], fYInit[1], fZPlane, ix, iy);
-    isec=fSeg2[1]->Sector(fInput->DetElemId(),ix, iy);
-    dpx=fSeg2[1]->Dpx(fInput->DetElemId(),isec);
-    fSeg2[0]->GetPadI(fInput->DetElemId(),fXInit[1], fYInit[1], fZPlane, ix, iy);
-    isec=fSeg2[0]->Sector(fInput->DetElemId(),ix, iy);
-    dpy=fSeg2[0]->Dpy(fInput->DetElemId(),isec);
-
-
-    //  Find save upper and lower limits    
-
-    icount=0;
-    
-    for (fSeg2[1]->FirstPad(fInput->DetElemId(),fXInit[1], fYInit[1], fZPlane, dpx, 0); 
-        fSeg2[1]->MorePads(fInput->DetElemId()); 
-        fSeg2[1]->NextPad(fInput->DetElemId()))
-      {
-       ix=fSeg2[1]->Ix(); iy=fSeg2[1]->Iy();
-       //      if (fDigitMap[1]->TestHit(ix, iy) == kEmpty) continue;
-       fSeg2[1]->GetPadC(fInput->DetElemId(),ix,iy,upper[2],ydum,zdum);        
-       if (icount ==0) lower[2]=upper[2];
-       icount++;
-      }
-    if (lower[2]>upper[2]) {xdum=lower[2]; lower[2]=upper[2]; upper[2]=xdum;}    
-    //    vstart[2] = 0.5*(lower[2]+upper[2]);
-
-    icount=0;
-    
-    for (fSeg2[0]->FirstPad(fInput->DetElemId(),fXInit[1], fYInit[1], fZPlane, 0, dpy); 
-        fSeg2[0]-> MorePads(fInput->DetElemId()); 
-        fSeg2[0]->NextPad(fInput->DetElemId()))
-      {
-       ix=fSeg2[0]->Ix(); iy=fSeg2[0]->Iy();
-       //      if (fDigitMap[0]->TestHit(ix, iy) != kEmpty) continue;
-       
-       fSeg2[0]->GetPadC(fInput->DetElemId(),ix,iy,xdum,upper[3],zdum);        
-       if (icount ==0) lower[3]=upper[3];
-       icount++;
-
-      }
-    if (lower[3]>upper[3]) {xdum=lower[3]; lower[3]=upper[3]; upper[3]=xdum;}  
-    
-    lower[4]=0.;
-    upper[4]=1.;
-    lower[5]=0.;
-    upper[5]=1.;
-
-// step sizes
-    static Double_t step[6]={0.0005, 0.0005, 0.0005, 0.0005, 0.001, 0.001};
-    clusterInput.Fitter()->mnparm(0,"x1",vstart[0],step[0],lower[0],upper[0],ierflag);
-    clusterInput.Fitter()->mnparm(1,"y1",vstart[1],step[1],lower[1],upper[1],ierflag);
-    clusterInput.Fitter()->mnparm(2,"x2",vstart[2],step[2],lower[2],upper[2],ierflag);
-    clusterInput.Fitter()->mnparm(3,"y2",vstart[3],step[3],lower[3],upper[3],ierflag);
-    clusterInput.Fitter()->mnparm(4,"a0",vstart[4],step[4],lower[4],upper[4],ierflag);
-    clusterInput.Fitter()->mnparm(5,"a1",vstart[5],step[5],lower[5],upper[5],ierflag);
-// ready for minimisation      
-    arglist[0]= -1;
-    arglist[1]= 0;
-    
-    clusterInput.Fitter()->mnexcm("SET NOGR", arglist, 0, ierflag);
-    clusterInput.Fitter()->mnexcm("MIGRAD", arglist, 0, ierflag);
-    //    clusterInput.Fitter()->mnexcm("EXIT" , arglist, 0, ierflag);
-// Get fitted parameters
-    TString chname;
-    Double_t epxz, b1, b2;
-    Int_t ierflg;
-    clusterInput.Fitter()->mnpout(0, chname, fXFit[0],  epxz, b1, b2, ierflg); 
-    clusterInput.Fitter()->mnpout(1, chname, fYFit[0],  epxz, b1, b2, ierflg); 
-    clusterInput.Fitter()->mnpout(2, chname, fXFit[1],  epxz, b1, b2, ierflg); 
-    clusterInput.Fitter()->mnpout(3, chname, fYFit[1],  epxz, b1, b2, ierflg); 
-    clusterInput.Fitter()->mnpout(4, chname, fQrFit[0], epxz, b1, b2, ierflg); 
-    clusterInput.Fitter()->mnpout(5, chname, fQrFit[1], epxz, b1, b2, ierflg); 
-
-    Double_t fmin, fedm, errdef;
-    Int_t   npari, nparx, istat;
-      
-    clusterInput.Fitter()->mnstat(fmin, fedm, errdef, npari, nparx, istat);  
-    fFitStat=istat;
-    
-    fChi2[0]=fmin;
-    fChi2[1]=fmin;
-    return fmin;
-}
-
-void AliMUONClusterFinderVS::Split(AliMUONRawCluster* c)
-{
-/// One cluster for each maximum
-
-    Int_t i, j, cath;
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());
-    for (j=0; j<2; j++) {
-       AliMUONRawCluster cnew;
-       cnew.SetGhost(c->GetGhost());
-       for (cath=0; cath<2; cath++) {
-           cnew.SetChi2(cath,fChi2[0]);
-           // ?? why not cnew.fChi2[cath]=fChi2[cath];
-           
-           if (fNPeaks == 0) {
-               cnew.SetNcluster(0,-1);
-               cnew.SetNcluster(1,fNRawClusters);
-           } else {
-               cnew.SetNcluster(0,fNPeaks);
-               cnew.SetNcluster(1,0);
-           }
-           cnew.SetMultiplicity(cath,0);
-           cnew.SetX(cath, Float_t(fXFit[j]));
-           cnew.SetY(cath, Float_t(fYFit[j]));
-           cnew.SetZ(cath, fZPlane);
-           if (j==0) {
-               cnew.SetCharge(cath, Int_t(clusterInput.TotalCharge(cath)*fQrFit[cath]));
-           } else {
-               cnew.SetCharge(cath, Int_t(clusterInput.TotalCharge(cath)*(1-fQrFit[cath])));
-           }
-           fSeg2[cath]->SetHit(fInput->DetElemId(), fXFit[j],fYFit[j],fZPlane);
-
-           for (i=0; i<fMul[cath]; i++) {
-             Float_t q1;
-               cnew.SetIndex(cnew.GetMultiplicity(cath), cath, c->GetIndex(i,cath));
-
-               fSeg2[cath]->SetPad(fInput->DetElemId(),fIx[i][cath], fIy[i][cath]);
-               q1 = fInput->Mathieson()->IntXY(fInput->DetElemId(),fSeg2[cath]);
-               
-               cnew.SetContrib(i, cath, q1*Float_t(cnew.GetCharge(cath))/Float_t(fQ[i][cath]));
-               cnew.SetMultiplicity(cath, cnew.GetMultiplicity(cath)+1 );
-           }
-           FillCluster(&cnew,0,cath);
-       } // cathode loop
-       cnew.SetClusterType(cnew.PhysicsContribution());
-       if (cnew.GetCharge(0)>0 && cnew.GetCharge(1)>0) AddRawCluster(cnew);
-       fNPeaks++;
-    }
-}
-void AliMUONClusterFinderVS::AddRawCluster(AliMUONRawCluster& c)
-{
-/// Add a raw cluster copy to the list
-
-  // Setting detection element in raw cluster for alignment
-  // BB 19/05/05
-  c.SetDetElemId(fInput->DetElemId());
-  
-  TClonesArray &lrawcl = *fRawClusters;
-  new(lrawcl[fNRawClusters++]) AliMUONRawCluster(c);
-  AliDebug(1,Form("\nfNRawClusters %d\n",fNRawClusters));
-}
-
-AliMUONClusterFinderVS& AliMUONClusterFinderVS
-::operator = (const AliMUONClusterFinderVS& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
-//
-// Minimisation functions
-// Single Mathieson
-void fcnS1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
-{
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());    
-    Int_t i;
-    Float_t delta;
-    Float_t chisq=0;
-    Float_t qcont=0;
-    Float_t qtot=0;
-
-    for (i=0; i<clusterInput.Nmul(0); i++) {
-       Float_t q0=clusterInput.Charge(i,0);
-       Float_t q1=clusterInput.DiscrChargeS1(i,par);
-       delta=(q0-q1)/q0;
-       chisq+=delta*delta;
-       qcont+=q1;
-       qtot+=q0;
-    }
-    f=chisq;
-}
-
-void fcnCombiS1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
-{
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());    
-    Int_t i, cath;
-    Float_t delta;
-    Float_t chisq=0;
-    Float_t qcont=0;
-    Float_t qtot=0;
-
-    for (cath=0; cath<2; cath++) {
-       for (i=0; i<clusterInput.Nmul(cath); i++) {
-           Float_t q0=clusterInput.Charge(i,cath);
-           Float_t q1=clusterInput.DiscrChargeCombiS1(i,par,cath);
-           delta=(q0-q1)/q0;
-           chisq+=delta*delta;
-           qcont+=q1;
-           qtot+=q0;
-       }
-    }
-    f=chisq;
-}
-
-// Double Mathieson
-void fcnS2(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
-{
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());    
-    Int_t i;
-    Float_t delta;
-    Float_t chisq=0;
-    Float_t qcont=0;
-    Float_t qtot=0;
-    
-    for (i=0; i<clusterInput.Nmul(0); i++) {
-
-       Float_t q0=clusterInput.Charge(i,0);
-       Float_t q1=clusterInput.DiscrChargeS2(i,par);
-       delta=(q0-q1)/q0;
-       chisq+=delta*delta;
-       qcont+=q1;
-       qtot+=q0;
-    }
-    f=chisq;
-}
-
-// Double Mathieson
-void fcnCombiS2(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
-{
-    AliMUONClusterInput& clusterInput = *(AliMUONClusterInput::Instance());    
-    Int_t i, cath;
-    Float_t delta;
-    Float_t chisq=0;
-    Float_t qcont=0;
-    Float_t qtot=0;
-    for (cath=0; cath<2; cath++) {
-       for (i=0; i<clusterInput.Nmul(cath); i++) {
-           Float_t q0=clusterInput.Charge(i,cath);
-           Float_t q1=clusterInput.DiscrChargeCombiS2(i,par,cath);
-           delta=(q0-q1)/q0;
-           chisq+=delta*delta;
-           qcont+=q1;
-           qtot+=q0;
-       }
-    }
-    f=chisq;
-}
diff --git a/MUON/AliMUONClusterFinderVS.h b/MUON/AliMUONClusterFinderVS.h
deleted file mode 100644 (file)
index 0cedb06..0000000
+++ /dev/null
@@ -1,142 +0,0 @@
-#ifndef ALIMUONCLUSTERFINDERVS_H
-#define ALIMUONCLUSTERFINDERVS_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
-
-/// \ingroup rec
-/// \class AliMUONClusterFinderVS
-/// \brief Class for clustering and reconstruction of space points
-///
-/// (Not used by default)
-
-#include <TObject.h>
-
-class TClonesArray;
-
-class AliMUONClusterInput;
-class AliMUONDigitMapA1;
-class AliMUONGeometrySegmentation;
-class AliMUONRawCluster;
-class AliMUONDigit;
-
-
-class AliMUONClusterFinderVS : public TObject 
-{
- public:
-    AliMUONClusterFinderVS();
-    virtual ~AliMUONClusterFinderVS();
-/// Decluster ?
-    virtual void SetDeclusterFlag(Int_t flag=1) {fDeclusterFlag =flag;}
-/// Set max. cluster size ; bigger clusters will deconvoluted
-    virtual void SetClusterSize(Int_t clsize=5) {fClusterSize = clsize;}
-/// Set max. number of pads per local cluster
-    virtual void SetNperMax(Int_t npermax=5) {fNperMax = npermax;}
-// Search for raw clusters
-    virtual void  FindRawClusters();
-// Find cluster    
-    virtual void  FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONRawCluster &c);
-// Decluster
-    virtual void Decluster(AliMUONRawCluster *cluster);
-//  Perform split by local maxima  
-    virtual void   SplitByLocalMaxima(AliMUONRawCluster *cluster);
-    virtual void   FindLocalMaxima(AliMUONRawCluster *cluster);
-    virtual void   Split(AliMUONRawCluster * cluster);
-//  Perform Double Mathieson Fit
-    Bool_t  DoubleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
-    Float_t CombiDoubleMathiesonFit(AliMUONRawCluster *c);
-    Float_t SingleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
-    Float_t CombiSingleMathiesonFit(AliMUONRawCluster *c);    
-//  Build up full cluster information    
-    virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t flag, Int_t cath);
-    virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t cath);
-/// \todo add comment    
-    virtual void   FillCluster(AliMUONRawCluster *cluster) {FillCluster(cluster,1,0);}
-// Add a new raw cluster    
-    virtual void AddRawCluster(AliMUONRawCluster& cluster);
-/// Set tracks for debugging    
-    virtual void SetTracks(Int_t t1, Int_t t2) {fTrack[0]=t1; fTrack[1]=t2;}
-/// Set cut in charge matching chi2
-    void SetGhostChi2Cut(Float_t cut) {fGhostChi2Cut = cut;}
-/// Get raw cluster pointer 
-    TClonesArray*  GetRawClusters() {return fRawClusters;}
-/// Reset raw clusters
-    void ResetRawClusters();
-/// Set evt number
-    void SetEventNumber(Int_t evtNumber) {fEvtNumber = evtNumber;}
-
- protected:
-
-    AliMUONClusterInput*          fInput;        //!< AliMUONClusterInput instance
-    AliMUONDigitMapA1*            fDigitMap[2];  ///< Hit Maps for cathode 1 and 2
-    AliMUONGeometrySegmentation*  fSeg2[2];      ///< New Segmentations for cathode 1 and 2
-
-    
-// Configuration    
-    Int_t                   fDeclusterFlag;      ///< flag for declusterin
-    Int_t                   fClusterSize;        ///< cluster size 
-    Int_t                   fNperMax;            ///< Maximum number of pads per peak
-    Float_t                 fGhostChi2Cut;       ///< \brief Cut in charge matching chi2
-                                                /// (2 degrees of freedom)
-                                                 /// Used by ghost removal
-    // Current decluster result    
-    Int_t                   fMul[2];             ///< current multiplicity
-    Int_t                   fNPeaks;             ///< number of local maxima
-    Int_t                   fNRawClusters;       ///< Number of Raw Clusters
-    TClonesArray*           fRawClusters;        ///< array of cluster per ch.
-
-    // Local data store    
-    AliMUONDigit*           fDig[100][2];        ///< current list of digits 
-    Int_t                   fIx[100][2];         ///< current list of x-pad-coord.
-    Int_t                   fIy[100][2];         ///< current list of y-pad-coord.
-    Float_t                 fX[100][2];          ///< current list of x-coord.
-    Float_t                 fY[100][2];          ///< current list of y-coord.
-    Float_t                 fZ[100][2];          ///< current list of z-coord.
-    Int_t                   fIndLocal[100][2];   ///< indices of local maxima
-    Int_t                   fNLocal[2];          ///< Number of local maxima
-    Float_t                   fQ[100][2];          ///< current list of charges
-    Float_t                 fZPlane;             ///< currenz z-plane position
-    Int_t                   fSector;             ///< current sector
-    
-    // Current Fit
-    Double_t                 fXFit[2];         ///< x-coordinate
-    Double_t                 fYFit[2];         ///< y-coordinate
-    Double_t                 fQrFit[2];        ///< charge ratio
-    Float_t                  fChi2[2];         ///< chi2 of fit
-    Float_t                  fXInit[2];        ///< start values
-    Float_t                  fYInit[2];        ///< start values
-    Float_t                  fQrInit[2];       ///< start values
-    Int_t                    fFitStat;         ///< status of fit
-    
-    // Selected track for debugging
-    Int_t                    fTrack[2];        ///< Only digits with main contributions from these tracks are
-    // considered 
-    
-    Int_t                    fEvtNumber;       ///< evt number for AZ
-    
- private:
-    /// Not implemented
-    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
-    /// Not implemented assignment operator
-    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
-
-    ClassDef(AliMUONClusterFinderVS,3) //Class for clustering and reconstruction of space points
-      };
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/MUON/AliMUONClusterInput.cxx b/MUON/AliMUONClusterInput.cxx
deleted file mode 100644 (file)
index 159473f..0000000
+++ /dev/null
@@ -1,272 +0,0 @@
-/**************************************************************************
- * 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 AliMUONClusterInput
-// ----------------------------
-// Global data service for hit reconstruction
-// Author: to be added
-
-#include "AliMUONClusterInput.h"
-
-#include "AliMUONGeometryTransformer.h"
-#include "AliMUONGeometrySegmentation.h"
-#include "AliMUONSegFactory.h"
-#include "AliMUONSegmentation.h"
-#include "AliMUONConstants.h"
-#include "AliMUONMathieson.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONDigit.h"
-
-#include "AliLog.h"
-
-#include <TClonesArray.h>
-#include <TClass.h>
-#include <TMinuit.h>
-#include <TGeoManager.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONClusterInput)
-/// \endcond
-
-AliMUONClusterInput*        AliMUONClusterInput::fgClusterInput = 0; 
-TMinuit*                    AliMUONClusterInput::fgMinuit = 0; 
-AliMUONMathieson*           AliMUONClusterInput::fgMathieson = 0; 
-AliMUONGeometryTransformer* AliMUONClusterInput::fgTransformer = 0; 
-AliMUONSegmentation*        AliMUONClusterInput::fgSegmentation = 0; 
-
-//______________________________________________________________________________
-AliMUONClusterInput::AliMUONClusterInput()
-  : TObject(),
-    fNseg(0),
-    fChamber(0),
-    fCluster(0),
-    fZ(0.),
-    fChargeCorrel(1.),
-    fDetElemId(0)
-  
-{
-/// Default constructor
-
-  fDigits[0]=0;
-  fDigits[1]=0;
-  fSegmentation2[0]=0;
-  fSegmentation2[1]=0;
-}
-
-//______________________________________________________________________________
-AliMUONClusterInput* AliMUONClusterInput::Instance()
-{
-/// return pointer to the singleton instance
-    if (fgClusterInput == 0) {
-       fgClusterInput = new AliMUONClusterInput();
-       fgMinuit = new TMinuit(8);
-       
-       // Create segmentation with activated Root geometry  
-       if ( ! gGeoManager ) {
-         AliFatalClass("Geometry not loaded.");
-         return fgClusterInput;
-       }  
-        fgTransformer = new AliMUONGeometryTransformer(true);
-        fgTransformer->ReadGeometryData("volpath.dat", gGeoManager);
-        AliMUONSegFactory factory(fgTransformer);
-       fgSegmentation = factory.CreateSegmentation(); 
-    }
-    
-    return fgClusterInput;
-}
-
-//______________________________________________________________________________
-AliMUONClusterInput::~AliMUONClusterInput()
-{
-/// Destructor
-    delete fgMinuit;
-    delete fgMathieson;
-    delete fgTransformer;
-    delete fgSegmentation;
-    fgMinuit = 0;
-    fgMathieson = 0;
-}
-
-//______________________________________________________________________________
-void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
-{
-  /// Set pointer to digits with corresponding segmentations and responses (two cathode planes)
-    fChamber = chamber;
-    fDetElemId = idDE;
-    fDigits[0]  = dig1;
-    fDigits[1]  = dig2; 
-    fNDigits[0] = dig1->GetEntriesFast();
-    fNDigits[1] = dig2->GetEntriesFast();
-    
-    delete fgMathieson;
-    fgMathieson = new AliMUONMathieson();
-
-    fSegmentation2[0]= fgSegmentation->GetModuleSegmentationByDEId(fDetElemId, 0);
-    fSegmentation2[1]= fgSegmentation->GetModuleSegmentationByDEId(fDetElemId, 1);
-
-    fNseg = 2;
-    if (chamber < AliMUONConstants::NTrackingCh()) {
-      if (chamber > 1 ) {
-       fgMathieson->SetPitch(AliMUONConstants::Pitch());
-       fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3());
-       fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3());
-       fChargeCorrel = AliMUONConstants::ChargeCorrel();
-      } else {
-       fgMathieson->SetPitch(AliMUONConstants::PitchSt1());
-       fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3St1());
-       fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3St1());
-       fChargeCorrel = AliMUONConstants::ChargeCorrelSt1();
-      }
-    }
-}
-
-//______________________________________________________________________________
-void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig)
-{
-/// Set pointer to digits with corresponding segmentations and responses (one cathode plane)
-
-    fChamber = chamber;
-    fDetElemId = idDE;
-    fDigits[0] = dig;
-
-    fSegmentation2[0]= fgSegmentation->GetModuleSegmentationByDEId(fDetElemId, 0);
-    fNseg=1;
-}
-
-//______________________________________________________________________________
-void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
-{
-/// Set the current cluster
-  //PH printf("\n %p \n", cluster);
-  fCluster=cluster;
-  Float_t qtot;
-  Int_t   i, cath, ix, iy;
-  AliMUONDigit* digit;
-  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++) {
-    qtot=0;
-    for (i=0; i<fNmul[cath]; i++) {
-      // pointer to digit
-      digit =(AliMUONDigit*)
-               (fDigits[cath]->UncheckedAt(cluster->GetIndex(i,cath)));
-           // pad coordinates
-           ix = digit->PadX();
-           iy = digit->PadY();
-           // pad charge
-           fCharge[i][cath] = digit->Signal();
-           // pad centre coordinates
-//         fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
-            // globals kUsed in fitting functions
-           fix[i][cath]=ix;
-           fiy[i][cath]=iy;
-           // total charge per cluster
-           qtot+=fCharge[i][cath];
-           // Current z
-           Float_t xc, yc;
-           fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
-       } // loop over cluster digits
-       fQtot[cath]=qtot;
-       fChargeTot[cath]=Int_t(qtot);  
-    }  // loop over cathodes
-}
-
-//______________________________________________________________________________
-Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par) 
-{
-/// Compute the charge on first cathod only.
-return DiscrChargeCombiS1(i,par,0);
-}
-
-//______________________________________________________________________________
-Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath) 
-{
-/// \todo add comment
-/// - par[0]    x-position of cluster
-/// - param par[1]    y-position of cluster
-
-   Float_t q1;
-   fSegmentation2[cath]-> SetPad(fDetElemId, fix[i][cath], fiy[i][cath]);
-   //  First Cluster
-   fSegmentation2[cath]-> SetHit(fDetElemId, par[0],par[1],fZ);
-   q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
-       
-   Float_t value = fQtot[cath]*q1;
-   return value;
-}
-
-
-//______________________________________________________________________________
-Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par) 
-{
-/// \todo add comment
-/// - par[0]    x-position of first  cluster
-/// - par[1]    y-position of first  cluster
-/// - par[2]    x-position of second cluster
-/// - par[3]    y-position of second cluster
-/// - par[4]    charge fraction of first  cluster
-/// - 1-par[4]  charge fraction of second cluster
-
-  Float_t q1, q2;
-  
-  fSegmentation2[0]->SetPad(fDetElemId, fix[i][0], fiy[i][0]);
-  //  First Cluster
-  fSegmentation2[0]->SetHit(fDetElemId, par[0],par[1],fZ);
-  q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
-
-  //  Second Cluster
-  fSegmentation2[0]->SetHit(fDetElemId,par[2],par[3],fZ);
-  q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
-  
-  Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
-  return value;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath) 
-{
-/// \todo add comment
-/// - par[0]    x-position of first  cluster
-/// - par[1]    y-position of first  cluster
-/// - par[2]    x-position of second cluster
-/// - par[3]    y-position of second cluster
-/// - par[4]    charge fraction of first  cluster - first cathode
-/// - 1-par[4]  charge fraction of second cluster 
-/// - par[5]    charge fraction of first  cluster - second cathode
-
-  Float_t q1, q2;
-
-  fSegmentation2[cath]->SetPad(fDetElemId,fix[i][cath], fiy[i][cath]);
-  //  First Cluster
-  fSegmentation2[cath]->SetHit(fDetElemId,par[0],par[1],fZ);
-  q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
-  
-  //  Second Cluster
-  fSegmentation2[cath]->SetHit(fDetElemId,par[2],par[3],fZ);
-  q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
-  
-  Float_t value;
-  if (cath==0) {
-    value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
-  } else {
-    value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
-  }
-  return value;
-}
diff --git a/MUON/AliMUONClusterInput.h b/MUON/AliMUONClusterInput.h
deleted file mode 100644 (file)
index 8aec46f..0000000
+++ /dev/null
@@ -1,113 +0,0 @@
-#ifndef ALIMUONCLUSTERINPUT_H
-#define ALIMUONCLUSTERINPUT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id $*/
-// Revision of includes 07/04/2006
-
-/// \ingroup rec
-/// \class AliMUONClusterInput
-/// \brief Global data service for hit reconstruction
-
-#include <TObject.h>
-#include <TClonesArray.h> // needed for inline function Digit
-
-class AliMUONDigit;
-class AliMUONRawCluster;
-class AliMUONMathieson;
-class AliMUONGeometryTransformer;
-class AliMUONSegmentation;
-class AliMUONGeometrySegmentation;
-
-class TMinuit;
-
-class AliMUONClusterInput : public TObject 
-{
- public:
-    virtual ~AliMUONClusterInput();
-    static AliMUONClusterInput* Instance();
-//  Configuration
-    void SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2);
-    void SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig);
-    void SetCluster(AliMUONRawCluster* cluster);
-// Access functions
-    /// Return the current chamber number
-    Int_t Chamber() const {return fChamber;}
-    /// Return i-th digit for given cath
-    AliMUONDigit* Digit(Int_t cath, Int_t i) const {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
-    /// Return the array of digits for given cathod 
-    TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
-    /// Return number of digits for given cathod 
-    Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
-    /// Return geometry segmentation for given cathod 
-    AliMUONGeometrySegmentation* Segmentation2(Int_t cath) const {return fSegmentation2[cath];}
-
-    /// Return Mathieson    
-    AliMUONMathieson* Mathieson() const {return fgMathieson;}    
-    /// Return charge correlation
-    Float_t ChargeCorrel() const {return fChargeCorrel;}    
-    /// Return detection elt id
-    Int_t DetElemId() const {return fDetElemId;}
-
-// Fitting    
-    /// Return the fitter
-    TMinuit*      Fitter() const {return fgMinuit;}
-// Current cluster information    
-    /// Return the total charge for given cathod 
-    Float_t       TotalCharge(Int_t cath) const {return fChargeTot[cath];}
-    /// Return the charge for the given cluster and cathod
-    Float_t       Charge(Int_t dig, Int_t cath) const {return fCharge[dig][cath];}
-    /// Return the x-position for the given cluster and cathod
-    Int_t         Ix(Int_t dig, Int_t cath) const {return fix[dig][cath];}
-    /// Return the y-position for the given cluster and cathod
-    Int_t         Iy(Int_t dig, Int_t cath) const {return fiy[dig][cath];}
-    /// Return the cluster multiplicity for given cathod 
-    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);
-    Float_t DiscrChargeS2(Int_t i,Double_t *par);
-    Float_t DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath);
-// 
- private:
-    /// Not implemented
-    AliMUONClusterInput();
-    /// Not implemented
-    AliMUONClusterInput(const AliMUONClusterInput& clusterInput);
-    /// Not implemented
-    AliMUONClusterInput & operator = (const AliMUONClusterInput& rhs);
-
-    static AliMUONClusterInput*  fgClusterInput;  //!< singleton instance
-    static AliMUONMathieson*     fgMathieson;     //!< Mathieson
-    static AliMUONGeometryTransformer*  fgTransformer;  //!< Geometry transformer
-    static AliMUONSegmentation*  fgSegmentation;  //!< Segmentation
-
-    // Digits
-    TClonesArray*        fDigits[2];       //!< Array of pointers to digits
-    Int_t                fNDigits[2];      //!< Number of digits
-    AliMUONGeometrySegmentation*     fSegmentation2[2]; //!< Geometry Segmentation per cathode
-
-    Int_t                fNseg;            //!< number of cathode planes
-    Int_t                fChamber;         //!< Current chamber number
-    
-    // Current cluster
-    AliMUONRawCluster*   fCluster;         //!< current cluster
-    Int_t                fNmul[2];         //!< current cluster multiplicity
-    // Digits contribuing to current cluster
-    Int_t                fix[500][2];      //!< List of x-positions for current cluster
-    Int_t                fiy[500][2];      //!< List of y-positions for current cluster
-    Float_t              fCharge[500][2];  //!< List of charges for current cluster
-    Int_t                fChargeTot[2];    //!< Total charge
-    Float_t              fQtot[2];         //!< Total charge
-    Float_t              fZ;               //!< Current z-position
-    Float_t              fChargeCorrel;    //!< charge correlation 
-    Int_t                fDetElemId;       //!< detection elt id    
-
-    // Fitter
-    static TMinuit*      fgMinuit;          //!< Fitter
-    ClassDef(AliMUONClusterInput, 0)        // Global data service for hit reconstruction
-};
-#endif
-
diff --git a/MUON/AliMUONData.cxx b/MUON/AliMUONData.cxx
deleted file mode 100644 (file)
index e0d5bfd..0000000
+++ /dev/null
@@ -1,744 +0,0 @@
-/**************************************************************************
- * 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 AliMUONData
-///
-/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
-/// The classe makes the lik between the MUON data lists and the event trees from loaders
-///
-/// \author Gines Martinez, Subatech,  September 2003
-///
-
-#include "AliMUONData.h"
-#include "AliMUONDataIterator.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONGlobalTrigger.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONRegionalTrigger.h"
-#include "AliMUONTriggerCrateStore.h"
-#include "AliMUONTriggerCircuit.h"
-#include "AliMUONGeometryTransformer.h"
-#include "AliMUONRawCluster.h"
-
-#include "AliRunLoader.h"
-#include "AliStack.h"
-#include "AliLog.h"
-
-#include <TString.h>
-#include <TParticle.h>
-#include <TNtuple.h>
-#include <Riostream.h>
-#include <TFile.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONData)
-/// \endcond
-//_____________________________________________________________________________
-  AliMUONData::AliMUONData():
-    TNamed(),
-    fRunLoader(0x0),
-    fLoader(0x0),
-    fSDigits(0x0),
-    fDigits(0x0),
-    fGlobalTrigger(0x0),
-    fLocalTrigger(0x0),
-    fRegionalTrigger(0x0),
-    fNSdigits(0x0),
-    fNdigits(0x0),
-    fNglobaltrigger(0),
-    fNlocaltrigger(0),
-    fNregionaltrigger(0),
-    fSplitLevel(0),
-    fCurrentEvent(-1)
-{
-/// Default constructor
-}
-//_____________________________________________________________________________
-AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
-  TNamed(name,title),
-    fRunLoader(0x0),
-    fLoader(loader),
-    fSDigits(0x0),
-    fDigits(0x0),
-    fGlobalTrigger(0x0),
-    fLocalTrigger(0x0),
-    fRegionalTrigger(0x0),
-    fNSdigits(0x0),
-    fNdigits(0x0),
-    fNglobaltrigger(0),
-    fNlocaltrigger(0),
-    fNregionaltrigger(0),
-    fSplitLevel(0),
-    fCurrentEvent(-1)
-{
-/// Standard constructor
-}
-
-//_____________________________________________________________________________
-AliMUONData::AliMUONData(const char* galiceFile, const char* folderName):
-  TNamed("MUON", "MUON"),
-    fRunLoader(0x0),
-    fLoader(0x0),
-    fSDigits(0x0),
-    fDigits(0x0),
-    fGlobalTrigger(0x0),
-    fLocalTrigger(0x0),
-    fRegionalTrigger(0x0),
-    fNSdigits(0x0),
-    fNdigits(0x0),
-    fNglobaltrigger(0),
-    fNlocaltrigger(0),
-    fNregionaltrigger(0),
-    fSplitLevel(0),
-    fCurrentEvent(-1)
-{
-/// Constructor for loading data from gAlice file
-
-  fRunLoader = AliRunLoader::Open(galiceFile, folderName, "READ");
-  if (!fRunLoader) {
-    AliError(Form("Error opening %s file \n", galiceFile));
-    return;
-  }  
-
-  fLoader = fRunLoader->GetLoader("MUONLoader");
-  if ( ! fLoader ) {
-    AliError(Form("Could get MUONLoader"));
-    return;
-  }  
-}
-
-//_____________________________________________________________________________
-AliMUONData::~AliMUONData()
-{
-/// Destructor for AliMUONData
-  
-  if (fSDigits) {
-    fSDigits->Delete();
-    delete fSDigits;
-  }
-
-  if (fDigits) {
-    fDigits->Delete();
-    delete fDigits;
-  }
-  if (fGlobalTrigger){
-    fGlobalTrigger->Delete();
-    delete fGlobalTrigger;
-  }  
-  if (fRegionalTrigger){
-    fRegionalTrigger->Delete();
-    delete fRegionalTrigger;
-  }
-  if (fLocalTrigger){
-    fLocalTrigger->Delete();
-    delete fLocalTrigger;
-  }
-
-  if (fRunLoader) {
-    fRunLoader->UnloadAll();
-    delete fRunLoader;
-  }  
-}
-//_____________________________________________________________________________
-void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
-{
-/// Add a MUON Sdigit to the list of SDigits of the detection plane id
-
-  TClonesArray &lSdigits = * SDigits(id) ; 
-  new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
-}
-//_____________________________________________________________________________
-void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
-{
-/// Add a MUON digit to the list of Digits of the detection plane id
-
-  TClonesArray &ldigits = * Digits(id) ; 
-  new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
-}
-
-//_____________________________________________________________________________
-void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
-{
-/// Add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
-
-  TClonesArray &globalTrigger = *fGlobalTrigger;
-  new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
-}
-
-//____________________________________________________________________________
-void AliMUONData::AddRegionalTrigger(const  AliMUONRegionalTrigger& trigger)
-{
-/// add a MUON regional Trigger to the list
-  TClonesArray &regionalTrigger = *fRegionalTrigger;
-  new(regionalTrigger[fNregionaltrigger++]) AliMUONRegionalTrigger(trigger);
-}
-//____________________________________________________________________________
-void AliMUONData::AddLocalTrigger(const  AliMUONLocalTrigger& trigger)
-{
-/// add a MUON Local Trigger to the list
-
-  TClonesArray &localTrigger = *fLocalTrigger;
-  new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
-}
-
-//____________________________________________________________________________
-TClonesArray*  AliMUONData::SDigits(Int_t DetectionPlane) const
-{
-/// Getting List of SDigits
-
-  if (fSDigits)
-    return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
-  else
-    return NULL;
-}
-//____________________________________________________________________________
-TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane) const
-{
-/// Getting List of Digits
-
-  if (fDigits)
-    return ( (TClonesArray*) fDigits->At(DetectionPlane) );
-  else
-    return NULL;
-}
-//____________________________________________________________________________
-Bool_t   AliMUONData::IsDigitsBranchesInTree()
-{
-/// Checking if there are Digits Branches In TreeD
-
-  if (TreeD()==0x0) {
-    AliError("No treeD in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sDigits1",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeD()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-//____________________________________________________________________________
-Bool_t   AliMUONData::IsTriggerBranchesInTreeD()
-{
-/// Checking if there are Trigger Branches In TreeD
- if (TreeD()==0x0) {
-    AliError("No treeD in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sLocalTrigger",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeD()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-
-//____________________________________________________________________________
-void AliMUONData::Fill(Option_t* option)
-{
-/// Method to fill the trees
-
-  const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
-  const char *cD   = strstr(option,"D");   // Digits branches in TreeD
-  const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
-  
-  char branchname[30];
-  TBranch * branch = 0x0;
-
-  // Filling TreeS
-  if ( TreeS() && cS) 
-  {
-    TreeS()->Fill();
-  }
-
-  // Filling TreeD
-
-  if ( TreeD() && cD && cGLT )
-  {
-    // Writing digits and (global+local) trigger at once.
-    TreeD()->Fill();
-  }
-  else
-  {
-    if ( TreeD() && cD ) 
-    {
-      if ( IsTriggerBranchesInTreeD() ) 
-      {
-        for (int i=0; i<AliMUONConstants::NCh(); i++) 
-        {
-          sprintf(branchname,"%sDigits%d",GetName(),i+1);
-          branch = TreeD()->GetBranch(branchname);
-          branch->Fill();
-        }
-      } 
-      else
-      {
-        TreeD()->Fill();
-      }
-    }
-    
-    if ( TreeD() && cGLT ) 
-    {
-      if ( IsDigitsBranchesInTree() ) 
-      {
-        sprintf(branchname,"%sLocalTrigger",GetName());
-        branch = TreeD()->GetBranch(branchname); 
-        branch->Fill();
-       sprintf(branchname,"%sRegionalTrigger",GetName());
-        branch = TreeD()->GetBranch(branchname);
-        branch->Fill();
-        sprintf(branchname,"%sGlobalTrigger",GetName());
-        branch = TreeD()->GetBranch(branchname);
-        branch->Fill();
-
-      } 
-      else
-      {
-        TreeD()->Fill();
-      }
-    }
-  } // end of TreeD() handling.
-}
-
-//_____________________________________________________________________________
-void AliMUONData::MakeBranch(Option_t* option)
-{
-/// Create Tree branches for the MUON.
-
-  const Int_t kBufferSize = 4000;
-  char branchname[30];
-  
-  //Setting Data Container
-  SetDataContainer(option);  
-
-  const char *cS   = strstr(option,"S");   // Digits branches in TreeS
-  const char *cD   = strstr(option,"D");   // Digits branches in TreeD
-  const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
-  
-  TBranch * branch = 0x0;
-  
-  //Creating Branches for SDigits
-  if (TreeS() && cS ) {
-    // one branch for Sdigits per chamber
-    for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
-      sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
-      branch = 0x0;
-      branch = TreeS()->GetBranch(branchname);
-      if (branch) {  
-        AliInfo(Form("Branch %s is already in tree.",branchname));
-        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);
-    }
-  }
-
-  //Creating Branches for Digits
-  TTree* treeD = 0x0;
-  if ( cD || cGLT )
-  {
-    treeD = TreeD();
-  }
-
-  if ( treeD && cD ) 
-  {
-    // one branch for digits per chamber
-    for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) 
-    {
-      sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
-      branch = treeD->GetBranch(branchname);
-      if (branch) 
-      {  
-        AliInfo(Form("Branch %s is already in tree.",branchname));
-        return;
-      }
-      TClonesArray * digits = Digits(iDetectionPlane); 
-      branch = treeD->Branch(branchname, &digits, kBufferSize,1);
-    }
-  }
-  
-  if ( treeD && cGLT ) 
-  {
-    //
-    // one branch for global trigger
-    //
-    sprintf(branchname,"%sGlobalTrigger",GetName());
-    branch = treeD->GetBranch(branchname);
-    if (branch) 
-    {  
-      AliInfo(Form("Branch GlobalTrigger is already in treeD."));
-      return ;
-    }
-    branch = treeD->Branch(branchname, &fGlobalTrigger, kBufferSize);
-
-  //
-    // one branch for regional trigger
-    //  
-    sprintf(branchname,"%sRegionalTrigger",GetName());
-    branch = 0x0;
-    branch = treeD->GetBranch(branchname);
-    if (branch) 
-    {  
-      AliInfo(Form("Branch RegionalTrigger is already in treeD."));
-      return;
-    }
-    branch = treeD->Branch(branchname, &fRegionalTrigger, kBufferSize);
-  
-
-    //
-    // one branch for local trigger
-    //  
-    sprintf(branchname,"%sLocalTrigger",GetName());
-    branch = 0x0;
-    branch = treeD->GetBranch(branchname);
-    if (branch) 
-    {  
-      AliInfo(Form("Branch LocalTrigger is already in treeD."));
-      return;
-    }
-    branch = treeD->Branch(branchname, &fLocalTrigger, kBufferSize);
-  }
-}
-
-//____________________________________________________________________________
-TClonesArray*  
-AliMUONData::LocalTrigger() const
-{
-/// Getting local trigger
-
-  return fLocalTrigger;
-}
-
-//____________________________________________________________________________
-TClonesArray*  
-AliMUONData::RegionalTrigger() const
-{
-/// Getting regional trigger
-
-  return fRegionalTrigger;
-}
-
-//____________________________________________________________________________
-void
-AliMUONData::GetDigits() const 
-{
-/// Load the digits from TreeD for the current event.
-
-  Int_t event = fLoader->GetRunLoader()->GetEventNumber();
-  if ( fCurrentEvent != event )
-  {
-    if (fLoader->TreeD()) {
-      fLoader->TreeD()->GetEvent(0);
-      fCurrentEvent = event;
-    }
-  }
-}
-
-//____________________________________________________________________________
-TClonesArray*  
-AliMUONData::GlobalTrigger() const
-{
-/// Return the global trigger 
-
-  return fGlobalTrigger;
-}
-
-//____________________________________________________________________________
-void AliMUONData::ResetSDigits()
-{
-/// Reset number of Sdigits and the Sdigits array for this detector
-
-    if (fSDigits == 0x0) return;
-    for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
-      if ((*fSDigits)[i])    ((TClonesArray*)fSDigits->At(i))->Clear();
-      if (fNSdigits)  fNSdigits[i]=0;
-    }
-}
-//____________________________________________________________________________
-void AliMUONData::ResetDigits()
-{
-/// Reset number of digits and the digits array for this detector
-
-    if (fDigits == 0x0) return;
-    for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
-      if ((*fDigits)[i])    ((TClonesArray*)fDigits->At(i))->Clear("C");
-      if (fNdigits)  fNdigits[i]=0;
-    }
-}
-//_______________________________________________________________________________
-void AliMUONData::ResetTrigger()
-{
-/// Reset Local and Global Trigger 
-
-  fNglobaltrigger = 0;
-  if (fGlobalTrigger) fGlobalTrigger->Clear();
-  fNregionaltrigger = 0;
-  if (fRegionalTrigger) fRegionalTrigger->Clear();
-  fNlocaltrigger = 0;
-  if (fLocalTrigger) fLocalTrigger->Clear();
-
-}
-//____________________________________________________________________________
-void AliMUONData::SetDataContainer(Option_t* option)
-{
-/// Setting data containers of muon data
-
-  const char *cS   = strstr(option,"S");   // SDigits
-  const char *cD   = strstr(option,"D");   // Digits
-  const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger
-
-  AliDebug(1,Form("option=%s",option));
-  
-  //
-  // Container for Sdigits
-  if (cS) {
-    if (fSDigits == 0x0) { 
-      AliDebug(1,"Creating fSDigits TObjArray");
-      fSDigits = new TObjArray(AliMUONConstants::NCh());
-      fNSdigits= new Int_t[AliMUONConstants::NCh()];
-      for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-       TClonesArray* a = new TClonesArray("AliMUONDigit",10000);
-       a->SetOwner();
-       fSDigits->AddAt(a,i);
-       AliDebug(1,Form("fSDigits[%d]=%p",i,a));
-        fNSdigits[i]=0;
-      }
-    }
-    else {
-      AliDebug(1,Form("fSDigits already there = %p",fSDigits));
-    }
-    ResetSDigits();
-  }  
-
-  //
-  // ObjArray of ClonesArrays for Digits
-  if ( cD ) {      
-    if (fDigits == 0x0 ) {
-      fDigits = new TObjArray(AliMUONConstants::NCh());
-      fNdigits= new Int_t[AliMUONConstants::NCh()];
-      for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-       TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
-       tca->SetOwner();
-        fDigits->AddAt(tca,i); 
-        fNdigits[i]=0;
-      }
-    } 
-    else {
-      AliDebug(1,Form("fDigits already there = %p",fDigits));
-    }
-    ResetDigits();
-  }
-
-  //
-  // ClonesArrays for Trigger
-  if ( cGLT ) { 
-    if (fLocalTrigger == 0x0) {
-      fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
-    }
-    if (fRegionalTrigger == 0x0) {
-      fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
-    }
-    if (fGlobalTrigger== 0x0) {
-      fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
-    }
-    ResetTrigger();
-  }
-}
-
-//____________________________________________________________________________
-void AliMUONData::SetTreeAddress(Option_t* option)
-{
-/// Setting Addresses to the events trees
-
-  // Setting Data containers
-  SetDataContainer(option);
-
-  const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
-  const char *cD   = strstr(option,"D");   // Digits branches in TreeD
-  const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeD
-  
-  // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
-  char branchname[30];
-  TBranch * branch = 0x0;
-  
-  AliDebug(1,Form("option=%s",option));
-  
-  //
-  // Branch address for Sdigit tree
-  if (TreeS() && fSDigits && cS) {
-    AliDebug(1,"Setting branch addresses");
-    for (int i=0; i<AliMUONConstants::NCh(); i++) {
-      sprintf(branchname,"%sSDigits%d",GetName(),i+1);
-      if (fSDigits) {
-        AliDebug(1,Form("TreeS=%p for ich=%d branchname=%s",
-                        TreeS(),i,branchname));
-        branch = TreeS()->GetBranch(branchname);
-        TClonesArray * sdigits = SDigits(i);
-        if (branch) branch->SetAddress( &sdigits );
-        else AliWarning(Form("(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i));
-      }
-    }
-  }
-
-  //
-  // Branch address for digit tree
-  if (TreeD() && fDigits && cD) {
-    for (int i=0; i<AliMUONConstants::NCh(); i++) {
-      sprintf(branchname,"%sDigits%d",GetName(),i+1);
-      if (fDigits) {
-        branch = TreeD()->GetBranch(branchname);
-        TClonesArray * digits = Digits(i);
-        if (branch) {
-          branch->SetAddress( &digits );
-        }
-        else AliWarning(Form("(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i));
-      }
-    }
-  }
-  if ( TreeD()  && fLocalTrigger && cGLT) {
-    sprintf(branchname,"%sLocalTrigger",GetName());
-    branch = TreeD()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fLocalTrigger);
-    else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeD.",GetName()));
-  }
- if ( TreeD()  && fRegionalTrigger && cGLT) {
-    sprintf(branchname,"%sRegionalTrigger",GetName());
-    branch = TreeD()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fRegionalTrigger);
-    else AliWarning(Form("(%s) Failed for RegionalTrigger. Can not find branch in treeD.",GetName()));
-  }
-  if ( TreeD() && fGlobalTrigger && cGLT) {
-    sprintf(branchname,"%sGlobalTrigger",GetName());
-    branch = TreeD()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fGlobalTrigger);
-    else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeD.",GetName()));
-  }
-}
-
-//_____________________________________________________________________________
-void
-AliMUONData::Print(Option_t* opt) const
-{
-/// Dump object on screen
-
-  TString options(opt);
-  options.ToUpper();
-  
-  if ( options.Contains("D") )
-  {
-    for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich)
-    {
-      TClonesArray* digits = Digits(ich);
-      Int_t ndigits = digits->GetEntriesFast();
-      for ( Int_t id = 0; id < ndigits; ++id )
-      {
-        AliMUONDigit* digit = 
-          static_cast<AliMUONDigit*>(digits->UncheckedAt(id));
-        digit->Print();
-      }
-    }
-  }
-
-  if ( options.Contains("S") )
-  {
-    for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich)
-    {
-      TClonesArray* digits = SDigits(ich);
-      Int_t ndigits = digits->GetEntriesFast();
-      for ( Int_t id = 0; id < ndigits; ++id )
-      {
-        AliMUONDigit* digit = 
-        static_cast<AliMUONDigit*>(digits->UncheckedAt(id));
-        digit->Print();
-      }
-    }
-  }  
-}
-
-//_____________________________________________________________________________
-void 
-AliMUONData::DumpSDigits(Int_t event2Check, Option_t* opt)
-{
-/// Dump SDigits
-
-  fLoader->LoadSDigits("READ");
-  
-  // Event loop
-  Int_t nevents = fRunLoader->GetNumberOfEvents();
-  for (Int_t ievent=0; ievent<nevents; ievent++) {
-    if (event2Check!=0) ievent=event2Check;
-    printf(">>> Event %d \n",ievent);
-
-    // Getting event ievent
-    fRunLoader->GetEvent(ievent);
-    SetTreeAddress("S");
-    GetSDigits();
-
-    // Loop on chambers
-    Int_t nchambers = AliMUONConstants::NCh(); ;
-    for (Int_t ichamber=0; ichamber<nchambers; ichamber++) {
-      TClonesArray* digits = SDigits(ichamber);
-
-      // Loop on Sdigits
-      Int_t ndigits = (Int_t)digits->GetEntriesFast();
-      for (Int_t idigit=0; idigit<ndigits; idigit++) {
-        AliMUONDigit* mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
-        mDigit->Print(opt);
-      }
-    }
-    ResetSDigits();
-    if (event2Check!=0) ievent=nevents;
-  }
-  fLoader->UnloadSDigits();
-}
-//_____________________________________________________________________________
-void 
-AliMUONData::DumpDigits(Int_t event2Check, Option_t* opt)
-{
-/// Dump digits
-
-  fLoader->LoadDigits("READ");
-  
-  // Event loop
-  Int_t firstEvent = 0;
-  Int_t lastEvent = fRunLoader->GetNumberOfEvents()-1;
-  if ( event2Check != 0 ) {
-    firstEvent = event2Check;
-    lastEvent = event2Check;
-  }  
-  
-  for ( Int_t ievent = firstEvent; ievent <= lastEvent; ++ievent ) {
-    printf(">>> Event %d \n",ievent);
-    fRunLoader->GetEvent(ievent);
-
-    AliMUONDataIterator it(this, "digit", AliMUONDataIterator::kTrackingChambers);
-    AliMUONDigit* digit;
-     while ( ( digit = (AliMUONDigit*)it.Next() ) )
-     {
-       digit->Print(opt);
-     }
-  } 
-  fLoader->UnloadDigits();
-}
diff --git a/MUON/AliMUONData.h b/MUON/AliMUONData.h
deleted file mode 100644 (file)
index baff514..0000000
+++ /dev/null
@@ -1,151 +0,0 @@
-#ifndef ALIMUONDATA_H
-#define ALIMUONDATA_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
-//
-/// \ingroup base
-/// \class AliMUONData
-/// \brief Class containing MUON data: hits, digits, rawclusters, globaltrigger, 
-/// localtrigger, etc ...
-///
-//  Author: Gines Martinez, Subatech,  September 2003
-
-#include <TNamed.h>
-
-#include "AliLoader.h"
-
-class AliMUONDigit;
-class AliMUONLocalTrigger;
-class AliMUONRegionalTrigger;
-class AliMUONGlobalTrigger;
-
-class AliRunLoader;
-
-class TClonesArray;
-class TObjArray;
-class TTree;
-
-
-//__________________________________________________________________
-/////////////////////////////////////////////////////////////////////
-//                                                                 //
-//  class AliMUONData                                              //
-//                                                                 //
-/////////////////////////////////////////////////////////////////////
-
-class AliMUONData : public TNamed 
-{
-  public:
-  
-  //  enum EChamberIteration { kAllChambers, kTrackingChambers, kTriggerChambers };
-  
-    AliMUONData();
-    AliMUONData(AliLoader * loader, const char* name, const char* title);
-    AliMUONData(const char* galiceFile, const char* folderName);
-    virtual ~AliMUONData();  
-    virtual void   AddSDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
-    virtual void   AddDigit(Int_t id, const AliMUONDigit& digit); // use copy constructor
-
-    
-    virtual void   AddGlobalTrigger(const AliMUONGlobalTrigger& trigger); // use copy constructor
-
-    virtual void   AddLocalTrigger(const AliMUONLocalTrigger& trigger); // use copy constructor
-    virtual void   AddRegionalTrigger(const AliMUONRegionalTrigger& trigger); // use copy constructor
-
-
-    TClonesArray*  SDigits(Int_t DetectionPlane) const;
-    TClonesArray*  Digits(Int_t DetectionPlane) const;
-    TClonesArray*  LocalTrigger() const;
-    TClonesArray*  RegionalTrigger() const;
-    TClonesArray*  GlobalTrigger() const;    
-
-    void           GetSDigits() const;
-    void           GetDigits() const;
-    void           GetTriggerD() const;
-
-                   /// Return split level
-    Int_t          GetSplitLevel() const {return fSplitLevel;}
-
-                   /// Set split level
-    void           SetSplitLevel(Int_t SplitLevel) {fSplitLevel=SplitLevel;}
-
-    Bool_t        IsDigitsBranchesInTree();
-    Bool_t        IsTriggerBranchesInTreeD();
-
-                       /// Get loader
-    virtual AliLoader* GetLoader() const { return fLoader; }
-                       /// Set loader
-    virtual void       SetLoader(AliLoader * loader) {fLoader=loader;}    
-    
-    virtual void   Fill(Option_t* opt=" ");
-    virtual void   MakeBranch(Option_t *opt=" ");
-    virtual void   SetDataContainer(Option_t *opt=" ");
-    virtual void   SetTreeAddress(Option_t *opt=" ");
-    
-    virtual void Print(Option_t* opt="") const;
-    
-    virtual void   ResetSDigits();
-    virtual void   ResetDigits();
-    virtual void   ResetTrigger();
-  
-                   /// Return tree with summable digits
-    TTree*         TreeS() {return fLoader->TreeS(); }
-                   /// Return tree with digits
-    TTree*         TreeD() {return fLoader->TreeD(); }
-
-                   // Methods to dump data
-    void DumpSDigits(Int_t event2Check=0, Option_t* opt="tracks");
-    void DumpDigits(Int_t event2Check=0, Option_t* opt="tracks");
-    
-  protected: 
-    /// Not implemented
-    AliMUONData(const AliMUONData& rhs);
-    /// Not implemented
-    AliMUONData& operator=(const AliMUONData& rhs);
-
-    AliRunLoader*   fRunLoader; //!< Run loader pointer
-    AliLoader*      fLoader;  //!< Detector Loader pointer
-
-    TObjArray*      fSDigits; ///< One event in treeS and one branch per detection plane
-    TObjArray*      fDigits;  ///< One event in treeD and one branch per detection plane
-    TClonesArray*   fGlobalTrigger; ///< List of Global Trigger One event in TreeR/GlobalTriggerBranch
-    TClonesArray*   fLocalTrigger;  ///< List of Local Trigger, One event in TreeR/LocalTriggerBranch
-    TClonesArray*   fRegionalTrigger;  ///< List of Regional Trigger, One event in TreeR/LocalTriggerBranch
-
-    Int_t*          fNSdigits;//!< Number of Digits
-    Int_t*          fNdigits; //!< Number of Digits
-    Int_t           fNglobaltrigger;//!< Number of Global trigger
-    Int_t           fNlocaltrigger; //!< Number of Local trigger
-    Int_t           fNregionaltrigger; //!< Number of regional trigger
-    Int_t           fSplitLevel;   ///< Splitting of branches 0 no spitting (root files are smaller) 1 splitting (larger output files)
-
-    mutable Int_t fCurrentEvent; ///< Current event we're dealing with
-    
-private:  
-
-  ClassDef(AliMUONData,4) // Data accessor for MUON module
-      
-};
-// inline functions
-
-
-/// Load sdigits tree
-inline void AliMUONData::GetSDigits() const {
-  if (fLoader && fLoader->TreeS())
-    fLoader->TreeS()->GetEvent(0);
-}
-
-/// Load trigger D tree
-inline void AliMUONData::GetTriggerD() const {
-  if (fLoader && fLoader->TreeD())
-    fLoader->TreeD()->GetEvent(0);
-}
-
-
-#endif
-
diff --git a/MUON/AliMUONDataDigitIterator.cxx b/MUON/AliMUONDataDigitIterator.cxx
deleted file mode 100644 (file)
index 142c55a..0000000
+++ /dev/null
@@ -1,160 +0,0 @@
-/**************************************************************************
-* 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 "AliMUONDataDigitIterator.h"
-
-#include "AliMUONData.h"
-#include "TClonesArray.h"
-
-///
-/// \class AliMUONDataDigitIterator
-///
-/// An iterator to access digits (stored into AliMUONData).
-///
-/// Iteration can occur on tracking chambers only, trigger chambers only,
-/// or both.
-///
-/// \author L. Aphecetche
-///
-
-/// \cond CLASSIMP
-ClassImp(AliMUONDataDigitIterator)
-/// \endcond
-
-//_____________________________________________________________________________
-AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONData* data,
-                                                   Int_t firstChamber, 
-                                                   Int_t lastChamber)
-: 
-AliMUONVDataIterator(),
-fData(data),
-fFirstChamber(firstChamber),
-fLastChamber(lastChamber),
-fDigits(0x0),
-fCurrentDigit(-1),
-fCurrentChamber(-1)
-{
-  /// Standard constructor
-  Reset();
-}
-
-//_____________________________________________________________________________
-AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONDataDigitIterator& rhs)
-: 
-AliMUONVDataIterator(),
-fData(0x0),
-fFirstChamber(-1),
-fLastChamber(-1),
-fDigits(0x0),
-fCurrentDigit(-1),
-fCurrentChamber(-1)
-{
-  /// Copy constructor
-
-  rhs.CopyTo(*this);
-}
-
-//_____________________________________________________________________________
-AliMUONDataDigitIterator::~AliMUONDataDigitIterator()
-{
-  /// Destructor
-}
-
-//_____________________________________________________________________________
-AliMUONDataDigitIterator&
-AliMUONDataDigitIterator::operator=(const AliMUONDataDigitIterator& rhs)
-{
-  /// Assignment operator
-
-  rhs.CopyTo(*this);
-  return *this;
-}
-
-//_____________________________________________________________________________
-void
-AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
-{
-  /// Copy *this to destination
-  destination.fData=fData;
-  destination.fFirstChamber=fFirstChamber;
-  destination.fLastChamber=fLastChamber;
-  destination.fCurrentDigit=fCurrentDigit;
-  destination.fCurrentChamber=fCurrentChamber;
-  destination.fDigits=fDigits;
-}
-
-//_____________________________________________________________________________
-TObject*
-AliMUONDataDigitIterator::Next()
-{
-  /// Return current element and self-position to the next one.
-  
-  TObject* rv(0x0);
-  
-  if ( fDigits ) 
-  {
-    // get the pointer to be returned
-    rv = fDigits->At(fCurrentDigit);
-    // prepare for the next position, if it exists
-    if ( fCurrentDigit < fDigits->GetLast() ) 
-    {
-      ++fCurrentDigit;
-    }
-    else
-    {
-      fCurrentDigit = 0;
-      ++fCurrentChamber;
-      if ( fCurrentChamber <= fLastChamber )
-      {
-        fDigits = fData->Digits(fCurrentChamber);
-      }
-      else
-      {
-        fDigits = 0x0;
-      }
-    }
-  }
-  
-  return rv;
-}
-
-//_____________________________________________________________________________
-Bool_t
-AliMUONDataDigitIterator::Remove()
-{
-  /// Remove current element.
-  
-  if ( fDigits ) 
-  {
-    fDigits->RemoveAt(fCurrentDigit);
-    fDigits->Compress();
-    return kTRUE;
-  }
-  
-  return kFALSE;
-}
-
-//_____________________________________________________________________________
-void
-AliMUONDataDigitIterator::Reset()
-{
-  /// Reset the iterator
-  fData->GetDigits();
-  fCurrentDigit = 0;
-  fCurrentChamber = fFirstChamber;
-  fDigits = fData->Digits(fCurrentChamber);
-}
diff --git a/MUON/AliMUONDataDigitIterator.h b/MUON/AliMUONDataDigitIterator.h
deleted file mode 100644 (file)
index f2c651c..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef ALIMUONDATADIGITITERATOR_H
-#define ALIMUONDATADIGITITERATOR_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-* See cxx source for full Copyright notice                               */
-
-// $Id$
-
-/// \ingroup base
-/// \class AliMUONDataDigitIterator
-/// \brief Iterator on digits (handled by AliMUONData).
-/// 
-//  Author: Laurent Aphecetche
-
-#ifndef ALIMUONVDATAITERATOR_H
-#  include "AliMUONVDataIterator.h"
-#endif
-
-class AliMUONData;
-class TClonesArray;
-
-class AliMUONDataDigitIterator : public AliMUONVDataIterator
-{
-public:
-  AliMUONDataDigitIterator(const AliMUONData* data, Int_t firstChamber, Int_t lastChamber);
-  AliMUONDataDigitIterator(const AliMUONDataDigitIterator& rhs);
-  AliMUONDataDigitIterator& operator=(const AliMUONDataDigitIterator& rhs);
-  virtual ~AliMUONDataDigitIterator();
-    
-  TObject* Next();
-  
-  void Reset(); 
-  
-  Bool_t Remove();
-  
-  Bool_t IsOwner() const { return kFALSE; }
-  
-private:
-    void CopyTo(AliMUONDataDigitIterator& destination) const;
-  
-private:
-  const AliMUONData* fData; //!< Pointer to data accessor
-  Int_t fFirstChamber;      //!< First chamber to iterate on
-  Int_t fLastChamber;       //!< Last chamber to iterate on      
-  TClonesArray* fDigits;    //!< Digits of the current chamber
-  Int_t fCurrentDigit;      //!< Current position within fDigits array
-  Int_t fCurrentChamber;    //!< Current chamber
-  
-  ClassDef(AliMUONDataDigitIterator,0) // Iterator on digits
-};      
-
-#endif
diff --git a/MUON/AliMUONDataIterator.cxx b/MUON/AliMUONDataIterator.cxx
deleted file mode 100644 (file)
index 79711c5..0000000
+++ /dev/null
@@ -1,133 +0,0 @@
-/**************************************************************************
-* 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 "AliMUONDataIterator.h"
-
-#include "AliMUONConstants.h"
-#include "AliMUONData.h"
-#include "AliMUONDataDigitIterator.h"
-#include "TString.h"
-
-/// \class AliMUONDataIterator
-/// A wrapper to various iterators used to loop over
-/// objects handled by AliMUONData, like sdigits, digits, rawclusters, 
-/// and so on.
-/// Currently only implemented for digits, as a proof-of-principle.
-///
-/// \author Laurent Aphecetche
-
-/// \cond CLASSIMP
-ClassImp(AliMUONDataIterator)
-/// \endcond
-
-namespace
-{
-  void GetChamberNumbers(AliMUONDataIterator::EIterationStyle type, 
-                         Int_t& firstChamber, Int_t& lastChamber)
-{
-    switch ( type )
-    {
-      case AliMUONDataIterator::kAllChambers:
-        firstChamber=0;
-        lastChamber=AliMUONConstants::NCh()-1;
-        break;
-      case AliMUONDataIterator::kTrackingChambers:
-        firstChamber=0;
-        lastChamber=AliMUONConstants::NCh()-1;
-        break;
-      case AliMUONDataIterator::kTriggerChambers:
-        firstChamber=AliMUONConstants::NTrackingCh();
-        lastChamber=AliMUONConstants::NCh()-1;
-        break;
-      default:
-        firstChamber=lastChamber=-1;
-        break;
-    }
-}
-}
-
-//_____________________________________________________________________________
-AliMUONDataIterator::AliMUONDataIterator() 
-: 
-TObject(),
-fIterator(0x0)
-{
-/// Default constructor
-}
-
-//_____________________________________________________________________________
-AliMUONDataIterator::AliMUONDataIterator(AliMUONData* data,
-                                         const char* onWhatToIterate,
-                                         EIterationStyle howToIterate) 
-: 
-TObject(),
-fIterator(0x0)
-{
-/// Standard constructor
-
-  TString opt(onWhatToIterate);
-  opt.ToLower();
-  if ( opt.Contains("digit") || opt.Contains("d") )
-  {
-      Int_t firstChamber;
-      Int_t lastChamber;
-      GetChamberNumbers(howToIterate,firstChamber,lastChamber); 
-      if ( firstChamber >= 0 && lastChamber >= 0 )
-      {
-        data->GetLoader()->LoadDigits("READ");
-        data->SetTreeAddress("D,GLT");
-        fIterator = new AliMUONDataDigitIterator(data,firstChamber,lastChamber);
-      }
-  }
-}
-
-//_____________________________________________________________________________
-AliMUONDataIterator::~AliMUONDataIterator()
-{
-/// Destructor
-
-  delete fIterator;
-}
-
-//_____________________________________________________________________________
-TObject* 
-AliMUONDataIterator::Next() 
-{ 
-/// Set iterator to the next element
-
-  if (fIterator) return fIterator->Next(); 
-  return 0x0;
-}
-
-//_____________________________________________________________________________
-Bool_t 
-AliMUONDataIterator::Remove() 
-{
-/// Remove current element
-  if (fIterator) return fIterator->Remove(); 
-  return kFALSE;
-}
-
-//_____________________________________________________________________________
-void 
-AliMUONDataIterator::Reset() 
-{ 
-/// Reset 
-
-  if (fIterator) fIterator->Reset(); 
-}
diff --git a/MUON/AliMUONDataIterator.h b/MUON/AliMUONDataIterator.h
deleted file mode 100644 (file)
index 0c3bf6d..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
-* See cxx source for full Copyright notice                               */
-
-// $Id$
-
-/// \ingroup base
-/// \class AliMUONDataIterator
-/// \brief An iterator on MUON data structures (so far only Digits).
-/// 
-//  Author Laurent Aphecetche
-
-#ifndef ALIMUONDATAITERATOR_H
-#define ALIMUONDATAITERATOR_H
-
-#ifndef ROOT_TObject
-#  include "TObject.h"
-#endif
-
-class AliMUONData;
-class AliMUONVDataIterator;
-
-class AliMUONDataIterator : public TObject
-{
-public:
-  /// Iteration style
-  enum EIterationStyle { kAllChambers, kTrackingChambers, kTriggerChambers };
-  
-  AliMUONDataIterator();
-  AliMUONDataIterator(AliMUONData* data, const char* onWhatToIterate,
-                      EIterationStyle howToIterate);
-  virtual ~AliMUONDataIterator();
-    
-  TObject* Next();
-  
-  Bool_t Remove();
-  
-  void Reset();
-  
-private:
-  AliMUONVDataIterator* fIterator; //!< the real worker   
-
-private:
-  /// Not implemented
-  AliMUONDataIterator(const AliMUONDataIterator& rhs);
-  /// Not implemented
-  AliMUONDataIterator& operator=(const AliMUONDataIterator& rhs);
-  
-  ClassDef(AliMUONDataIterator,0) // Iterator on MUON data structures.
-};
-
-#endif
diff --git a/MUON/AliMUONDetElement.cxx b/MUON/AliMUONDetElement.cxx
deleted file mode 100644 (file)
index 81fe1a7..0000000
+++ /dev/null
@@ -1,366 +0,0 @@
-/**************************************************************************
- * 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 AliMUONDetElement
-// --------------------------
-// Detection element object containing information for combined 
-// cluster / track finder in the MUON arm 
-// Author: Alexander Zinchenko, JINR Dubna
-#include "AliMUONDetElement.h"
-#include "AliMUONSegmentation.h"
-#include "AliMUONDigit.h"
-#include "AliMUONHitMapA1.h"
-#include "AliMUONData.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONHitForRec.h"
-#include "AliMUONClusterInput.h"
-#include "AliMUONClusterFinderAZ.h"
-#include "AliMUONGeometryModuleTransformer.h" 
-#include "AliMUONSegmentation.h"
-#include "AliMUONGeometrySegmentation.h" 
-#include "AliMUONVGeometryDESegmentation.h" 
-#include "AliMpVSegmentation.h" 
-
-#include "AliRun.h"
-#include "AliLog.h"
-
-#include <TObjArray.h>
-#include <TClonesArray.h>
-#include <TVector2.h> 
-
-/// \cond CLASSIMP
-ClassImp(AliMUONDetElement) // Class implementation in ROOT context
-/// \endcond
-  FILE *lun = 0x0; //fopen("hitmap.dat","w");
-
-//_________________________________________________________________________
-AliMUONDetElement::AliMUONDetElement()
-  : TObject(),
-    fidDE(0),
-    fIndex(0),
-    fChamber(0),
-    fZ(0.),
-    fNHitsForRec(0),
-    fRawClus(0x0),
-    fHitsForRec(0x0),
-    fRecModel(0x0)
-{
-  /// Default constructor
-  for (Int_t i = 0; i < 2; i++) {
-    fHitMap[i] = NULL;
-    fDigits[i] = NULL;
-    fSeg[i] = NULL;
-  }
-} 
-
-//_________________________________________________________________________
-AliMUONDetElement::AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, AliMUONClusterFinderAZ *recModel,
-                                     AliMUONSegmentation* segmentation) 
-  : TObject(),
-    fidDE(idDE),
-    fIndex(0),
-    fChamber(idDE / 100 - 1),
-    fZ(0.),
-    fNHitsForRec(0),
-    fRawClus(new TObjArray(10)),
-    fHitsForRec(new TObjArray(10)),
-    fRecModel(recModel)
-{
-  /// Constructor
-  fRawClus->SetOwner(kTRUE);
-  fHitsForRec->SetOwner(kTRUE);
-  fDigits[0] = new TObjArray(20);
-  fDigits[1] = new TObjArray(20);
-  fDigits[0]->SetOwner(kTRUE);
-  fDigits[1]->SetOwner(kTRUE);
-
-  // Segmentations
-  fSeg[0] = segmentation->GetModuleSegmentationByDEId(idDE, 0);
-  fSeg[1] = segmentation->GetModuleSegmentationByDEId(idDE, 1);
-  
-  /*
-  Float_t x, y, z;
-  fSeg[dig->Cathode()]->GetPadC(fidDE, dig->PadX(), dig->PadY(), x, y, z);
-  fZ = z;
-  */
-  AddDigit(dig);
-}
-
-//_________________________________________________________________________
-AliMUONDetElement::~AliMUONDetElement()
-{
-  /// Destructor
-  for (Int_t i = 0; i < 2; i++) {
-    delete fHitMap[i]; 
-    delete fDigits[i]; 
-  }
-  delete fRawClus;
-  for (Int_t i = 0; i < fNHitsForRec; i++) {
-    Int_t ntracks = ((AliMUONHitForRec*)fHitsForRec->UncheckedAt(i))->GetNTrackHits();
-    //cout << ntracks << endl;
-    if (ntracks) fHitsForRec->RemoveAt(i);
-  }
-  delete fHitsForRec;
-  //fHitsForRec->SetOwner(kFALSE);
-  //fHitsForRec->Clear(); cout << " here " << fHitsForRec->GetEntriesFast() << endl; delete fHitsForRec; fHitsForRec = 0;
-}
-
-//_________________________________________________________________________
-Int_t AliMUONDetElement::Compare(const TObject* detElem) const
-{
-  /// "Compare" function to sort in Z (towards interaction point)
-  /// Returns -1 (0, +1) if charge of current pixel
-  /// is greater than (equal to, less than) charge of pixel
-  if (fZ > ((AliMUONDetElement*)detElem)->Z()) return(+1);
-  else if (fZ == ((AliMUONDetElement*)detElem)->Z()) return( 0);
-  else return(-1);
-}
-
-//_________________________________________________________________________
-void AliMUONDetElement::Fill(AliMUONData */*data*/)
-{
-  /// Fill hit maps
-  fLeft[0] = fDigits[0]->GetEntriesFast();
-  fLeft[1] = fDigits[1]->GetEntriesFast();
-
-  Int_t  npx0  = fSeg[0]->Npx(fidDE)+1;
-  Int_t  npy0  = fSeg[0]->Npy(fidDE)+1;
-  fHitMap[0] = new AliMUONHitMapA1(npx0, npy0, fDigits[0]);
-  fHitMap[0]->FillHits();
-
-  Int_t  npx1  = fSeg[1]->Npx(fidDE)+1;
-  Int_t  npy1  = fSeg[1]->Npy(fidDE)+1;
-  fHitMap[1] = new AliMUONHitMapA1(npx1, npy1, fDigits[1]);
-  fHitMap[1]->FillHits();
-
-  // The part below is just for debugging (fill rec. points already found)
-  /*
-  fLeft[0] = fLeft[1] = 0;
-  TClonesArray *rawClus = data->RawClusters(fChamber);
-  cout << rawClus << " " << rawClus->GetEntriesFast() << endl;
-  for (Int_t i = 0; i < rawClus->GetEntriesFast(); i++) {
-    AliMUONRawCluster *recP = (AliMUONRawCluster*) rawClus->UncheckedAt(i);
-    cout << fChamber << " " << recP->GetZ(0) << " " << recP->GetZ(1) << " " << fZ << endl;
-    if (TMath::Abs(recP->GetZ(0)-fZ) > 0.5) continue;
-    if (!Inside(recP->GetX(0), recP->GetY(0), recP->GetZ(0))) continue;
-    AddHitForRec(recP); // add hit for rec.
-    rawClus->RemoveAt(i); // remove
-  }
-  cout << fHitsForRec->GetEntriesFast() << endl;
-  rawClus->Compress();
-  */
-}
-
-//_________________________________________________________________________
-void AliMUONDetElement::AddDigit(AliMUONDigit *dig)
-{
-  /// Add digit
-
-  //fDigits[dig->Cathode()]->Add(dig);
-  fDigits[dig->Cathode()]->Add(new AliMUONDigit(*dig));
-  Float_t x, y, z;
-  fSeg[dig->Cathode()]->GetPadC(fidDE, dig->PadX(), dig->PadY(), x, y, z);
-  fZ += z;
-  /*
-  Int_t ndig = fDigits[dig->Cathode()]->GetEntriesFast();
-  new((*fDigits[dig->Cathode()])[ndig]) AliMUONDigit(*dig);
-  */
-}
-
-//_________________________________________________________________________
-Bool_t AliMUONDetElement::Inside(Double_t x, Double_t y, Double_t z, Double_t dx, Double_t dy) const
-{
-  /// Check if point is inside detection element
-
-  dx = TMath::Max (dx, 1.);
-  dy = TMath::Max (dy, 1.);
-  Int_t ix, iy;
-  ix = iy = 0;
-  Double_t xl, yl, zl;
-  for (Int_t i = 0; i < 2; i++) {
-    if (!fSeg[i]) continue;
-    if (i == 0 || fSeg[0] == 0x0) {
-      fSeg[i]->GetTransformer()->Global2Local(fidDE, x, y, z, xl, yl, zl);
-      //cout << xl << " " << yl << " " << zl << endl;
-      if (TMath::Abs (zl) > 0.5) return kFALSE;
-      //if (fChamber < 4 && (xl < 0 || yl < 0)) return kFALSE;
-    }
-    fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy);
-    //cout << x << " " << y << " " << z << " " << fChamber << " " << ix << " " << iy << " " << fSeg[i]->Npx(fidDE) << " " << fSeg[i]->Npy(fidDE) /*<< " " << fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy)*/ << " " << fSeg[i]->HasPad(fidDE, (Float_t)x, (Float_t)y, (Float_t)z) << endl; 
-    //if (ix > 0 && iy > 0 && ix <= fSeg[i]->Npx(fidDE) && iy <= fSeg[i]->Npy(fidDE)) return kTRUE;
-    if (fSeg[i]->HasPad(fidDE, (Float_t)x, (Float_t)y, (Float_t)z)) return kTRUE;
-  }
-  //Double_t xl, yl, zl;
-  //fSeg[0]->GetTransformer()->Global2Local(fidDE, x, y, z, xl, yl, zl);
-  //cout << xl << " " << yl << " " << zl << endl;
-
-  Int_t cath = fSeg[0] ? 0 : 1;
-  const AliMpVSegmentation *mpSeg = fSeg[cath]->GetDESegmentation(fidDE)->GetMpSegmentation();
-  TVector2 dim = mpSeg->Dimensions(); 
-  if (fChamber < 4) dim *= 2.; // quadrants
-  //cout << fChamber << " " << dim.X() << " " << dim.Y() << endl;
-  if (TMath::Abs (xl) - dim.X() > dx) return kFALSE;
-  if (TMath::Abs (yl) - dim.Y() > dy) return kFALSE;
-
-  Int_t flagX = 0, flagY = 0;
-  if (TMath::Abs (xl) - dim.X() < -2) flagX = 1;
-  if (TMath::Abs (yl) - dim.Y() < -2) flagY = 1;
-  if (flagX && flagY) flagX = flagY = 0; // both coordinates "inside" det. elem. limits
-
-  // Check for edge effect (extrapolated track "right outside" det. elem. boundaries 
-  // (+- dx * cath in X and Y)
-  dx /= 2;
-  dy /= 2;
-  for (Int_t i = 0; i < 2; i++) {
-    if (!fSeg[i]) continue;
-    for (Int_t idx = -1; idx < 2; idx++) {
-      if (flagX && idx) continue;
-      Double_t x1 = x + dx * idx * (i + 1);
-      for (Int_t idy = -1; idy < 2; idy++) {
-       if (idx == 0 && idy == 0) continue;
-       if (flagY && idy) continue;
-       Double_t y1 = y + dy * idy * (i + 1);
-       fSeg[i]->GetPadI(fidDE, x1, y1, z, ix, iy);
-       //cout << x1 << " " << y1 << " " << z << " " << fChamber << " " << ix << " " << iy << " " << fSeg[i]->Npx(fidDE) << " " << fSeg[i]->Npy(fidDE) /*<< " " << fSeg[i]->GetPadI(fidDE, x, y, z, ix, iy)*/ << " " << fSeg[i]->HasPad(fidDE, (Float_t)x1, (Float_t)y1, (Float_t)z) << endl; 
-       //if (ix > 0 && iy > 0 && ix <= fSeg[i]->Npx(fidDE) && iy <= fSeg[i]->Npy(fidDE)) return kTRUE;
-       if (fSeg[i]->HasPad(fidDE, (Float_t)x1, (Float_t)y1, (Float_t)z)) return kTRUE;
-      }
-    }
-  }
-  return kFALSE;
-}
-
-//_________________________________________________________________________
-void AliMUONDetElement::ClusterReco(Double_t xTrack, Double_t yTrack, Double_t dx, Double_t dy)
-{
-  /// Run cluster reconstruction around point (x,y) inside window (dx,dy)
-
-  if (fLeft[0] == 0 && fLeft[1] == 0) return; // all digits have been used 
-  AliMUONClusterInput::Instance()->SetDigits(fChamber, fidDE, 
-             (TClonesArray*)fDigits[0], (TClonesArray*)fDigits[1]);
-
-  // Mark used pads
-  for (Int_t cath = 0; cath < 2; cath++) {
-    Int_t ndig = fDigits[cath]->GetEntriesFast();
-    if (ndig == 0) continue; // empty cathode
-    //cout << fidDE << " " << cath << " " << ndig << endl; 
-    for (Int_t i = 0; i < ndig; i++) {
-      if (fLeft[cath] == 0) { fRecModel->SetUsed(cath,i); continue; }
-      AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath]->UncheckedAt(i);
-      //cout << i << " " << dig << " " /*<< dig->PadX() << " " << dig->PadY() << " " << fHitMap[cath]->TestHit(dig->PadX(), dig->PadY()) */<< endl;
-      if (fHitMap[cath]->TestHit(dig->PadX(), dig->PadY()) == kUsed) fRecModel->SetUsed(cath,i);
-      else fRecModel->SetUnused(cath,i);
-    }
-  }
-
-  fRecModel->ResetRawClusters();
-
-  for (Int_t cath = 0; cath < 2; cath++) {
-    Int_t ndig = fDigits[cath]->GetEntriesFast();
-    if (ndig == 0) continue; // empty cathode
-    // Loop over pads
-    for (fSeg[cath]->FirstPad(fidDE, xTrack, yTrack, fZ, dx, dy);
-        fSeg[cath]->MorePads(fidDE);
-        fSeg[cath]->NextPad(fidDE)) {
-      if (fLeft[cath] == 0) break;
-      //cout << cath << " " << fSeg[cath]->Ix() << " " << fSeg[cath]->Iy() << " " << fSeg[cath]->DetElemId() << " " << fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) << endl;
-      if (fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) == kEmpty ||
-         fHitMap[cath]->TestHit(fSeg[cath]->Ix(), fSeg[cath]->Iy()) == kUsed) continue;
-
-      Int_t iOK = 0;
-      // Set starting pad
-      for (Int_t j = 0; j < ndig; j++) {
-       AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath]->UncheckedAt(j);
-       if (dig->PadX() != fSeg[cath]->Ix() || dig->PadY() != fSeg[cath]->Iy()) continue;
-       //cout << fidDE << " " << j << " " << fDigits[cath]->GetEntriesFast() << " " << fSeg[cath]->Ix() << " " << fSeg[cath]->Iy() << endl;
-       fRecModel->SetStart(cath, j);
-       iOK = 1;
-       break;
-      }
-      if (!iOK) continue;
-
-      fRecModel->FindRawClusters();
-      Int_t nClusEnd = fRecModel->GetRawClusters()->GetEntriesFast();
-      //cout << " ***nclus: " << nClusEnd << endl;
-      for (Int_t i = 0; i < nClusEnd; i++) {
-       AliMUONRawCluster *clus = (AliMUONRawCluster*) fRecModel->GetRawClusters()->UncheckedAt(i);
-       AddHitForRec(clus); // add hit for rec.
-       //cout << clus->GetX(0) << " " << clus->GetY(0) << endl;
-      }
-      // Mark used pads
-      for (Int_t cath1 = 0; cath1 < 2; cath1++) {
-       Int_t ndig1 = fDigits[cath1]->GetEntriesFast();
-       for (Int_t j = 0; j < ndig1; j++) {
-         if (fLeft[cath1] == 0) break;
-         AliMUONDigit *dig = (AliMUONDigit*) fDigits[cath1]->UncheckedAt(j);
-         Float_t x, y, z;
-         fSeg[cath1]->GetPadC(fidDE,dig->PadX(),dig->PadY(),x,y,z);
-         //cout << "clus " << cath1 << " " << fLeft[cath1] << " " << dig->PadX() << " " << dig->PadY() << " " << x << " " << y << " " << z << " " << fRecModel->GetUsed(cath1,j) << endl;
-         if (!fRecModel->GetUsed(cath1,j)) continue;
-         if (fHitMap[cath1]->TestHit(dig->PadX(), dig->PadY()) == kUsed) continue;
-         fHitMap[cath1]->FlagHit(dig->PadX(), dig->PadY());
-         if (lun) fprintf(lun," %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY());
-         fLeft[cath1]--;
-       }
-      }
-    } // for (fSeg[cath]->FirstPad(...
-  } // for (Int_t cath = 0;
-}
-
-//_________________________________________________________________________
-void AliMUONDetElement::AddHitForRec(AliMUONRawCluster *clus)
-{
-  /// Make HitForRec from raw cluster (rec. point)
-
-  fRawClus->Add(new AliMUONRawCluster(*clus));
-  //AliMUONHitForRec *hitForRec = 
-  //new ((*fHitsForRec)[fNHitsForRec++]) AliMUONHitForRec(clus);
-  AliMUONHitForRec *hitForRec = new AliMUONHitForRec(clus);
-  fHitsForRec->Add(hitForRec);
-  fNHitsForRec++;
-
-  // more information into HitForRec
-  //  resolution: info should be already in raw cluster and taken from it ????
-  //hitForRec->SetBendingReso2(-1); //fBendingResolution * fBendingResolution);
-  //hitForRec->SetNonBendingReso2(-1); //fNonBendingResolution * fNonBendingResolution);
-  hitForRec->SetBendingReso2(clus->GetErrY() * clus->GetErrY());
-  hitForRec->SetNonBendingReso2(clus->GetErrX() * clus->GetErrX());
-  //  original raw cluster
-  hitForRec->SetChamberNumber(fChamber);
-  hitForRec->SetZ(clus->GetZ(0));
-  //hitForRec->SetHitNumber(-(fIndex+1)*100000-fNHitsForRec+1);
-  hitForRec->SetHitNumber(-(fIndex+1)*100000-fRawClus->GetEntriesFast()+1);
-  //delete clus; // for now
-}
-
-/*
-//_________________________________________________________________________
-Int_t AliMUONDetElement::GetMapElem(AliMUONDigit *digit)
-{
-  Int_t cath = digit->Cathode();
-  return 0;
-
-}
-
-//_________________________________________________________________________
-void AliMUONDetElement::SetMapElem(const AliMUONDigit *digit, Int_t flag)
-{
-  Int_t cath = digit->Cathode();
-}
-*/
diff --git a/MUON/AliMUONDetElement.h b/MUON/AliMUONDetElement.h
deleted file mode 100644 (file)
index a17ddfd..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef ALIMUONDETELEMENT_H
-#define ALIMUONDETELEMENT_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-/// \ingroup rec
-/// \class AliMUONDetElement
-/// \brief Detection element object containing information for combined 
-/// cluster / track finder in the MUON arm 
-///
-/// \author Alexander Zinchenko, JINR Dubna
-#include <TObject.h>
-class TObjArray;
-class TClonesArray;
-class AliMUONDigit;
-class AliMUONHitMapA1;
-class AliMUONSegmentation;
-class AliMUONGeometrySegmentation;
-class AliMUONData;
-class AliMUONRawCluster;
-class AliMUONClusterFinderAZ;
-
-class AliMUONDetElement : public TObject 
-{
- public:
-
-  AliMUONDetElement();
-  AliMUONDetElement(Int_t idDE, AliMUONDigit *dig, 
-                    AliMUONClusterFinderAZ *recModel, AliMUONSegmentation* segmentation); // constructor
-  virtual ~AliMUONDetElement(); // Destructor
-
-  Int_t IdDE(void) const { return fidDE; } ///< det. elem. ID
-  Int_t Chamber(void) const { return fChamber; } ///< chamber No
-  Double_t Z(void) const { return fZ; } ///< Z-coordinate
-  Int_t Left(Int_t cath) const { return fLeft[cath]; } ///< number of unused digits
-  //Int_t GetMapElem(AliMUONDigit *digit) const; ///< get map element
-  TObjArray *Digits(Int_t cath) const { return fDigits[cath]; } ///< array of digits
-  TObjArray *RawClusters() const { return fRawClus; } ///< array of raw clusters
-  TObjArray *HitsForRec() const { return fHitsForRec; } ///< hits for rec.
-  Int_t NHitsForRec() const { return fNHitsForRec; } ///< No. of hits for rec.
-  //Bool_t Inside(Double_t x, Double_t y, Double_t z) const; // check if point inside DE
-  Bool_t Inside(Double_t x, Double_t y, Double_t z, Double_t dx, Double_t dy) const; // check if point inside DE
-  
-  void SetID(Int_t idDE) { fidDE = idDE; } ///< set det. elem. ID
-  void SetIndex(Int_t index) { fIndex = index; } ///< set position index
-  void SetZ(Double_t z) { fZ = z; } ///< set Z-coord.
-  void SetLeft(Int_t cath, Int_t left) { fLeft[cath] = left; } ///< set No. of digits
-  //void SetMapElem(const AliMUONDigit *digit, Int_t flag); ///< set map element 
-  void AddDigit(AliMUONDigit *dig); ///< add digit
-  void Fill(AliMUONData *data); ///< fill hit maps 
-  void ClusterReco(Double_t x, Double_t y, Double_t dx, Double_t dy); ///< run cluster reco around (x,y)
-  void AddHitForRec(AliMUONRawCluster *clus); ///< make HitForRec
-  /// What is necessary for sorting TObjArray's
-  Bool_t IsSortable() const { return kTRUE; }
-  Int_t Compare(const TObject* detElem) const; ///< "Compare" function for sorting
-
- private:
-  Int_t fidDE; ///< det. elem. ID
-  Int_t fIndex; ///< det. elem. position index in container
-  Int_t fChamber; ///< chamber No
-  Double_t fZ; ///< det. elem. Z-coordinate
-  Int_t fLeft[2]; ///< numbers of digits not used for clustering
-  Int_t fNHitsForRec; ///< number of hits for rec.
-  AliMUONGeometrySegmentation* fSeg[2]; ///< segmentation
-  AliMUONHitMapA1 *fHitMap[2]; ///< map of digits
-  TObjArray *fDigits[2]; ///< container of digits from this det. elem.
-  TObjArray *fRawClus; ///< raw clusters
-  TObjArray *fHitsForRec; ///< HitForRec's
-  AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
-
-  // Functions
-  /// Not implemented
-  AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
-  /// Not implemented
-  AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
-
-  ClassDef(AliMUONDetElement,0) // detection element object
-    };
-#endif
diff --git a/MUON/AliMUONDigitMapA1.cxx b/MUON/AliMUONDigitMapA1.cxx
deleted file mode 100644 (file)
index ac92f2b..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-/**************************************************************************
- * 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 AliMUONDigitMapA1
-// ---------------------------
-// Implements cluster Map as a 1-dim array
-// Author: Christian Finck
-
-#include "AliMUONDigitMapA1.h"
-#include "AliMUONDigit.h"
-
-#include "AliLog.h"
-
-#include <TObjArray.h>
-#include <TMath.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONDigitMapA1)
-/// \endcond
-
-AliMUONDigitMapA1::AliMUONDigitMapA1() 
-  : fIdDE(0),
-    fNpx(0),
-    fNpy(0),
-    fDigits(0),
-    fMaxIndex(0),
-    fHitMap(0)
-{
-/// Default constructor
-
-}
-//________________________________________________________________________________
-AliMUONDigitMapA1::AliMUONDigitMapA1(Int_t idDE, Int_t npx, Int_t npy )
-  : fIdDE(idDE),
-    fNpx(npx),
-    fNpy(npy),
-    fDigits(0),
-    fMaxIndex(fNpx * fNpy + fNpx),
-    fHitMap(new Int_t[fMaxIndex])
-{
-/// Standard constructor
-   Clear();
-}
-
-//_________________________________
-AliMUONDigitMapA1::~AliMUONDigitMapA1()
-{
-/// Destructor
-    if (fHitMap) delete[] fHitMap;
-}
-//______________________________________
-void AliMUONDigitMapA1::Clear(const char *)
-{
-/// Clear hitmap
-    memset(fHitMap,0,sizeof(int)*fMaxIndex);
-}
-
-//_________________________________________________________
-Int_t AliMUONDigitMapA1::CheckedIndex(Int_t ix, Int_t iy) const
-{
-/// Return checked indices ix, iy
-  Int_t index =  iy * fNpx + ix;
-    if ( index < 0 || index >= fMaxIndex ) {
-      AliWarning(Form("index outside array idDE %d ix %d iy %d MaxIndex %d index %d Npx %d Npy %d",
-                     fIdDE, ix,iy, fMaxIndex, index, fNpx, fNpy));
-       return  fMaxIndex-1;
-    } else {
-       return index;
-    }
-}
-//_____________________________
-void  AliMUONDigitMapA1::FillHits(TObjArray* digits)
-{
-/// Fill hits from digits list  
-    fDigits = digits;
-    Int_t ndigits = fDigits->GetEntriesFast();
-    if (!ndigits) return;
-    AliMUONDigit *dig;
-    for (Int_t ndig = 0; ndig < ndigits; ndig++) {
-       dig = (AliMUONDigit*)fDigits->UncheckedAt(ndig);
-       SetHit(dig->PadX(),dig->PadY(),ndig);
-    }
-}
-//___________________________________________________________
-void  AliMUONDigitMapA1::SetHit(Int_t ix, Int_t iy, Int_t idigit)
-{
-/// Assign digit to hit cell ix,iy
-
-    fHitMap[CheckedIndex(ix, iy)] = idigit + 1;
-}
-//_______________________________________________
-void AliMUONDigitMapA1::DeleteHit(Int_t ix, Int_t iy)
-{
-/// Delete hit at cell ix,iy
-
-    fHitMap[CheckedIndex(ix, iy)]=0;
-}
-//_____________________________________________
-void AliMUONDigitMapA1::FlagHit(Int_t ix, Int_t iy)
-{
-/// Flag hit as used
-    fHitMap[CheckedIndex(ix, iy)]=
-       -TMath::Abs(fHitMap[CheckedIndex(ix, iy)]);
-}
-//________________________________________________________
-Int_t AliMUONDigitMapA1::GetHitIndex(Int_t ix, Int_t iy) const
-{
-/// Get absolute value of contents of hit cell ix,iy
-    return TMath::Abs(fHitMap[CheckedIndex(ix, iy)])-1;
-}
-//_______________________________________________________
-TObject* AliMUONDigitMapA1::GetHit(Int_t ix, Int_t iy) const
-{
-/// Get pointer to object at hit cell ix, iy
-/// Force crash if index does not exist ! (Manu)
-    Int_t index = GetHitIndex(ix,iy);
-    return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
-}
-//_________________________________________________
-FlagType AliMUONDigitMapA1::TestHit(Int_t ix, Int_t iy) const
-{
-/// Check if hit cell is empty, used or unused
-
-    Int_t index = CheckedIndex(ix, iy);
-    if (index<0 || index >= fMaxIndex) return kEmpty;
-
-    Int_t inf = fHitMap[index];
-    if (inf < 0) {
-       return kUsed;
-    } else if (inf == 0) {
-       return kEmpty;
-    } else {
-       return kUnused;
-    }
-}
diff --git a/MUON/AliMUONDigitMapA1.h b/MUON/AliMUONDigitMapA1.h
deleted file mode 100644 (file)
index 54eeb24..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef ALIMUONDIGITMAPA1_H
-#define ALIMUONDIGITMAPA1_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
-
-/// \ingroup rec
-/// \class AliMUONDigitMapA1
-/// \brief Implements cluster Map as a 1-dim array
-/// 
-/// \author Christian Finck
-
-#include "AliHitMap.h"
-
-#include <TObject.h>
-
-class TObjArray;
-
-class AliMUONDigitMapA1 : public TObject
-{
- public:
-    AliMUONDigitMapA1();
-    AliMUONDigitMapA1(Int_t idDE, Int_t npx, Int_t npy);
-    virtual ~AliMUONDigitMapA1();
-
-    // Fill hits from list of digits into hit map
-    virtual  void  FillHits(TObjArray* dig);
-    // Clear the hit map
-    virtual  void  Clear(const char *opt = "");
-    // Set a single hit
-    virtual  void  SetHit(Int_t ix, Int_t iy, Int_t idigit);
-    // Delete a single hit
-    virtual  void  DeleteHit(Int_t ix, Int_t iy);
-    // Get index of hit in the list of digits
-    virtual Int_t  GetHitIndex(Int_t ix, Int_t iy) const;
-    // Get pointer to digit
-    virtual TObject*  GetHit(Int_t ix, Int_t iy) const;
-    // Flag a hit as used
-    virtual  void  FlagHit(Int_t ix, Int_t iy);
-    // Test hit status
-    virtual FlagType TestHit(Int_t ix, Int_t iy) const;
-
- private:
-    /// Not implemented
-    AliMUONDigitMapA1(const AliMUONDigitMapA1 & hitMap);
-    /// Not implemented
-    AliMUONDigitMapA1& operator = (const AliMUONDigitMapA1& rhs);
-
-    // Check index
-    Int_t CheckedIndex(Int_t ix, Int_t iy) const;
- private:
-    Int_t fIdDE;                          ///< id DE
-    Int_t fNpx;                           ///< Maximum number of pads in x
-    Int_t fNpy;                           ///< Maximum number of pads in y
-    TObjArray *fDigits;                   ///< Pointer to digits
-    Int_t fMaxIndex;                      ///< maximum index in hit map
-    
-    /// The array of hits
-    Int_t *fHitMap;                       // ! [fMaxIndex]         
-
-    ClassDef(AliMUONDigitMapA1,0) // Implements HitMap as a 1-dim array
-};
-#endif 
diff --git a/MUON/AliMUONDisplay.cxx b/MUON/AliMUONDisplay.cxx
deleted file mode 100644 (file)
index d889216..0000000
+++ /dev/null
@@ -1,1693 +0,0 @@
-/**************************************************************************
- * 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 AliMUONDisplay
-/// Create an event display object.
-/// A canvas named "edisplay" is created with a vertical size in pixels  \n
-///
-///    A QUICK Overview of the Event Display functions                   \n
-///    ===============================================                   \n
-///
-/// The event display can ve invoked by executing the macro "display.C"  \n
-/// A canvas like in the picture below will appear.
-///
-///  On the left side of the canvas, the following buttons appear:
-///  - *Next*       to move to the next event
-///  - *Previous*   to move to the previous event
-///  - *Pick*       Select this option to be able to point on a track with the
-///                 mouse. Once on the track, use the right button to select
-///                 an action. For example, select SetMarkerAttributes to
-///                 change the marker type/color/size for the track.
-///  - *Zoom*       Select this option (default) if you want to zoom.
-///                 To zoom, simply select the selected area with the left button.
-///  - *UnZoom*     To revert to the previous picture size.
-///
-///  - slider R     On the left side, the vertical slider can be used to
-///                 set the default picture size.
-///
-///  When you are in Zoom mode, you can click on the black part of the canvas
-///  to select special options with the right mouse button.
-///
-/// When you are in pick mode, you can "Inspect" the object pointed by the mouse.
-/// When you are on a track, select the menu item "InspectParticle"
-/// to display the current particle attributes.
-///
-/// You can activate the Root browser by selecting the Inspect menu
-/// in the canvas tool bar menu. Then select "Start Browser"
-/// This will open a new canvas with the browser. At this point, you may want
-/// to display some histograms (from the Trees). Go to the "File" menu
-/// of the browser and click on "New canvas".
-/// In the browser, click on item "ROOT files" in the left pane.
-/// Click on galice.root.
-/// Click on TH
-/// Click on TPC for example
-/// Click on any variable (eg TPC.fX) to histogram the variable.
-///
-/// If you are lost, you can click on HELP in any Root canvas or browser.
-
-//Begin_Html
-/*
-<img src="gif/AliMUONDisplay.gif">
-*/
-//End_Html
-
-#include "AliMUONDisplay.h"
-#include "AliMUON.h"
-#include "AliMUONPoints.h"
-#include "AliMUONGlobalTrigger.h"
-#include "AliMUONHit.h"
-#include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackParam.h"
-#include "AliMUONGeometryTransformer.h"
-#include "AliMUONSegmentation.h"
-#include "AliMUONGeometrySegmentation.h"
-#include "AliMUONConstants.h"
-#include "AliMUONTriggerSegmentation.h"
-#include "AliMUONSimData.h"
-#include "AliMUONRecData.h"
-
-#include "AliMpDEIterator.h"
-#include "AliMpSegmentation.h"
-#include "AliMpSlatSegmentation.h"
-#include "AliMpSlat.h"
-#include "AliMpSectorSegmentation.h"
-#include "AliMpSector.h"
-#include "AliMpTriggerSegmentation.h"
-#include "AliMpTrigger.h"
-#include "AliMpStationType.h"
-#include "AliMpCathodType.h"
-#include "AliMpDEManager.h"
-
-#include "AliMC.h"
-#include "AliLog.h"
-#include "AliRun.h"
-#include "AliHeader.h"
-
-#include <TButton.h>
-#include <TColor.h>
-#include <TCanvas.h>
-#if ROOT_VERSION_CODE>= 331523
-#include <TView3D.h>
-#else
-#include <TView.h>
-#endif
-#include <TText.h>
-#include <TPaveLabel.h>
-#include <TPaveText.h>
-#include <TDiamond.h>
-#include <TNode.h>
-#include <TArc.h>
-#include <TSlider.h>
-#include <TVirtualX.h>
-#include <TMath.h>
-#include <TGeometry.h>
-#include <TMarker3DBox.h>
-#include <TParticle.h>
-#include <TPolyLine3D.h>
-#include <TBox.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONDisplay)
-/// \endcond
-
-//_____________________________________________________________________________
-AliMUONDisplay::AliMUONDisplay()
-  : AliDisplay(),
-    fEvent(0),
-    fChamber(0),
-    fCathode(0),
-    fDrawClusters(kTRUE),
-    fDrawCoG(kTRUE),
-    fDrawTracks(kFALSE),
-    fClustersCuts(0),
-    fColPad(0),
-    fPoints(0),
-    fPhits(0),
-    fRpoints(0),
-    fNextCathode(0),
-    fSimLoader(0), 
-    fRecLoader(0), 
-    fMUONSimData(0),
-    fMUONRecData(0)
-{
-/// Default constructor
-}
-
-//_____________________________________________________________________________
-AliMUONDisplay::AliMUONDisplay(Int_t size, 
-                               AliLoader * simLoader, AliLoader * recLoader)
-  : AliDisplay(),
-    fEvent(0),
-    fChamber(1),
-    fCathode(1),
-    fDrawClusters(kTRUE),
-    fDrawCoG(kTRUE),
-    fDrawTracks(kFALSE),
-    fClustersCuts(0),
-    fColPad(0),
-    fPoints(0),
-    fPhits(0),
-    fRpoints(0),
-    fNextCathode(kFALSE),
-    fSimLoader(simLoader), 
-    fRecLoader(recLoader), 
-    fMUONSimData(0),
-    fMUONRecData(0)
-  
-{
-/// Standard constructor to create an event display object.
-
-    fPad = 0;
-    
-    gAlice->SetDisplay(this);
-   
-   // Initialize display default parameters
-    SetRange(200,2000);
-
-   // Set front view by default
-    fTheta =   0;
-    fPhi   = -90;
-    fPsi   =   0;
-    fZoomMode      = 1;
-    fZooms         = 0;
-
-    // Create colors
-    CreateColors();
-    // Create display canvas
-    Int_t ysize = size;
-    if (ysize < 100) ysize = 750;
-    Int_t xsize = Int_t(size*830./ysize);
-    fCanvas = new TCanvas("Canvas", "MUON Display",14,47,xsize,ysize);
-    fCanvas->ToggleEventStatus();
-    
-   // Create main display pad
-    fPad = new TPad("viewpad", "MUON display",0.15,0,0.9,1);
-    fPad->Draw();
-    fPad->Modified();
-    fPad->SetFillColor(30);
-    fPad->SetBorderSize(2);
-
-    fCanvas->cd();
-
-   // Create colors pad
-    fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
-    fColPad->Draw();
-    fColPad->SetFillColor(17);
-    fColPad->SetBorderSize(2);
-    fColPad->cd();
-    DisplayColorScale();
-
-    fCanvas->cd();
-   // Create user interface control pad
-    DisplayButtons();
-    fCanvas->cd();
-
-   // Create Range and mode pad
-    Float_t dxtr     = 0.15;
-    Float_t dytr     = 0.45;
-    fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
-    fTrigPad->Draw();
-    fTrigPad->cd();
-    fTrigPad->SetFillColor(22);
-    fTrigPad->SetBorderSize(2);
-    fRangeSlider = new TSlider("range","range",0.7,0.42,0.9,0.98);
-    fRangeSlider->SetObject(this);
-    char pickmode[] = "gAlice->Display()->SetPickMode()";
-    Float_t db = 0.09;
-    fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
-    fPickButton->SetFillColor(38);
-    fPickButton->Draw();
-    char zoommode[] = "gAlice->Display()->SetZoomMode()";
-    fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
-    fZoomButton->SetFillColor(38);
-    fZoomButton->Draw();
-    fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
-    fArcButton->SetFillColor(kGreen);
-    fArcButton->Draw();
-    char butUnzoom[] = "gAlice->Display()->UnZoom()";
-    TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
-    button->SetFillColor(38);
-    button->Draw();
-    AppendPad(); // append display object as last object to force selection
-    
-    fCanvas->cd();
-    fTrigPad->SetEditable(kFALSE);
-    fButtons->SetEditable(kFALSE);
-    fCanvas->Update();
-    // initialize container
-    if(fSimLoader) 
-      fMUONSimData = new AliMUONSimData(fSimLoader,"MUON","MUON");
-    if(fRecLoader) 
-      fMUONRecData = new AliMUONRecData(fRecLoader,"MUON","MUON");
-}
-
-//_____________________________________________________________________________
-AliMUONDisplay::~AliMUONDisplay()
-{
-/// Destructor
-
-  // Delete space point structure
-    if (fPoints) fPoints->Delete();
-    delete fPoints;
-    fPoints     = 0;
-    //
-    if (fPhits) fPhits->Delete();
-    delete fPhits;
-    fPhits     = 0;
-    //
-    if (fRpoints) fRpoints->Delete();
-    delete fRpoints;
-    fRpoints     = 0;
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::Clear(Option_t *)
-{
-/// Delete graphics temporary objects
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DisplayButtons()
-{
-/// Create the user interface buttons
-
-
-    fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
-    fButtons->Draw();
-    fButtons->SetFillColor(38);
-    fButtons->SetBorderSize(2);
-    fButtons->cd();
-    
-//   Int_t butcolor = 33;
-    Float_t dbutton = 0.08;
-    Float_t y  = 0.96;
-    Float_t dy = 0.014;
-    Float_t x0 = 0.05;
-    Float_t x1 = 0.95;
-    
-    TButton *button;
-    char but1[] = "gAlice->Display()->ShowNextEvent(1)";
-    button = new TButton("Event +", but1, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-    
-    y -= dbutton + dy;
-    char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
-    button = new TButton("Event -", but2, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-   
-    y -= dbutton + dy;
-    char but3[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(1)";
-    button = new TButton("Chamber +", but3, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-    
-    y -= dbutton + dy;
-    char but4[] = "((AliMUONDisplay*)(gAlice->Display()))->NextChamber(-1)";
-    button = new TButton("Chamber -", but4, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-    
-    y -= dbutton + dy;
-    char but5[] = "((AliMUONDisplay*)(gAlice->Display()))->SetChamberAndCathode(1,1)";
-    button = new TButton("Chamber 1", but5, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-   
-    y -= dbutton + dy;
-    char but6[] = "((AliMUONDisplay*)(gAlice->Display()))->NextCathode()";
-    button = new TButton("Cathode <>", but6, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-
-    y -= dbutton + dy;
-    char but7[] = "((AliMUONDisplay*)(gAlice->Display()))->Trigger()";
-    button = new TButton("Trigger", but7, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-    
-    y -= dbutton + dy;
-    char but8[] = "((AliMUONDisplay*)(gAlice->Display()))->DrawReco()";
-    button = new TButton("Tracking", but8, x0, y - dbutton, x1, y);
-    button->SetFillColor(38);
-    button->Draw();
-
-   // display logo
-    TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
-    diamond->SetFillColor(50);
-    diamond->SetTextAlign(22);
-    diamond->SetTextColor(5);
-    diamond->SetTextSize(0.11);
-    diamond->Draw();
-    diamond->AddText(".. ");
-    diamond->AddText("ROOT");
-    diamond->AddText("MUON");
-    diamond->AddText("... ");
-    diamond->AddText(" ");
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::CreateColors() const
-{
-/// Create the colors palette used to display clusters
-
-    Int_t k,i;
-    Int_t color;
-    Float_t r,g,b;
-    
-    for (k=1;k<=5;k++) {
-       switch(k) {
-       case 1:
-           for (i=1;i<=5;i++) {
-               r=1.;
-               g=i*0.2;  
-               b=0.;
-               color=i;
-               color=260+23-color;
-               new TColor(color,r,g,b);
-           } 
-           break;
-       case 2:
-           for (i=1;i<=4;i++) {
-               r=1.1-i*0.2;
-               g=1.;  
-               b=0.;
-               color=i+5;
-               color=260+23-color;
-               new TColor(color,r,g,b);
-           } 
-           break;
-       case 3:
-           for (i=1;i<=4;i++) {
-               r=0.;
-               g=1.;  
-               b=i*0.2+0.2;
-               color=i+9;
-               color=260+23-color;
-               new TColor(color,r,g,b);
-           } 
-           break;
-       case 4:
-           for (i=1;i<=4;i++) {
-               r=0.;
-               g=1.1-i*0.2;  
-               b=1.;
-               color=i+13;
-               color=260+23-color;
-               new TColor(color,r,g,b);
-           } 
-           break;
-       case 5:
-           for (i=1;i<=5;i++) {
-               r=i*0.2;
-               g=0.;  
-               b=1.;
-               color=i+17;
-               color=260+23-color;
-               new TColor(color,r,g,b);
-           } 
-           break;
-       }
-    }
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DisplayColorScale()
-{
-/// Display pulse height color scale
-
-    Int_t i;
-    Int_t color;
-    Float_t xlow, ylow, xup, yup, hs;
-    Float_t x1, y1, x2, y2;
-    x1 = y1 = 0;
-    x2 = y2 = 1.0;
-    
-    TText *text = new TText(0,0,"");
-    text->SetTextFont(61);
-    text->SetTextSize(0.2);
-    text->SetTextAlign(22);
-    
-
-    Int_t adcmax=4096; // default 12 bits ADC
-
-    
-
-    TBox *box;
-    char label[8];
-//*-* draw colortable boxes
-    hs = (y2-y1)/Float_t(22);
-    xlow=x1+.05;
-    xup=x2-0.5;
-    for (i=0;i<22;i++) {
-       ylow = y1 + hs*(Float_t(i));
-       yup  = y1 + hs*(Float_t(i+1));
-       color = 261+i;
-       Double_t logscale=Double_t(i+1)*(TMath::Log(adcmax)/22);
-       Int_t scale=(Int_t)TMath::Exp(logscale);
-       sprintf(label,"%d",scale);
-       box = new TBox(xlow, ylow, xup, yup);
-       box->Draw();
-       box->SetFillColor(color);
-       text->DrawText(xlow+0.7, 0.5*(ylow+yup),label);
-    }
-}
-
-//______________________________________________________________________________
-Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
-{
-/// Compute distance from point px,py to objects in event
-
-    gPad->SetCursor(kCross);
-    
-    if (gPad == fTrigPad) return 9999;
-    
-    const Int_t kBig = 9999;
-    Int_t dist   = kBig;
-    Float_t xmin = gPad->GetX1();
-    Float_t xmax = gPad->GetX2();
-    Float_t dx   = 0.02*(xmax - xmin);
-    Float_t x    = gPad->AbsPixeltoX(px);
-    if (x < xmin+dx || x > xmax-dx) return dist;
-    
-    if (fZoomMode) return 0;
-    else           return 7;
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::Draw(Option_t *)
-{
-/// Display current event
-
-    if (!fDrawTracks) 
-      DrawChamber();   
-    else 
-      DrawReco();
-    
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawChamber()
-{
-/// Display current event
-
-  fDrawTracks = kFALSE;
-  fPad->cd();
-  DrawView(fTheta, fPhi, fPsi);   
-  // Display the event number and title
-  fPad->cd();
-  DrawTitle();
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawReco(Option_t *)
-{
-/// Display current event
-
-  fDrawTracks = kTRUE;
-  // print kinematics of generated particles
-    PrintKinematics();
-    // Draw global view of muon system
-    fPad->cd();
-    DrawGlobalView(135, -50, -140); 
-  
-    // Display the event number and title
-    fPad->cd();
-    DrawTitle();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::PrintKinematics()
-{
-/// Print kinematic tree
-
-  if ( !fSimLoader || !fRecLoader ) {
-    AliErrorStream() << "Detector loaders are not defined." << endl;
-    return;
-  }  
-
-  AliRunLoader* runLoader = fSimLoader->GetRunLoader();
-  TParticle *particle = new TParticle();
-  Int_t nPart;
-  Float_t vertex[3], momentum[3];
-
-  printf("******  Event # %d ******\n",runLoader->GetEventNumber());
-  runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle);
-  nPart = (Int_t)runLoader->TreeK()->GetEntries();
-  for(Int_t iPart = 0; iPart < nPart; iPart++) {
-    runLoader->TreeK()->GetEvent(iPart);
-    vertex[0] = particle->Vx();
-    vertex[1] = particle->Vy();
-    vertex[2] = particle->Vz();
-    momentum[0] = particle->Px();
-    momentum[1] = particle->Py();
-    momentum[2] = particle->Pz();
-    
-    printf("===================================================\n");
-    printf(" Generated particle # %d \n",iPart);
-    printf(" name: %s \n",particle->GetName());
-    printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]); 
-    printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
-  }
-  delete particle;    
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawSegmentation()
-{
-/// \todo to be re-written for new seg
-/// Draw graphical representation of segmenatation
-/// Attention: still experimental code
-//     Int_t icat=1;
-    
-//     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-//     AliMUONChamber*   iChamber;
-
-//     AliSegmentation*  seg;
-//     iChamber = &(pMUON->Chamber(fChamber));
-//     seg=iChamber->SegmentationModel(icat);
-
-//     Float_t zpos=iChamber->Z();
-//     Float_t r=iChamber->ROuter();
-    
-//     TMarker3DBox *marker;
-//     if (icat == 1) {
-//     for (Int_t j=0; j<seg->Npy(); j++) {
-//         Float_t y0;
-//         y0=j*seg->Dpy()-seg->Dpy()/2.;
-//         for (seg->FirstPad(0.,y0,0,300,0.); 
-//              seg->MorePads();
-//              seg->NextPad())
-//         {
-//             if (seg->ISector()==0) continue;
-//             Float_t x,y,z;
-//             seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
-//             Float_t dpx=seg->Dpx(seg->ISector())/2;
-//             Float_t dpy=seg->Dpy(seg->ISector())/2;
-//             marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
-//             marker->SetLineColor(seg->ISector()+1);
-//             marker->SetFillStyle(1001);
-//             marker->SetFillColor(0);
-//             marker->Draw();
-//         }
-//     }
-//     } else {
-//     for (Int_t j=0; j<250; j++) {
-//         Float_t x0=j*seg->Dpx();
-//         Float_t y0=TMath::Sqrt(r*r-x0*x0);
-           
-//         for (seg->FirstPad(x0,0,0,0,y0); 
-//              seg->MorePads();
-//              seg->NextPad())
-//         {
-//             if (seg->ISector()==0) continue;
-               
-//             Float_t x,y,z;
-//             seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
-//             Float_t dpx=seg->Dpx(seg->ISector())/2;
-//             Float_t dpy=seg->Dpy(seg->ISector())/2;
-//             marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
-//             marker->SetLineColor(seg->ISector()+1);
-//             marker->SetFillStyle(1001);
-//             marker->SetFillColor(0);
-//             marker->Draw();
-//         }
-//     }
-//     }
- }
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawClusters()
-{
-/// Draw clusters for MUON chambers
-
-    Int_t ndigits, digit;
-    TObjArray *points;
-    AliMUONPoints *pm;
-
-      
-    fClustersCuts = 0;
-    points = Points();
-    if (!points) return;
-    ndigits = points->GetEntriesFast();
-    for (digit=0;digit<ndigits;digit++){
-       pm = (AliMUONPoints*)points->UncheckedAt(digit);
-       if (!pm) continue;
-       Float_t *pxyz;
-       pxyz=pm->GetP();
-       for (Int_t im=0;im<3;im++) {
-           TMarker3DBox *marker=pm->GetMarker(im);
-           if (marker)
-               marker->Draw();
-       }
-       pm->Draw();
-       fClustersCuts += pm->GetN();
-    }
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawHits()
-{
-/// Draw hits for MUON chambers
-
-    LoadHits(fChamber);
-
-    Int_t ntracks, track;
-    TObjArray *points;
-    AliMUONPoints *pm;
-    
-    fHitsCuts = 0;
-    points = Phits();
-    if (!points) return;
-    ntracks = points->GetEntriesFast();
-    for (track=0;track<ntracks;track++) {
-       pm = (AliMUONPoints*)points->UncheckedAt(track);
-       if (!pm) continue;
-       pm->Draw();
-       fHitsCuts += pm->GetN();
-    }
-}
-
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawCoG()
-{
-/// Draw hits for MUON chambers
-
-    if (!fDrawCoG) return;
-    if (fChamber > 10) return;
-    LoadCoG(fChamber,fCathode);
-    
-    Int_t ncog, icog;
-    TObjArray *points;
-    AliMUONPoints *pm;
-
-    points = Rpoints();
-    if (!points) return;
-    ncog = points->GetEntriesFast();
-    for (icog=0;icog<ncog;icog++) {
-       pm = (AliMUONPoints*)points->UncheckedAt(icog);
-       if (!pm) continue;
-       pm->Draw();
-    }
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawTracks()
-{
-/// Draw tracks
-
-    if (!fDrawTracks) return;
-    LoadTracks();
-    
-    Int_t nTrack, iTrack;
-    TObjArray *points;
-    TPolyLine3D *pm;
-
-    points = Rpoints();
-    if (!points) return;
-    nTrack = points->GetEntriesFast();
-    for ( iTrack = 0; iTrack < nTrack; iTrack++) {
-       pm = (TPolyLine3D*)points->UncheckedAt(iTrack);
-       if (!pm) continue;
-       pm->Draw();
-    }
-}
-//_____________________________________________________________________________
-
-void AliMUONDisplay::DrawTitle(Option_t *option)
-{
-/// Draw the event title
-
-  if ( !fSimLoader || !fRecLoader ) {
-    AliErrorStream() << "Detector loaders are not defined." << endl;
-    return;
-  }  
-
-    Float_t xmin = gPad->GetX1();
-    Float_t xmax = gPad->GetX2();
-    Float_t ymin = gPad->GetY1();
-    Float_t ymax = gPad->GetY2();
-    Float_t dx   = xmax-xmin;
-    Float_t dy   = ymax-ymin;
-    
-    AliRunLoader * runLoader = fSimLoader->GetRunLoader();
-
-    if (strlen(option) == 0) {
-       TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
-//      title->SetTextSize(0.023932);
-       title->SetTextSize(0.02);
-       title->SetBit(kCanDelete);
-       title->SetFillColor(42);
-       title->Draw();
-       char ptitle[100];
-       sprintf(ptitle, "Alice event:%d Run:%d Chamber:%d Cathode:%d",
-               runLoader->GetEventNumber(),
-               gAlice->GetHeader()->GetRun(),
-               fChamber,
-               fCathode);
-       title->AddText(ptitle);
-       Int_t nparticles = gAlice->GetMCApp()->Particles()->GetEntriesFast();
-       sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",
-               nparticles, fHitsCuts,fClustersCuts);
-       title->AddText(ptitle);
-    } else {
-       TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
-       label->SetBit(kCanDelete);
-       label->SetFillColor(42);
-       label->Draw();
-    }
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
-{
-/// Draw a view of MUON clusters
-
-  AliInfo(" Draw View");
-  
-  gPad->SetCursor(kWatch);
-  // gPad->SetFillColor(39);
-  gPad->SetFillColor(1);
-  gPad->Clear();
-  // gPad->SetFillColor(39);
-  gPad->SetFillColor(1);
-  
-  Int_t iret=0;
-#if ROOT_VERSION_CODE>= 331523
-   Double_t rmin[]={-1,-1,-1};
-   Double_t rmax[]={ 1, 1, 1};
-   TView *view = new TView3D(1,rmin,rmax);
-#else
-  TView *view = new TView(1);
-#endif
-  
-  Float_t range = fRrange*fRangeSlider->GetMaximum();
-  view->SetRange(-range,-range,-range,range, range, range);
-  // zoom back to full scale only if DrawView not called from NextCathode
-  if (!fNextCathode) {
-    fZoomX0[0] = -1;
-    fZoomY0[0] = -1;
-    fZoomX1[0] =  1;
-    fZoomY1[0] =  1;
-    fZooms = 0;
-  }
-  
-  Float_t xg1, xg2, yg1, yg2, zg1, zg2;
-  
-  // Recovering the chamber 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-  
-  const AliMUONGeometryTransformer* kGeomTransformer 
-    = pMUON->GetGeometryTransformer();
-  
-  AliMUONSegmentation* segmentation = pMUON->GetSegmentation();
-  
-  // Display MUON Chamber Geometry
-  char nodeName[7];
-  sprintf(nodeName,"MUON%d",100+fChamber);
-  printf(">>>> chamber is %d\n",fChamber);
-  
-  if(fChamber < 5) {
-    AliMpDEIterator it;
-    for ( it.First(fChamber-1); ! it.IsDone(); it.Next() ) {
-      
-      Int_t detElemId = it.CurrentDEId();
-      AliMpSectorSegmentation * seg =   
-        (AliMpSectorSegmentation *) AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0);
-      const AliMpSector * sector = seg->GetSector();
-      
-      // get sector measurements
-      TVector2 position  = sector->Position(); 
-      TVector2 dimension = sector->Dimensions(); // half length
-      
-      Float_t xlocal1 =  position.Px(); // FIXME: not really needed as it's 0 ?
-      Float_t ylocal1 =  position.Py(); // FIXME: not really needed as it's 0 ?
-      Float_t xlocal2 =  dimension.Px() * 2.;
-      Float_t ylocal2 =  dimension.Px() * 2.;
-      
-      kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
-      kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
-      
-      // drawing 
-      TPolyLine3D* poly = new  TPolyLine3D();
-      Int_t nPoint = 0;
-      
-      poly->SetPoint(nPoint++, xg1, yg1, 0.);
-      for (Float_t d = 0; d < TMath::Pi()/2.; d+= 0.01) {
-        Float_t x = xg1 + xg2 * TMath::Cos(d);
-        Float_t y = yg1 + yg2 * TMath::Sin(d);
-        poly->SetPoint(nPoint++, x, y, 0.);
-      }
-      poly->SetPoint(nPoint++, xg1, yg1, 0.);
-      
-      poly->SetLineColor(2);
-      poly->Draw("s");
-    }
-    
-  }
-  
-  if (fChamber>4) 
-  {
-    AliMpDEIterator it;
-    for ( it.First(fChamber-1); ! it.IsDone(); it.Next() ) 
-    {
-      Int_t detElemId = it.CurrentDEId();
-      AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
-
-      if (  segmentation->HasDE(detElemId) ) 
-      {
-        const AliMpVSegmentation* seg 
-         = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::kCath0);
-        if (seg) 
-        {  
-          Float_t deltax = seg->Dimensions().X();
-          Float_t deltay = seg->Dimensions().Y();
-          Float_t xlocal1 =  -deltax;
-          Float_t ylocal1 =  -deltay;
-          Float_t xlocal2 =  +deltax;
-          Float_t ylocal2 =  +deltay;
-          kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
-          kGeomTransformer->Local2Global(detElemId, xlocal2, ylocal2, 0, xg2, yg2, zg2);
-          
-          // drawing slat active volumes
-          Float_t xCenter = (xg1 + xg2)/2.;
-          Float_t yCenter = (yg1 + yg2)/2.;
-          
-          TMarker3DBox* box = new TMarker3DBox(xCenter,yCenter,0,xlocal1,ylocal2,0,0,0);
-          
-          box->SetFillStyle(0);
-          box->SetLineColor( stationType == AliMp::kStationTrigger ? 4 : 2);
-          box->Draw("s");
-          
-          if ( stationType == AliMp::kStation345 )
-          {
-            // drawing inner circle + disc
-            TPolyLine3D* poly  = new  TPolyLine3D();
-            TPolyLine3D* poly1 = new  TPolyLine3D();
-            
-            Int_t nPoint = 0;
-            Int_t nPoint1 = 0;
-            for (Float_t d = 0; d < 6.24; d+= 0.005) 
-            {
-              Double_t x = AliMUONConstants::Dmin((fChamber-1)/2) * TMath::Cos(d)/2.;
-              Double_t y = AliMUONConstants::Dmin((fChamber-1)/2) * TMath::Sin(d)/2.;
-              if (nPoint % 2 == 0) poly->SetPoint(nPoint++, 0., 0., 0.);
-              poly->SetPoint(nPoint++, x, y, 0.);
-              poly1->SetPoint(nPoint1++, x, y, 0.);            
-            }
-            poly->SetLineColor(1);
-            poly->Draw("s");
-            poly1->SetLineColor(2);
-            poly1->Draw("s");
-          }
-        }  
-      }
-    }
-  }
-  
-  //add clusters to the pad
-  DrawClusters();
-  DrawHits();
-  DrawCoG();
-  //     DrawSegmentation();
-  // add itself to the list (must be last)
-  AppendPad();
-  view->SetView(phi, theta, psi, iret);
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
-{
-/// Draw a view of muons chambers with tracks
-    
-    gPad->SetCursor(kWatch);
-    // gPad->SetFillColor(39);
-    gPad->SetFillColor(1);
-    gPad->Clear();
-    // gPad->SetFillColor(39);
-    gPad->SetFillColor(1);
-    
-
-    Int_t iret=0;
-#if ROOT_VERSION_CODE>= 331523
-    Double_t rmin[]={-1,-1,-1};
-    Double_t rmax[]={ 1, 1, 1};
-    TView *view = new TView3D(1,rmin,rmax);
-#else
-    TView *view = new TView(1);
-#endif
-    
-    Float_t range = fRrange*fRangeSlider->GetMaximum()*3.;
-    view->SetRange(-range,-range,-range,range,range,range);
-
-// Display all MUON Chambers segmentation
-    char nodeName[7];
-    TNode *node1;
-    sprintf(nodeName,"alice");
-    
-    node1=gAlice->GetGeometry()->GetNode(nodeName);
-    if (node1) node1->Draw("same"); 
-     
-      
-// Draw clusters for all chambers
-    Int_t chamberSave = fChamber;
-    for (fChamber = 1; fChamber <= 10; fChamber++){
-      DrawCoG();
-    }
-    fChamber = chamberSave;
-// Draw reconstructed tracks
-    DrawTracks();
-
-    AppendPad();
-
-    Float_t zoom = 2.;
-    Float_t shift = 0.9;
-    Float_t x0 = (-1+shift)/zoom;
-    Float_t y0 = (-1+shift)/zoom;
-    Float_t x1 = (1+shift)/zoom;
-    Float_t y1 = (1+shift)/zoom;
-    gPad->Range(x0,y0,x1,y1);
-    view->SetView(phi, theta, psi, iret);
-
-}
-
-//______________________________________________________________________________
-void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
-{
-/// Execute action corresponding to the mouse event
-
-    static Float_t x0, y0, x1, y1;
-    
-    static Int_t pxold, pyold;
-    static Int_t px0, py0;
-    static Int_t linedrawn;
-    Float_t temp;
-    
-    if (px == 0 && py == 0) { //when called by sliders
-       if (event == kButton1Up) {
-           Draw();
-       }
-       return;
-    }
-    if (!fZoomMode && gPad->GetView()) {
-       gPad->GetView()->ExecuteRotateView(event, px, py);
-       return;
-    }
-
-    // something to zoom ?
-    gPad->SetCursor(kCross);
-    
-    switch (event) {
-
-    case kButton1Down:
-       gVirtualX->SetLineColor(-1);
-       gPad->TAttLine::Modify();  //Change line attributes only if necessary
-       x0 = gPad->AbsPixeltoX(px);
-       y0 = gPad->AbsPixeltoY(py);
-       px0   = px; py0   = py;
-       pxold = px; pyold = py;
-       linedrawn = 0;
-       return;
-       
-    case kButton1Motion:
-       if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
-       pxold = px;
-       pyold = py;
-       linedrawn = 1;
-       gVirtualX->DrawBox(px0, py0, pxold, pyold,  TVirtualX::kHollow);
-       return;
-       
-    case kButton1Up:
-       gPad->GetCanvas()->FeedbackMode(kFALSE);
-       if (px == px0) return;
-       if (py == py0) return;
-       x1 = gPad->AbsPixeltoX(px);
-       y1 = gPad->AbsPixeltoY(py);
-       
-       if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
-       if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
-       gPad->Range(x0,y0,x1,y1);
-       if (fZooms < AliMUONConstants::MaxZoom()-1) {
-           fZooms++;
-           fZoomX0[fZooms] = x0;
-           fZoomY0[fZooms] = y0;
-           fZoomX1[fZooms] = x1;
-           fZoomY1[fZooms] = y1;
-       }
-       gPad->Modified(kTRUE);
-       return;
-    }
-}
-//___________________________________________
-void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
-{
-/// Read digits info and store x,y,z info in arrays fPoints.
-/// Loop on all detectors
-
-    if (chamber > 14) return;
-    fChamber = chamber;
-    fCathode = cathode;
-    
-    ResetPoints();
-    
-    AliMUON *pMUON  =     (AliMUON*)gAlice->GetModule("MUON");
-
-    GetMUONSimData()->SetTreeAddress("D");
-
-    TClonesArray *muonDigits  = GetMUONSimData()->Digits(chamber-1);
-    if (muonDigits == 0) return;
-
-    gAlice->ResetDigits();
-    Int_t nent = 0;
-    if (GetSimLoader()->TreeD()) {
-       nent = (Int_t) GetSimLoader()->TreeD()->GetEntries();
-       //     gAlice->TreeD()->GetEvent(nent-2+cathode-1);
-       GetMUONSimData()->GetDigits();
-    }
-    
-    Int_t ndigits = muonDigits->GetEntriesFast();    
-    if (ndigits == 0) return;  
-    if (fPoints == 0) fPoints = new TObjArray(ndigits);
-    
-    Float_t zpos = AliMUONConstants::DefaultChamberZ(chamber-1);
-
-    AliMUONDigit  *mdig;
-    AliMUONPoints *points  = 0;
-    TMarker3DBox  *marker  = 0;
-
-    Int_t npoints  = 1;
-    Float_t adcmax = 1024; // default
-    if (chamber<11) adcmax = 4096;
-
-// check if trigger is using new or old segmentation
-    Bool_t old = true;
-    AliMUONSegmentation* segmentation = pMUON->GetSegmentation();
-    const AliMUONVGeometryDESegmentation* kdeSegmentation 
-      = segmentation->GetDESegmentation(1100, cathode-1);
-    if ( dynamic_cast<const AliMUONTriggerSegmentation*>(kdeSegmentation) ) old = false;
-
-    if ( old  && chamber > 10) {
-       if (chamber > 10) printf(">>> old segmentation for trigger \n");
-       else printf(">>> old segmentation for tracking \n");
-
-       for (Int_t digit = 0; digit < ndigits; digit++) {
-           mdig    = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
-           if (mdig->Cathode() != cathode-1) continue;
-           
-           //
-           // First get all needed parameters
-           //
-           Float_t charge = mdig->Signal();
-           Int_t index  = Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
-           Int_t color  = 261+index;
-           Int_t colorTrigger = 2;   
-           if (color > 282) color = 282;
-           
-           if (chamber > 10) { // trigger chamber 
-               
-               Float_t sumCharge = 0;
-               for (Int_t icharge = 0; icharge < 10; icharge++) {
-                   sumCharge = sumCharge+mdig->TrackCharge(icharge);
-               }
-               Float_t testCharge = sumCharge-(Int_t(sumCharge/10))*10;
-               if(sumCharge <= 10 || testCharge > 0) {
-                   colorTrigger = color; 
-               } else {
-                   colorTrigger = 5; 
-               }
-           }
-           
-           // get the center of the pad - add on x and y half of pad size
-           Float_t xpad, ypad, zpad;
-           Int_t isec;
-           Float_t dpx, dpy;
-           
-           Int_t detElemId = mdig->DetElemId();
-           AliMUONGeometrySegmentation* segmentation2
-             = pMUON->GetSegmentation()->GetModuleSegmentationByDEId(detElemId, cathode-1);
-           segmentation2->GetPadC(detElemId, mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
-           isec = segmentation2->Sector(detElemId, mdig->PadX(), mdig->PadY());
-           dpx = segmentation2->Dpx(detElemId, isec)/2;
-           dpy = segmentation2->Dpy(detElemId, isec)/2;
-           
-           // Then set the objects
-           points = new AliMUONPoints(npoints);
-           fPoints->AddAt(points,digit);
-           if (chamber > 10) {
-               points->SetMarkerColor(colorTrigger);
-           } else {  
-               points->SetMarkerColor(color);
-           }
-           points->SetMarkerStyle(21);
-           points->SetMarkerSize(0.5);
-           points->SetParticle(-1);
-           points->SetHitIndex(-1);
-           points->SetTrackIndex(-1);
-           points->SetDigitIndex(digit);
-           points->SetPoint(0,xpad,ypad,zpos);
-           
-           Int_t lineColor = (zpad-zpos > 0) ? 2:3;
-           marker=new TMarker3DBox(xpad,ypad,zpos,dpx,dpy,0,0,0);
-           
-           
-           marker->SetLineColor(lineColor);
-           marker->SetFillStyle(1001);
-           marker->SetFillColor(color);
-           marker->SetRefObject((TObject*)points);
-           points->Set3DMarker(0, marker);
-       } // end loop on digits     
-       
-    } else {   
-       if (chamber > 10) printf(">>> new segmentation for trigger \n");
-       else printf(">>> new segmentation for tracking \n");
-       
-       const AliMUONGeometryTransformer* kGeomTransformer 
-           = pMUON->GetGeometryTransformer();
-       
-       //loop over all digits and store their position
-       for (Int_t digit = 0; digit < ndigits; digit++) {
-           mdig    = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
-           if (mdig->Cathode() != cathode-1) continue;
-           
-           // get all needed parameters
-           Int_t ix=mdig->PadX();
-           Int_t iy=mdig->PadY();
-           Int_t detElemId=mdig->DetElemId();      
-           Float_t charge = mdig->Signal();
-           Int_t index  = Int_t(TMath::Log(charge)/(TMath::Log(adcmax)/22));
-           Int_t color  = 261+index;
-           Int_t colorTrigger = 2;   
-           if (color > 282) color = 282;
-           
-           const AliMpVSegmentation* seg = 
-              AliMpSegmentation::Instance()
-                ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode-1));
-           
-           AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
-           
-           if (chamber > 10) { // trigger chamber
-               Float_t sumCharge = 0;
-    Int_t n = mdig->Ntracks();
-               for (Int_t icharge = 0; icharge < n; icharge++) {
-                   sumCharge = sumCharge+mdig->TrackCharge(icharge);
-               }
-               Float_t testCharge = sumCharge-(Int_t(sumCharge/n))*n;
-               if(sumCharge <= n || testCharge > 0) {
-                   colorTrigger = color; 
-               } else {
-                   colorTrigger = 5; 
-               }
-           }
-           
-           // get the pad position and dimensions
-           Float_t xlocal1 = pad.Position().X();
-           Float_t ylocal1 = pad.Position().Y();
-           Float_t xlocal2 = pad.Dimensions().X();
-           Float_t ylocal2 = pad.Dimensions().Y();
-           
-           Float_t xg1, xg2, yg1, yg2, zg1;
-           
-           kGeomTransformer->Local2Global(detElemId, xlocal1, ylocal1, 0, xg1, yg1, zg1);
-           // (no transformation for pad dimensions)
-           xg2 = xlocal2;
-           yg2 = ylocal2;
-           
-           // Then set the objects
-           points = new AliMUONPoints(npoints);
-           fPoints->AddAt(points,digit);
-           if (chamber > 10) {
-               points->SetMarkerColor(colorTrigger);
-           } else {  
-               points->SetMarkerColor(color);
-           }
-           points->SetMarkerStyle(21);
-           points->SetMarkerSize(0.5);
-           points->SetParticle(-1);
-           points->SetHitIndex(-1);
-           points->SetTrackIndex(-1);
-           points->SetDigitIndex(digit);
-           points->SetPoint(0,xg1,yg1,zpos);
-           
-           Int_t lineColor = (zg1-zpos > 0) ? 2:3;
-           marker=new TMarker3DBox(xg1,yg1,zpos,xg2,yg2,0,0,0);
-           
-           marker->SetLineColor(lineColor);
-           marker->SetFillStyle(1001);
-           marker->SetFillColor(color);
-           marker->SetRefObject((TObject*)points);
-           points->Set3DMarker(0, marker);
-           
-       } // end loop on digits
-    } // end of new segmentation    
-}
-//___________________________________________
-void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
-{
-/// Read raw clusters info and store x,y,z info in arrays fRpoints.
-/// Loop on all detectors
-
-    if (chamber > 10) return;
-    
-    ResetRpoints();
-    
-    GetMUONRecData()->SetTreeAddress("RC");
-    TClonesArray *muonRawClusters  = GetMUONRecData()->RawClusters(chamber-1);
-
-    if (muonRawClusters == 0) return;
-
-    Int_t nent = 0;
-    if (GetMUONRecData()->TreeR()) {
-       nent=(Int_t) GetMUONRecData()->TreeR()->GetEntries();
-       GetMUONRecData()->TreeR()->GetEvent(0);
-    }
-    
-    Int_t nrawcl = muonRawClusters->GetEntriesFast();
-    if (nrawcl == 0) return;
-    if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
-    
-    Float_t zpos = AliMUONConstants::DefaultChamberZ(chamber-1);  
-    AliMUONRawCluster  *mRaw;
-    AliMUONPoints *points = 0;
-    //
-    //loop over all raw clusters and store their position
-    points = new AliMUONPoints(nrawcl);
-    for (Int_t iraw=0;iraw<nrawcl;iraw++) {
-       mRaw   = (AliMUONRawCluster*)muonRawClusters->UncheckedAt(iraw);
-        points->SetMarkerColor(51);
-        points->SetMarkerStyle(2);
-        points->SetMarkerSize(1.);
-        points->SetParticle(-1);
-        points->SetHitIndex(-1);
-        points->SetTrackIndex(-1);
-        points->SetDigitIndex(-1);
-        points->SetPoint(iraw,mRaw->GetX(0),mRaw->GetY(0),zpos);
-       fRpoints->AddAt(points,iraw);
-       //      printf("%f and %f and %f\n",mRaw->GetX(0),mRaw->GetY(0),mRaw->GetZ(0));
-    }
-}
-
-//___________________________________________
-void AliMUONDisplay::LoadTracks()
-{
-/// Load tracks
-
-  AliMUONTrack* recTrack = 0;
-  AliMUONTrackParam* trackParam = 0;
-  TClonesArray *  trackParamAtHit = 0;   
-
-  ResetRpoints();
-
-  GetMUONRecData()->SetTreeAddress("RT");
-  TClonesArray* recTracksArray = GetMUONRecData()->RecTracks();
-  if (recTracksArray == NULL) return;
-  GetMUONRecData()->GetRecTracks();
-
-  Int_t nRecTracks = 0;
-  if (recTracksArray)
-    nRecTracks = (Int_t) recTracksArray->GetEntriesFast();
-
-
-  if (fRpoints == 0) fRpoints = new TObjArray(nRecTracks);
-
-  for (Int_t iRecTracks = 0; iRecTracks <  nRecTracks;  iRecTracks++) {
-    // reading info from tracks
-    recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
-
-    Int_t nTrackHits = recTrack->GetNTrackHits();
-
-    if (nTrackHits == 0) continue;
-
-    Int_t iPoint = 0;
-    TPolyLine3D *points = new TPolyLine3D(nTrackHits+1); 
-    points->SetLineColor(6);
-    points->SetLineWidth(1);
-    fRpoints->AddAt(points,iRecTracks);
-
-    Float_t xRec=0;
-    Float_t yRec=0;
-    Float_t zRec=0;
-
-    // vertex unknown at the tracking level -> put it at (0,0,0)
-    points->SetPoint(iPoint,0.,0.,0.);
-    iPoint++;  
-
-    for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
-      trackParamAtHit = recTrack->GetTrackParamAtHit();
-      trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit); 
-      xRec  = trackParam->GetNonBendingCoor();
-      yRec  = trackParam->GetBendingCoor();
-      zRec  = trackParam->GetZ();
-      points->SetPoint(iPoint,xRec,yRec,zRec);
-      iPoint++;        
-    } // end loop rec. hits
-    PrintTrack(iRecTracks,recTrack);
-  } // end loop tracks
-  
-
-}
-
-//___________________________________________
-void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
-{
-/// Print reconstructed track
-  
-  AliMUONTrackParam *trackParam;
-  Float_t vertex[3], momentum[3];
-  Float_t pYZ, bendingSlope, nonBendingSlope, chi2dof;
-  Int_t charge;
-
-  trackParam = recTrack->GetTrackParamAtVertex(); // meaningless since the vertex is not known at the tracking level
-  vertex[0] = trackParam->GetNonBendingCoor();
-  vertex[1] = trackParam->GetBendingCoor();
-  vertex[2] = trackParam->GetZ();
-  charge = Int_t(TMath::Sign(1.,trackParam->GetInverseBendingMomentum()));
-
-  printf("===================================================\n");
-  printf("//*****************************************************************//\n");
-  printf("// meaningless since the vertex is not known at the tracking level //\n");
-  printf("//*****************************************************************//\n");
-  printf(" Reconstructed track # %d \n",iRecTracks);
-  printf(" charge: %d \n",charge);
-  printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]); 
-
-  if ( trackParam->GetInverseBendingMomentum() != 0. ) {
-    pYZ =  1./TMath::Abs(trackParam->GetInverseBendingMomentum());
-    bendingSlope = trackParam->GetBendingSlope();
-    nonBendingSlope = trackParam->GetNonBendingSlope();
-    momentum[2] = -pYZ / TMath::Sqrt(1.0 + bendingSlope*bendingSlope);
-    momentum[0] = momentum[2] * nonBendingSlope;
-    momentum[1] = momentum[2] * bendingSlope;
-    printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
-  }
-  else { 
-    AliErrorStream() << "Cannot calculate momentum: pYZ = inf" << endl;
-  }  
-  chi2dof = recTrack->GetFitFMin()/(2.0 * recTrack->GetNTrackHits() - 5.);
-  printf(" track chi2/dof: %f \n",chi2dof); 
-}
-
-//___________________________________________
-void AliMUONDisplay::LoadHits(Int_t chamber)
-{
-/// Read hits info and store x,y,z info in arrays fPhits.
-/// Loop on all detectors
-
-    if (chamber > 14) return;
-    Int_t track;
-
-    fChamber=chamber;
-    ResetPhits();
-    
-    Float_t zpos=AliMUONConstants::DefaultChamberZ(chamber-1);
-
-    if (GetMUONSimData()->TreeH()) {
-      GetMUONSimData()->SetTreeAddress("H");
-      Int_t ntracks = (Int_t)GetMUONSimData()->TreeH()->GetEntries(); //skowron
-      Int_t nthits  = 0;
-      for (track = 0; track < ntracks; track++) {
-       GetMUONSimData()->ResetHits();
-       GetMUONSimData()->GetTrack(track);//skowron
-       TClonesArray *muonHits  = GetMUONSimData()->Hits();
-       if (muonHits == 0) return;
-       nthits += muonHits->GetEntriesFast();
-      } 
-      if (fPhits == 0) fPhits = new TObjArray(nthits);
-      Int_t nhold=0;
-      for (track=0; track<ntracks;track++) {
-       GetMUONSimData()->ResetHits();
-       GetMUONSimData()->GetTrack(track);//skowron
-       TClonesArray *muonHits  = GetMUONSimData()->Hits();
-       if (muonHits == 0) return;
-       Int_t nhits = muonHits->GetEntriesFast();
-       if (nhits == 0) continue;
-       AliMUONHit *mHit;
-       AliMUONPoints *points = 0;
-       Int_t npoints=1;
-       for (Int_t hit=0;hit<nhits;hit++) {
-         mHit = (AliMUONHit*)muonHits->UncheckedAt(hit);
-         Int_t nch  = mHit->Chamber();              // chamber number
-         if (nch != chamber) continue;
-         //
-         // Retrieve info and set the objects
-         //
-         points = new AliMUONPoints(npoints);
-         fPhits->AddAt(points,nhold+hit);
-         points->SetMarkerColor(kRed);
-         points->SetMarkerStyle(5);
-         points->SetMarkerSize(1.);
-         points->SetParticle(mHit->Track());
-         points->SetHitIndex(hit);
-         points->SetTrackIndex(track);
-         points->SetDigitIndex(-1);
-         points->SetPoint(0,mHit->X(),mHit->Y(),zpos);
-         //        printf("%f and %f and %f\n",mHit->X(),mHit->Y(),mHit->Z());
-       }
-       nhold+=nhits;
-      }
-    }
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::Paint(Option_t *)
-{
-/// Paint miscellaneous items
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::SetPickMode()
-{
-/// Set parameters for pick mode.
-    fZoomMode = 0;
-
-    fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
-    fTrigPad->Modified();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::SetZoomMode()
-{
-/// Set parameters for zoom mode
-
-    fZoomMode = 1;
-    
-    fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
-    fTrigPad->Modified();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::NextChamber(Int_t delta)
-{
-/// To go from chamber to next chamber if delta = 1
-/// or previous chamber otherwise
-    if (delta == 1) {
-       if (fChamber < AliMUONConstants::NCh()) fChamber++;
-    } else {
-       if (fChamber > 1) fChamber--;
-    }
-    if (!fPad) return;
-    fPad->Clear();
-    LoadDigits(fChamber, fCathode);
-    DrawChamber();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::NextCathode()
-{
-/// To switch to other cathode plane
-
-    if (!fPad) return;
-    fPad->Clear();
-    if (fCathode == 1) {
-       LoadDigits(fChamber, 2);        
-    } else {
-       LoadDigits(fChamber, 1);
-    }
-    fNextCathode = kTRUE; // to keep the same zoom
-    DrawChamber();
-    fNextCathode = kFALSE;
-    TPad *pad = (TPad*)gPad->GetPadSave();
-    pad->Range(fZoomX0[fZooms], fZoomY0[fZooms],
-              fZoomX1[fZooms], fZoomY1[fZooms]);
-    pad->Modified();
-    fPad->cd();
-    DrawTitle();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::Trigger()
-{
-/// Print global trigger output
-
-  AliMUONGlobalTrigger* globalTrig;
-
-  GetMUONRecData()->SetTreeAddress("GLT");
-  GetMUONRecData()->GetTriggerD();
-
-  globalTrig =  (AliMUONGlobalTrigger*)GetMUONRecData()->GlobalTrigger()->UncheckedAt(0);
-  if (globalTrig == 0) return;
-
-  globalTrig->Print("full");
-
- //  // returns Trigger Decision for current event
-//   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(GetLoader(),1);
-
-//   //  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
-//   AliMUONData* muonData = decision->GetMUONRecData();
-//   muonData->SetTreeAddress("D");
-//   decision->Trigger(); 
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
-{
-/// Set chamber and cathode number
-
-   fChamber = chamber;
-   fCathode = cathode;
-
-   if (!fPad) return;
-   fPad->Clear();
-   LoadDigits(chamber,cathode);
-   DrawChamber();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::SetEvent(Int_t newevent)
-{
-/// Chose event 
-
-    gAlice->GetEvent(newevent);
-    fEvent=newevent;
-    if (!gAlice->TreeD()) return; 
-    if (!fPad) return;
-    fPad->Clear();
-    LoadDigits(fChamber,fCathode);
-    Draw();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
-{
-/// Set view range along R and Z
-
-    fRrange = rrange;
-    fZrange = zrange;
-
-    if (!fPad) return;
-    fPad->Clear();
-    Draw();
-}
-   
-//_____________________________________________________________________________
-void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
-{
-/// Change viewing angles for current event
-
-    fPad->cd();
-    fPhi   = phi;
-    fTheta = theta;
-    fPsi   = psi;
-    Int_t iret = 0;
-    
-    TView *view = gPad->GetView();
-    if (view) view->SetView(fPhi, fTheta, fPsi, iret);
-    else      Draw();
-    gPad->Modified();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::ShowNextEvent(Int_t delta)
-{
-/// Display (current event_number + delta)
-///  -  delta =  1  shown next event
-///  -  delta = -1 show previous event
-
-   if ( !fSimLoader || !fRecLoader ) {
-     AliErrorStream() << "Detector loaders are not defined." << endl;
-     return;
-   }  
-    
-   AliRunLoader* runSimLoader =  fSimLoader->GetRunLoader();
-   AliRunLoader* runRecLoader =  fRecLoader->GetRunLoader();
-   
-    
-   if (delta) {
-      //runLoader->CleanDetectors();
-      //runLoader->CleanKinematics();
-      Int_t currentEvent = runSimLoader->GetEventNumber();
-      Int_t newEvent     = currentEvent + delta;
-      runSimLoader->GetEvent(newEvent);
-      runRecLoader->GetEvent(newEvent);
-      fEvent=newEvent;
-    }
-    LoadDigits(fChamber, fCathode);
-    fPad->cd(); 
-    Draw();
-}
-
-//______________________________________________________________________________
-void AliMUONDisplay::UnZoom()
-{
-/// Unzoom 
-
-    if (fZooms <= 0) return;
-    fZooms--;
-    TPad *pad = (TPad*)gPad->GetPadSave();
-    pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
-    pad->Modified();
-}
-
-//_____________________________________________________________________________
-void AliMUONDisplay::ResetPoints()
-{
-/// Reset array of points
-
-    if (fPoints) {
-       fPoints->Delete();
-       delete fPoints;
-       fPoints = 0;
-    }
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::ResetPhits()
-{
-/// Reset array of points
-
-    if (fPhits) {
-       fPhits->Delete();
-       delete fPhits;
-       fPhits = 0;
-    }
-}
-//_____________________________________________________________________________
-void AliMUONDisplay::ResetRpoints()
-{
-/// Reset array of points
-
-    if (fRpoints) {
-       fRpoints->Clear();
-       //      delete fRpoints;
-       fRpoints = 0;
-    }
-}
diff --git a/MUON/AliMUONDisplay.h b/MUON/AliMUONDisplay.h
deleted file mode 100644 (file)
index 126d052..0000000
+++ /dev/null
@@ -1,130 +0,0 @@
-#ifndef ALIMUONDISPLAY_H
-#define ALIMUONDISPLAY_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
-
-/// \ingroup evaluation
-/// \class AliMUONDisplay
-/// \brief Utility class to display MUON events
-
-#include "AliDisplay.h"
-
-class AliLoader;
-class AliMUONSimData;
-class AliMUONRecData;
-class AliMUONTrack;
-class TCanvas;
-class TPad;
-class TList;
-class TSlider;
-class TButton;
-class TArc;
-
-class AliMUONDisplay : public AliDisplay 
-{
-public:
-                     AliMUONDisplay();
-                     AliMUONDisplay(Int_t size, 
-                                    AliLoader * simLoader, AliLoader * recLoader);
-                    
-   virtual          ~AliMUONDisplay();
-   virtual void      Clear(Option_t *option="");
-   virtual void      DisplayButtons();
-   virtual void      CreateColors() const;
-   virtual void      DisplayColorScale();
-   virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py);
-   virtual void      DrawReco(Option_t *option="");
-   virtual void      PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack); 
-   virtual void      PrintKinematics(); 
-   virtual void      Draw(Option_t *option="");
-   virtual void      DrawChamber();
-   virtual void      DrawClusters();
-   virtual void      DrawHits();
-   virtual void      DrawCoG();
-   virtual void      DrawTracks();
-   virtual void      DrawSegmentation();
-   virtual void      DrawTitle(Option_t *option="");
-   virtual void      DrawView(Float_t theta, Float_t phi, Float_t psi=0);
-   virtual void      DrawGlobalView(Float_t theta, Float_t phi, Float_t psi=0);
-                     /// Not implemented function
-   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() const {return fZoomMode;}  ///< Return zoom mode
-   Int_t             GetChamber() const {return fChamber;}    ///< Return current chamber
-   Int_t             GetCathode() const {return fCathode;}    ///< Return current cathode
-
-   AliMUONSimData*   GetMUONSimData() {return fMUONSimData;}        ///< Return MUON data
-   AliMUONRecData*   GetMUONRecData() {return fMUONRecData;}        ///< Return MUON data
-   AliLoader*        GetSimLoader()  {return fSimLoader;}           ///< Return loader
-   AliLoader*        GetRecLoader()  {return fRecLoader;}           ///< Return loader
-
-   virtual void      LoadDigits(Int_t chamber, Int_t cathode);
-   virtual void      LoadHits(Int_t chamber);
-   virtual void      LoadCoG(Int_t chamber, Int_t cathode);
-   virtual void      LoadTracks();
-   TPad             *Pad() {return fPad;}         ///< Return pad
-   TObjArray        *Points() {return fPoints;}   ///< Return points for each cathode
-   TObjArray        *Phits() {return fPhits;}     ///< Return hit points for each chamber
-   TObjArray        *Rpoints() {return fRpoints;} ///< Return cog points for each cathode
-   virtual void      Paint(Option_t *option="");
-   virtual void      SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;}   ///< Set flag to draw clusters
-   virtual void      SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1);    ///< Set chamber and cathod
-   virtual void      SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;}             ///< Set flag to draw CoG 
-   virtual void      SetDrawTracks(Bool_t draw=kTRUE) {fDrawTracks=draw;}       ///< Set flag to draw tracks
-   virtual void      SetRange(Float_t rrange=250., Float_t zrange=1050.);      
-   virtual void      SetEvent(Int_t newevent=0);                                  
-   virtual void      SetView(Float_t theta=0, Float_t phi=-90, Float_t psi=0);
-   virtual void      SetPickMode();
-   virtual void      SetZoomMode();
-   virtual void      ShowNextEvent(Int_t delta=1);
-   virtual void      UnZoom();                                                
-   virtual void      ResetPoints();
-   virtual void      ResetPhits();
-   virtual void      ResetRpoints();
-   virtual void      NextChamber(Int_t delta=1);
-   virtual void      NextCathode();
-           void      Trigger();
-
-protected:
-                     /// Not implemented
-                    AliMUONDisplay(const AliMUONDisplay& display);
-                     /// Not implemented
-   AliMUONDisplay&   operator = (const AliMUONDisplay& rhs);
-          
-
-private:
-   Int_t             fEvent;                ///< Current event
-   Int_t             fChamber;              ///< Current Chamber
-   Int_t             fCathode;              ///< Current cathode plane
-   Bool_t            fDrawClusters;         ///< Flag True if Clusters to be drawn
-   Bool_t            fDrawCoG;              ///< Flag True if CoG to be drawn
-   Bool_t            fDrawTracks;           ///< Flag True if tracks to be drawn
-                                           
-   Int_t             fClustersCuts;         ///< Number of clusters surviving cuts
-   TPad             *fColPad;               ///< Pointer to the colors pad 
-   TObjArray        *fPoints;               ///< Array of points for each cathode
-   TObjArray        *fPhits;                ///< Array of hit points for each chamber
-   TObjArray        *fRpoints;              ///< Array of cog points for each cathode
-   Int_t            fNextCathode;           ///< Flagging next cathode
-
-   AliLoader*        fSimLoader;            //!< MUON loader to get data
-   AliLoader*        fRecLoader;            //!< MUON loader to get data
-   AliMUONSimData*   fMUONSimData;          //!< Data container for MUON subsystem 
-   AliMUONRecData*   fMUONRecData;          //!< Data container for MUON subsystem 
-
-   ClassDef(AliMUONDisplay, 0)   //Utility class to display MUON events
-};
-
-#endif
-
-
-
-
-
-
-
-
diff --git a/MUON/AliMUONEventRecoCombi.cxx b/MUON/AliMUONEventRecoCombi.cxx
deleted file mode 100644 (file)
index 899d7b6..0000000
+++ /dev/null
@@ -1,249 +0,0 @@
-/**************************************************************************
- * 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 AliMUONEventRecoCombi
-// -------------------------------------
-// Steering class for the combined cluster / track reconstructor
-// Author: Alexander Zinchenko, JINR Dubna
-
-#include "AliMUONEventRecoCombi.h"
-
-#include "AliMUONRecData.h"
-#include "AliMUONDetElement.h"
-#include "AliMUONDigit.h"
-#include "AliMUONHitForRec.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONTrackK.h"
-#include "AliMUONTrackReconstructorK.h"
-#include "AliMUONConstants.h"
-
-#include "AliLoader.h"
-#include "AliLog.h"
-
-#include <Riostream.h>
-#include <TClonesArray.h>
-#include <TArrayS.h>
-#include <TArrayD.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONEventRecoCombi)
-/// \endcond
-
-AliMUONEventRecoCombi* AliMUONEventRecoCombi::fgRecoCombi = 0; 
-
-//_________________________________________________________________________
-AliMUONEventRecoCombi::AliMUONEventRecoCombi(AliMUONSegmentation* segmentation) 
-  : TObject(),
-    fSegmentation(segmentation),
-    fDetElems(0x0),
-    fZ(new TArrayD(20)),
-    fNZ(0),
-    fDEvsZ(0x0)
-{
-  /// Ctor
-
-  fDetElems = new TClonesArray("AliMUONDetElement", 20);
-}
-
-//_________________________________________________________________________
-AliMUONEventRecoCombi* AliMUONEventRecoCombi::Instance(AliMUONSegmentation* segmentation)
-{
-/// Return pointer to the singleton instance
-
-  if (fgRecoCombi == 0) {
-    fgRecoCombi = new AliMUONEventRecoCombi(segmentation);
-  }
-  return fgRecoCombi;
-}
-
-//_________________________________________________________________________
-AliMUONEventRecoCombi::~AliMUONEventRecoCombi()
-{
-  /// Destructor
-  delete fDetElems;
-  delete fZ;
-  delete [] fDEvsZ;
-}
-
-//_________________________________________________________________________
-void AliMUONEventRecoCombi::FillEvent(AliMUONRecData *data, AliMUONClusterFinderAZ *recModel)
-{
-  /// Fill event information
-
-  // Clear previous event
-  fDetElems->Delete();
-  for (Int_t i = 0; i < fNZ; i++) delete [] fDEvsZ[i];
-  delete [] fDEvsZ; fDEvsZ = NULL;
-  fNZ = -1;
-
-  Int_t nDetElem = 0;
-  for (Int_t ich = 0; ich < 6; ich++) {
-    // loop over chambers 0-5
-    TClonesArray *digs = data->Digits(ich);
-    digs->Sort(); //AZ
-    //cout << ich << " " << digs << " " << digs->GetEntriesFast() << endl;
-    Int_t idDE = -1;
-    for (Int_t i = 0; i < digs->GetEntriesFast(); i++) {
-      AliMUONDigit *dig = (AliMUONDigit*) digs->UncheckedAt(i);
-      if (dig->DetElemId() != idDE) {
-       idDE = dig->DetElemId();
-       new ((*fDetElems)[nDetElem++]) AliMUONDetElement(idDE, dig, recModel, fSegmentation);
-      }
-      else ((AliMUONDetElement*)fDetElems->UncheckedAt(nDetElem-1))->AddDigit(dig);
-    }
-  }
-
-  // Compute average Z-position
-  for (Int_t i = 0; i < nDetElem; i++) {
-    AliMUONDetElement *detElem = (AliMUONDetElement*) fDetElems->UncheckedAt(i);
-    Int_t nDigs = detElem->Digits(0)->GetEntriesFast() + 
-                  detElem->Digits(1)->GetEntriesFast();
-    detElem->SetZ(detElem->Z() / nDigs);
-  }
-  
-  // Sort according to Z
-  fDetElems->Sort();
-  //cout << nDetElem << endl;
-  // Fill det. elems. position index in the container
-  for (Int_t i = 0; i < nDetElem; i++) 
-    ((AliMUONDetElement*)fDetElems->UncheckedAt(i))->SetIndex(i);
-
-  // Find groups of det. elements with the same Z
-  Double_t z0 = -99999;
-  TArrayS *nPerZ = new TArrayS(20);
-  for (Int_t i = 0; i < nDetElem; i++) {
-    AliMUONDetElement *detElem = (AliMUONDetElement*) fDetElems->UncheckedAt(i);
-    detElem->Fill(data);
-    //cout << i << " " << detElem->IdDE() << " " << detElem->Z() << endl;
-    if (detElem->Z() - z0 < 0.05) { 
-      // the same Z
-      (*nPerZ)[fNZ]++;
-    } else {
-      if (fZ->GetSize() <= fNZ+1) fZ->Set(fZ->GetSize()+10);
-      if (nPerZ->GetSize() <= fNZ+1) nPerZ->Set(nPerZ->GetSize()+10);
-      (*fZ)[++fNZ] = detElem->Z();
-      z0 = detElem->Z();
-      (*nPerZ)[fNZ]++;
-    }
-  }
-  fNZ++;
-  /*
-  cout << fNZ << endl;
-  for (Int_t i = 0; i < 7; i++) {
-    cout << i << " " << data->RawClusters(i)->GetEntriesFast() << endl;
-  }
-  */
-
-  // Build list of DE locations vs Z
-  fDEvsZ = new Int_t* [fNZ];
-  Int_t iPos = 0;
-  for (Int_t i = 0; i < fNZ; i++) {
-    Int_t *idPerZ = new Int_t[(*nPerZ)[i]+1]; 
-    for (Int_t j = 1; j < (*nPerZ)[i]+1; j++) idPerZ[j] = iPos++;
-    idPerZ[0] = (*nPerZ)[i]; // number of DE's as first element of array
-    fDEvsZ[i] = idPerZ;
-    //cout << (*nPerZ)[i] << " ";
-  }
-  //cout << endl;
-  delete nPerZ;
-
-  // Fill rec. point container for stations 4 and 5
-  //cout << data->TreeR() << endl;
-  //data->MakeBranch("RC");
-  /*
-  data->SetTreeAddress("RCC");
-  for (Int_t ch = 6; ch < 10; ch++) {
-    TClonesArray *raw = data->RawClusters(ch);
-    cout << ch << " " << raw->GetEntriesFast() << " " << data->RawClusters(ch) << endl;
-    //for (Int_t i = 0; i < raw->GetEntriesFast(); i++) {
-    for (Int_t i = 0; i < TMath::Min(raw->GetEntriesFast(),1000); i++) {
-      AliMUONRawCluster *clus = (AliMUONRawCluster*) raw->UncheckedAt(i);
-      data->AddRawCluster(ch, *clus);
-      cout << i << " " << raw->GetEntriesFast() << endl;
-    }
-  }
-  */
-  //data->SetTreeAddress("RC");
-}
-
-//_________________________________________________________________________
-void AliMUONEventRecoCombi::FillRecP(AliMUONRecData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const
-{
-  /// Fill rec. points used for tracking from det. elems
-
-  TClonesArray *tracks = recoTrack->GetRecTracksPtr();
-  for (Int_t i = 0; i < recoTrack->GetNRecTracks(); i++) {
-    AliMUONTrackK *track = (AliMUONTrackK*) tracks->UncheckedAt(i);
-    TObjArray *hits = track->GetTrackHits();
-    for (Int_t j = 0; j < track->GetNTrackHits(); j++) {
-      AliMUONHitForRec *hit = (AliMUONHitForRec*) hits->UncheckedAt(j);
-      if (hit->GetHitNumber() >= 0) continue;
-      // Combined cluster / track finder
-      Int_t index = -hit->GetHitNumber() / 100000;
-      Int_t iPos = -hit->GetHitNumber() - index * 100000;
-      AliMUONRawCluster *clus = (AliMUONRawCluster*) DetElem(index-1)->RawClusters()->UncheckedAt(iPos);
-      //cout << j << " " << iPos << " " << clus << " " << index << " " << DetElem(index-1)->Chamber() << endl; 
-      dataCluster->AddRawCluster(DetElem(index-1)->Chamber(), *clus);
-    }
-  }
-  /*
-  for (Int_t ch = 0; ch < 10; ch++) {
-    TClonesArray *raw = dataCluster->RawClusters(ch);
-    cout << ch << " " << raw->GetEntriesFast() << endl;
-  }
-  */
-  // Reset raw cluster tree
-  /*
-  char branchname[30];
-  TBranch * branch = 0x0;
-  if ( dataCluster->TreeR()) {
-    if ( dataCluster->IsTriggerBranchesInTree() ) {
-      // Branch per branch filling
-      for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
-        sprintf(branchname,"%sRawClusters%d",dataCluster->GetName(),i+1);
-        branch = dataCluster->TreeR()->GetBranch(branchname);
-        //branch->Fill();
-        //branch->Reset();
-        //branch->Clear();
-        branch->Delete();
-      }
-    }
-    //else  TreeR()->Fill();
-    else  dataCluster->TreeR()->Reset();
-  }
-  */
-}
-
-//_________________________________________________________________________
-Int_t AliMUONEventRecoCombi::IZfromHit(AliMUONHitForRec *hit) const
-{
-  /// Get Iz of det. elem. from the hit
-
-  Int_t index = -hit->GetHitNumber() / 100000 - 1, iz0 = -1;
-  for (Int_t iz = 0; iz < fNZ; iz++) {
-    Int_t *pDEatZ = DEatZ(iz);
-    Int_t nDetElem = pDEatZ[-1];
-    for (Int_t j = 0; j < nDetElem; j++) {
-      if (pDEatZ[j] != index) continue;
-      iz0 = iz;
-      break;
-    }
-    if (iz0 >= 0) break;
-  }
-  return iz0;
-}
diff --git a/MUON/AliMUONEventRecoCombi.h b/MUON/AliMUONEventRecoCombi.h
deleted file mode 100644 (file)
index d4625d2..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef ALIMUONEVENTRECOCOMBI_H
-#define ALIMUONEVENTRECOCOMBI_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-/// \ingroup rec
-/// \class AliMUONEventRecoCombi
-/// \brief Combined cluster / track finder in the MUON arm of ALICE
-/// \author Alexander Zinchenko, JINR Dubna
-#include <TObject.h>
-#include <TArrayD.h>
-#include <TClonesArray.h>
-
-class AliMUONRecData;
-class AliMUONDetElement;
-class AliMUONTrackReconstructorK;
-class AliMUONClusterFinderAZ;
-class AliMUONHitForRec;
-class AliMUONSegmentation;
-class AliLoader;
-
-class AliMUONEventRecoCombi : public TObject 
-{
- public:
-    virtual ~AliMUONEventRecoCombi();
-    static AliMUONEventRecoCombi* Instance(AliMUONSegmentation* segmentation = 0);
-    void FillEvent(AliMUONRecData *data, AliMUONClusterFinderAZ *recModel); // fill event info
-    void FillRecP(AliMUONRecData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
-
-    Int_t Nz() const { return fNZ; } ///< number of DE different Z-positions
-    Double_t Z(Int_t iz) const { return (*fZ)[iz]; } ///< Z of DE
-    Int_t *DEatZ(Int_t iz) const { return fDEvsZ[iz]+1; } ///< list of DE's at Z
-    AliMUONDetElement *DetElem(Int_t iPos) const { return (AliMUONDetElement*) fDetElems->UncheckedAt(iPos); } ///< Det element
-    Int_t IZfromHit(AliMUONHitForRec *hit) const; // IZ from Hit
-
- protected:
-    AliMUONEventRecoCombi(AliMUONSegmentation* segmentation = 0);
-
- private:
-    /// Not implemented
-    AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
-    /// Not implemented
-    AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
-
-    static AliMUONEventRecoCombi* fgRecoCombi; //!< singleton instance
-    AliMUONSegmentation*  fSegmentation;  //!< Segmentation
-    TClonesArray *fDetElems; //!< array of Det. Elem. objects
-    TArrayD *fZ; //!< array of det. elem. Z-coordinates
-    Int_t fNZ; //!< number of different Z's
-    Int_t **fDEvsZ; //!< list of DE's vs Z-coordinates
-
-    ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
-      };
-#endif
diff --git a/MUON/AliMUONGeometrySegmentation.cxx b/MUON/AliMUONGeometrySegmentation.cxx
deleted file mode 100644 (file)
index 16a908d..0000000
+++ /dev/null
@@ -1,685 +0,0 @@
-/**************************************************************************
- * 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 AliMUONGeometrySegmentation
-// -------------------------------
-// New class for the module segmentation 
-// composed of the segmentations of detection elements.
-// Applies transformations defined in geometry.
-//
-// Author:Ivana Hrivnacova, IPN Orsay
-
-#include "AliMUONGeometrySegmentation.h"
-#include "AliMUONVGeometryDESegmentation.h"
-#include "AliMUONGeometryModuleTransformer.h"
-#include "AliMUONGeometryDetElement.h"
-
-#include "AliMpExMap.h"
-
-#include "AliLog.h"
-
-#include <Riostream.h>
-#include <TObjString.h>
-#include <TClass.h>
-
-const Float_t  AliMUONGeometrySegmentation::fgkMaxDistance = 1.0e6;
-
-/// \cond CLASSIMP
-ClassImp(AliMUONGeometrySegmentation)
-/// \endcond
-
-//______________________________________________________________________________
-AliMUONGeometrySegmentation::AliMUONGeometrySegmentation(
-                             const AliMUONGeometryModuleTransformer* transformer) 
-: TObject(),
-  fCurrentDetElemId(0),
-  fCurrentDetElement(0),
-  fCurrentSegmentation(0),
-  fkModuleTransformer(transformer),
-  fDESegmentations(0),
-  fDENames(0)
-  
-{
-/// Standard constructor
-
-  fDESegmentations = new AliMpExMap(true);
-  fDESegmentations->SetOwner(false);
-  fDENames = new AliMpExMap(true);
-
-  AliDebug(1, Form("ctor this = %p", this) ); 
-}
-
-//______________________________________________________________________________
-AliMUONGeometrySegmentation::AliMUONGeometrySegmentation() 
-: TObject(),
-  fCurrentDetElemId(0),
-  fCurrentDetElement(0),
-  fCurrentSegmentation(0),
-  fkModuleTransformer(0),
-  fDESegmentations(0),
-  fDENames(0)
-  
-{
-/// Default Constructor
-
-  AliDebug(1, Form("default (empty) ctor this = %p", this));
-}
-
-//______________________________________________________________________________
-AliMUONGeometrySegmentation::~AliMUONGeometrySegmentation() 
-{
-/// Destructor
-
-  AliDebug(1, Form("dtor this = %p", this));
-
-  delete fDESegmentations;
-  delete fDENames;
-} 
-
-//
-// private methods
-//
-
-//______________________________________________________________________________
-Bool_t AliMUONGeometrySegmentation::OwnNotify(Int_t detElemId, Bool_t warn) const
-{
-/// Update current detection element and segmentation,
-/// and checks if they exist.
-/// Return true if success.
-
-  if (detElemId != fCurrentDetElemId) {
-
-    // Find detection element and its segmentation
-    AliMUONGeometryDetElement* detElement
-      = fkModuleTransformer->GetDetElement(detElemId, warn);
-    if (!detElement) {
-      if (warn)
-        AliError(Form("Detection element %d not defined", detElemId));
-      return false;
-    }     
-
-    AliMUONVGeometryDESegmentation* segmentation 
-      = (AliMUONVGeometryDESegmentation*) fDESegmentations->GetValue(detElemId);
-    if (!segmentation) {
-      if (warn)
-        AliError(Form("Segmentation for detection element %d not defined",
-                       detElemId));
-      return false;                 
-    }
-  
-    fCurrentDetElemId = detElemId;
-    fCurrentDetElement = detElement;
-    fCurrentSegmentation = segmentation;
-  }  
-  return true;
-}        
-
-//
-// public methods
-//
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Add(Int_t detElemId, const TString& detElemName,
-                                      AliMUONVGeometryDESegmentation* segmentation)
-{
-/// Add detection element segmentation
-
-  fDESegmentations->Add(detElemId, segmentation); 
-  fDENames->Add(detElemId, new TObjString(detElemName)); 
-}  
-
-
-//______________________________________________________________________________
-const AliMUONVGeometryDESegmentation* 
-AliMUONGeometrySegmentation::GetDESegmentation(Int_t detElemId, Bool_t warn) const
-{
-/// Return the DE segmentation 
-
-  if (!OwnNotify(detElemId, warn)) return 0;
-
-  return fCurrentSegmentation;
-}
-
-//______________________________________________________________________________
-AliMUONGeometryDirection 
-AliMUONGeometrySegmentation::GetDirection(Int_t detElemId) const
-{
-/// Return direction with a constant pad size. 
-/// (Direction or coordinate where the resolution is the best)
-
-  if (!OwnNotify(detElemId)) return kDirUndefined;
-
-  return fCurrentSegmentation->GetDirection();
-}
-
-//______________________________________________________________________________
-TString AliMUONGeometrySegmentation::GetDEName(Int_t detElemId) const
-{
-/// Return name of the given detection element
-
-  TObjString* deName = (TObjString*)fDENames->GetValue(detElemId);
-  
-  if (deName)
-    return deName->GetString();
-  else {  
-    AliWarningStream()
-         << "Detection element " << detElemId  << " not defined. " << endl;
-    return "Undefined";
-  }
-}    
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Print(Option_t* opt) const
-{
-/// Print DE segmentations
-
-  std::cout << "fDESegmentations (class " 
-           << fDESegmentations->Class()->GetName() << ") entries=" 
-           << fDESegmentations->GetSize() 
-           << std::endl;
-  fDESegmentations->Print(opt);        
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::SetPadSize(Float_t p1, Float_t p2)
-{
-/// Set pad size Dx*Dy to all detection element segmentations 
-
-  for (Int_t i=0; i<fDESegmentations->GetSize(); i++) {
-     AliMUONVGeometryDESegmentation* segmentation
-       = (AliMUONVGeometryDESegmentation*)fDESegmentations->GetObject(i);
-     segmentation->SetPadSize(p1, p2);
-  }   
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::SetDAnod(Float_t d)
-{
-/// Set anod pitch to all detection element segmentations
-
-  for (Int_t i=0; i<fDESegmentations->GetSize(); i++) {
-     AliMUONVGeometryDESegmentation* segmentation
-       = (AliMUONVGeometryDESegmentation*)fDESegmentations->GetObject(i);
-     segmentation->SetDAnod(d);
-  }   
-}
-
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::GetAnod(Int_t detElemId, Float_t xhit) const
-{
-/// Anod wire coordinate closest to xhit
-/// Returns for a hit position xhit the position of the nearest anode wire
-/// !!! xhit is understand a a distance, not as a position in the space
-/// CHECK
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  return fCurrentSegmentation->GetAnod(xhit);
-}
-
-//______________________________________________________________________________
-Bool_t  AliMUONGeometrySegmentation::GetPadI(Int_t detElemId,
-                                        Float_t xg, Float_t yg, Float_t zg, 
-                                        Int_t& ix, Int_t& iy)
-{                                      
-/// Return pad coordinates (ix,iy) for given real coordinates (x,y)
-
-  if (!OwnNotify(detElemId)) return false;
-  
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  if (!fCurrentSegmentation->HasPad(xl, yl, zl)) return false;
-
-  fCurrentSegmentation->GetPadI(xl, yl, zl, ix, iy);
-  return true;
-}
-
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometrySegmentation::HasPad(Int_t detElemId, Int_t ix, Int_t iy)
-{
-/// Tell if a given pad exists in a given detector element
-
-  if (!OwnNotify(detElemId)) return false;
-       
-  return fCurrentSegmentation->HasPad(ix,iy);
-}
-                                    
-//______________________________________________________________________________
-Bool_t
-AliMUONGeometrySegmentation::HasPad(Int_t detElemId, 
-                                    Float_t xg, Float_t yg, Float_t zg)
-{
-/// Tell if a given pad exists in a given detector element
-
-  if (!OwnNotify(detElemId)) return false;
-       
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  return fCurrentSegmentation->HasPad(xl, yl, zl);
-}
-                                    
-//______________________________________________________________________________
-Bool_t  
-AliMUONGeometrySegmentation::GetPadC(Int_t detElemId,
-                                     Int_t ix, Int_t iy, 
-                                     Float_t& xg, Float_t& yg, Float_t& zg)
-{                                      
-/// Transform from pad to real coordinates
-
-  if (!OwnNotify(detElemId)) return false;
-  if (!fCurrentSegmentation->HasPad(ix, iy)) {
-    xg = yg = zg = fgkMaxDistance;
-    return false;
-  }
-  
-  Float_t xl, yl, zl;
-  fCurrentSegmentation->GetPadC(ix, iy, xl , yl, zl);
-
-  fkModuleTransformer->Local2Global(detElemId, xl, yl, zl, xg, yg, zg); 
-  return true;
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Init(Int_t chamber)
-{
-/// Initialize segmentation.
-/// Check that all detection elements have segmanetation set
-
-  // Loop over detection elements
-  AliMpExMap* detElements = fkModuleTransformer->GetDetElementStore();
-
-  for (Int_t i=0; i<detElements->GetSize(); i++) {
-
-    // Skip not filled entries
-    if (!detElements->GetObject(i)) continue;
-
-    // Get detction element Id
-    Int_t detElemId = detElements->GetObject(i)->GetUniqueID();
-
-    // Check segmentation
-    if (! fDESegmentations->GetValue(detElemId) ) {
-      AliErrorStream()
-        << "Detection element " << detElemId << " has not a segmentation set." 
-       << endl;
-    }
-    else {             
-      // Initialize DE Segmentation
-      ((AliSegmentation*)fDESegmentations->GetValue(detElemId))->Init(chamber);
-    }                 
-  }               
-}
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::Dpx(Int_t detElemId) const
-{
-/// Get pad size in x
-
-  if (!OwnNotify(detElemId)) return 0.;
-  
-  return fCurrentSegmentation->Dpx();
-}
-
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::Dpy(Int_t detElemId) const
-{
-/// Get pad size in y
-
-  if (!OwnNotify(detElemId)) return 0.;
-
-  return fCurrentSegmentation->Dpy();
-}
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::Dpx(Int_t detElemId, Int_t isector) const
-{
-/// Pad size in x by sector
-
-  if (!OwnNotify(detElemId)) return 0.;
-
-  return fCurrentSegmentation->Dpx(isector);
-} 
-
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::Dpy(Int_t detElemId, Int_t isector) const
-{
-/// Pad size in y by Sector 
-
-  if (!OwnNotify(detElemId)) return 0.;
-
-  return fCurrentSegmentation->Dpy(isector);
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::Npx(Int_t detElemId) const
-{
-/// Maximum number of Pads in x
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  return fCurrentSegmentation->Npx();
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::Npy(Int_t detElemId) const
-{
-/// Maximum number of Pads in y
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  return fCurrentSegmentation->Npy();
-}
-
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::SetPad(Int_t detElemId, Int_t ix, Int_t iy)
-{
-/// Set pad position.
-/// Sets virtual pad coordinates, needed for evaluating pad response 
-/// outside the tracking program.
-/// From AliMUONGeometrySegmentationV01.
-
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->SetPad(ix, iy);
-}
-
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::SetHit(Int_t detElemId, 
-                                        Float_t xghit, Float_t yghit, Float_t zghit)
-{
-/// Set hit position.
-/// Sets virtual hit position, needed for evaluating pad response 
-/// outside the tracking program 
-/// From AliMUONGeometrySegmentationV01.
-
-  if (!OwnNotify(detElemId)) return;
-
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xghit, yghit, zghit, xl, yl, zl); 
-
-  fCurrentSegmentation->SetHit(xl, yl, zl);
-}
-    
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::FirstPad(Int_t detElemId,
-                                        Float_t xghit, Float_t yghit, Float_t zghit, 
-                                        Float_t dx, Float_t dy) 
-{                                       
-/// Iterate over pads - initialiser
-
-  if (!OwnNotify(detElemId)) return;
-
-  AliDebug(1,Form("xghit, yghit, zghit, dx, dy = %e,%e,%e,%e, %e",
-                   xghit, yghit, zghit, dx, dy));
-  
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xghit, yghit, zghit, xl, yl, zl); 
-
-  fCurrentSegmentation->FirstPad(xl, yl, zl, dx, dy);
-}
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::NextPad(Int_t detElemId)
-{
-/// Iterate over pads - stepper
-
-  if (!OwnNotify(detElemId)) return;
-  
-  fCurrentSegmentation->NextPad();
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::MorePads(Int_t detElemId)
-{
-/// Iterate over pads - condition
-
-  if (!OwnNotify(detElemId)) return 0;
-  
-  return fCurrentSegmentation->MorePads();
-}
-
-//______________________________________________________________________________
-Float_t AliMUONGeometrySegmentation::Distance2AndOffset(Int_t detElemId,
-                                           Int_t ix, Int_t iy, 
-                                          Float_t xg, Float_t yg,  Float_t zg,
-                                          Int_t* dummy)
-{                                         
-/// Return the square of the distance between 1 pad
-/// labelled by its channel numbers and a coordinate
-
-  if (!OwnNotify(detElemId)) return 0.;
-
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  return fCurrentSegmentation->Distance2AndOffset(ix, iy, xl, yl, dummy);
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::GetNParallelAndOffset(Int_t detElemId,
-                                            Int_t ix, Int_t iy,
-                                           Int_t* nparallel, Int_t* offset)
-{                                         
-/// Number of pads read in parallel and offset to add to x 
-/// (specific to LYON, but mandatory for display)
-/// CHECK
-
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->GetNParallelAndOffset(ix, iy, nparallel, offset);  
-}
-
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Neighbours(Int_t detElemId,
-                                           Int_t ix, Int_t iy, 
-                                           Int_t* nlist, 
-                                          Int_t xlist[10], Int_t ylist[10])
-{                                        
-/// Get next neighbours 
-
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->Neighbours(ix, iy, nlist, xlist, ylist);
-}
-
-//______________________________________________________________________________
-Int_t  AliMUONGeometrySegmentation::Ix()
-{
-/// Current pad cursor during disintegration
-/// x, y-coordinate
-
-  return fCurrentSegmentation->Ix();
-}
-
-//______________________________________________________________________________
-Int_t  AliMUONGeometrySegmentation::Iy()
-{
-/// Current pad cursor during disintegration
-/// x, y-coordinate
-
-  return fCurrentSegmentation->Iy();
-}
-
-//______________________________________________________________________________
-Int_t  AliMUONGeometrySegmentation::DetElemId()
-{
-/// Current pad cursor during disintegration
-/// x, y-coordinate
-
-  return fCurrentDetElemId;
-}
-
-//______________________________________________________________________________
-Int_t  AliMUONGeometrySegmentation::ISector()
-{
-/// Current sector
-
-  return fCurrentSegmentation->ISector();
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::Sector(Int_t detElemId, Int_t ix, Int_t iy)
-{
-/// Calculate sector from pad indices
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  return fCurrentSegmentation->Sector(ix, iy);
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::Sector(Int_t detElemId,
-                                        Float_t xg, Float_t yg, Float_t zg)
-{
-/// Calculate sector from pad coordinates
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  return fCurrentSegmentation->Sector(xl, yl);
-}
-
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::IntegrationLimits(Int_t detElemId,
-                                        Float_t& x1, Float_t& x2,
-                                        Float_t& y1, Float_t& y2)
-{                                                
-/// Current integration limits 
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->IntegrationLimits(x1, x2, y1, y2);
-}
-
-//______________________________________________________________________________
-Int_t AliMUONGeometrySegmentation::SigGenCond(Int_t detElemId,
-                                        Float_t xg, Float_t yg, Float_t zg)
-{
-/// Signal Generation Condition during Stepping
-///  0: don't generate signal                                                 \n
-///  1: generate signal                                                       \n
-///  Comments:                                                                \n
-///                                                                           \n
-///  Crossing of pad boundary and mid plane between neighbouring wires is checked.
-///  To correctly simulate the dependence of the spatial resolution on the angle 
-///  of incidence signal must be generated for constant steps on 
-///  the projection of the trajectory along the anode wire.
-///                                                                           \n
-///  Signal will be generated if particle crosses pad boundary or
-///  boundary between two wires. 
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  return fCurrentSegmentation->SigGenCond(xl, yl, zl);
- }
-
-//______________________________________________________________________________
-void  AliMUONGeometrySegmentation::SigGenInit(Int_t detElemId,
-                                       Float_t xg, Float_t yg, Float_t zg)
-{
-/// Initialise signal generation at coord (x,y,z)
-/// Initialise pad and wire position during stepping.
-/// From AliMUONGeometrySegmentationV01
-
-  if (!OwnNotify(detElemId)) return;
-
-  Float_t xl, yl, zl;
-  fCurrentDetElement->Global2Local(xg, yg, zg, xl, yl, zl); 
-
-  if (!fCurrentSegmentation->HasPad(xl, yl, zl)) {
-    AliWarningStream()
-         << "No pad at " << detElemId 
-         << " global position: " << xg << "  " << yg << "  " << zg
-         << " local position: " << xl << "  " << yl << "  " << zl << endl;
-    return ;
-  }  
-
-  fCurrentSegmentation->SigGenInit(xl, yl, zl);
-}                  
-    
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::GiveTestPoints(Int_t /*detElemId*/,
-                                       Int_t& /*n*/, 
-                                      Float_t* /*xg*/, Float_t* /*yg*/) const
-{                                            
-/// Test points for auto calibration
-/// Return test point on the pad plane.
-/// Used during determination of the segmoid correction of the COG-method
-/// From AliMUONGeometrySegmentationV01
-
-  // Requires change of interface
-  // to convert points from local to global we need z coordinate
-  AliError("Not implemented.");
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Draw(const char* opt)
-{
-/// Draw the segmentation zones for all detElemId 
-
-  for (Int_t i=0; i<fDESegmentations->GetSize(); i++) {
-     AliMUONVGeometryDESegmentation* segmentation
-       = (AliMUONVGeometryDESegmentation*)fDESegmentations->GetObject(i);
-     segmentation->Draw(opt);
-  }   
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::Draw(Int_t detElemId, const char* opt)
-{
-/// Draw the segmentation zones for a given detElemId.
-
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->Draw(opt);
-}
-
-//______________________________________________________________________________
-void AliMUONGeometrySegmentation::SetCorrFunc(Int_t detElemId, 
-                                              Int_t isec, TF1* func)
-{
-/// Set the correction function.
-/// From AliMUONGeometrySegmentationV01
-
-  if (!OwnNotify(detElemId)) return;
-
-  fCurrentSegmentation->SetCorrFunc(isec, func);
-}
-
-//______________________________________________________________________________
-TF1* AliMUONGeometrySegmentation::CorrFunc(Int_t detElemId, Int_t isec) const
-{
-/// Get the correction Function.
-/// From AliMUONGeometrySegmentationV01
-
-  if (!OwnNotify(detElemId)) return 0;
-
-  return  fCurrentSegmentation->CorrFunc(isec);
-} 
-
diff --git a/MUON/AliMUONGeometrySegmentation.h b/MUON/AliMUONGeometrySegmentation.h
deleted file mode 100644 (file)
index 91d1bef..0000000
+++ /dev/null
@@ -1,228 +0,0 @@
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-/// \ingroup geometry
-/// \class AliMUONGeometrySegmentation
-/// \brief Segmentation for a geometry module 
-/// 
-/// New class for the geometry segmentation 
-/// composed of the segmentations of detection elements.
-/// Applies transformations defined in geometry.
-///
-/// \author Ivana Hrivnacova, IPN Orsay
-
-#ifndef ALI_MUON_GEOMETRY_SEGMENTATION_H
-#define ALI_MUON_GEOMETRY_SEGMENTATION_H
-
-#include "AliMUONGeometryDirection.h"
-
-#include <TObject.h>
-#include <TString.h>
-
-class TObjArray;
-class TF1;
-
-class AliMUONGeometryModuleTransformer;
-class AliMUONGeometryDetElement;
-class AliMUONVGeometryDESegmentation;
-class AliMUONSegmentManuIndex;
-
-class AliMpExMap;
-
-class AliMUONGeometrySegmentation : public TObject
-{
-  public:
-    AliMUONGeometrySegmentation(
-           const AliMUONGeometryModuleTransformer* geometry);
-    AliMUONGeometrySegmentation();
-    virtual ~AliMUONGeometrySegmentation();
-
-    // Methods
-    //
-    void Add(Int_t detElemId, const TString& detElemName,
-             AliMUONVGeometryDESegmentation* segmentation); 
-    // Get methods
-    //
-    const AliMUONGeometryModuleTransformer* GetTransformer() const;
-                       // Geometry transformer       
-    const AliMUONVGeometryDESegmentation* GetDESegmentation(
-                        Int_t detElemId, Bool_t warn = true) const;
-                       // DE segmentation
-    
-    AliMUONGeometryDirection GetDirection(Int_t detElemId) const;
-                       // Direction with a constant pad size  
-                      // (Direction or coordinate where the resolution 
-                      // is the best)
-    
-    TString GetDEName(Int_t detElemId) const;                 
-                       // DE name
-
-    // Redefined methods from AliSegmentation interface
-    // 
-
-    // Set Chamber Segmentation Parameters
-    //
-    virtual void SetPadSize(Float_t p1, Float_t p2);
-                       // Pad size Dx*Dy 
-    virtual void SetDAnod(Float_t D);
-                       // Anode Pitch
-
-    // Transform from pad (wire) to real coordinates and vice versa
-    //
-    virtual Float_t GetAnod(Int_t detElemId, Float_t xlhit) const;
-                       // Anode wire coordinate closest to xhit
-    virtual Bool_t  GetPadI(Int_t detElemId,
-                          Float_t xg, Float_t yg, Float_t  zg, 
-                          Int_t& ix, Int_t& iy);
-                       // Transform from pad to real coordinates
-    virtual Bool_t  GetPadC(Int_t detElemId,
-                          Int_t ix, Int_t iy,
-                          Float_t& x, Float_t& y, Float_t& z);
-                       // Transform from real to pad coordinates
-
-    virtual Bool_t HasPad(Int_t detElemId, 
-                          Int_t ix, Int_t iy);
-    virtual Bool_t HasPad(Int_t detElemId, 
-                          Float_t x, Float_t y, Float_t z);
-  
-    // Initialisation
-    //
-    virtual void Init(Int_t chamber);
-    // Get member data
-    //
-    virtual Float_t Dpx(Int_t detElemId) const;
-    virtual Float_t Dpy(Int_t detElemId) const ;
-                      // Pad size in x, y 
-    virtual Float_t Dpx(Int_t detElemId, Int_t isector) const;
-    virtual Float_t Dpy(Int_t detElemId, Int_t isector) const;
-                      // Pad size in x, y by Sector 
-    virtual Int_t   Npx(Int_t detElemId) const;
-    virtual Int_t   Npy(Int_t detElemId) const;
-                      // Maximum number of Pads in y
-
-    virtual void  SetPad(Int_t detElemId, Int_t ix, Int_t iy);
-                      // Set pad position
-    virtual void  SetHit(Int_t detElemId, Float_t xghit, Float_t yghit, Float_t zghit);
-                      // Set hit position
-    
-    // Iterate over pads
-    //    
-    virtual void  FirstPad(Int_t detElemId, 
-                           Float_t xghit, Float_t yghit, Float_t zghit, 
-                           Float_t dx, Float_t dy);
-    virtual void  NextPad(Int_t detElemId);
-    virtual Int_t MorePads(Int_t detElemId);
-
-    virtual Float_t Distance2AndOffset(Int_t detElemId,
-                           Int_t ix, Int_t iy, 
-                           Float_t xg, Float_t yg, Float_t zg, 
-                          Int_t* dummy);
-                      // Distance between 1 pad and a position
-    virtual void GetNParallelAndOffset(Int_t detElemId,
-                           Int_t ix, Int_t iy,
-                          Int_t* nparallel, Int_t* offset);
-                      // Number of pads read in parallel and offset to add to x 
-                      // (specific to LYON, but mandatory for display)
-    virtual void Neighbours(Int_t detElemId,
-                            Int_t ix, Int_t iy,
-                            Int_t* nlist, Int_t xlist[10], Int_t ylist[10]);
-                      // Get next neighbours 
-
-    // Current values
-    //
-    virtual Int_t  Ix();
-    virtual Int_t  Iy();
-    virtual Int_t  DetElemId();
-                     // Current pad cursor during disintegration
-                     // x, y-coordinate
-    virtual Int_t  ISector();
-                    // current sector
-
-    virtual Int_t  Sector(Int_t detElemId,
-                          Int_t ix, Int_t iy);
-    virtual Int_t  Sector(Int_t detElemId,
-                          Float_t xg, Float_t yg, Float_t zg);
-                    // calculate sector from pad coordinates
-
-    virtual void  IntegrationLimits(Int_t detElemId,
-                          Float_t& x1, Float_t& x2,
-                          Float_t& y1, Float_t& y2);
-                   // Current integration limits 
-
-    // Signal Generation
-    //
-    virtual Int_t SigGenCond(Int_t detElemId,
-                          Float_t xg, Float_t yg, Float_t zg);
-                    // Signal Generation Condition during Stepping
-    virtual void  SigGenInit(Int_t detElemId,
-                          Float_t xg, Float_t yg, Float_t zg);
-                    // Initialise signal generation at coord (x,y,z)
-                   
-    
-    virtual void GiveTestPoints(Int_t detElemId,
-                          Int_t& n, Float_t* xg, Float_t* yg) const;
-                   // Test points for auto calibration
-    virtual void Draw(const char *opt = "");
-    virtual void Draw(Int_t detElemId, const char *opt = "");
-                   // Draw the segmentation zones
-
-    // Function for systematic corrections
-    //
-    virtual void SetCorrFunc(Int_t detElemId,
-                          Int_t isec,  TF1* func);
-                   // Set the correction function
-    virtual TF1* CorrFunc(Int_t detElemId, Int_t isec) const;
-                   // Get the correction Function
-    // Printing
-    //
-    virtual void Print(Option_t* opt = "") const;
-       
-  protected:
-    /// Not implemented
-    AliMUONGeometrySegmentation(const AliMUONGeometrySegmentation& rhs);
-    /// Not implemented
-    AliMUONGeometrySegmentation& operator=(const AliMUONGeometrySegmentation & rhs);
-
-  private:
-    // methods
-    Bool_t OwnNotify(Int_t detElemId, Bool_t warn = true) const;
-
-    // static data members
-    static  const Float_t  fgkMaxDistance; ///< \brief the big value passed to pad coordinates
-                                           /// if pad does not exist
-  
-    // data members
-    mutable  Int_t                           fCurrentDetElemId;   ///< current DE ID 
-    mutable  AliMUONGeometryDetElement*      fCurrentDetElement;  ///< current detection element 
-    mutable  AliMUONVGeometryDESegmentation* fCurrentSegmentation;///< current DE segmentation
-   
-    const AliMUONGeometryModuleTransformer*  fkModuleTransformer; ///< associated geometry transformer
-    AliMpExMap*  fDESegmentations; ///< DE segmentations
-    AliMpExMap*  fDENames;         ///< DE names
-    
-   ClassDef(AliMUONGeometrySegmentation,3) // Geometry segmentation
-};
-
-// inline functions
-
-/// Return associated geometry transformer
-inline 
-const AliMUONGeometryModuleTransformer* 
-AliMUONGeometrySegmentation::GetTransformer() const
-{ return fkModuleTransformer; }              
-
-#endif //ALI_MUON_GEOMETRY_SEGMENTATION_H
-
-
-
-
-
-
-
-
diff --git a/MUON/AliMUONHitMapA1.cxx b/MUON/AliMUONHitMapA1.cxx
deleted file mode 100644 (file)
index a202a71..0000000
+++ /dev/null
@@ -1,158 +0,0 @@
-/**************************************************************************
- * 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 AliMUONHitMapA1
-// -----------------------
-// Implements AliHitMap as a 1-dim array
-// ...
-
-#include "AliMUONHitMapA1.h"
-#include "AliMUONDigit.h"
-
-#include "AliLog.h"
-
-#include <TObjArray.h>
-#include <TMath.h>
-
-ClassImp(AliMUONHitMapA1)
-
-AliMUONHitMapA1::AliMUONHitMapA1()
-  : AliHitMap(),
-    fNpx(0),
-    fNpy(0),
-    fDigits(0),
-    fMaxIndex(0),
-    fHitMap(0)
-{
-/// Default constructor
-}
-
-//________________________________________________________________________________
-AliMUONHitMapA1::AliMUONHitMapA1(Int_t npx, Int_t npy, TObjArray* dig)
-  : AliHitMap(),
-    fNpx(npx),
-    fNpy(npy),
-    fDigits(dig),
-    fMaxIndex(2*(fNpx+1)*2*(fNpy+1)+2*fNpy),
-    fHitMap(new Int_t[fMaxIndex])
-{
-/// Standard constructor
-    Clear();
-}
-//_________________________________
-AliMUONHitMapA1::~AliMUONHitMapA1()
-{
-/// Destructor
-    if (fHitMap) delete[] fHitMap;
-}
-//______________________________________
-void AliMUONHitMapA1::Clear(const char *)
-{
-/// Clear hitmap
-    memset(fHitMap,0,sizeof(int)*fMaxIndex);
-}
-//___________________________________________________
-Bool_t AliMUONHitMapA1::ValidateHit(Int_t ix, Int_t iy)
-{
-/// Check if pad coordinates are within boundaries
-
-//    printf("\n Validate %d %d %d %d", ix, iy, fNpx, fNpy);
-    
-    return (TMath::Abs(ix) <= fNpx && TMath::Abs(iy) <= fNpy); 
-}
-//_________________________________________________________
-Int_t AliMUONHitMapA1::CheckedIndex(Int_t ix, Int_t iy) const
-{
-/// Return checked indices ix, iy
-    Int_t index=2*fNpy*(ix+fNpx)+(iy+fNpy);
-    if ( index < 0 || index >= fMaxIndex ) {
-        AliWarning(Form("index outside array ix %d iy %d MaxIndex %d index %d Npx %d Npy %d",
-                     ix, iy, fMaxIndex, index, fNpx, fNpy));
-       return  fMaxIndex-1;
-    } else {
-       return index;
-    }
-}
-//_____________________________
-void  AliMUONHitMapA1::FillHits()
-{
-/// Fill hits from digits list  
-    Int_t ndigits = fDigits->GetEntriesFast();
-    //printf("\n Filling hits into HitMap\n");
-    //printf("FindRawClusters -- ndigits %d \n",ndigits);
-    if (!ndigits) return;
-    AliMUONDigit *dig;
-    for (Int_t ndig=0; ndig<ndigits; ndig++) {
-       dig = (AliMUONDigit*)fDigits->UncheckedAt(ndig);
-       SetHit(dig->PadX(),dig->PadY(),ndig);
-    }
-}
-//___________________________________________________________
-void  AliMUONHitMapA1::SetHit(Int_t ix, Int_t iy, Int_t idigit)
-{
-/// Assign digit to hit cell ix,iy
-
-//    fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=idigit+1;
-    fHitMap[CheckedIndex(ix, iy)]=idigit+1;
-}
-//_______________________________________________
-void AliMUONHitMapA1::DeleteHit(Int_t ix, Int_t iy)
-{
-/// Delete hit at cell ix,iy
-
-//    fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=0;
-    fHitMap[CheckedIndex(ix, iy)]=0;
-}
-//_____________________________________________
-void AliMUONHitMapA1::FlagHit(Int_t ix, Int_t iy)
-{
-/// Flag hit as used
-    fHitMap[CheckedIndex(ix, iy)]=
-       -TMath::Abs(fHitMap[CheckedIndex(ix, iy)]);
-}
-//________________________________________________________
-Int_t AliMUONHitMapA1::GetHitIndex(Int_t ix, Int_t iy) const
-{
-/// Get absolute value of contents of hit cell ix,iy
-    return TMath::Abs(fHitMap[CheckedIndex(ix, iy)])-1;
-}
-//_______________________________________________________
-TObject* AliMUONHitMapA1::GetHit(Int_t ix, Int_t iy) const
-{
-/// Get pointer to object at hit cell ix, iy
-/// Force crash if index does not exist ! (Manu)
-    Int_t index=GetHitIndex(ix,iy);
-    return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
-}
-//_________________________________________________
-FlagType AliMUONHitMapA1::TestHit(Int_t ix, Int_t iy)
-{
-/// Check if hit cell is empty, used or unused
-
-    Int_t index = CheckedIndex(ix, iy);
-    if (index<0 || index >= fMaxIndex) return kEmpty;
-
-    Int_t inf=fHitMap[index];
-    if (inf < 0) {
-       return kUsed;
-    } else if (inf == 0) {
-       return kEmpty;
-    } else {
-       return kUnused;
-    }
-}
diff --git a/MUON/AliMUONHitMapA1.h b/MUON/AliMUONHitMapA1.h
deleted file mode 100644 (file)
index b1da3d9..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef ALIMUONHITMAPA1_H
-#define ALIMUONHITMAPA1_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
-
-/// \ingroup base
-/// \class AliMUONHitMapA1
-/// \brief Implements AliHitMap as a 1-dim array
-
-#include "AliHitMap.h"
-
-class TObjArray;
-
-class AliMUONHitMapA1 : public AliHitMap 
-{
- public:
-    AliMUONHitMapA1();
-    //AliMUONHitMapA1(Int_t idDE, AliMUONGeometrySegmentation* seg, TObjArray* dig);
-    AliMUONHitMapA1(Int_t npx, Int_t npy, TObjArray* dig);
-    virtual ~AliMUONHitMapA1();
-
-    // Fill hits from list of digits into hit map
-    virtual  void  FillHits();
-    // Clear the hit map
-    virtual  void  Clear(const char *opt = "");
-    // Set a single hit
-    virtual  void  SetHit(Int_t ix, Int_t iy, Int_t idigit);
-    // Delete a single hit
-    virtual  void  DeleteHit(Int_t ix, Int_t iy);
-    // Get index of hit in the list of digits
-    virtual Int_t  GetHitIndex(Int_t ix, Int_t iy) const;
-    // Get pointer to digit
-    virtual TObject*  GetHit(Int_t ix, Int_t iy) const;
-    // Flag a hit as used
-    virtual  void  FlagHit(Int_t ix, Int_t iy);
-    // Validate
-    virtual  Bool_t ValidateHit(Int_t ix, Int_t iy);
-    // Test hit status
-    virtual FlagType TestHit(Int_t ix, Int_t iy);
-
- private:
-    /// Not implemented
-    AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap);
-    /// Not implemented
-    AliMUONHitMapA1& operator = (const AliMUONHitMapA1& rhs);
-
-    // Check index
-    Int_t CheckedIndex(Int_t ix, Int_t iy) const;
- private:
-    Int_t fNpx;                           ///< Maximum number of pads in x
-    Int_t fNpy;                           ///< Maximum number of pads in y
-    TObjArray *fDigits;                   ///< Pointer to digits
-    Int_t fMaxIndex;                      ///< maximum index in hit map
-
-    /// The array of digits
-    Int_t *fHitMap;                       // ! [fMaxIndex]         
-
-    ClassDef(AliMUONHitMapA1,0) // Implements HitMap as a 1-dim array
-};
-#endif 
diff --git a/MUON/AliMUONPoints.cxx b/MUON/AliMUONPoints.cxx
deleted file mode 100644 (file)
index 089fc6a..0000000
+++ /dev/null
@@ -1,221 +0,0 @@
-/**************************************************************************
- * 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$ */
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  This class contains the points for the ALICE event display               //
-//                                                                           //
-//Begin_Html
-/*
-<img src="gif/AliMUONPointsClass.gif">
-*/
-//End_Html
-//                                                                           //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-#include <TClonesArray.h>
-#include <TROOT.h>
-#include <TPolyMarker3D.h>
-#include <TVirtualPad.h>
-#include <TPaveText.h>
-#include <TMarker3DBox.h>
-#include "AliMUONPoints.h"
-#include "AliMUONDisplay.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include "AliMUONHit.h"
-#include "AliMUONDigit.h"
-#include "AliLog.h"
-
-/// \cond CLASSIMP
-ClassImp(AliMUONPoints)
-/// \endcond
-
-//_____________________________________________________________________________
-AliMUONPoints::AliMUONPoints()
-  : AliPoints(),
-    fHitIndex(0),
-    fTrackIndex(0),
-    fDigitIndex(0),
-    fMatrix(0)
-
-{
-  /// Default constructor
-
-  fMarker[0] = fMarker[1] = fMarker[2]=0;
-}
-
-//_____________________________________________________________________________
-AliMUONPoints::AliMUONPoints(Int_t npoints)
-  : AliPoints(npoints),
-    fHitIndex(0),
-    fTrackIndex(0),
-    fDigitIndex(0),
-    fMatrix(0)
-{
-  /// Standard constructor
-
-  fMarker[0] = fMarker[1] = fMarker[2]=0;
-}
-
-//_____________________________________________________________________________
-AliMUONPoints::~AliMUONPoints()
-{
-  /// Destructor
-
-  fHitIndex = 0;
-  fTrackIndex = 0;
-  fDigitIndex = 0;
-  for (Int_t i=0;i<3;i++){
-      if (fMarker[i]) delete fMarker[i];
-  }
-  fMatrix = 0;
-}
-
-//_____________________________________________________________________________
-void AliMUONPoints::DumpHit() const
-{
-  /// Dump hit corresponding to this point
-  AliMUONHit *hit = GetHit();
-  if (hit) hit->Dump();
-}
-
-//_____________________________________________________________________________
-void AliMUONPoints::DumpDigit() const
-{
-  /// Dump digit corresponding to this point
-
-  AliMUONDigit *digit = GetDigit();
-  if (digit) digit->Dump();
-}
-
-//_____________________________________________________________________________
-void AliMUONPoints::InspectHit()
-{
-  /// Inspect hit corresponding to this point
-
-  if (fHitIndex < 0 ) return;
-  TVirtualPad *padsav = gPad;
-  AliMUONHit *hit = GetHit();
-  if (hit) hit->Inspect();
-  TVirtualPad *padinspect = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("inspect");
-   padinspect->cd();
-   Float_t xmin = gPad->GetX1();
-   Float_t xmax = gPad->GetX2();
-   Float_t ymin = gPad->GetY1();
-   Float_t ymax = gPad->GetY2();
-   Float_t dy   = ymax-ymin;
-
-      TPaveText *pad = new TPaveText(xmin, ymin+0.1*dy, xmax, ymin+0.15*dy);
-      pad->SetBit(kCanDelete);
-      pad->SetFillColor(42);
-      pad->Draw();
-      char ptitle[100];
-      sprintf(ptitle," %s , fTrack: %d  fTrackIndex: %d ",GetName(),fIndex,fTrackIndex);
-      pad->AddText(ptitle);
-      padinspect->cd();
-      padinspect->Update();
-  if (padsav) padsav->cd();
-
-}
-
-//_____________________________________________________________________________
-void AliMUONPoints::InspectDigit()
-{
-  /// Inspect digit corresponding to this point
-
-  if (fDigitIndex < 0) return;
-  TVirtualPad *padsav = gPad;
-  AliMUONDigit *digit = GetDigit();
-  if (digit) digit->Inspect();
-  TVirtualPad *padinspect = (TVirtualPad*)(gROOT->GetListOfCanvases())->FindObject("inspect");
-   padinspect->cd();
-   Float_t xmin = gPad->GetX1();
-   Float_t xmax = gPad->GetX2();
-   Float_t ymin = gPad->GetY1();
-   Float_t ymax = gPad->GetY2();
-   Float_t dy   = ymax-ymin;
-
-      TPaveText *pad = new TPaveText(xmin, ymin+0.1*dy, xmax, ymin+0.25*dy);
-      pad->SetBit(kCanDelete);
-      pad->SetFillColor(42);
-      pad->Draw();
-      char ptitle[11][100];
-      //      sprintf(ptitle[11],"Tracks making this digit");
-      //      pad->AddText(ptitle[11]);
-  for (int i=0;i<digit->Ntracks();i++) {
-      if (digit->Track(i) == 0) continue;  
-      sprintf(ptitle[i],"fTrackIndex: %d  Charge: %e",
-             digit->Track(i), digit->TrackCharge(i));
-      pad->AddText(ptitle[i]);
-  }
-      padinspect->cd();
-      padinspect->Update();
-  if (padsav) padsav->cd();
-      
-}
-
-//_____________________________________________________________________________
-Int_t AliMUONPoints::GetTrackIndex() const
-{
-  /// Dump digit corresponding to this point
-
-  Inspect();
-  /*
-  if (fDigitIndex != 0) {
-    Int_t ncol=this->fMatrix->GetNcols();
-    for (int i=0;i<ncol;i++) {
-        printf(" track charge %f %f \n",(*(this->fMatrix))(0,i),(*(this->fMatrix))(1,i));
-    }
-  }
-  */
-  return fTrackIndex;
-}
-
-//_____________________________________________________________________________
-AliMUONHit *AliMUONPoints::GetHit() const
-{
-  /// Returns pointer to hit index in AliRun::fParticles
-
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-  
-  pMUON->TreeH()->GetEvent(fTrackIndex);
-  TClonesArray *muonHits  = pMUON->Hits();
-  Int_t nhits = muonHits->GetEntriesFast();
-  if (fHitIndex < 0 || fHitIndex >= nhits) return 0;
-  return (AliMUONHit*)muonHits->UncheckedAt(fHitIndex);
-}
-
-//_____________________________________________________________________________
-AliMUONDigit *AliMUONPoints::GetDigit() const
-{
-  /// Returns pointer to digit index in AliRun::fParticles
-
-  AliMUONDisplay *display=(AliMUONDisplay*)gAlice->Display();
-  Int_t chamber=display->GetChamber();
-   
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-  TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1);
-  pMUON->GetMUONData()->GetDigits();
-  //gAlice->TreeD()->GetEvent(cathode);
-  Int_t ndigits = muonDigits->GetEntriesFast();
-  if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
-  return (AliMUONDigit*)muonDigits->UncheckedAt(fDigitIndex);
-}
diff --git a/MUON/AliMUONPoints.h b/MUON/AliMUONPoints.h
deleted file mode 100644 (file)
index a037d9b..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef ALIMUONPOINTS_H
-#define ALIMUONPOINTS_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
-//
-/// \ingroup evaluation
-/// \class AliMUONPoints
-/// \brief Class to draw detector clusters (is PolyMarker3D)
-
-class TMarker3DBox;
-#include <TMatrixFfwd.h>
-
-class AliMUONDigit;
-class AliMUONHit;
-#include "AliPoints.h"
-
-class AliMUONPoints : public AliPoints 
-{
-public:
-  AliMUONPoints();
-  AliMUONPoints(Int_t npoints);
-  virtual ~AliMUONPoints();
-                        
-                       /// Return hit index
-  Int_t                 GetHitIndex() const {return fHitIndex;}
-  Int_t                 GetTrackIndex() const; // *MENU*
-                       /// Return digit index
-  Int_t                 GetDigitIndex() const {return fDigitIndex;}
-                       /// Return associated 3D-marker
-  TMarker3DBox         *GetMarker(Int_t i) const {return fMarker[i];}
-  AliMUONHit           *GetHit() const;
-  AliMUONDigit         *GetDigit() const;
-  virtual void          InspectHit(); // *MENU*
-  virtual void          DumpHit() const; // *MENU*
-  virtual void          InspectDigit(); // *MENU*
-  virtual void          DumpDigit() const; // *MENU*
-                        /// Set hit index
-  virtual void          SetHitIndex(Int_t hitindex) {fHitIndex = hitindex;}
-                        /// Set track index
-  virtual void          SetTrackIndex(Int_t trackindex) {fTrackIndex = trackindex;}
-                        /// Set digit index
-  virtual void          SetDigitIndex(Int_t digitindex) {fDigitIndex = digitindex;}
-                        /// Set associated 3D-marker
-  virtual void          Set3DMarker(Int_t i,TMarker3DBox *marker) {fMarker[i] = marker;}
-                        /// Set matrix
-  virtual void          SetMatrix(TMatrixF *matrix) {fMatrix = matrix;}
-  
-protected:
-  /// Not implemented
-  AliMUONPoints(const AliMUONPoints& points);  
-  /// Not implemented
-  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 
-   TMarker3DBox    *fMarker[3];        ///< pointer to  associated 3D-marker
-   TMatrixF        *fMatrix;           ///< test
-   
-  ClassDef(AliMUONPoints,1) //Class to draw detector clusters (is PolyMarker3D) for MUON
-};
-#endif
-
-
diff --git a/MUON/AliMUONRecData.cxx b/MUON/AliMUONRecData.cxx
deleted file mode 100644 (file)
index 6a9667c..0000000
+++ /dev/null
@@ -1,838 +0,0 @@
-/**************************************************************************
- * 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 AliMUONRecData
-///
-/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
-/// The classe makes the lik between the MUON data lists and the event trees from loaders
-///
-/// \author Gines Martinez, Subatech,  September 2003
-///
-
-#include "AliMUONRecData.h"
-#include "AliMUONDataIterator.h"
-#include "AliMUONConstants.h"
-#include "AliMUONDigit.h"
-#include "AliMUONGlobalTrigger.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONRegionalTrigger.h"
-#include "AliMUONTriggerCrateStore.h"
-#include "AliMUONTriggerCircuit.h"
-#include "AliMUONGeometryTransformer.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTriggerTrack.h"
-
-#include "AliRunLoader.h"
-#include "AliStack.h"
-#include "AliLog.h"
-
-#include <TString.h>
-#include <TParticle.h>
-#include <TNtuple.h>
-#include <Riostream.h>
-#include <TFile.h>
-
-/// \cond CLASSIMP
-ClassImp(AliMUONRecData)
-/// \endcond
-//_____________________________________________________________________________
-AliMUONRecData::AliMUONRecData()
-  : AliMUONData(),
-    fRawClusters(0x0),
-    fRecTracks(0x0),
-    fRecTriggerTracks(0x0),
-    fNrawclusters(0x0),
-    fNrectracks(0),
-    fNrectriggertracks(0)
-{
-/// Default constructor
-}
-//_____________________________________________________________________________
-AliMUONRecData::AliMUONRecData(AliLoader * loader, const char* name, const char* title)
-  : AliMUONData(loader, name, title),
-    fRawClusters(0x0),
-    fRecTracks(0x0),
-    fRecTriggerTracks(0x0),
-    fNrawclusters(0x0),
-    fNrectracks(0),
-    fNrectriggertracks(0)
-{
-/// Standard constructor
-}
-
-//_____________________________________________________________________________
-AliMUONRecData::AliMUONRecData(const char* galiceFile)
-  : AliMUONData(galiceFile, "MUONFolder"),
-    fRawClusters(0x0),
-    fRecTracks(0x0),
-    fRecTriggerTracks(0x0),
-    fNrawclusters(0x0),
-    fNrectracks(0),
-    fNrectriggertracks(0)
-{
-/// Constructor for loading data from gAlice file
-}
-
-//_____________________________________________________________________________
-AliMUONRecData::~AliMUONRecData()
-{
-/// Destructor for AliMUONRecData
-
-  if (fRawClusters) {
-    fRawClusters->Delete();
-    delete fRawClusters;
-  }
-  if (fRecTracks){
-    fRecTracks->Delete();
-    delete fRecTracks;
-  }
-  if (fRecTriggerTracks){
-    fRecTriggerTracks->Delete();
-    delete fRecTriggerTracks;
-  }
-}
-//_____________________________________________________________________________
-void AliMUONRecData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
-{
-/// Add a MUON rawcluster to the list in the detection plane id
-
-  TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
-  new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
-}
-//_____________________________________________________________________________
-void AliMUONRecData::AddRecTrack(const AliMUONTrack& track)
-{
-/// Add a MUON rectrack
-
-  TClonesArray &lrectracks = *fRecTracks;
-  new(lrectracks[fNrectracks++]) AliMUONTrack(track);
-}
-//_____________________________________________________________________________
-void AliMUONRecData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
-{
-/// Add a MUON triggerrectrack
-
-  TClonesArray &lrectriggertracks = *fRecTriggerTracks;  
-  new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
-}
-//____________________________________________________________________________
-Bool_t   AliMUONRecData::IsRawClusterBranchesInTree()
-{
-/// Checking if there are RawCluster Branches In TreeR
-
-  if (TreeR()==0x0) {
-    AliError("No treeR in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sRawClusters1",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeR()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-//____________________________________________________________________________
-Bool_t   AliMUONRecData::IsTrackBranchesInTree()
-{
-/// Checking if there are Track Branches In TreeT
-  if (TreeT()==0x0) {
-    AliError("No treeT in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sTrack",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeT()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-//____________________________________________________________________________
-Bool_t   AliMUONRecData::IsTriggerBranchesInTree()
-{
-/// Checking if there are Trigger Branches In TreeR
- if (TreeR()==0x0) {
-    AliError("No treeR in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sLocalTrigger",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeR()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-//____________________________________________________________________________
-Bool_t   AliMUONRecData::IsTriggerTrackBranchesInTree()
-{
-/// Checking if there are TriggerTrack Branches In TreeT
-  if (TreeT()==0x0) {
-    AliError("No treeT in memory");
-    return kFALSE;
-  }
-  else {
-     char branchname[30];
-     sprintf(branchname,"%sTriggerTrack",GetName());
-     TBranch * branch = 0x0;
-     branch = TreeT()->GetBranch(branchname);
-     if (branch)  return kTRUE;
-     else return kFALSE;    
-  }
-}
-//____________________________________________________________________________
-void AliMUONRecData::FillOwn(Option_t* option)
-{
-/// Method to fill the trees
-
-  const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
-  const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
-  const char *cRL = strstr(option,"RL");   // Reconstructed Trigger Track in TreeT
-  const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
-  
-  char branchname[30];
-  TBranch * branch = 0x0;
-
-  // Filling TreeR
-  
-  if ( TreeR() && cRC && cTC )
-  {
-    TreeR()->Fill();
-  }
-  else
-  {  
-    if ( TreeR()  && cRC ) 
-    {
-      if ( IsTriggerBranchesInTree() ) 
-      {
-      // Branch per branch filling
-        for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) 
-        {
-          sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
-          branch = TreeR()->GetBranch(branchname);
-          branch->Fill();
-        }
-      }
-      else  
-      {
-        TreeR()->Fill();
-      }
-    }
-    
-    if ( TreeR()  && cTC) 
-    {
-      if (IsRawClusterBranchesInTree()) 
-      {
-        // Branch per branch filling
-        sprintf(branchname,"%sLocalTrigger",GetName());
-        branch = TreeR()->GetBranch(branchname); 
-        branch->Fill();
-       sprintf(branchname,"%sRegionalTrigger",GetName());
-        branch = TreeR()->GetBranch(branchname); 
-        branch->Fill();
-        sprintf(branchname,"%sGlobalTrigger",GetName());
-        branch = TreeR()->GetBranch(branchname);
-        branch->Fill();
-      }
-      else
-      {
-        TreeR()->Fill();
-      }
-    }
-  }
-
-  // Filling TreeT
-  
-  if ( TreeT() && cRT && cRL )
-  {
-    TreeT()->Fill();
-  }
-  else
-  {
-    if ( TreeT() && cRT ) 
-    {
-      if (IsTriggerTrackBranchesInTree()) 
-      {
-        sprintf(branchname,"%sTrack",GetName());  
-        branch = TreeT()->GetBranch(branchname);
-        branch->Fill();
-      }
-      else 
-      {
-        TreeT()->Fill();
-      }
-    }
-
-    if ( TreeT() && cRL ) 
-    {
-      if (IsTrackBranchesInTree()) 
-      {
-        sprintf(branchname,"%sTriggerTrack",GetName());  
-        branch = TreeT()->GetBranch(branchname);
-        branch->Fill();
-      }    
-      else 
-      {
-        TreeT()->Fill();
-      }
-    }
-  }
-}
-
-//_____________________________________________________________________________
-void AliMUONRecData::MakeOwnBranch(Option_t* option)
-{
-/// Create Tree branches for the MUON.
-
-  const Int_t kBufferSize = 4000;
-  char branchname[30];
-  
-  //Setting Data Container
-  SetDataContainer(option);  
-
-  const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
-  const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
-  const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
-                                           //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
-  const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
-  
-  TBranch * branch = 0x0;
-  
-  if (TreeR() && cRC ) {
-    //  one branch for raw clusters per tracking detection plane
-    //        
-    Int_t i; 
-    for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
-      sprintf(branchname,"%sRawClusters%d",GetName(),i+1);     
-      branch = 0x0;
-      branch = TreeR()->GetBranch(branchname);
-      if (branch) {  
-        AliInfo(Form("Branch %s is already in tree.",branchname));
-        return;
-      }
-      branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
-      //Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
-    }
-  }
-  
-  if (TreeR() && cTC ) {
-    //
-    // one branch for global trigger
-    //
-    sprintf(branchname,"%sGlobalTrigger",GetName());
-    branch = 0x0;
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) {  
-      AliInfo(Form("Branch GlobalTrigger is already in treeR."));
-      return ;
-    }
-    branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
-    //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
-
-  //
-    // one branch for regional trigger
-    //  
-    sprintf(branchname,"%sRegionalTrigger",GetName());
-    branch = 0x0;
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) {  
-      AliInfo(Form("Branch RegionalTrigger is already in treeR."));
-      return;
-    }
-    branch = TreeR()->Branch(branchname, &fRegionalTrigger, kBufferSize);
-     
-    //
-    // one branch for local trigger
-    //  
-    sprintf(branchname,"%sLocalTrigger",GetName());
-    branch = 0x0;
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) {  
-      AliInfo(Form("Branch LocalTrigger is already in treeR."));
-      return;
-    }
-    branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
-    //Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);  
-  }
-  
-  if (TreeT() && cRT ) {
-    sprintf(branchname,"%sTrack",GetName());  
-    branch = TreeT()->GetBranch(branchname);
-    if (branch) {  
-      AliInfo(Form("Branch %s is already in tree.",GetName()));
-      return ;
-    }
-    branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
-    //Info("MakeBranch","Making Branch %s for tracks \n",branchname);
-  }  
-  // trigger tracks
-  if (TreeT() && cRL ) {
-    sprintf(branchname,"%sTriggerTrack",GetName());  
-    branch = TreeT()->GetBranch(branchname);
-    if (branch) {  
-      AliInfo(Form("Branch %s is already in tree.",GetName()));
-      return ;
-    }
-    branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
-    //Info("MakeBranch","Making Branch %s for trigger tracks \n",branchname);
-  }  
-}
-//____________________________________________________________________________
-void AliMUONRecData::SetOwnDataContainer(Option_t* option)
-{
-/// Setting data containers of muon data
-
-  const char *cRC  = strstr(option,"RC");  // RawCluster
-  const char *cRT  = strstr(option,"RT");  // Reconstructed Tracks
-  const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Tracks
-                                           //const char *cRP  = strstr(option,"RP");  // Reconstructed Particles  
-  const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
-
-  AliDebug(1,Form("option=%s",option));
-
-  //
-  // Containers for rawclusters, globaltrigger and local trigger tree
-  if (cRC ) {
-    if (fRawClusters == 0x0) {
-      fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
-      fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
-      for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
-       TClonesArray* tca = new TClonesArray("AliMUONRawCluster",10000);
-       tca->SetOwner();
-        fRawClusters->AddAt(tca,i); 
-        fNrawclusters[i]=0;
-      }
-    }
-    // ResetRawClusters(); 
-    // It breaks the correct functioning of the combined reconstruction (AZ)
-    
-  }
-  if (cTC ) {
-    if (fLocalTrigger == 0x0) {
-      fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
-    }
-   if (fRegionalTrigger == 0x0) {
-      fRegionalTrigger  = new TClonesArray("AliMUONRegionalTrigger",16);
-    }
-    if (fGlobalTrigger== 0x0) {
-      fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
-    }
-    // ResetTrigger(); 
-    // This is not necessary here since trigger info ins copied from digits info on flight to RecPoint output
-  }
-
-  //
-  // Containers for rectracks and rectrigger tracks
-  if ( cRT ) {
-    if (fRecTracks == 0x0)  {
-      fRecTracks  = new TClonesArray("AliMUONTrack",100);
-    }
-    ResetRecTracks();
-  }
-  if (cRL) {
-    if (fRecTriggerTracks == 0x0 && cRL)  {
-      fRecTriggerTracks  = new TClonesArray("AliMUONTriggerTrack",100);
-    }
-    ResetRecTriggerTracks();
-  }  
-}
-
-//____________________________________________________________________________
-void AliMUONRecData::SetOwnTreeAddress(Option_t* option)
-{
-  // Setting Data containers
-  SetOwnDataContainer(option);
-
-/// Setting Addresses to the events trees
-
-  const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
-  const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
-  const char *cRL  = strstr(option,"RL");  // Reconstructed Trigger Track in TreeT
-                                           //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
-  const char *cTC = strstr(option,"TC");   // global and local Trigger branches Copy in TreeR
-  
-  // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
-  char branchname[30];
-  TBranch * branch = 0x0;
-  
-  AliDebug(1,Form("option=%s",option));
-
-  //
-  // Branch address for rawclusters, globaltrigger and local trigger tree
-  if ( TreeR()  && fRawClusters && cRC && !strstr(cRC,"RCC")) {
-    for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
-      sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
-      if (fRawClusters) {
-        branch = TreeR()->GetBranch(branchname);
-        if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
-        else AliWarning(Form("(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i));
-      }
-    }
-  }
-  if ( TreeR()  && fLocalTrigger && cTC) {
-    sprintf(branchname,"%sLocalTrigger",GetName());
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fLocalTrigger);
-    else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName()));
-  }
-  if ( TreeR()  && fRegionalTrigger && cTC) {
-    sprintf(branchname,"%sRegionalTrigger",GetName());
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fRegionalTrigger);
-    else AliWarning(Form("(%s) Failed for RegionalTrigger. Can not find branch in treeR.",GetName()));
-  }
-  if ( TreeR() && fGlobalTrigger && cTC) {
-    sprintf(branchname,"%sGlobalTrigger",GetName());
-    branch = TreeR()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fGlobalTrigger);
-    else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName()));
-  }
-
-  // Rec Trakcs
-  if ( TreeT() && fRecTracks && cRT ) {
-    sprintf(branchname,"%sTrack",GetName());  
-    branch = TreeT()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fRecTracks);
-    else AliWarning(Form("(%s) Failed for Tracks. Can not find branch in tree.",GetName()));
-  }
-  // Trigger tracks
-  if ( TreeT() && fRecTriggerTracks && cRL ) {
-    sprintf(branchname,"%sTriggerTrack",GetName());  
-    branch = TreeT()->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fRecTriggerTracks);
-    else AliWarning(Form("(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName()));
-  }
-}
-
-//____________________________________________________________________________
-void AliMUONRecData::Fill(Option_t* option)
-{
-/// Method to fill the trees
-
-  AliMUONData::Fill(option);
-  FillOwn(option);
-}  
-
-//_____________________________________________________________________________
-void AliMUONRecData::MakeBranch(Option_t* option)
-{
-/// Create Tree branches for the MUON.
-
-  AliMUONData::MakeBranch(option);
-  MakeOwnBranch(option);
-}  
-
-//____________________________________________________________________________
-void AliMUONRecData::SetDataContainer(Option_t* option)
-{
-/// Setting data containers of muon data
-  AliMUONData::SetDataContainer(option);
-  SetOwnDataContainer(option);
-}
-
-//____________________________________________________________________________
-void AliMUONRecData::SetTreeAddress(Option_t* option)
-{
-/// Setting Addresses to the events trees
-
-  AliMUONData::SetTreeAddress(option);
-  SetOwnTreeAddress(option);
-}  
-
-//____________________________________________________________________________
-TClonesArray*  AliMUONRecData::RawClusters(Int_t DetectionPlane)
-{
-/// Getting Raw Clusters
-
-  if (fRawClusters) 
-    return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
-  else
-    return NULL;
-}
-
-//_______________________________________________________________________________
-void AliMUONRecData::ResetRawClusters()
-{
-/// Reset number of raw clusters and the raw clust array for this detector
-
-  for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
-    if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
-    if (fNrawclusters)  fNrawclusters[i]=0;
-  }
-}
-
-//____________________________________________________________________________
-void AliMUONRecData::ResetRecTracks()
-{
-/// Reset tracks information
-
-  fNrectracks = 0;
-  if (fRecTracks) fRecTracks->Delete(); // necessary to delete in case of memory allocation
-}
-
-//____________________________________________________________________________
-void AliMUONRecData::ResetRecTriggerTracks()
-{
-/// Reset tracks information
-
-  fNrectriggertracks = 0;