Removing old segmentation, obsolete classes and removing old new conditions (Christian)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Jun 2005 03:26:32 +0000 (03:26 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 14 Jun 2005 03:26:32 +0000 (03:26 +0000)
31 files changed:
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONChamber.cxx
MUON/AliMUONChamber.h
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONChamberTrigger.h
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.cxx
MUON/AliMUONClusterInput.h
MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONDigitizer.cxx
MUON/AliMUONDigitizer.h
MUON/AliMUONDigitizerv2.cxx
MUON/AliMUONDisplay.cxx
MUON/AliMUONFactoryV2.cxx
MUON/AliMUONFactoryV2.h
MUON/AliMUONSDigitizerv1.cxx
MUON/AliMUONTest.cxx
MUON/AliMUONTest.h
MUON/AliMUONTriggerCircuit.cxx
MUON/AliMUONTriggerCircuit.h
MUON/AliMUONv1.cxx
MUON/AliMUONv1.h
MUON/MUONbaseLinkDef.h
MUON/MUONsimLinkDef.h
MUON/libMUONbase.pkg
MUON/libMUONsim.pkg

index aa59705..350ef55 100644 (file)
@@ -67,7 +67,7 @@
 #include "AliMUONDigitizerv2.h"
 #include "AliMUONSDigitizerv1.h"
 #include "AliMUONRawData.h"
-#include "AliMUONFactory.h"
+#include "AliMUONFactoryV2.h"
 #include "AliLog.h"
 
 // Defaults parameters for Z positions of chambers
@@ -96,7 +96,7 @@ AliMUON::AliMUON()
     fChambers(0),
     fTriggerCircuits(0),
     fGeometryBuilder(0),
-    fSegmentationType(1),// set to 1 default wise old seg
+    fSegmentationType(2),// set to 2 default wise new seg
     fDEIndexing(0),
     fAccCut(kFALSE),
     fAccMin(0.),
@@ -125,7 +125,7 @@ AliMUON::AliMUON(const char *name, const char *title)
     fChambers(0),
     fTriggerCircuits(0),
     fGeometryBuilder(0),
-    fSegmentationType(1),// set to 1 default wise old seg
+    fSegmentationType(2),// set to 2 default wise new seg
     fDEIndexing(0),
     fAccCut(kFALSE),
     fAccMin(0.),
@@ -262,18 +262,11 @@ void AliMUON::BuildGeometry()
     return;
   }
 
-  if (fSegmentationType == 1) {
-    for (Int_t i=0; i<7; i++) {
-      for (Int_t j=0; j<2; j++) {
-       Int_t id=2*i+j+1;
-       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
-      }
-    }
-  } else { 
+
 //     for (Int_t i = 0; i < AliMUONConstants::NCh(); i++)     
 //       this->Chamber(i).SegmentationModel2(1)->Draw("eventdisplay");// to be check !
      
-  }
+  
 }
 
 //__________________________________________________________________
@@ -293,15 +286,6 @@ void  AliMUON::SetTreeAddress()
   fHits = GetMUONData()->Hits(); // Added by Ivana to use the methods FisrtHit, NextHit of AliDetector    
 }
 
-//____________________________________________________________________
-void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
-{
-// Set the pad size for chamber id and cathode isec
-    Int_t i=2*(id-1);
-    ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
-    ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
-}
-
 //___________________________________________
 void AliMUON::SetChambersZ(const Float_t *Z)
 {
@@ -420,12 +404,6 @@ Float_t  AliMUON::GetMaxDestepAlu() const
 }   
     
 //____________________________________________________________________
-void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
-{
-// Set the segmentation for chamber id cathode isec
-    ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
-}
-//____________________________________________________________________
 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliMUONGeometrySegmentation*  segmentation)
 {
 // Set the segmentation for chamber id cathode isec
index e47a1bc..898d9f5 100644 (file)
@@ -21,7 +21,6 @@ class TFile;
 class TTree;
 
 class AliLoader;
-class AliSegmentation;
 class AliMUONGeometrySegmentation;
 class AliMUONTriggerCircuit;
 class AliMUONData;
@@ -35,7 +34,7 @@ class AliMUONMerger;
 class AliMUONGeometryBuilder;
 class AliMUONVGeometryBuilder;
 class AliMUONGeometryDEIndexing;
-class AliMUONFactory;
+class AliMUONFactoryV2;
 class AliESD;
 
 class AliMUON : public  AliDetector 
@@ -76,7 +75,6 @@ class AliMUON : public  AliDetector
     // Set Z values for all chambers
     virtual void SetChambersZ(const Float_t *Z);
     virtual void SetChambersZToDefault(void);
-    virtual void SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2);
     // Set Signal Generation Parameters
     virtual void   SetSigmaIntegration(Int_t id, Float_t p1);
     virtual void   SetChargeSlope(Int_t id, Float_t p1);
@@ -84,8 +82,6 @@ class AliMUON : public  AliDetector
     virtual void   SetMaxAdc(Int_t id, Int_t p1);
     // Set Segmentation and Response Model
     virtual void   SetSegmentationModel(Int_t id, Int_t isec,
-                                       AliSegmentation *segmentation);
-    virtual void   SetSegmentationModel(Int_t id, Int_t isec,
                                        AliMUONGeometrySegmentation* segmentation);
 
     void SetSegmentationType(Int_t type) {fSegmentationType = type;}// 1 for old 2 for new, 0 undefined
@@ -159,7 +155,7 @@ class AliMUON : public  AliDetector
     Int_t fCurIterPad;        // Current pad index
     // Background eent for event mixing
     AliMUONMerger *fMerger;   // ! pointer to merger
-    AliMUONFactory* fFactory; // ! MUON factory
+    AliMUONFactoryV2* fFactory; // ! MUON factory
     
     ClassDef(AliMUON,8)  // MUON Detector base class
 };
index b868de8..1a37d24 100644 (file)
@@ -40,7 +40,6 @@ AliMUONChamber::AliMUONChamber()
     frMin(0.),
     frMax(0.),
     fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
-    fSegmentation(0),
     fSegmentation2(0),
     fResponse(0),
     fGeometry(0),
@@ -60,7 +59,6 @@ AliMUONChamber::AliMUONChamber(Int_t id)
     frMin(0.),
     frMax(0.),
     fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
-    fSegmentation(0),
     fSegmentation2(0),
     fResponse(0),
     fGeometry(0),
@@ -73,11 +71,7 @@ AliMUONChamber::AliMUONChamber(Int_t id)
       AliFatal("MUON detector not defined.");
       return;
     }  
-// Construtor with chamber id 
-    fSegmentation = new TObjArray(2);
-    fSegmentation->AddAt(0,0);
-    fSegmentation->AddAt(0,1);
-    
+
     // new segmentation
     fSegmentation2 = new TObjArray(2);
     fSegmentation2->AddAt(0,0);
@@ -101,17 +95,12 @@ AliMUONChamber::AliMUONChamber(const AliMUONChamber& rChamber)
 AliMUONChamber::~AliMUONChamber() 
 {
   // Destructor
-  if (fMUON->WhichSegmentation() == 1) {
-    if (fSegmentation) {
-      fSegmentation->Delete();
-      delete fSegmentation;
-    } 
-  } else {
-    if (fSegmentation2) {
-      fSegmentation2->Delete();
-      delete fSegmentation2;
-    }
+
+  if (fSegmentation2) {
+    fSegmentation2->Delete();
+    delete fSegmentation2;
   }
+  
   delete fGeometry;
 }
 
@@ -136,57 +125,6 @@ Bool_t  AliMUONChamber::IsSensId(Int_t volId) const
   return fGeometry->IsSensitiveVolume(volId);
 }  
 
-//_______________________________________________________
-void AliMUONChamber::Init()
-{
-  // Initalisation ..
-  //
-  // ... for chamber segmentation
-
-  if (fSegmentation->At(0)) 
-    ((AliSegmentation *) fSegmentation->At(0))->Init(fId);
-
-  if (fnsec==2) {
-    if (fSegmentation->At(1))
-      ((AliSegmentation *) fSegmentation->At(1))->Init(fId);
-  }
-
-  
-}
-
-//_________________________________________________________________
-Int_t   AliMUONChamber::SigGenCond(Float_t x, Float_t y, Float_t z)
-{
-  // Ask segmentation if signal should be generated 
-
-  if (fnsec==1) {
-    return ((AliSegmentation*) fSegmentation->At(0))
-      ->SigGenCond(x, y, z) ;
-  } else {
-    return (((AliSegmentation*) fSegmentation->At(0))
-           ->SigGenCond(x, y, z)) ||
-      (((AliSegmentation*) fSegmentation->At(1))
-       ->SigGenCond(x, y, z)) ;
-  }
-  
-}
-
-//_________________________________________________________________
-void    AliMUONChamber::SigGenInit(Float_t x, Float_t y, Float_t z)
-{
-  //
-  // Initialisation of segmentation for hit
-  //  
-
-
-  if (fnsec==1) {
-    ((AliSegmentation*) fSegmentation->At(0))->SigGenInit(x, y, z) ;
-  } else {
-    ((AliSegmentation*) fSegmentation->At(0))->SigGenInit(x, y, z) ;
-    ((AliSegmentation*) fSegmentation->At(1))->SigGenInit(x, y, z) ;
-  }
-  
-}
 
 //_____________________________________________________
 void AliMUONChamber::ChargeCorrelationInit() {
@@ -201,65 +139,6 @@ void AliMUONChamber::ChargeCorrelationInit() {
 }
 
 //_______________________________________________________
-void AliMUONChamber::DisIntegration(Float_t eloss, Float_t /*tof*/, 
-                                   Float_t xhit, Float_t yhit, Float_t zhit,
-                                   Int_t& nnew,Float_t newclust[6][500]) 
-{
-  //    
-  //  Generates pad hits (simulated cluster) 
-  //  using the segmentation and the response model 
-  Float_t dx, dy;
-  //
-  // Width of the integration area
-  //
-  dx=fResponse->SigmaIntegration()*fResponse->ChargeSpreadX();
-  dy=fResponse->SigmaIntegration()*fResponse->ChargeSpreadY();
-  //
-  // Get pulse height from energy loss
-  Float_t qtot = fResponse->IntPH(eloss);
-  //
-  // Loop Over Pads
-    
-  Float_t qp; 
-  nnew=0;
-    
-  // Cathode plane loop
-  for (Int_t i=1; i<=fnsec; i++) {
-    Float_t qcath = qtot * (i==1? fCurrentCorrel : 1/fCurrentCorrel);
-    AliSegmentation* segmentation=
-      (AliSegmentation*) fSegmentation->At(i-1);
-    for (segmentation->FirstPad(xhit, yhit, zhit, dx, dy); 
-        segmentation->MorePads(); 
-        segmentation->NextPad()) 
-      {
-       qp=fResponse->IntXY(segmentation);
-       qp=TMath::Abs(qp);
-       //
-       //
-       if (qp > 1.e-4) 
-         {
-           if (nnew >= 500) // Perform a bounds check on nnew since it is assumed
-             // newclust only contains 500 elements.
-             {
-               AliError("Limit of 500 pad responses reached.");
-               return;
-             };
-           //
-           // --- store signal information
-           newclust[0][nnew]=qcath;                     // total charge
-           newclust[1][nnew]=segmentation->Ix();       // ix-position of pad
-           newclust[2][nnew]=segmentation->Iy();       // iy-position of pad
-           newclust[3][nnew]=qp * qcath;                // charge on pad
-           newclust[4][nnew]=segmentation->ISector();  // sector id
-           newclust[5][nnew]=(Float_t) i;              // counter
-           nnew++;
-               
-         }
-      } // Pad loop
-  } // Cathode plane loop
-}
-
-//_______________________________________________________
 void AliMUONChamber::InitGeo(Float_t /*zpos*/)
 {
   //    sensitive gas gap
index 70f61d6..98d2a6e 100644 (file)
@@ -9,7 +9,6 @@
 #include <TObject.h>
 #include <TObjArray.h>
 
-#include "AliSegmentation.h"
 #include "AliMUONResponse.h"
 #include "AliMUONGeometrySegmentation.h"
 
@@ -35,7 +34,6 @@ class AliMUONChamber : public TObject
   virtual Bool_t  IsSensId(Int_t volId) const;
   
 // Initialisation
-  virtual void    Init();
   virtual void    Init(Int_t flag);
 // Set z-position of chamber  
   virtual void    SetZ(Float_t Z) {fZ = Z;}
@@ -55,9 +53,6 @@ class AliMUONChamber : public TObject
   virtual void    SetResponseModel(AliMUONResponse* thisResponse) {fResponse=thisResponse;}
 //  
 // Set segmentation model
-  virtual void    SetSegmentationModel(Int_t isec, AliSegmentation* thisSegmentation) {
-      fSegmentation->AddAt(thisSegmentation,isec-1);
-  }
   virtual void    SetSegmentationModel(Int_t isec, AliMUONGeometrySegmentation* thissegmentation) {
       fSegmentation2->AddAt(thissegmentation,isec-1);
   }
@@ -66,11 +61,6 @@ class AliMUONChamber : public TObject
   virtual AliMUONResponse* &ResponseModel(){return fResponse;}
 //  
 //  Get reference to segmentation model
-  virtual AliSegmentation*  SegmentationModel(Int_t isec) {
-      return (AliSegmentation *) (*fSegmentation)[isec-1];
-  }
-  virtual TObjArray* ChamberSegmentation() {return fSegmentation;}
-
   virtual AliMUONGeometrySegmentation*  SegmentationModel2(Int_t isec) {
       return (AliMUONGeometrySegmentation*) (*fSegmentation2)[isec-1];
   }
@@ -86,11 +76,9 @@ class AliMUONChamber : public TObject
   virtual Float_t IntPH(Float_t eloss) {return fResponse->IntPH(eloss);}
 //  
 // Ask segmentation if signal should be generated  
-  virtual Int_t   SigGenCond(Float_t x, Float_t y, Float_t z);
   virtual Int_t   SigGenCond(AliMUONHit* hit);
 //
 // Initialisation of segmentation for hit  
-  virtual void    SigGenInit(Float_t x, Float_t y, Float_t z);
   virtual void    SigGenInit(AliMUONHit* hit);
 // Initialisation of charge fluctuation for given hit
   virtual void    ChargeCorrelationInit();
@@ -107,15 +95,8 @@ class AliMUONChamber : public TObject
   virtual void   SetChargeSpread(Float_t p1, Float_t p2) {fResponse->SetChargeSpread(p1,p2);}
 // Set maximum ADC count value
   virtual void   SetMaxAdc(Int_t p1)                   {fResponse->SetMaxAdc(p1);}
-// Set Pad size
-  virtual void   SetPadSize(Int_t isec, Float_t p1, Float_t p2) {
-      ((AliSegmentation*) (*fSegmentation)[isec-1])->SetPadSize(p1,p2);
-  }
 //  
 // Cluster formation method (charge disintegration)
-  virtual void   DisIntegration(Float_t eloss, Float_t tof,
-                               Float_t xhit, Float_t yhit, Float_t zhit,
-                               Int_t& x, Float_t newclust[6][500]);
   virtual void   DisIntegration(AliMUONHit* hit,
                                Int_t& x, Float_t newclust[6][500]);
 // Initialize geometry related parameters  
@@ -146,7 +127,6 @@ class AliMUONChamber : public TObject
   Float_t frMax; // outermost sensitive radius
   Float_t fCurrentCorrel; //! charge correlation for current hit.
 
-  TObjArray              *fSegmentation;    // pointer to segmentation
   TObjArray              *fSegmentation2;   // pointer to geometry segmentation bending & NBending
 
   AliMUONResponse        *fResponse;        // pointer to response
index 7c6073a..e560466 100644 (file)
@@ -39,92 +39,6 @@ AliMUONChamberTrigger::AliMUONChamberTrigger(Int_t id)
 }
 
 //-------------------------------------------
-void AliMUONChamberTrigger::DisIntegration(Float_t /*eloss*/, Float_t tof, 
-                                          Float_t xhit, Float_t yhit, Float_t zhit, 
-                                          Int_t& nnew,
-                                          Float_t newclust[6][500]) 
-{
-//    
-//  Generates pad hits (simulated cluster) 
-//  using the segmentation and the response model
-
-  Int_t twentyNano;
-  if (tof<75*TMath::Power(10,-9)) {
-    twentyNano=1;
-  } else {
-    twentyNano=100;
-  }
-
-  Float_t qp;
-  nnew=0;
-  for (Int_t i=1; i<=fnsec; i++) {
-    AliSegmentation * segmentation=
-      (AliSegmentation*) (*fSegmentation)[i-1];
-    
-// Find the module & strip Id. which has fired
-    Int_t ix,iy;
-    
-    segmentation->GetPadI(xhit,yhit,0,ix,iy);
-    segmentation->SetPad(ix,iy);
-//    printf("  fnsec xhit yhit zhit ix iy %i %f %f %f %i %i \n",i,xhit,yhit,zhit,ix,iy);      
-
-// treatment of GEANT hits w/o corresponding strip (due to the fact that
-// the 2 geometries are computed in a very slightly different way) 
-    if (ix==0&&iy==0) {
-      AliInfo(Form("AliMUONChamberTrigger hit w/o strip %f %f \n",xhit,yhit));
-    } else {          
-      // --- store signal information for this strip
-      newclust[0][nnew]=1.;                       // total charge
-      newclust[1][nnew]=ix;                       // ix-position of pad
-      newclust[2][nnew]=iy;                       // iy-position of pad
-      newclust[3][nnew]=twentyNano;               // time of flight
-      newclust[4][nnew]=segmentation->ISector();  // sector id
-      newclust[5][nnew]=(Float_t) i;              // counter
-      nnew++;
-
-// cluster-size if AliMUONResponseTriggerV1, nothing if AliMUONResponseTrigger
-      if (((AliMUONResponseTrigger*) fResponse)->SetGenerCluster()) {
-  
-       // set hits
-       segmentation->SetHit(xhit,yhit,zhit);
-       // get the list of nearest neighbours
-       Int_t nList, xList[10], yList[10];
-       segmentation->Neighbours(ix,iy,&nList,xList,yList);
-       
-       qp = 0;
-       for (Int_t j=0; j<nList; j++){       // loop over neighbours      
-         if (xList[j]!=0) {                 // existing neighbour          
-           if (j==0||j==5||qp!=0) {         // built-up cluster-size
-             
-             // neighbour real coordinates (just for checks here)
-             Float_t x,y,z;
-             segmentation->GetPadC(xList[j],yList[j],x,y,z);
-             // set pad (fx fy & fix fiy are the current pad coord. & Id.)
-             segmentation->SetPad(xList[j],yList[j]);    
-             // get the chamber (i.e. current strip) response
-             qp=fResponse->IntXY(segmentation);          
-             
-             if (qp > 0.5) {           
-               // --- store signal information for neighbours 
-               newclust[0][nnew]=qp;                      // total charge
-               newclust[1][nnew]=segmentation->Ix();      // ix-pos. of pad
-               newclust[2][nnew]=segmentation->Iy();      // iy-pos. of pad
-               newclust[3][nnew]=twentyNano;              // time of flight
-               newclust[4][nnew]=segmentation->ISector(); // sector id
-               newclust[5][nnew]=(Float_t) i;             // counter
-               nnew++;
-             } // qp > 0.5 
-           } // built-up cluster-size
-         } // existing neighbour
-       } // loop over neighbours
-      } // endif hit w/o strip
-    } // loop over planes
-  } // if AliMUONResponseTriggerV1
-}
-
-
-
-//-------------------------------------------
 void AliMUONChamberTrigger::DisIntegration(AliMUONHit* hit,
                                           Int_t& nnew,
                                           Float_t newclust[6][500]) 
index 7129a55..de4a526 100644 (file)
@@ -25,9 +25,6 @@ class AliMUONChamberTrigger : public AliMUONChamber
     
     // Cluster formation method (charge disintegration)
     
-    virtual void   DisIntegration(Float_t eloss, Float_t tof, Float_t xhit, Float_t yhit, Float_t zhit,
-                                       Int_t& nnew, Float_t newclust[6][500]);
-
     virtual void   DisIntegration(AliMUONHit* hit,
                                        Int_t& nnew, Float_t newclust[6][500]);
 
index e8ac627..805dbbe 100644 (file)
@@ -56,7 +56,7 @@ AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw, Int_t iReco)
 // Constructor
   for (Int_t i=0; i<4; i++) {fHist[i] = 0;}
   fMuonDigits = 0;
-  fSegmentation[1] = fSegmentation[0] = 0; 
+  //  fSegmentation[1] = fSegmentation[0] = 0; 
   fgClusterFinder = 0x0;
   fgMinuit = 0x0; 
   if (!fgClusterFinder) fgClusterFinder = this;
@@ -178,8 +178,9 @@ newchamber:
   fMuonDigits  = muon->GetMUONData()->Digits(ch);
   if (fMuonDigits == 0) return;
   iChamber = &(muon->Chamber(ch));
-  fSegmentation[0] = iChamber->SegmentationModel(1);
-  fSegmentation[1] = iChamber->SegmentationModel(2);
+  fSeg2[0] = iChamber->SegmentationModel2(1);
+  fSeg2[1] = iChamber->SegmentationModel2(2);
+  
   fResponse = iChamber->ResponseModel();
     
   nent = 0;
@@ -230,10 +231,12 @@ next:
       if (first) {
        // Find first unused pad
        if (fUsed[cath][digit]) continue;
-       fSegmentation[cath]->GetPadC(mdig->PadX(),mdig->PadY(),xpad,ypad,zpad0);
+       fSeg2[cath]->GetPadC(fInput->DetElemId(), mdig->PadX(),mdig->PadY(),xpad,ypad,zpad0);
+
       } else {
        if (fUsed[cath][digit]) continue;
-       fSegmentation[cath]->GetPadC(mdig->PadX(),mdig->PadY(),xpad,ypad,zpad);
+       fSeg2[cath]->GetPadC(fInput->DetElemId(), mdig->PadX(),mdig->PadY(),xpad,ypad,zpad);
+
        if (TMath::Abs(zpad-zpad0)>0.1) continue; // different slats
        // Find a pad overlapping with the cluster
        if (!Overlap(cath,mdig)) continue;
@@ -647,15 +650,19 @@ void AliMUONClusterFinderAZ::AddPad(Int_t cath, Int_t digit)
   Int_t charge = mdig->Signal();
   // get the center of the pad
   Float_t xpad, ypad, zpad;
-  fSegmentation[cath]->GetPadC(mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
-  
-  Int_t   isec = fSegmentation[cath]->Sector(mdig->PadX(), mdig->PadY());
+  fSeg2[cath]->GetPadC(fInput->DetElemId(), mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
+
+  Int_t   isec;
+  isec = fSeg2[cath]->Sector(fInput->DetElemId(), mdig->PadX(), mdig->PadY());
+
   Int_t nPads = fnPads[0] + fnPads[1];
   fXyq[0][nPads] = xpad;
   fXyq[1][nPads] = ypad;
   fXyq[2][nPads] = charge;
-  fXyq[3][nPads] = fSegmentation[cath]->Dpx(isec)/2;
-  fXyq[4][nPads] = fSegmentation[cath]->Dpy(isec)/2;
+
+  fXyq[3][nPads] = fSeg2[cath]->Dpx(fInput->DetElemId(),isec)/2;
+  fXyq[4][nPads] = fSeg2[cath]->Dpy(fInput->DetElemId(),isec)/2;
+  
   fXyq[5][nPads] = digit;
   fPadIJ[0][nPads] = cath;
   fPadIJ[1][nPads] = 0;
@@ -668,7 +675,8 @@ void AliMUONClusterFinderAZ::AddPad(Int_t cath, Int_t digit)
   AliMUONDigit  *mdig1;
 
   Int_t ndigits = fMuonDigits->GetEntriesFast();
-  fSegmentation[cath]->Neighbours(mdig->PadX(),mdig->PadY(),&nn,xList,yList); 
+  fSeg2[cath]->Neighbours(fInput->DetElemId(), mdig->PadX(),mdig->PadY(),&nn,xList,yList); 
+
   for (Int_t in=0; in<nn; in++) {
     ix=xList[in];
     iy=yList[in];
@@ -694,14 +702,17 @@ Bool_t AliMUONClusterFinderAZ::Overlap(Int_t cath, TObject *dig)
   AliMUONDigit *mdig = (AliMUONDigit*) dig;
 
   Float_t xpad, ypad, zpad;
-  fSegmentation[cath]->GetPadC(mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
-  Int_t   isec = fSegmentation[cath]->Sector(mdig->PadX(), mdig->PadY());
-
+  Int_t   isec;
   Float_t xy1[4], xy12[4];
-  xy1[0] = xpad - fSegmentation[cath]->Dpx(isec)/2;
-  xy1[1] = xy1[0] + fSegmentation[cath]->Dpx(isec);
-  xy1[2] = ypad - fSegmentation[cath]->Dpy(isec)/2;
-  xy1[3] = xy1[2] + fSegmentation[cath]->Dpy(isec);
+
+  fSeg2[cath]->GetPadC(fInput->DetElemId(), mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
+  isec = fSeg2[cath]->Sector(fInput->DetElemId(), mdig->PadX(), mdig->PadY());
+  xy1[0] = xpad - fSeg2[cath]->Dpx(fInput->DetElemId(),isec)/2;
+  xy1[1] = xy1[0] + fSeg2[cath]->Dpx(fInput->DetElemId(), isec);
+  xy1[2] = ypad - fSeg2[cath]->Dpy(fInput->DetElemId(), isec)/2;
+  xy1[3] = xy1[2] + fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
+
   //cout << " ok " << fnPads[0]+fnPads[1] << xy1[0] << xy1[1] << xy1[2] << xy1[3] << endl;
 
   Int_t cath1 = TMath::Even(cath);
@@ -1133,19 +1144,21 @@ Bool_t AliMUONClusterFinderAZ::MainLoop()
       for (Int_t j=0; j<npadTot; j++) {
        if (fPadIJ[1][j] < 0) { coef[j*nPix+ipix] = 0; continue; }
        cath = fPadIJ[0][j];
-       fSegmentation[cath]->GetPadI(fXyq[0][j],fXyq[1][j],fZpad,ix,iy);
-       fSegmentation[cath]->SetPad(ix,iy);
-       /*
-         fSegmentation[cath]->Neighbours(ix,iy,&nn,xList,yList); 
-         if (nn != 4) {
-         cout << nn << ": ";
-         for (Int_t i=0; i<nn; i++) {cout << xList[i] << " " << yList[i] << ", ";}
-         cout << endl;
-         }
-       */
        Double_t sum = 0;
-       fSegmentation[cath]->SetHit(pixPtr->Coord(0),pixPtr->Coord(1),fZpad);
-       sum += fResponse->IntXY(fSegmentation[cath]);
+
+       fSeg2[cath]->GetPadI(fInput->DetElemId(),fXyq[0][j],fXyq[1][j],fZpad,ix,iy);
+       fSeg2[cath]->SetPad(fInput->DetElemId(),ix,iy);
+         /*
+           fSeg2[cath]->Neighbours(fInput->DetElemId(),ix,iy,&nn,xList,yList); 
+           if (nn != 4) {
+           cout << nn << ": ";
+           for (Int_t i=0; i<nn; i++) {cout << xList[i] << " " << yList[i] << ", ";}
+           cout << endl;
+           }
+         */
+       fSeg2[cath]->SetHit(fInput->DetElemId(),pixPtr->Coord(0),pixPtr->Coord(1),fZpad);
+       sum += fResponse->IntXY(fInput->DetElemId(),fSeg2[cath]);
+       
        indx = j*nPix + ipix;
        coef[indx] = sum; 
        probi[ipix] += coef[indx];
@@ -2238,23 +2251,24 @@ void AliMUONClusterFinderAZ::Fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t
   
   Int_t cath, ix, iy, indx, npads=0;
   Double_t charge, delta, coef=0, chi2=0;
   for (Int_t j=0; j<c.fnPads[0]+c.fnPads[1]; j++) {
     if (c.fPadIJ[1][j] != 1) continue;
     cath = c.fPadIJ[0][j];
     npads++;
-    c.fSegmentation[cath]->GetPadI(c.fXyq[0][j],c.fXyq[1][j],c.fZpad,ix,iy);
-    c.fSegmentation[cath]->SetPad(ix,iy);
+    c.fSeg2[cath]->GetPadI(fInput->DetElemId(),c.fXyq[0][j],c.fXyq[1][j],c.fZpad,ix,iy);
+    c.fSeg2[cath]->SetPad(fInput->DetElemId(),ix,iy);
     charge = 0;
     for (Int_t i=c.fNpar/3; i>=0; i--) { // sum over tracks
       indx = i<2 ? 2*i : 2*i+1;
-      c.fSegmentation[cath]->SetHit(par[indx],par[indx+1],c.fZpad);
+      c.fSeg2[cath]->SetHit(fInput->DetElemId(),par[indx],par[indx+1],c.fZpad);
       //charge += c.fResponse->IntXY(c.fSegmentation[cath])*par[icl*3+2];
       if (c.fNpar == 2) coef = 1;
       else coef = i==c.fNpar/3 ? par[indx+2] : 1-coef;
       //coef = TMath::Max (coef, 0.);
       if (c.fNpar == 8 && i < 2) coef = i==1 ? coef*par[indx+2] : coef - par[7];
       //coef = TMath::Max (coef, 0.);
-      charge += c.fResponse->IntXY(c.fSegmentation[cath])*coef;
+      charge += c.fResponse->IntXY(fInput->DetElemId(),c.fSeg2[cath])*coef;
     }
     charge *= c.fQtot;
     //if (c.fXyq[2][j] > c.fResponse->MaxAdc()-1 && charge > 
@@ -2264,6 +2278,7 @@ void AliMUONClusterFinderAZ::Fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t
     //chi2 += TMath::Abs(delta);
     chi2 += delta*delta;
   } // for (Int_t j=0;
+  
   f = chi2; 
   Double_t qAver = c.fQtot/npads; //(c.fnPads[0]+c.fnPads[1]);
   f = chi2/qAver;
@@ -2276,26 +2291,28 @@ void AliMUONClusterFinderAZ::UpdatePads(Int_t /*nfit*/, Double_t *par)
 
   Int_t cath, ix, iy, indx;
   Double_t charge, coef=0;
+
   for (Int_t j=0; j<fnPads[0]+fnPads[1]; j++) {
     if (fPadIJ[1][j] != -1) continue;
     if (fNpar != 0) {
       cath = fPadIJ[0][j];
-      fSegmentation[cath]->GetPadI(fXyq[0][j],fXyq[1][j],fZpad,ix,iy);
-      fSegmentation[cath]->SetPad(ix,iy);
+      fSeg2[cath]->GetPadI(fInput->DetElemId(),fXyq[0][j],fXyq[1][j],fZpad,ix,iy);
+      fSeg2[cath]->SetPad(fInput->DetElemId(),ix,iy);
       charge = 0;
       for (Int_t i=fNpar/3; i>=0; i--) { // sum over tracks
        indx = i<2 ? 2*i : 2*i+1;
-       fSegmentation[cath]->SetHit(par[indx],par[indx+1],fZpad);
+       fSeg2[cath]->SetHit(fInput->DetElemId(),par[indx],par[indx+1],fZpad);
        if (fNpar == 2) coef = 1;
        else coef = i==fNpar/3 ? par[indx+2] : 1-coef;
        if (fNpar == 8 && i < 2) coef = i==1 ? coef*par[indx+2] : coef - par[7];
-       charge += fResponse->IntXY(fSegmentation[cath])*coef;
+       charge += fResponse->IntXY(fInput->DetElemId(),fSeg2[cath])*coef;
       }
       charge *= fQtot;
       fXyq[2][j] -= charge;
     } // if (fNpar != 0)
     if (fXyq[2][j] > fResponse->ZeroSuppression()) fPadIJ[1][j] = 0; // return pad for further using
   } // for (Int_t j=0;
+  
 }  
 
 //_____________________________________________________________________________
index 2ae07d8..9c27948 100644 (file)
@@ -42,7 +42,7 @@ protected:
   Int_t      fnPads[2];        // ! number of pads in the cluster on 2 cathodes
   Float_t    fXyq[6][fgkDim];    // ! pad information
   Int_t      fPadIJ[2][fgkDim];  // ! pad information
-  AliSegmentation *fSegmentation[2]; // ! segmentation
+  //  AliSegmentation *fSegmentation[2]; // ! segmentation
   AliMUONResponse *fResponse;// ! response
   Float_t    fZpad;            // ! z-coordinate of the hit
   Int_t      fNpar;            // ! number of fit parameters
index 47da52f..f122500 100644 (file)
@@ -23,7 +23,6 @@
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONDigit.h"
 #include "AliMUONRawCluster.h"
-#include "AliSegmentation.h"
 #include "AliMUONGeometrySegmentation.h"
 #include "AliMUONMathieson.h"
 #include "AliMUONClusterInput.h"
@@ -50,8 +49,6 @@ AliMUONClusterFinderVS::AliMUONClusterFinderVS()
     fTrack[0]=fTrack[1]=-1;
     fDebugLevel = 0; // make silent default
     fGhostChi2Cut = 1e6; // nothing done by default
-    fSeg[0]    = 0;
-    fSeg[1]    = 0;
     fSeg2[0]    = 0;
     fSeg2[1]    = 0;
 
@@ -122,10 +119,6 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        // pad charge
        fQ[i][cath] = fDig[i][cath]->Signal();
        // pad centre coordinates
-       if (fSegmentationType == 1)
-         fSeg[cath]->
-           GetPadC(fIx[i][cath], fIy[i][cath], fX[i][cath], fY[i][cath], fZ[i][cath]);
-       else
          fSeg2[cath]->
            GetPadC(fInput->DetElemId(), fIx[i][cath], fIy[i][cath], fX[i][cath], fY[i][cath], fZ[i][cath]);
       } // loop over cluster digits
@@ -176,13 +169,10 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        c->SetChi2(0,chi2);
        c->SetChi2(1,chi2);
         // Force on anod
-       if (fSegmentationType == 1) {
-         c->SetX(0, fSeg[0]->GetAnod(c->GetX(0)));
-         c->SetX(1, fSeg[1]->GetAnod(c->GetX(1)));
-       } else {
-         c->SetX(0, fSeg2[0]->GetAnod(fInput->DetElemId(), c->GetX(0)));
-         c->SetX(1, fSeg2[1]->GetAnod(fInput->DetElemId(), c->GetX(1)));
-       }
+
+       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) {
@@ -278,22 +268,15 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        for (ico=0; ico<4; ico++) {
            accepted[ico]=kFALSE;
 // cathode one: x-coordinate
-           if (fSegmentationType == 1) {
-             isec=fSeg[0]->Sector(ixm[ico][0], iym[ico][0]);
-             dpx=fSeg[0]->Dpx(isec)/2.;
-           } else {
-             isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-             dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           }
+           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
-           if (fSegmentationType == 1) {
-             isec=fSeg[1]->Sector(ixm[ico][1], iym[ico][1]);
-             dpy=fSeg[1]->Dpy(isec)/2.;
-           } else {
-             isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-             dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           }
+
+           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)) {
@@ -459,10 +442,7 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                                cnew.SetMultiplicity(cath,c->GetMultiplicity(cath));
                                for (i=0; i<fMul[cath]; i++) {
                                  cnew.SetIndex(i, cath, c->GetIndex(i,cath));
-                                 if (fSegmentationType == 1) 
-                                   fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-                                 else 
-                                   fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[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)));
@@ -653,22 +633,13 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        Float_t eps = 1.e-5;
 
        for (ico=0; ico<2; ico++) {
-           accepted[ico]=kFALSE;
-           if (fSegmentationType == 1) {
-             isec=fSeg[0]->Sector(ixm[ico][0], iym[ico][0]);
-             dpx=fSeg[0]->Dpx(isec)/2.;
-           } else {
-             isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-             dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           }
+           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]);
-           if (fSegmentationType == 1) {
-             isec=fSeg[1]->Sector(ixm[ico][1], iym[ico][1]);
-             dpy=fSeg[1]->Dpy(isec)/2.;
-           } else {
-             isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-             dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           }
+           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)) {
@@ -746,10 +717,7 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                        cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
                        for (i=0; i<fMul[cath]; i++) {
                            cnew.SetIndex(i, cath, c->GetIndex(i, cath));
-                           if (fSegmentationType == 1) 
-                             fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-                           else
-                             fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
+                           fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
 
                        }
                        AliDebug(1,Form("\nRawCluster %d cath %d\n",ico,cath));
@@ -803,21 +771,13 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        
        for (ico=0; ico<2; ico++) {
            accepted[ico]=kFALSE;
-           if (fSegmentationType == 1) {
-             isec=fSeg[0]->Sector(ixm[ico][0], iym[ico][0]);
-             dpx=fSeg[0]->Dpx(isec)/2.;
-           } else {
-             isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-             dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           }
+           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]);
-           if (fSegmentationType == 1) {
-             isec=fSeg[1]->Sector(ixm[ico][1], iym[ico][1]);
-             dpy=fSeg[1]->Dpy(isec)/2.;
-           } else {
-             isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-             dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           }
+           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)) {
@@ -895,11 +855,8 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                        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));
-                           if (fSegmentationType == 1) 
-                             fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-                           else 
-                             fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
+                         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)));
@@ -951,21 +908,13 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
        AliDebug(1,Form("nIco %d\n",nIco));
        for (ico=0; ico<nIco; ico++) {
            AliDebug(1,Form("ico = %d\n",ico));
-           if (fSegmentationType == 1) {
-             isec=fSeg[0]->Sector(ixm[ico][0], iym[ico][0]);
-             dpx=fSeg[0]->Dpx(isec)/2.;
-           } else {
-             isec=fSeg2[0]->Sector(fInput->DetElemId(), ixm[ico][0], iym[ico][0]);
-             dpx=fSeg2[0]->Dpx(fInput->DetElemId(), isec)/2.;
-           } 
+           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]);
-           if (fSegmentationType == 1) {
-             isec=fSeg[1]->Sector(ixm[ico][1], iym[ico][1]);
-             dpy=fSeg[1]->Dpy(isec)/2.;
-           } else {
-             isec=fSeg2[1]->Sector(fInput->DetElemId(), ixm[ico][1], iym[ico][1]);
-             dpy=fSeg2[1]->Dpy(fInput->DetElemId(), isec)/2.;
-           }
+           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]));
@@ -980,10 +929,7 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
                    cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
                    for (i=0; i<fMul[cath]; i++) {
                        cnew.SetIndex(i, cath, c->GetIndex(i, cath));
-                       if (fSegmentationType == 1) 
-                         fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-                       else 
-                         fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
+                       fSeg2[cath]->SetPad(fInput->DetElemId(), fIx[i][cath], fIy[i][cath]);
                    }
                    FillCluster(&cnew,cath);
                } 
@@ -1031,33 +977,21 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
        Int_t isec;
        Float_t a0;
 
-       if (fSegmentationType == 1)         
-         fSeg[cath]->Neighbours(fIx[i][cath], fIy[i][cath], &nn, x, y);
-       else 
-         fSeg2[cath]->Neighbours(fInput->DetElemId(), fIx[i][cath], fIy[i][cath], &nn, x, y);
+       fSeg2[cath]->Neighbours(fInput->DetElemId(), fIx[i][cath], fIy[i][cath], &nn, x, y);
          
        isLocal[i][cath]=kTRUE;
-
-       if (fSegmentationType == 1) {
-         isec = fSeg[cath]->Sector(fIx[i][cath], fIy[i][cath]);
-         a0   = fSeg[cath]->Dpx(isec)*fSeg[cath]->Dpy(isec);
-       } else {
-         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);
-       }
+       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 (fHitMap[cath]->TestHit(x[j], y[j])==kEmpty) continue;
          digt=(AliMUONDigit*) fHitMap[cath]->GetHit(x[j], y[j]);
          Float_t a1;
-         if (fSegmentationType == 1) {
-           isec=fSeg[cath]->Sector(x[j], y[j]);
-           a1 = fSeg[cath]->Dpx(isec)*fSeg[cath]->Dpy(isec);
-         } else {
-           isec=fSeg2[cath]->Sector(fInput->DetElemId(), x[j], y[j]);
-           a1 = fSeg2[cath]->Dpx(fInput->DetElemId(),isec)*fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
-         }
+         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;
@@ -1101,15 +1035,10 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
        cath1=1;
        
        for (i=0; i<fMul[cath]; i++) {
-         if (fSegmentationType == 1) {
-           isec=fSeg[cath]->Sector(fIx[i][cath],fIy[i][cath]);
-           dpy=fSeg[cath]->Dpy(isec);
-           dpx=fSeg[cath]->Dpx(isec);
-         } else {
-           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);
-         }
+         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.) && 
@@ -1121,26 +1050,9 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
 // 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;
-           if (fSegmentationType == 1) {
 
-             for (fSeg[cath]->FirstPad(fX[i][cath], fY[i][cath], fZPlane, 0., dpy);
-                  fSeg[cath]->MorePads();
-                  fSeg[cath]->NextPad())
-               {
-                 ix = fSeg[cath]->Ix();
-                 iy = fSeg[cath]->Iy();
-                 // skip the current pad
-                 if (iy == fIy[i][cath]) continue;
-               
-                 if (fHitMap[cath]->TestHit(ix, iy)!=kEmpty) {
-                   iNN++;
-                   digt=(AliMUONDigit*) fHitMap[cath]->GetHit(ix,iy);
-                   if (digt->Signal() > fQ[i][cath]) isLocal[i][cath]=kFALSE;
-                 }
-               } // Loop over pad neighbours in y
-           } else {
 
-             for (fSeg2[cath]->FirstPad(fInput->DetElemId(), fX[i][cath], fY[i][cath], fZPlane, 0., dpy);
+           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()))
                {
@@ -1155,7 +1067,7 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
                    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]++;
@@ -1185,15 +1097,10 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
 //
 //  Loop over cluster digits
        for (i=0; i<fMul[cath]; i++) {
-         if (fSegmentationType == 1) {
-           isec=fSeg[cath]->Sector(fIx[i][cath],fIy[i][cath]);
-           dpx=fSeg[cath]->Dpx(isec);
-           dpy=fSeg[cath]->Dpy(isec);
-         } else {
            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
@@ -1208,26 +1115,7 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
 
 // iNN counts the number of neighbours with signal, it should be 1 or 2
            Int_t iNN=0;
-           if (fSegmentationType == 1) {
-             for (fSeg[cath]->FirstPad(fX[i][cath], fY[i][cath], fZPlane, dpx, 0.);
-                  fSeg[cath]->MorePads();
-                  fSeg[cath]->NextPad())
-               {
-
-                 ix = fSeg[cath]->Ix();
-                 iy = fSeg[cath]->Iy();
-
-                 // skip the current pad
-                 if (ix == fIx[i][cath]) continue;
-               
-                 if (fHitMap[cath]->TestHit(ix, iy)!=kEmpty) {
-                   iNN++;
-                   digt=(AliMUONDigit*) fHitMap[cath]->GetHit(ix,iy);
-                   if (digt->Signal() > fQ[i][cath]) isLocal[i][cath]=kFALSE;
-                 }
-               } // Loop over pad neighbours in x
-           } else {
-             for (fSeg2[cath]->FirstPad(fInput->DetElemId(), fX[i][cath], fY[i][cath], fZPlane, dpx, 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()))
                {
@@ -1244,7 +1132,7 @@ void AliMUONClusterFinderVS::FindLocalMaxima(AliMUONRawCluster* /*c*/)
                    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]++;
@@ -1311,10 +1199,7 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
       }
       //
       if (flag) {
-       if (fSegmentationType == 1) 
-         fSeg[cath]->GetPadC(ix, iy, x, y, z);
-       else
-         fSeg2[cath]->GetPadC(fInput->DetElemId(), ix, iy, x, y, z);
+       fSeg2[cath]->GetPadC(fInput->DetElemId(), ix, iy, x, y, z);
        
        c->AddX(cath, q*x);
        c->AddY(cath, q*y);
@@ -1327,10 +1212,7 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
   if (flag) {
     c->SetX(cath, c->GetX(cath)/c->GetCharge(cath));
     // Force on anod
-    if (fSegmentationType == 1) 
-      c->SetX(cath, fSeg[cath]->GetAnod(c->GetX(cath)));
-    else
-      c->SetX(cath, fSeg2[cath]->GetAnod(fInput->DetElemId(), c->GetX(cath)));
+    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
@@ -1339,24 +1221,15 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t flag, Int_
     y=c->GetY(cath);
     TF1* cogCorr;
     Int_t isec;
-    if (fSegmentationType == 1) {
-      fSeg[cath]->GetPadI(x, y, fZPlane, ix, iy);
-      fSeg[cath]->GetPadC(ix, iy, x, y, z);
-      isec=fSeg[cath]->Sector(ix,iy);
-      cogCorr = fSeg[cath]->CorrFunc(isec-1);
-    } else {
-      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);
-    }
+    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;
-      if (fSegmentationType == 1) 
-       yOnPad=(c->GetY(cath)-y)/fSeg[cath]->Dpy(isec);
-      else 
-       yOnPad=(c->GetY(cath)-y)/fSeg2[cath]->Dpy(fInput->DetElemId(), isec);
+      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
@@ -1384,11 +1257,7 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t cath)
   for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
     {
       dig = fInput->Digit(cath,c->GetIndex(i,cath));
-      if (fSegmentationType == 1) 
-       fSeg[cath]->
-         GetPadC(dig->PadX(),dig->PadY(),xpad,ypad, zpad);
-      else
-       fSeg2[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);
@@ -1417,9 +1286,6 @@ void  AliMUONClusterFinderVS::FillCluster(AliMUONRawCluster* c, Int_t cath)
   
   //  apply correction to the coordinate along the anode wire
   // Force on anod
-  if (fSegmentationType == 1) 
-    c->SetX(cath,fSeg[cath]->GetAnod(c->GetX(cath)));
-  else
     c->SetX(cath,fSeg2[cath]->GetAnod(fInput->DetElemId(), c->GetX(cath)));
 }
 
@@ -1484,10 +1350,7 @@ void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONR
 
 // Prepare center of gravity calculation
     Float_t x, y, z;
-    if (fSegmentationType == 1) 
-      fSeg[cath]->GetPadC(i, j, x, y, z);
-    else
-      fSeg2[cath]->GetPadC(fInput->DetElemId(), i, j, 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);
@@ -1502,10 +1365,7 @@ void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONR
     ix=iy=0;
     Int_t nn;
     Int_t xList[10], yList[10];
-    if (fSegmentationType == 1) 
-      fSeg[cath]->Neighbours(i,j,&nn,xList,yList);
-    else 
-      fSeg2[cath]->Neighbours(fInput->DetElemId(), i,j,&nn,xList,yList);
+    fSeg2[cath]->Neighbours(fInput->DetElemId(), i,j,&nn,xList,yList);
     for (Int_t in=0; in<nn; in++) {
        ix=xList[in];
        iy=yList[in];
@@ -1522,86 +1382,46 @@ void  AliMUONClusterFinderVS::FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONR
 //  Neighbours on opposite cathode 
 //  Take into account that several pads can overlap with the present pad
     Int_t isec;
-    if (fSegmentationType == 1) 
-      isec=fSeg[cath]->Sector(i,j);    
-    else
-      isec=fSeg2[cath]->Sector(fInput->DetElemId(), i,j);    
+    isec=fSeg2[cath]->Sector(fInput->DetElemId(), i,j);    
 
     Int_t iop;
     Float_t dx, dy;
-
-    if (fSegmentationType == 1) {
-      if (cath==0) {
-       iop = 1;
-       dx  = (fSeg[cath]->Dpx(isec))/2.;
-       dy  = 0.;
-      } else {
-       iop = 0;
-       dx  = 0.;
-       dy  = (fSeg[cath]->Dpy(isec))/2;
-      }
-   
-
-    
-      // loop over pad neighbours on opposite cathode
-      for (fSeg[iop]->FirstPad(x, y, fZPlane, dx, dy);
-          fSeg[iop]->MorePads();
-          fSeg[iop]->NextPad())
-       {
-       
-         ix = fSeg[iop]->Ix(); iy = fSeg[iop]->Iy();
-         AliDebug(2,Form("\n ix, iy: %f %f %f %d %d %d", x,y,z,ix, iy, fSector));
-         if (fHitMap[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 (fHitMap[iop]->TestHit(iXopp[jopp],iYopp[jopp]) == kUnused) 
-         FindCluster(iXopp[jopp], iYopp[jopp], iop, c);
-      }
+  
+    if (cath==0) {
+      iop = 1;
+      dx  = (fSeg2[cath]->Dpx(fInput->DetElemId(), isec))/2.;
+      dy  = 0.;
     } else {
-
-      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;
-      }
+      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()))
-       {
+    // 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 (fHitMap[iop]->TestHit(ix,iy)==kUnused){
-           iXopp[nOpp]=ix;
-           iYopp[nOpp++]=iy;
-           AliDebug(2,Form("\n Opposite %d %d %d", iop, ix, iy));
-         }
+       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 (fHitMap[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 (fHitMap[iop]->TestHit(iXopp[jopp],iYopp[jopp]) == kUnused) 
-         FindCluster(iXopp[jopp], iYopp[jopp], iop, c);
-      }
+      } // 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 (fHitMap[iop]->TestHit(iXopp[jopp],iYopp[jopp]) == kUnused) 
+       FindCluster(iXopp[jopp], iYopp[jopp], iop, c);
     }
+
 }
 
 //_____________________________________________________________________________
@@ -1617,23 +1437,15 @@ void AliMUONClusterFinderVS::FindRawClusters()
 //  Return if no input datad available
     if (!fInput->NDigits(0) && !fInput->NDigits(1)) return;
 
-    fSegmentationType = fInput->GetSegmentationType();
+    if(fInput->GetSegmentationType() == 1)
+      AliFatal("Old Segmentation no more supported.");
 
-    if (fSegmentationType == 1) {
-      fSeg[0] = fInput->Segmentation(0);
-      fSeg[1] = fInput->Segmentation(1);
-
-      fHitMap[0]  = new AliMUONHitMapA1(fSeg[0], fInput->Digits(0));
-      fHitMap[1]  = new AliMUONHitMapA1(fSeg[1], fInput->Digits(1));
-
-    } else {
-      fSeg2[0] = fInput->Segmentation2(0);
-      fSeg2[1] = fInput->Segmentation2(1);
-      
-      fHitMap[0]  = new AliMUONHitMapA1(fInput->DetElemId(), fSeg2[0], fInput->Digits(0));
-      fHitMap[1]  = new AliMUONHitMapA1(fInput->DetElemId(), fSeg2[1], fInput->Digits(1));
-    }
+    fSeg2[0] = fInput->Segmentation2(0);
+    fSeg2[1] = fInput->Segmentation2(1);
+    
+    fHitMap[0]  = new AliMUONHitMapA1(fInput->DetElemId(), fSeg2[0], fInput->Digits(0));
+    fHitMap[1]  = new AliMUONHitMapA1(fInput->DetElemId(), fSeg2[1], fInput->Digits(1));
+    
     AliMUONDigit *dig;
 
     Int_t ndig, cath;
@@ -1667,13 +1479,9 @@ void AliMUONClusterFinderVS::FindRawClusters()
          // tag the beginning of cluster list in a raw cluster
          clus.SetNcluster(0,-1);
          Float_t xcu, ycu;
-         if (fSegmentationType == 1) {
-           fSeg[cath]->GetPadC(padx,pady, xcu, ycu, fZPlane);
-           fSector= fSeg[cath]->Sector(padx,pady)/100;
-         } else {
-           fSeg2[cath]->GetPadC(fInput->DetElemId(), padx, pady, xcu, ycu, fZPlane);
-           fSector= fSeg2[cath]->Sector(fInput->DetElemId(), padx, pady)/100;
-         }
+         fSeg2[cath]->GetPadC(fInput->DetElemId(), padx, pady, xcu, ycu, fZPlane);
+         fSector= fSeg2[cath]->Sector(fInput->DetElemId(), padx, pady)/100;
+         
          
          
          
@@ -1683,19 +1491,13 @@ void AliMUONClusterFinderVS::FindRawClusters()
          if (clus.GetX(0)!=0.) clus.SetX(0, clus.GetX(0)/clus.GetCharge(0)); // clus.fX[0] /= clus.fQ[0];
          
          // Force on anod
-         if (fSegmentationType == 1) 
-           clus.SetX(0,fSeg[0]->GetAnod(clus.GetX(0)));
-         else 
-           clus.SetX(0,fSeg2[0]->GetAnod(fInput->DetElemId(), clus.GetX(0)));
+         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
-         if (fSegmentationType == 1) 
-           clus.SetX(1, fSeg[0]->GetAnod(clus.GetX(1)));
-         else 
-           clus.SetX(1, fSeg2[0]->GetAnod(fInput->DetElemId(),clus.GetX(1)));
+         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);
@@ -1757,26 +1559,15 @@ Float_t AliMUONClusterFinderVS::SingleMathiesonFit(AliMUONRawCluster *c, Int_t c
 // lower and upper limits
     static Double_t lower[2], upper[2];
     Int_t ix,iy, isec;
-    if (fSegmentationType == 1) {
-      fSeg[cath]->GetPadI(c->GetX(cath), c->GetY(cath), fZPlane, ix, iy);
-      isec=fSeg[cath]->Sector(ix, iy);
+    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]-fSeg[cath]->Dpx(isec)/2;
-      lower[1]=vstart[1]-fSeg[cath]->Dpy(isec)/2;
+    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]+fSeg[cath]->Dpx(isec);
-      upper[1]=lower[1]+fSeg[cath]->Dpy(isec);
-
-    } else {
-      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);
     
-      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};
@@ -1831,70 +1622,37 @@ Float_t AliMUONClusterFinderVS::CombiSingleMathiesonFit(AliMUONRawCluster * /*c*
     Int_t ix,iy,isec;
     Float_t dpy, dpx;
 
-    if (fSegmentationType == 1) {
-      fSeg[0]->GetPadI(fXInit[0], fYInit[0], fZPlane, ix, iy);
-      isec=fSeg[0]->Sector(ix, iy);
-      dpy=fSeg[0]->Dpy(isec);
-      fSeg[1]->GetPadI(fXInit[0], fYInit[0], fZPlane, ix, iy);
-      isec=fSeg[1]->Sector(ix, iy);
-      dpx=fSeg[1]->Dpx(isec);
-
-    } else {
-      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);
-
-    }
+    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;
-    if (fSegmentationType == 1) {
-      for (fSeg[1]->FirstPad(fXInit[0], fYInit[0], fZPlane, dpx, 0.); 
-          fSeg[1]->MorePads(); 
-          fSeg[1]->NextPad())
-       {
-         ix=fSeg[1]->Ix(); iy=fSeg[1]->Iy();
-         fSeg[1]->GetPadC(ix,iy, upper[0], ydum, zdum);        
-         if (icount ==0) lower[0]=upper[0];
-         icount++;
-       }
-    } else {
-      for (fSeg2[1]->FirstPad(fInput->DetElemId(),fXInit[0], fYInit[0], fZPlane, dpx, 0.); 
-          fSeg2[1]->MorePads(fInput->DetElemId()); 
-          fSeg2[1]->NextPad(fInput->DetElemId()))
+    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]));
     
-    if (fSegmentationType == 1) {
-      for (fSeg[0]->FirstPad(fXInit[0], fYInit[0], fZPlane, 0., dpy); 
-          fSeg[0]->MorePads(); 
-          fSeg[0]->NextPad())
-       {
-         ix=fSeg[0]->Ix(); iy=fSeg[0]->Iy();
-         fSeg[0]->GetPadC(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]));
-       }
-    } else {
-      for (fSeg2[0]->FirstPad(fInput->DetElemId(), fXInit[0], fYInit[0], fZPlane, 0., dpy); 
-          fSeg2[0]->MorePads(fInput->DetElemId()); 
-          fSeg2[0]->NextPad(fInput->DetElemId()))
+    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);     
@@ -1902,7 +1660,7 @@ Float_t AliMUONClusterFinderVS::CombiSingleMathiesonFit(AliMUONRawCluster * /*c*
          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
@@ -1963,39 +1721,23 @@ Bool_t AliMUONClusterFinderVS::DoubleMathiesonFit(AliMUONRawCluster * /*c*/, Int
     static Float_t lower[5], upper[5];
     Int_t isec;
 
-    if (fSegmentationType == 1) {
-      isec=fSeg[cath]->Sector(fIx[fIndLocal[0][cath]][cath], fIy[fIndLocal[0][cath]][cath]);
-      lower[0]=vstart[0]-fSeg[cath]->Dpx(isec);
-      lower[1]=vstart[1]-fSeg[cath]->Dpy(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.*fSeg[cath]->Dpx(isec);
-      upper[1]=lower[1]+2.*fSeg[cath]->Dpy(isec);
+    upper[0]=lower[0]+2.*fSeg2[cath]->Dpx(fInput->DetElemId(),isec);
+    upper[1]=lower[1]+2.*fSeg2[cath]->Dpy(fInput->DetElemId(),isec);
     
-      isec=fSeg[cath]->Sector(fIx[fIndLocal[1][cath]][cath], fIy[fIndLocal[1][cath]][cath]);
-      lower[2]=vstart[2]-fSeg[cath]->Dpx(isec)/2;
-      lower[3]=vstart[3]-fSeg[cath]->Dpy(isec)/2;
+    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]+fSeg[cath]->Dpx(isec);
-      upper[3]=lower[3]+fSeg[cath]->Dpy(isec);
+    upper[2]=lower[2]+fSeg2[cath]->Dpx(fInput->DetElemId(),isec);
+    upper[1]=lower[1]+2.*fSeg2[cath]->Dpy(fInput->DetElemId(),isec);
 
-    } else {
-      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.;
@@ -2058,16 +1800,7 @@ Float_t AliMUONClusterFinderVS::CombiDoubleMathiesonFit(AliMUONRawCluster * /*c*
     static Float_t lower[6], upper[6];
     Int_t ix,iy,isec;
     Float_t dpx, dpy;
-  if (fSegmentationType == 1) {
-    fSeg[1]->GetPadI(fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg[1]->Sector(ix, iy);
-    dpx=fSeg[1]->Dpx(isec);
 
-    fSeg[0]->GetPadI(fXInit[0], fYInit[0], fZPlane, ix, iy);
-    isec=fSeg[0]->Sector(ix, iy);
-    dpy=fSeg[0]->Dpy(isec);
-
-  } else {
     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);
@@ -2076,165 +1809,87 @@ Float_t AliMUONClusterFinderVS::CombiDoubleMathiesonFit(AliMUONRawCluster * /*c*
     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] ));
 
-    if (fSegmentationType == 1) {
-      //  Find save upper and lower limits    
-      icount = 0;
-    
-      for (fSeg[1]->FirstPad(fXInit[0], fYInit[0], fZPlane, dpx, 0.); 
-          fSeg[1]->MorePads(); 
-          fSeg[1]->NextPad())
-       {
-         ix=fSeg[1]->Ix(); iy=fSeg[1]->Iy();
-         //    if (fHitMap[1]->TestHit(ix, iy) == kEmpty) continue;
-         fSeg[1]->GetPadC(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 (fSeg[0]->FirstPad(fXInit[0], fYInit[0], fZPlane, 0., dpy); 
-          fSeg[0]->MorePads(); 
-          fSeg[0]->NextPad())
-       {
-         ix=fSeg[0]->Ix(); iy=fSeg[0]->Iy();
-         //    if (fHitMap[0]->TestHit(ix, iy) == kEmpty) continue;
-         fSeg[0]->GetPadC(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]);
-
-
-      fSeg[1]->GetPadI(fXInit[1], fYInit[1], fZPlane, ix, iy);
-      isec=fSeg[1]->Sector(ix, iy);
-      dpx=fSeg[1]->Dpx(isec);
-      fSeg[0]->GetPadI(fXInit[1], fYInit[1], fZPlane, ix, iy);
-      isec=fSeg[0]->Sector(ix, iy);
-      dpy=fSeg[0]->Dpy(isec);
-
-
-      //  Find save upper and lower limits    
-
-      icount=0;
-    
-      for (fSeg[1]->FirstPad(fXInit[1], fYInit[1], fZPlane, dpx, 0); 
-          fSeg[1]->MorePads(); fSeg[1]->NextPad())
-       {
-         ix=fSeg[1]->Ix(); iy=fSeg[1]->Iy();
-         //    if (fHitMap[1]->TestHit(ix, iy) == kEmpty) continue;
-         fSeg[1]->GetPadC(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 (fSeg[0]->FirstPad(fXInit[1], fYInit[1], fZPlane, 0, dpy); 
-          fSeg[0]-> MorePads(); fSeg[0]->NextPad())
-       {
-         ix=fSeg[0]->Ix(); iy=fSeg[0]->Iy();
-         //    if (fHitMap[0]->TestHit(ix, iy) != kEmpty) continue;
-       
-         fSeg[0]->GetPadC(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;}    
-    
-      //     vstart[3] = 0.5*(lower[3]+upper[3]);
-    } else {
-
     //  Find save upper and lower limits    
-      icount = 0;
+    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 (fHitMap[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]);
+    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 (fHitMap[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;
+    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 (fHitMap[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++;
-       }
+    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 (fHitMap[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]);
+    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);
+    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    
+    //  Find save upper and lower limits    
 
-      icount=0;
+    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 (fHitMap[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]);
+    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 (fHitMap[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;
+    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 (fHitMap[0]->TestHit(ix, iy) != kEmpty) continue;
+    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 (fHitMap[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++;
+       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;}  
-    }
+      }
+    if (lower[3]>upper[3]) {xdum=lower[3]; lower[3]=upper[3]; upper[3]=xdum;}  
+    
     lower[4]=0.;
     upper[4]=1.;
     lower[5]=0.;
@@ -2307,21 +1962,15 @@ void AliMUONClusterFinderVS::Split(AliMUONRawCluster* c)
            } else {
                cnew.SetCharge(cath, Int_t(clusterInput.TotalCharge(cath)*(1-fQrFit[cath])));
            }
-           if (fSegmentationType == 1) 
-             fSeg[cath]->SetHit(fXFit[j],fYFit[j],fZPlane);
-           else 
-             fSeg2[cath]->SetHit(fInput->DetElemId(), fXFit[j],fYFit[j],fZPlane);
+           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));
-               if (fSegmentationType == 1) {
-                 fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-                 q1 = fInput->Mathieson()->IntXY(fSeg[cath]);
-               } else {
-                 fSeg2[cath]->SetPad(fInput->DetElemId(),fIx[i][cath], fIy[i][cath]);
-                 q1 = fInput->Mathieson()->IntXY(fInput->DetElemId(),fSeg2[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 );
            }
index 9b2c56a..1a0e141 100644 (file)
@@ -71,7 +71,6 @@ class AliMUONClusterFinderVS : public TObject
 
     AliMUONClusterInput*          fInput;              // ! AliMUONClusterInput instance
     AliMUONHitMapA1*              fHitMap[2];          // Hit Maps for cathode 1 and 2
-    AliSegmentation*              fSeg[2];             // Segmentations for cathode 1 and 2
     AliMUONGeometrySegmentation*  fSeg2[2];            // New Segmentations for cathode 1 and 2
 
     
@@ -115,7 +114,6 @@ class AliMUONClusterFinderVS : public TObject
     Int_t                    fTrack[2];        // Only digits with main contributions from these tracks are
     // considered 
     Int_t                    fDebugLevel;      // prinout control
-    Int_t                    fSegmentationType;// new seg
     
     //  Return pointer to raw clusters    
     ClassDef(AliMUONClusterFinderVS,2) //Class for clustering and reconstruction of space points
index ab82979..573b1ba 100644 (file)
@@ -38,14 +38,12 @@ AliMUONClusterInput::AliMUONClusterInput()
   : TObject(),
     fCluster(0),
     fChargeCorrel(1.),
-    fSegmentationType(1),
+    fSegmentationType(2),
     fDetElemId(0)
   
 {
   fDigits[0]=0;
   fDigits[1]=0;
-  fSegmentation[0]=0;
-  fSegmentation[1]=0;
   fSegmentation2[0]=0;
   fSegmentation2[1]=0;
 }
@@ -75,60 +73,6 @@ AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput
   AliFatal("Not implemented.");
 }
 
-void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
-{
-// Set pointer to digits with corresponding segmentations and responses (two cathode planes)
-    fChamber=chamber;
-    fDigits[0]=dig1;
-    fDigits[1]=dig2; 
-    fNDigits[0]=dig1->GetEntriesFast();
-    fNDigits[1]=dig2->GetEntriesFast();
-    
-    AliMUON *pMUON;
-    AliMUONChamber* iChamber;
-
-    pMUON = (AliMUON*) gAlice->GetModule("MUON");
-    if ((fSegmentationType = pMUON->WhichSegmentation()) != 1)
-      AliFatal("Wrong segmentation type");
-
-    iChamber =  &(pMUON->Chamber(chamber));
-    fgMathieson = new AliMUONMathieson();
-
-    fSegmentation[0]=iChamber->SegmentationModel(1);
-    fSegmentation[1]=iChamber->SegmentationModel(2);
-
-    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, TClonesArray* dig)
-{
-// Set pointer to digits with corresponding segmentations and responses (one cathode plane)
-    fDigits[0]=dig;
-    AliMUON *pMUON;
-    AliMUONChamber* iChamber;
-
-    pMUON = (AliMUON*) gAlice->GetModule("MUON");
-    if ((fSegmentationType = pMUON->WhichSegmentation()) != 1)
-      AliFatal("Wrong segmentation type");
-
-    iChamber =  &(pMUON->Chamber(chamber));
-    fSegmentation[0]=iChamber->SegmentationModel(1);
-
-    fNseg=1;
-}
 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)
@@ -221,10 +165,7 @@ void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
            qtot+=fCharge[i][cath];
            // Current z
            Float_t xc, yc;
-           if (fSegmentationType == 1)
-             fSegmentation[cath]->GetPadC(ix,iy,xc,yc,fZ);
-           else 
-             fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
+           fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
        } // loop over cluster digits
        fQtot[cath]=qtot;
        fChargeTot[cath]=Int_t(qtot);  
@@ -245,21 +186,11 @@ Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cat
 // par[1]    y-position of cluster
 
     Float_t q1;
-    if (fSegmentationType == 1) {
-
-      fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
-      //  First Cluster
-      fSegmentation[cath]->SetHit(par[0],par[1],fZ);
-      q1 = fgMathieson->IntXY(fSegmentation[cath]);
-
-    } else {
-
-      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]);
-   }
-    
+    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;
 }
@@ -276,29 +207,15 @@ Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
 
   Float_t q1, q2;
   
-  if (fSegmentationType == 1) {
-
-    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
-    //  First Cluster
-    fSegmentation[0]->SetHit(par[0],par[1],fZ);
-    q1 = fgMathieson->IntXY(fSegmentation[0]);
-    
-    //  Second Cluster
-    fSegmentation[0]->SetHit(par[2],par[3],fZ);
-    q2 = fgMathieson->IntXY(fSegmentation[0]);
-
-  } else {
-
-    fSegmentation2[0]->SetPad(fDetElemId, fix[i][0], fiy[i][0]);
-    //  First Cluster
-    fSegmentation2[0]->SetHit(fDetElemId, par[0],par[1],fZ);
-    q1 = fgMathieson->IntXY(fSegmentation[0]);
-    
-    //  Second Cluster
-    fSegmentation2[0]->SetHit(fDetElemId,par[2],par[3],fZ);
-    q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
-  }
-
+  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;
 }
@@ -315,27 +232,15 @@ Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cat
 
   Float_t q1, q2;
 
-  if (fSegmentationType == 1) {
-
-    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
-    //  First Cluster
-    fSegmentation[cath]->SetHit(par[0],par[1],fZ);
-    q1 = fgMathieson->IntXY(fSegmentation[cath]);
-    
-    //  Second Cluster
-    fSegmentation[cath]->SetHit(par[2],par[3],fZ);
-    q2 = fgMathieson->IntXY(fSegmentation[cath]);
-
-  } else {
-    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]);
-  }
+  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);
index 16b41ab..bff42fa 100644 (file)
@@ -23,8 +23,6 @@ class AliMUONClusterInput : public TObject
     virtual ~AliMUONClusterInput();
     static AliMUONClusterInput* Instance();
 //  Configuration
-    void SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2);
-    void SetDigits(Int_t chamber, TClonesArray* dig);
     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);
@@ -33,7 +31,6 @@ class AliMUONClusterInput : public TObject
     AliMUONDigit* Digit(Int_t cath, Int_t i) const {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
     TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
     Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
-    AliSegmentation* Segmentation(Int_t cath) const {return fSegmentation[cath];}
     AliMUONGeometrySegmentation* Segmentation2(Int_t cath) const {return fSegmentation2[cath];}
 
     AliMUONMathieson* Mathieson() const {return fgMathieson;}    
@@ -66,7 +63,6 @@ class AliMUONClusterInput : public TObject
     // Digits
     TClonesArray*        fDigits[2];       // ! Array of pointers to digits
     Int_t                fNDigits[2];      // ! Number of digits
-    AliSegmentation*     fSegmentation[2]; // ! Segmentation per cathode
     AliMUONGeometrySegmentation*     fSegmentation2[2]; // ! Geometry Segmentation per cathode
 
     Int_t                fNseg;            // ! number of cathode planes
index 59bc2bc..ef444b0 100644 (file)
@@ -108,79 +108,6 @@ AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
 //____________________________________________________________________
 void AliMUONClusterReconstructor::Digits2Clusters()
 {
-//
-//  Perform cluster finding
-//
-
-    AliMUON* pMUON = (AliMUON*) gAlice->GetModule("MUON");
-    if (pMUON->WhichSegmentation() == 1)
-      Digits2ClustersOld();
-    else
-      Digits2ClustersNew();
-
-}
-//____________________________________________________________________
-void AliMUONClusterReconstructor::Digits2ClustersOld()
-{
-
-//
-//  Perform cluster finding
-//
-    TClonesArray *dig1, *dig2;
-    Int_t ndig, k;
-    dig1 = new TClonesArray("AliMUONDigit",1000);
-    dig2 = new TClonesArray("AliMUONDigit",1000);
-    AliMUONDigit *digit;
-
-// Loop on chambers and on cathode planes     
-    TClonesArray * muonDigits;
-
-    for (Int_t ich = 0; ich < 10; ich++) {
-
-        fMUONData->ResetDigits();
-        fMUONData->GetCathode(0);
-        //TClonesArray *
-        muonDigits = fMUONData->Digits(ich); 
-        ndig=muonDigits->GetEntriesFast();
-        AliDebug(1,Form("1 Found %d digits in %p chamber %d", ndig, (void*)muonDigits,ich));
-        TClonesArray &lhits1 = *dig1;
-        Int_t n = 0;
-        for (k = 0; k < ndig; k++) {
-            digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           new(lhits1[n++]) AliMUONDigit(*digit);
-        }
-        fMUONData->ResetDigits();
-        fMUONData->GetCathode(1);
-        muonDigits =  fMUONData->Digits(ich);  
-        ndig=muonDigits->GetEntriesFast();
-        AliDebug(1,Form("2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich));
-        TClonesArray &lhits2 = *dig2;
-        n=0;
-        
-        for (k=0; k<ndig; k++) {
-            digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           new(lhits2[n++]) AliMUONDigit(*digit);
-        }
-
-        if (fRecModel) {         
-            AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
-            fRecModel->FindRawClusters();
-        }
-        // copy into the container
-        TClonesArray* tmp = fRecModel->GetRawClusters();
-        for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
-          AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
-          fMUONData->AddRawCluster(ich, *pClus);
-        }
-        dig1->Delete();
-        dig2->Delete();
-    } // for ich
-    delete dig1;
-    delete dig2;
-}
-//____________________________________________________________________
-void AliMUONClusterReconstructor::Digits2ClustersNew()
-{
 
     TClonesArray *dig1, *dig2, *digAll;
     Int_t ndig, k, idDE, idDE_prev;
index 825dd74..cd93836 100644 (file)
@@ -30,9 +30,6 @@ class AliMUONClusterReconstructor : public TObject
     
   // Cluster Finding & Trigger
   virtual void   Digits2Clusters();
-  virtual void   Digits2ClustersOld();
-  virtual void   Digits2ClustersNew();
-
   virtual void   Digits2Clusters(AliRawReader* rawReader);
   virtual void   Trigger2Trigger() ;
   virtual void   Trigger2Trigger(AliRawReader* rawReader);
index c48ecb3..81e6179 100644 (file)
@@ -120,13 +120,12 @@ AliMUONDigitizer::operator=(const AliMUONDigitizer& rhs)
 }    
 
 //------------------------------------------------------------------------
-Int_t AliMUONDigitizer::GetSegmentation()
+void AliMUONDigitizer::CheckSegmentation()
 {
-  if (!fMUON->WhichSegmentation()) {
-      AliFatal("No Segmentation Type defined.");
-      return kFALSE;
-  } else 
-    return fMUON->WhichSegmentation();
+  if (fMUON->WhichSegmentation()==1) {
+      AliFatal("Old Segmentation no more supported.");
+      return;
+  }
 
 }
          
@@ -328,10 +327,7 @@ void AliMUONDigitizer::AddDigit(
        digits[3] = responseCharge;
        digits[4] = td->Physics();
        digits[5] = td->Hit();
-       if (GetSegmentation() == 1)
-         digits[6] = 0;
-       else
-         digits[6] =  td->DetElemId();
+       digits[6] =  td->DetElemId();
 
        Int_t nptracks = td->GetNTracks();
        if (nptracks > kMAXTRACKS) {
@@ -505,39 +501,26 @@ void AliMUONDigitizer::InitArrays()
     // Array of pointer of the AliMUONHitMapA1:
     //  two HitMaps per chamber, or one HitMap per cahtode plane
     fHitMap = new AliMUONHitMapA1* [2*AliMUONConstants::NCh()];
+    CheckSegmentation(); // check it one for all
+
+    for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
+
+      Int_t idDE = 100*(i+1);// central DE = max # of pads ?
+      if (i == 4 || i == 5) //St3
+       idDE += 4;
 
-    if (fMUON->WhichSegmentation() == 1) {
-      // Loop over chambers for the definition AliMUONHitMap
-      for (Int_t i = 0; i < AliMUONConstants::NCh(); i++)  {
-
-       AliDebug(4,Form( "Creating hit map for chamber %d, cathode 1.", i+1));
-       AliMUONChamber* chamber = &(fMUON->Chamber(i));
-       AliSegmentation* c1Segmentation = chamber->SegmentationModel(1); // Cathode plane 1
-       fHitMap[i] = new AliMUONHitMapA1(c1Segmentation, fTDList);
-       AliDebug(4,Form( "Creating hit map for chamber %d, cathode 2.", i+1));
-       AliSegmentation* c2Segmentation = chamber->SegmentationModel(2); // Cathode plane 2
-       fHitMap[i+AliMUONConstants::NCh()] = new AliMUONHitMapA1(c2Segmentation, fTDList);
-      }
-
-    } else {
-      for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
-
-       Int_t idDE = 100*(i+1);// central DE = max # of pads ?
-       if (i == 4 || i == 5) //St3
-         idDE += 4;
-
-       if (i > 5)
-         idDE += 5;// DE for max # of pads in St45 and Trigger Station
-
-       AliDebug(4,Form( "Creating hit map for chamber %d, cathode 1.", i+1));
-       AliMUONChamber* chamber = &(fMUON->Chamber(i));
-       AliMUONGeometrySegmentation* c1Segmentation = chamber->SegmentationModel2(1); // Cathode plane 1
-       fHitMap[i] = new AliMUONHitMapA1(idDE,c1Segmentation, fTDList); 
-       AliDebug(4,Form( "Creating hit map for chamber %d, cathode 2.", i+1));
-       AliMUONGeometrySegmentation* c2Segmentation = chamber->SegmentationModel2(2); // Cathode plane 2
-       fHitMap[i+AliMUONConstants::NCh()] = new AliMUONHitMapA1(idDE,c2Segmentation, fTDList);
-      }
+      if (i > 5)
+       idDE += 5;// DE for max # of pads in St45 and Trigger Station
+
+      AliDebug(4,Form( "Creating hit map for chamber %d, cathode 1.", i+1));
+      AliMUONChamber* chamber = &(fMUON->Chamber(i));
+      AliMUONGeometrySegmentation* c1Segmentation = chamber->SegmentationModel2(1); // Cathode plane 1
+      fHitMap[i] = new AliMUONHitMapA1(idDE,c1Segmentation, fTDList); 
+      AliDebug(4,Form( "Creating hit map for chamber %d, cathode 2.", i+1));
+      AliMUONGeometrySegmentation* c2Segmentation = chamber->SegmentationModel2(2); // Cathode plane 2
+      fHitMap[i+AliMUONConstants::NCh()] = new AliMUONHitMapA1(idDE,c2Segmentation, fTDList);
     }
+    
 }
 //------------------------------------------------------------------------
 void AliMUONDigitizer::CleanupArrays()
index 627784c..4c2d388 100644 (file)
@@ -175,7 +175,7 @@ protected:
                        Int_t charges[kMAXTRACKS], Int_t digits[6],
                        const Int_t digitindex
                ) = 0;
-       virtual Int_t GetSegmentation();
+       virtual void CheckSegmentation();
 
        AliRunLoader* fRunLoader;         //! Global run loader.
        AliMUONLoader* fGime;             //! MUON specific loader.
index b19d612..47f4f75 100644 (file)
@@ -114,10 +114,7 @@ void AliMUONDigitizerv2::MakeTransientDigitFromSDigit(Int_t iChamber, AliMUONDig
                digits[4] = 0;
                
        digits[5] = sDigit->Hit();    // Hit number in the list
-       if (GetSegmentation() == 1)
-         digits[6] = 0;
-       else
-         digits[6] = sDigit->DetElemId();
+       digits[6] = sDigit->DetElemId();
 
        AliDebug(5,Form("Made digit from sDigit 0x%X: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d\tidDE %d",
                        (void*)sDigit, digits[0], digits[1], digits[2], digits[3], digits[5], digits[6]));
index fa8dc5d..f65c1af 100644 (file)
@@ -55,7 +55,6 @@
 #include "AliMUONTrackParam.h"
 
 #include "AliMUONGeometrySegmentation.h"
-#include "AliSegmentation.h"
 #include "AliMUONChamber.h"
 #include "AliMUONConstants.h"
 #include "AliMC.h"
@@ -546,65 +545,66 @@ void AliMUONDisplay::PrintKinematics()
 
 void AliMUONDisplay::DrawSegmentation()
 {
+  // to be re-written for new seg
 // Draw graphical representation of segmenatation
 // Attention: still experimental code
-    Int_t icat=1;
+//     Int_t icat=1;
     
-    AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-    AliMUONChamber*   iChamber;
+//     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
+//     AliMUONChamber*   iChamber;
 
-    AliSegmentation*  seg;
-    iChamber = &(pMUON->Chamber(fChamber));
-    seg=iChamber->SegmentationModel(icat);
+//     AliSegmentation*  seg;
+//     iChamber = &(pMUON->Chamber(fChamber));
+//     seg=iChamber->SegmentationModel(icat);
 
-    Float_t zpos=iChamber->Z();
-    Float_t r=iChamber->ROuter();
+//     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);
+//     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;
+//         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();
-           }
-       }
-    }
-}
+//             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()
@@ -922,7 +922,6 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     
     AliMUON *pMUON  =     (AliMUON*)gAlice->GetModule("MUON");
     AliMUONChamber*       iChamber;
-    AliSegmentation*      segmentation = 0x0;
     AliMUONGeometrySegmentation*  segmentation2 = 0x0;
 
     GetMUONData()->SetTreeAddress("D");
@@ -945,10 +944,7 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     
     iChamber = &(pMUON->Chamber(chamber-1));
 
-    if (pMUON->WhichSegmentation()==1) 
-      segmentation = iChamber->SegmentationModel(cathode);
-    else
-      segmentation2 = iChamber->SegmentationModel2(cathode);
+    segmentation2 = iChamber->SegmentationModel2(cathode);
 
     Float_t zpos = iChamber->Z();
 
@@ -994,18 +990,12 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
        Int_t isec;
        Float_t dpx, dpy;
 
-       if (pMUON->WhichSegmentation()==1) {
-         segmentation->GetPadC(mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
-         isec = segmentation->Sector(mdig->PadX(), mdig->PadY());
-         dpx = segmentation->Dpx(isec)/2;
-         dpy = segmentation->Dpy(isec)/2;
-       } else {
-         Int_t detElemId = mdig->DetElemId();
-         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;
-       }
+       Int_t detElemId = mdig->DetElemId();
+       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;
+       
 //
 //     segmentation->Dump();
        
index a4a3941..1a39a6d 100644 (file)
@@ -21,7 +21,6 @@
 
 #include "AliMUONFactoryV2.h"
 #include "AliRun.h"
-#include "AliSegmentation.h"
 #include "AliLog.h"
 
 #include "AliMUON.h"
@@ -42,7 +41,7 @@ ClassImp(AliMUONFactoryV2)
 
 //__________________________________________________________________________
   AliMUONFactoryV2::AliMUONFactoryV2(const char* name)
-    : AliMUONFactory(name),
+    : TNamed(name, ""),
       fMUON(0),
       fResponse0(0),
       fDESegmentations(0)
@@ -56,7 +55,7 @@ ClassImp(AliMUONFactoryV2)
 
 //__________________________________________________________________________
   AliMUONFactoryV2::AliMUONFactoryV2()
-    : AliMUONFactory(),
+    : TNamed(),
       fMUON(0),
       fResponse0(0),
       fDESegmentations(0)
@@ -66,7 +65,7 @@ ClassImp(AliMUONFactoryV2)
 
 //__________________________________________________________________________
 AliMUONFactoryV2::AliMUONFactoryV2(const AliMUONFactoryV2& rhs)
-  : AliMUONFactory(rhs)
+ : TNamed(rhs)
 {
   // Protected copy constructor
 
index 5dadce9..9da6437 100644 (file)
@@ -9,18 +9,16 @@
 ////////////////////////////////////////////////////////////
 //  Factory for muon chambers, segmentations and response 
 //  The number 2 is refering to new segmentation
-//  For the moment derive from AliMUONFactory
-//  only for used of switching from standart to V2 version 
-//  in AliMUONv1
+//
 ////////////////////////////////////////////////////////////
 
 #include <TObject.h>
-#include "AliMUONFactory.h"
+#include <TNamed.h>
 
 class AliMUON;
 class AliMUONResponseV0;
 
-class AliMUONFactoryV2 : public  AliMUONFactory {
+class AliMUONFactoryV2 : public  TNamed {
 
   public:
     AliMUONFactoryV2(const char* name);
index ab5b63f..696085b 100644 (file)
@@ -101,10 +101,8 @@ void AliMUONSDigitizerv1::GenerateTransientDigits()
                        {
                                // Tracking Chamber
                                // Initialize hit position (cursor) in the segmentation model 
-                         if (GetSegmentation() == 1) // old segmentation
-                           chamber.SigGenInit(mHit->X(), mHit->Y(), mHit->Z());
-                         else 
-                           chamber.SigGenInit(mHit);
+                         
+                         chamber.SigGenInit(mHit);
 
                        } // else do nothing for Trigger Chambers
                        
@@ -132,10 +130,8 @@ void AliMUONSDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, Al
        Int_t nnew=0;              // Number of touched Pads per hit
        Int_t ichamber = mHit->Chamber()-1;
        AliMUONChamber& chamber = fMUON->Chamber(ichamber);
-       if (GetSegmentation() == 1)
-         chamber.DisIntegration(mHit->Eloss(), mHit->Age(), mHit->X(), mHit->Y(), mHit->Z(), nnew, newdigit);
-       else
-         chamber.DisIntegration(mHit, nnew, newdigit);
+
+       chamber.DisIntegration(mHit, nnew, newdigit);
 
        // Creating new TransientDigits from hit
        for(Int_t iTD = 0; iTD < nnew; iTD++) 
@@ -158,10 +154,7 @@ void AliMUONSDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, Al
                        digits[4] = 0;    // No signal due to physics since this is now background.
                }
                digits[5] = iHit+fMask;    // Hit number in the list
-               if (GetSegmentation() == 1)
-                 digits[6] = 0;
-               else
-                 digits[6] =  mHit->DetElemId();
+               digits[6] =  mHit->DetElemId();
 
                AliDebug(5,Form("MakeTransientDigitsFromHit", 
                                "DisIntegration result %d: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d\tidDE %d",
index f253528..044e94d 100644 (file)
@@ -844,57 +844,6 @@ void  AliMUONTest::DetElemTransforms()
   }
 }       
 
-//________________________________________________________________________
-void AliMUONTest::PrintPadPositionsOld()
-{
-// Iterate over all old chamber segmentations and prints
-// global pad positions
-
-  AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
-  if (!muon) {
-    AliFatal("MUON detector not defined.");
-    return;
-  }  
-
-  // Loop over chambers
-  for (Int_t i=0; i<1; i++) {
-
-    // Create chamber segmentations
-    AliSegmentation* seg[2];
-    seg[0] = muon->Chamber(i).SegmentationModel(0);
-    seg[1] = muon->Chamber(i).SegmentationModel(1);
-
-    // Iterate over the whole plane and return pad indices and 
-    // global/local positions
-    cout << "Go to loop over pads" << endl;
-    for (Int_t cath=0; cath<2; cath++) {
-      
-      cout << setw(6) << "Pads in chamber " << i << " cathod " << cath << endl;
-      cout << "===================================" << endl;  
-      TStopwatch timer;
-      timer.Start();  
-
-      Int_t counter = 0;
-      for ( seg[cath]->FirstPad(70., 70., 0., 80., 80.);
-            seg[cath]->MorePads(); 
-            seg[cath]->NextPad() )
-      {
-        cout << setw(6) << "counter " << counter++ << "   ";
-  
-        Int_t ix = seg[cath]->Ix();
-        Int_t iy = seg[cath]->Iy();
-        cout << "Pad indices:  ( " << ix << ", " << iy << " )  " ;
-
-        Float_t x, y, z;
-        seg[cath]->GetPadC(ix, iy, x, y, z);
-        cout << "Pad position: ( " << x << ", " << y << ", " << z << " )" << endl;
-      }
-      timer.Stop();
-      timer.Print();
-    }  
-  }  
-}
-
 //______________________________________________________________________________
 void AliMUONTest::ForWhole(AliMUONTests testCase)
 {
index 6968ce5..f0ba662 100644 (file)
@@ -36,8 +36,6 @@ class AliMUONTest : public  TObject
     // other tests
     //
     void DetElemTransforms();
-    void PrintPadPositionsOld();
-
 
     // selected tests
     //                                                   
index 6b0d737..1dd652e 100644 (file)
@@ -21,7 +21,6 @@
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONTriggerConstants.h"
-#include "AliSegmentation.h"
 #include "AliMUONGeometrySegmentation.h"
 #include "AliMUONChamber.h"
 #include "AliMUONConstants.h"
@@ -84,13 +83,12 @@ void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
   LoadXCode();
   LoadYCode();
 
-  if (pMUON->WhichSegmentation() == 1) {
-    LoadXPos();
-    LoadYPos();
-  } else {
-    LoadXPos2();
-    LoadYPos2();
-  }
+  if (pMUON->WhichSegmentation() == 1) 
+      AliFatal("Old Segmentation no more supported.");
+
+  LoadXPos2();
+  LoadYPos2();
+  
 }
 
 //----------------------------------------------------------------------
@@ -290,101 +288,6 @@ void AliMUONTriggerCircuit::LoadYCode(){
 }
 
 //----------------------------------------------------------------------
-void AliMUONTriggerCircuit::LoadYPos(){
-// fill fYpos11 and fYpos21 -> y position of X declusterized strips
-
-  Int_t chamber, cathode;
-  Int_t code, idModule, idStrip, idSector;
-  Float_t x, y, z, width;
-  Int_t istrip;
-
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
-  AliMUONChamber*  iChamber;
-  AliSegmentation*  segmentation;    
-
-// first plane (11)
-  chamber=11;
-  cathode=1;
-  iChamber = &(pMUON->Chamber(chamber-1));
-  segmentation=iChamber->SegmentationModel(cathode);
-  
-  for (istrip=0; istrip<16; istrip++) {
-    code=fXcode[0][istrip];           // decode current strip
-    idModule=Int_t(code/100);           // corresponding module Id.
-    idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
-    idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
-    width=segmentation->Dpy(idSector);      // corresponding strip width
-    segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
-    
-    fYpos11[2*istrip]=y;
-    if (istrip!=15) fYpos11[2*istrip+1]=y+width/2.;
-  }   
-   
-// second plane (21)
-  chamber=13;
-  cathode=1;
-  iChamber = &(pMUON->Chamber(chamber-1));
-  segmentation=iChamber->SegmentationModel(cathode);
-  
-  for (istrip=0; istrip<32; istrip++) {
-    code=fXcode[2][istrip];    // decode current strip
-    idModule=Int_t(code/100);           // corresponding module Id.
-    idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
-    idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
-    width=segmentation->Dpy(idSector);      // corresponding strip width
-    segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
-    
-// using idModule!=0 prevents to fill garbage in case of circuits 
-// in the first and last rows 
-    if (idModule!=0) { 
-      fYpos21[2*istrip]=y;
-      if (istrip!=31) fYpos21[2*istrip+1]=y+width/2.;
-    }
-  }   
-}
-
-//----------------------------------------------------------------------
-void AliMUONTriggerCircuit::LoadXPos(){
-// fill fXpos11 -> x position of Y strips for the first plane only
-// fXpos11 contains the x position of Y strip for the current circuit
-// taking into account whether or nor not part(s) of the circuit
-// (middle, up or down) has(have) 16 strips
-  
-  Float_t x, y, z;
-  Int_t istrip;  
-
-  Int_t chamber=11;
-  Int_t cathode=2;
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
-  AliMUONChamber*  iChamber;
-  AliSegmentation*  segmentation; 
-  iChamber = &(pMUON->Chamber(chamber-1));
-  segmentation=iChamber->SegmentationModel(cathode);
-  
-  Int_t idModule=Module(fIdCircuit);        // corresponding module Id.  
-// number of Y strips
-  Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule)); 
-  Int_t idSector=segmentation->Sector(idModule,0); // corresp. sector
-  Float_t width=segmentation->Dpx(idSector);      // corresponding strip width
-  
-// first case : up middle and down parts have all 8 or 16 strip 
-  if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) { 
-    for (istrip=0; istrip<nStrY; istrip++) {
-      segmentation->GetPadC(idModule,istrip,x,y,z); 
-      fXpos11[istrip]=x;
-    }
-// second case : mixing 8 and 16 strips within same circuit      
-  } else {
-    for (istrip=0; istrip<nStrY; istrip++) {
-      if (nStrY!=8) { printf(" bug in LoadXpos \n");}
-      segmentation->GetPadC(idModule,istrip,x,y,z); 
-      fXpos11[2*istrip]=x-width/4.;
-      fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
-    }
-  }   
-}
-
-//----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
 // returns calculated pt for circuit/istripX/idev/istripY according 
 // to the formula of the TRD. Note : idev (input) is in [0+30]
index 5f38dfe..905b7b8 100644 (file)
@@ -60,8 +60,6 @@ class AliMUONTriggerCircuit : public TObject
   void LoadX2();
   void LoadXCode();
   void LoadYCode();
-  void LoadYPos();
-  void LoadXPos();
   void LoadYPos2();
   void LoadXPos2();
    
index 75c06e5..8848896 100644 (file)
@@ -177,8 +177,7 @@ void AliMUONv1::Init()
    AliDebug(1,"Finished Init for version 1 - CPC chamber type");   
 
    if (fSegmentationType == 1) {
-     fFactory = new AliMUONFactory("Old MUON Factory");
-     printf("\n Old Segmentation \n\n");
+     AliFatal("Old Segmentation no more supported");
    }
 
    if (fSegmentationType == 2) {
@@ -196,15 +195,9 @@ void AliMUONv1::Init()
      return;
    }
 
-   if (fSegmentationType == 1) {
    for (i=0; i<AliMUONConstants::NCh(); i++) 
-       ( (AliMUONChamber*) (*fChambers)[i])->Init();
-   }
-
-   if (fSegmentationType == 2) {
-     for (i=0; i<AliMUONConstants::NCh(); i++) 
-       ( (AliMUONChamber*) (*fChambers)[i])->Init(fSegmentationType);// new segmentation
-   }
+     ( (AliMUONChamber*) (*fChambers)[i])->Init(fSegmentationType);// new segmentation
+   
  
    // trigger circuit
    // cp 
@@ -271,10 +264,6 @@ void AliMUONv1::StepManager()
     return;
   }
 
- if (fStepManagerVersionOld) {
-    StepManagerOld();
-    return;
-  }
 
   // Only charged tracks
   if( !(gMC->TrackCharge()) ) return; 
@@ -433,11 +422,6 @@ void AliMUONv1::StepManager2()
 {
   // Stepmanager for the chambers
 
- if (fStepManagerVersionOld) {
-    StepManagerOld2();
-    return;
-  }
-
   // Only charged tracks
   if( !(gMC->TrackCharge()) ) return; 
   // Only charged tracks
@@ -589,400 +573,3 @@ void AliMUONv1::StepManager2()
     fDestepSum[idvol]=0; // Reset for the next event
   }
 }
-
-//__________________________________________
-void AliMUONv1::StepManagerOld()
-{
-  // Old Stepmanager for the chambers
-  // TBR
-  
-  Int_t          copy, id;
-  static Int_t   idvol =-1;
-  static Int_t   vol[2];
-  Int_t          ipart;
-  TLorentzVector pos;
-  TLorentzVector mom;
-  Float_t        theta,phi;
-  Float_t        destep, step;
-  
-  static Float_t sstep;
-  static Float_t eloss, eloss2, xhit, yhit, zhit, tof, tlength;
-  const  Float_t kBig = 1.e10;
-  static Float_t hits[15];
-
-  TClonesArray &lhits = *fHits;
-
-  //
-  //
-  // Only charged tracks
-  if( !(gMC->TrackCharge()) ) return; 
-  //
-  // Only gas gap inside chamber
-  // Tag chambers and record hits when track enters 
-  id=gMC->CurrentVolID(copy);
-  vol[0] = GetChamberId(id);
-  idvol = vol[0] -1;
-
-  if (idvol == -1) return;
-
-  //
-  // Get current particle id (ipart), track position (pos)  and momentum (mom) 
-  gMC->TrackPosition(pos);
-  gMC->TrackMomentum(mom);
-
-  ipart  = gMC->TrackPid();
-
-  //
-  // momentum loss and steplength in last step
-  destep = gMC->Edep();
-  step   = gMC->TrackStep();
-  // cout<<"------------"<<step<<endl;
-  //
-  // record hits when track enters ...
-  if( gMC->IsTrackEntering()) {
-
-      gMC->SetMaxStep(fMaxStepGas);
-      Double_t tc = mom[0]*mom[0]+mom[1]*mom[1];
-      Double_t rt = TMath::Sqrt(tc);
-      Double_t pmom = TMath::Sqrt(tc+mom[2]*mom[2]);
-      Double_t tx = mom[0]/pmom;
-      Double_t ty = mom[1]/pmom;
-      Double_t tz = mom[2]/pmom;
-      Double_t s  = ((AliMUONChamber*)(*fChambers)[idvol])
-          ->ResponseModel()
-          ->Pitch()/tz;
-      theta   = Float_t(TMath::ATan2(rt,Double_t(mom[2])))*kRaddeg;
-      phi     = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
-      hits[0] = Float_t(ipart);         // Geant3 particle type
-      hits[1] = pos[0]+s*tx;            // X-position for hit
-      hits[2] = pos[1]+s*ty;            // Y-position for hit
-      hits[3] = pos[2]+s*tz;            // Z-position for hit
-      hits[4] = theta;                  // theta angle of incidence
-      hits[5] = phi;                    // phi angle of incidence 
-      hits[8] = 0;//PadHits does not exist anymore  (Float_t) fNPadHits;    // first padhit
-      hits[9] = -1;                     // last pad hit
-      hits[10] = mom[3];                // hit momentum P
-      hits[11] = mom[0];                // Px
-      hits[12] = mom[1];                // Py
-      hits[13] = mom[2];                // Pz
-      tof=gMC->TrackTime();
-      hits[14] = tof;                   // Time of flight
-      tlength  = 0;
-      eloss    = 0;
-      eloss2   = 0;
-      sstep=0;
-      xhit     = pos[0];
-      yhit     = pos[1];      
-      zhit     = pos[2];      
-      Chamber(idvol).ChargeCorrelationInit();
-      // Only if not trigger chamber
-
-//       printf("---------------------------\n");
-//       printf(">>>> Y =  %f \n",hits[2]);
-//       printf("---------------------------\n");
-    
-      
-
-     //  if(idvol < AliMUONConstants::NTrackingCh()) {
-//        //
-//        //  Initialize hit position (cursor) in the segmentation model 
-//        ((AliMUONChamber*) (*fChambers)[idvol])
-//            ->SigGenInit(pos[0], pos[1], pos[2]);
-//       } else {
-//        //geant3->Gpcxyz();
-//        //printf("In the Trigger Chamber #%d\n",idvol-9);
-//       }
-  }
-  eloss2+=destep;
-  sstep+=step;
-
-  // cout<<sstep<<endl;
-
-  // 
-  // Calculate the charge induced on a pad (disintegration) in case 
-  //
-  // Mip left chamber ...
-  if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
-      gMC->SetMaxStep(kBig);
-      eloss   += destep;
-      tlength += step;
-      
-      Float_t x0,y0,z0;
-      Float_t localPos[3];
-      Float_t globalPos[3] = {pos[0], pos[1], pos[2]};
-      gMC->Gmtod(globalPos,localPos,1); 
-
-      if(idvol < AliMUONConstants::NTrackingCh()) {
-// tracking chambers
-          x0 = 0.5*(xhit+pos[0]);
-          y0 = 0.5*(yhit+pos[1]);
-          z0 = 0.5*(zhit+pos[2]);
-      } else {
-// trigger chambers
-          x0 = xhit;
-          y0 = yhit;
-          z0 = 0.;
-      }
-      
-
-      //      if (eloss >0)  MakePadHits(x0,y0,z0,eloss,tof,idvol);
-      
-          
-      hits[6] = tlength;   // track length
-      hits[7] = eloss2;    // de/dx energy loss
-
-
-      //      if (fNPadHits > (Int_t)hits[8]) {
-      //          hits[8] = hits[8]+1;
-      //          hits[9] = 0: // PadHits does not exist anymore (Float_t) fNPadHits;
-      //}
-//
-//    new hit 
-      
-      new(lhits[fNhits++]) 
-       AliMUONHit(fIshunt, gAlice->GetMCApp()->GetCurrentTrackNumber(), vol, hits, kTRUE);
-      eloss = 0; 
-      //
-      // Check additional signal generation conditions 
-      // defined by the segmentation
-      // model (boundary crossing conditions)
-      // only for tracking chambers
-  } else if 
-      ((idvol < AliMUONConstants::NTrackingCh()) &&
-       ((AliMUONChamber*) (*fChambers)[idvol])->SigGenCond(pos[0], pos[1], pos[2]))
-  {
-      ((AliMUONChamber*) (*fChambers)[idvol])
-          ->SigGenInit(pos[0], pos[1], pos[2]);
-      
-      Float_t localPos[3];
-      Float_t globalPos[3] = {pos[0], pos[1], pos[2]};
-      gMC->Gmtod(globalPos,localPos,1); 
-
-      eloss    += destep;
-
-      // if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
-      //        MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
-      xhit     = pos[0];
-      yhit     = pos[1]; 
-      zhit     = pos[2];
-      eloss = 0;
-      tlength += step ;
-      //
-      // nothing special  happened, add up energy loss
-  } else {        
-      eloss   += destep;
-      tlength += step ;
-  }
-}
-
-//__________________________________________
-void AliMUONv1::StepManagerOld2()
-{
-  // Old Stepmanager for the chambers
-  Int_t          copy, id;
-  static Int_t   idvol =-1;
-  static Int_t   vol[2];
-  Int_t          ipart;
-  TLorentzVector pos;
-  TLorentzVector mom;
-  Float_t        theta,phi;
-  Float_t        destep, step;
-  
-  static Float_t sstep;
-  static Float_t eloss, eloss2, xhit, yhit, zhit, tof, tlength;
-  const  Float_t kBig = 1.e10;
-  static Float_t hits[15];
-
-  TClonesArray &lhits = *fHits;
-
-  //
-  //
-  // Only charged tracks
-  if( !(gMC->TrackCharge()) ) return; 
-  //
-  // Only gas gap inside chamber
-  // Tag chambers and record hits when track enters 
-  id=gMC->CurrentVolID(copy);
-
-  Int_t iChamber = GetChamberId(id);
-  idvol =  iChamber-1;
-
-  if (idvol == -1) return;
-
-  // Detection elements id
-  AliMUONGeometryModule* geometry
-    = Chamber(iChamber-1).GetGeometry();
-
-  AliMUONGeometryDetElement* detElement
-    = geometry->FindBySensitiveVolume(CurrentVolumePath());
-
-  Int_t detElemId = 0;
-  if (detElement) detElemId = detElement->GetUniqueID(); 
-  if (!detElemId) {
-    cerr << "Chamber id: "
-         << setw(3) << iChamber << "  "
-         << "Current SV: " 
-         <<  CurrentVolumePath() 
-        << "  detElemId: "
-         << setw(5) << detElemId 
-        << endl;
-    Double_t x, y, z;
-    gMC->TrackPosition(x, y, z);          
-    cerr << "   global position: "
-         << x << ", " << y << ", " << z
-         << endl;
-    AliError("DetElemId not identified.");
-  }  
-  vol[0] = detElemId;
-    
-  //
-  // Get current particle id (ipart), track position (pos)  and momentum (mom) 
-  gMC->TrackPosition(pos);
-  gMC->TrackMomentum(mom);
-
-  ipart  = gMC->TrackPid();
-
-  //
-  // momentum loss and steplength in last step
-  destep = gMC->Edep();
-  step   = gMC->TrackStep();
-  // cout<<"------------"<<step<<endl;
-  //
-  // record hits when track enters ...
-  if( gMC->IsTrackEntering()) {
-
-      gMC->SetMaxStep(fMaxStepGas);
-      Double_t tc = mom[0]*mom[0]+mom[1]*mom[1];
-      Double_t rt = TMath::Sqrt(tc);
-      Double_t pmom = TMath::Sqrt(tc+mom[2]*mom[2]);
-      Double_t tx = mom[0]/pmom;
-      Double_t ty = mom[1]/pmom;
-      Double_t tz = mom[2]/pmom;
-      Double_t s  = ((AliMUONChamber*)(*fChambers)[idvol])
-          ->ResponseModel()
-          ->Pitch()/tz;
-      theta   = Float_t(TMath::ATan2(rt,Double_t(mom[2])))*kRaddeg;
-      phi     = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
-      hits[0] = Float_t(ipart);         // Geant3 particle type
-      hits[1] = pos[0]+s*tx;            // X-position for hit
-      hits[2] = pos[1]+s*ty;            // Y-position for hit
-      hits[3] = pos[2]+s*tz;            // Z-position for hit
-      hits[4] = theta;                  // theta angle of incidence
-      hits[5] = phi;                    // phi angle of incidence 
-      hits[8] = 0;//PadHits does not exist anymore  (Float_t) fNPadHits;    // first padhit
-      hits[9] = -1;                     // last pad hit
-      hits[10] = mom[3];                // hit momentum P
-      hits[11] = mom[0];                // Px
-      hits[12] = mom[1];                // Py
-      hits[13] = mom[2];                // Pz
-      tof=gMC->TrackTime();
-      hits[14] = tof;                   // Time of flight
-      tlength  = 0;
-      eloss    = 0;
-      eloss2   = 0;
-      sstep=0;
-      xhit     = pos[0];
-      yhit     = pos[1];      
-      zhit     = pos[2];      
-      Chamber(idvol).ChargeCorrelationInit();
-      // Only if not trigger chamber
-
-//       printf("---------------------------\n");
-//       printf(">>>> Y =  %f \n",hits[2]);
-//       printf("---------------------------\n");
-    
-      
-
-     //  if(idvol < AliMUONConstants::NTrackingCh()) {
-//        //
-//        //  Initialize hit position (cursor) in the segmentation model 
-//        ((AliMUONChamber*) (*fChambers)[idvol])
-//            ->SigGenInit(pos[0], pos[1], pos[2]);
-//       } else {
-//        //geant3->Gpcxyz();
-//        //printf("In the Trigger Chamber #%d\n",idvol-9);
-//       }
-  }
-  eloss2+=destep;
-  sstep+=step;
-
-  // cout<<sstep<<endl;
-
-  // 
-  // Calculate the charge induced on a pad (disintegration) in case 
-  //
-  // Mip left chamber ...
-  if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
-      gMC->SetMaxStep(kBig);
-      eloss   += destep;
-      tlength += step;
-      
-      Float_t x0,y0,z0;
-      Float_t localPos[3];
-      Float_t globalPos[3] = {pos[0], pos[1], pos[2]};
-      gMC->Gmtod(globalPos,localPos,1); 
-
-      if(idvol < AliMUONConstants::NTrackingCh()) {
-// tracking chambers
-          x0 = 0.5*(xhit+pos[0]);
-          y0 = 0.5*(yhit+pos[1]);
-          z0 = 0.5*(zhit+pos[2]);
-      } else {
-// trigger chambers
-          x0 = xhit;
-          y0 = yhit;
-          z0 = 0.;
-      }
-      
-
-      //      if (eloss >0)  MakePadHits(x0,y0,z0,eloss,tof,idvol);
-      
-          
-      hits[6] = tlength;   // track length
-      hits[7] = eloss2;    // de/dx energy loss
-
-
-      //      if (fNPadHits > (Int_t)hits[8]) {
-      //          hits[8] = hits[8]+1;
-      //          hits[9] = 0: // PadHits does not exist anymore (Float_t) fNPadHits;
-      //}
-//
-//    new hit 
-      
-      new(lhits[fNhits++]) 
-          AliMUONHit(fIshunt, gAlice->GetMCApp()->GetCurrentTrackNumber(), vol,hits,
-                    true);
-      eloss = 0; 
-      //
-      // Check additional signal generation conditions 
-      // defined by the segmentation
-      // model (boundary crossing conditions)
-      // only for tracking chambers
-  } else if 
-      ((idvol < AliMUONConstants::NTrackingCh()) &&
-       ((AliMUONChamber*) (*fChambers)[idvol])->SigGenCond(pos[0], pos[1], pos[2]))
-  {
-      ((AliMUONChamber*) (*fChambers)[idvol])
-          ->SigGenInit(pos[0], pos[1], pos[2]);
-      
-      Float_t localPos[3];
-      Float_t globalPos[3] = {pos[0], pos[1], pos[2]};
-      gMC->Gmtod(globalPos,localPos,1); 
-
-      eloss    += destep;
-
-      // if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
-      //        MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
-      xhit     = pos[0];
-      yhit     = pos[1]; 
-      zhit     = pos[2];
-      eloss = 0;
-      tlength += step ;
-      //
-      // nothing special  happened, add up energy loss
-  } else {        
-      eloss   += destep;
-      tlength += step ;
-  }
-}
index 3c3797c..4d881f9 100644 (file)
@@ -32,9 +32,7 @@ class AliMUONv1 : public AliMUON
    virtual void   StepManager();
                   //TBR
    virtual void   StepManager2();
-   void StepManagerOld();
-                  //TBR
-   void StepManagerOld2();
+
    void SetStepManagerVersionOld(Bool_t Opt) 
      { fStepManagerVersionOld = Opt; }
    void SetStepManagerVersionDE(Bool_t Opt) 
index 7c93cbb..43255c5 100644 (file)
@@ -7,17 +7,6 @@
 #pragma link C++ class AliMUONv1+; 
 
 // mapping & segmentation (change in progress)
-#pragma link C++ class AliMUONSegmentationV0+;
-#pragma link C++ class AliMUONSegmentationV01+; 
-#pragma link C++ class AliMUONSegmentationV02+; 
-#pragma link C++ class AliMUONSegmentationTrigger+;  
-#pragma link C++ class AliMUONSegmentationTriggerX+; 
-#pragma link C++ class AliMUONSegmentationTriggerY+; 
-#pragma link C++ class AliMUONSegmentationSlatModule+; 
-#pragma link C++ class AliMUONSegmentationSlatModuleN+; 
-#pragma link C++ class AliMUONSegmentationSlat+; 
-#pragma link C++ class AliMUONSegmentationSlatN+;
-#pragma link C++ class AliMUONSt1Segmentation+; 
 #pragma link C++ class AliMUONSegmentationDetectionElement+;
 #pragma link C++ class AliMUONSegmentIndex+;
 #pragma link C++ class AliMUONSegmentManuIndex+;
index 2aaedc2..b4a1691 100644 (file)
@@ -3,10 +3,7 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class AliMUONv0+; 
-
 // builder
-#pragma link C++ class AliMUONFactory+; 
 #pragma link C++ class AliMUONFactoryV2+; 
 
 #pragma link C++ class AliMUONPadHit+; 
index 5f61fc6..345e452 100644 (file)
@@ -1,17 +1,6 @@
 # $Id$
 
 SRCS:=  AliMUON.cxx AliMUONv1.cxx \
-        AliMUONSegmentationV0.cxx \
-        AliMUONSegmentationV01.cxx \
-        AliMUONSegmentationV02.cxx \
-        AliMUONSegmentationTrigger.cxx  \
-        AliMUONSegmentationTriggerX.cxx \
-        AliMUONSegmentationTriggerY.cxx \
-        AliMUONSegmentationSlatModule.cxx \
-        AliMUONSegmentationSlatModuleN.cxx \
-        AliMUONSegmentationSlat.cxx \
-        AliMUONSegmentationSlatN.cxx \
-        AliMUONSt1Segmentation.cxx \
         AliMUONSegmentationDetectionElement.cxx \
         AliMUONSegmentIndex.cxx \
         AliMUONSegmentManuIndex.cxx \
index e0621c5..120868e 100644 (file)
@@ -1,8 +1,6 @@
 # $Id$
 
-SRCS:= AliMUONv0.cxx \
-       AliMUONFactory.cxx \
-       AliMUONFactoryV2.cxx \
+SRCS:= AliMUONFactoryV2.cxx \
        AliMUONSt1Response.cxx \
        AliMUONSt1ElectronicElement.cxx \
        AliMUONSt1SpecialMotif.cxx \
@@ -17,10 +15,10 @@ SRCS:= AliMUONv0.cxx \
        AliMUONMerger.cxx \
        AliMUONTriggerDecision.cxx \
        AliMUONTest.cxx \
-        AliMUONResponse.cxx \
-        AliMUONResponseV0.cxx \
-        AliMUONResponseTrigger.cxx \
-        AliMUONResponseTriggerV1.cxx\
+       AliMUONResponse.cxx \
+       AliMUONResponseV0.cxx \
+       AliMUONResponseTrigger.cxx \
+       AliMUONResponseTriggerV1.cxx\
 
 HDRS:= $(SRCS:.cxx=.h)