Removing unsupported code related to beam test setups, old trackers and old geometries
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 2 Feb 2011 18:36:09 +0000 (18:36 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 2 Feb 2011 18:36:09 +0000 (18:36 +0000)
44 files changed:
ITS/AliITSBeamTest.C [deleted file]
ITS/AliITSBeamTestDig.cxx [deleted file]
ITS/AliITSBeamTestDig.h [deleted file]
ITS/AliITSBeamTestDigSDD.cxx [deleted file]
ITS/AliITSBeamTestDigSDD.h [deleted file]
ITS/AliITSBeamTestDigSPD.cxx [deleted file]
ITS/AliITSBeamTestDigSPD.h [deleted file]
ITS/AliITSBeamTestDigSSD.cxx [deleted file]
ITS/AliITSBeamTestDigSSD.h [deleted file]
ITS/AliITSBeamTestDigitizer.cxx [deleted file]
ITS/AliITSBeamTestDigitizer.h [deleted file]
ITS/AliITSInitGeometry.cxx
ITS/AliITSInitGeometry.h
ITS/AliITSL2GConvertPointsV1.C [deleted file]
ITS/AliITSRawStreamSDDBeamTest.cxx [deleted file]
ITS/AliITSRawStreamSDDBeamTest.h [deleted file]
ITS/AliITSRawStreamSDDBeamTestNov04.cxx [deleted file]
ITS/AliITSRawStreamSDDBeamTestNov04.h [deleted file]
ITS/AliITSRawStreamSPD_OLDGEO.cxx [deleted file]
ITS/AliITSTrackV1.cxx [deleted file]
ITS/AliITSTrackV1.h [deleted file]
ITS/AliITSTrackerV1.cxx [deleted file]
ITS/AliITSTrackerV1.h [deleted file]
ITS/AliITSclusterSSD.cxx [deleted file]
ITS/AliITSclusterSSD.h [deleted file]
ITS/AliITSpackageSSD.cxx [deleted file]
ITS/AliITSpackageSSD.h [deleted file]
ITS/AliITSvBeamTestITS04.cxx [deleted file]
ITS/AliITSvBeamTestITS04.h [deleted file]
ITS/AliITSvSDD03.cxx [deleted file]
ITS/AliITSvSDD03.h [deleted file]
ITS/AliITSvSPD02.cxx [deleted file]
ITS/AliITSvSPD02.h [deleted file]
ITS/AliITSvSSD03.cxx [deleted file]
ITS/AliITSvSSD03.h [deleted file]
ITS/CMakelibITSbase.pkg
ITS/CMakelibITSrec.pkg
ITS/CMakelibITSsim.pkg
ITS/ConfigSDD03.C [deleted file]
ITS/ConfigSPD02.C [deleted file]
ITS/ConfigSSD03.C [deleted file]
ITS/ITSbaseLinkDef.h
ITS/ITSrecLinkDef.h
ITS/ITSsimLinkDef.h

diff --git a/ITS/AliITSBeamTest.C b/ITS/AliITSBeamTest.C
deleted file mode 100644 (file)
index 3429ba9..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-///////////////////////////////////////////////////////
-// Macro to create the galice.root file for         ///
-// beam test analysis (using AliITSBeamTestDigitizer //
-// class). Before using AliITSBeamTestDigitizer it   // 
-// is necessary to run this macro to create the      //
-// galice.root file.                                 //
-// Options: Nov04 for integrated                     // 
-//          ITS beam test November 2004              //
-//                                                   //
-//          Aug04 for SDD beam test August 2004      //
-// E. Crescio: crescio@to.infn.it                    //
-///////////////////////////////////////////////////////
-
-void AliITSBeamTest(Char_t* opt="Nov04"){
-
-  TString choice(opt);
-  Bool_t aug04 = choice.Contains("Aug04");
-  Bool_t nov04 = choice.Contains("Nov04");
-
-  AliRunLoader* rl = AliRunLoader::Open("galice.root",
-                   AliConfig::GetDefaultEventFolderName(),"recreate");
-
-  gAlice->SetRunLoader(rl);  
-  rl->SetEventFolderName();
-
-  AliITS* bt;
-  if(nov04){
-    if(gGeoManager) delete gGeoManager;
-    gGeoManager = new TGeoManager("ITSGeometry","ITS Simulation Geometry Manager");
-    TGeoMaterial *vacmat = new TGeoMaterial("Vacuum",0,0,0);
-    TGeoMedium   *vacmed = new TGeoMedium("Vacuum_med",1,vacmat);
-    TGeoVolume *aLICE = gGeoManager->MakeBox("ALICE",vacmed,100.,100.,200.);
-    gGeoManager->SetTopVolume(aLICE);  
-    bt = new AliITSvBeamTestITS04("ITS","ITS beam test");
-    bt->CreateGeometry();
-    bt->Init();
-  }
-  if(aug04){
-    bt = new AliITSvSDD03("ITS",2004);
-    gSystem->Load("libgeant321");
-    new TGeant3("C++ Interface to Geant3");
-    if(strcmp(gMC->GetName(),"TGeant3")) {
-       Fatal("Init","TGeant3 should be instantiated in advance");
-       return;
-    } 
-    bt->CreateMaterials();
-    bt->CreateGeometry();
-    bt->Init();
-  }
-  gAlice->AddModule(bt);
-  bt->SetDefaults();   
-  rl->AddLoader(bt);
-  // rl->MakeTree("E");  
-  //rl->WriteHeader("OVERWRITE");
-  rl->WriteRunLoader("OVERWRITE");
-  rl->WriteAliRun("OVERWRITE"); 
-
-}
diff --git a/ITS/AliITSBeamTestDig.cxx b/ITS/AliITSBeamTestDig.cxx
deleted file mode 100644 (file)
index bba8d75..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  beam test raw 2 dig conv.                     //
-//  Origin: E. Crescio crescio@to.infn.it         //
-//                                                //
-////////////////////////////////////////////////////
-
-#include "AliITSBeamTestDig.h"
-
-ClassImp(AliITSBeamTestDig)
-
-
-
-//_____________________________________________________________
-  AliITSBeamTestDig::AliITSBeamTestDig(): TTask(),
-fITSHeader(0),
-fReader(0),
-fTreeD(0),
-fITSgeom(0)
-{
-  //
-  // Default constructor
-  //
-}
-
-//_____________________________________________________________
-AliITSBeamTestDig::AliITSBeamTestDig(const Text_t* name, const Text_t* title): TTask(name,title),
-fITSHeader(0),
-fReader(0),
-fTreeD(0),
-fITSgeom(0)
-{
-  //
-  // Standard constructor
-  //
-
-}
-
-//______________________________________________________________________
-AliITSBeamTestDig::AliITSBeamTestDig(const AliITSBeamTestDig &bt):TTask(bt),
-fITSHeader(bt.fITSHeader),
-fReader(bt.fReader),
-fTreeD(bt.fTreeD),
-fITSgeom(bt.fITSgeom){
-    // Copy constructor. 
-
-}
-//______________________________________________________________________
-AliITSBeamTestDig& AliITSBeamTestDig::operator=(const AliITSBeamTestDig &source){
-    // Assignment operator
-  this->~AliITSBeamTestDig();
-  new(this) AliITSBeamTestDig(source);
-  return *this;
-}
-
-
-  
diff --git a/ITS/AliITSBeamTestDig.h b/ITS/AliITSBeamTestDig.h
deleted file mode 100644 (file)
index 4c39fa3..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef ALIITSBEAMTESTDIG_H
-#define ALIITSBEAMTESTDIG_H
-
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  beam test raw 2 dig conv.                     //
-//  Origin: E. Crescio crescio@to.infn.it         //
-//  November 2004                                 //
-////////////////////////////////////////////////////
-
-#include "TTask.h"
-
-
-class AliRawReader;
-class TTree;
-class AliITSEventHeader;
-class AliITSgeom;
-
-class AliITSBeamTestDig: public TTask {
- public:
-
-  AliITSBeamTestDig();
-  AliITSBeamTestDig(const Text_t* name, const Text_t* title);
-  AliITSBeamTestDig(const AliITSBeamTestDig& bt);
-  AliITSBeamTestDig& operator=(const AliITSBeamTestDig &source);
-  virtual ~AliITSBeamTestDig() {}
-  void SetRawReader(AliRawReader* rd) {fReader=rd;}
-  void SetTree(TTree* treedig) {fTreeD=treedig;}
-  void SetITSEventHeader(AliITSEventHeader* header){fITSHeader = header;}
-  void SetITSgeom(AliITSgeom* geom) {fITSgeom=geom;}  
-
-
- protected:      
-  
-  AliITSEventHeader* fITSHeader;     // its event header
-  AliRawReader* fReader;             // !reader ;
-  TTree* fTreeD;                     // tree of digits
-  AliITSgeom* fITSgeom;              // !ITS geometry
-
-
-  ClassDef(AliITSBeamTestDig,4)   // its beam test digitization 
-
- };
-
-
-
-#endif
-
-    
diff --git a/ITS/AliITSBeamTestDigSDD.cxx b/ITS/AliITSBeamTestDigSDD.cxx
deleted file mode 100644 (file)
index a302c9a..0000000
+++ /dev/null
@@ -1,209 +0,0 @@
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  SDD beam test raw 2 dig conv.                 //
-//  Origin: E. Crescio crescio@to.infn.it         //
-//                                                // 
-//                                                //
-////////////////////////////////////////////////////
-#include "AliITSdigitSDD.h"
-#include "AliRawReader.h"
-#include "AliVMERawStream.h"
-#include "AliITSRawStreamSDDBeamTest.h"
-#include "AliITSRawStreamSDDBeamTestNov04.h"
-#include "AliITSBeamTestDigSDD.h"
-#include "AliITSEventHeader.h"
-#include "AliITSgeom.h"
-#include <TBranch.h>
-#include <TTree.h>
-
-ClassImp(AliITSBeamTestDigSDD)
-
-//_____________________________________________________________
-  AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(): AliITSBeamTestDig(),
-fSDDEvType(0),
-fSubEventAttributes(0),
-fBtPer(),
-fThreshold(0),
-fStreamer(0){
-  //
-  // Constructor
-  //
-  SetBtPeriod();
-}
-
-//_____________________________________________________________
-AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title),
-fSDDEvType(0),
-fSubEventAttributes(0),
-fBtPer(),
-fThreshold(0),
-fStreamer(0)
-{
-  //
-  // Constructor
-  //
-  SetBtPeriod();
-}
-
-//__________________________________________________________________
-AliITSBeamTestDigSDD::~AliITSBeamTestDigSDD()
-{
-  //
-  // Destructor
-  //
-  if(fSubEventAttributes) delete fSubEventAttributes;
-  if(fStreamer) delete fStreamer;
- }
-
-
-//_______________________________________________________________________
-void AliITSBeamTestDigSDD::Exec(Option_t* /*opt*/)
-{
-
-  // Reads raw data and fills the tree of digits
-
-  TBranch* branch = fTreeD->GetBranch("ITSDigitsSDD");
-  Int_t maxn=0;
-
-  if(!fITSgeom){
-    Error("Exec","fITSgeom is null!");
-    return;
-  }
-
-  Int_t nsdd=0;
-  Int_t nspd=0;
-  Int_t nssd=0;
-  for(Int_t nlay=1;nlay<=fITSgeom->GetNlayers();nlay++){
-    for(Int_t nlad=1;nlad<=fITSgeom->GetNladders(nlay);nlad++){
-      for(Int_t ndet=1;ndet<=fITSgeom->GetNdetectors(nlay);ndet++){
-       Int_t index=fITSgeom->GetModuleIndex(nlay,nlad,ndet);
-       TString dtype(fITSgeom->GetModuleTypeName(index));
-       if(dtype.Contains("SPD")) nspd++;
-       if(dtype.Contains("SDD")) nsdd++;
-       if(dtype.Contains("SSD")) nssd++;
-      }
-    }
-  }
-  if(GetBtPeriod()==kAug04) maxn=nsdd;
-  if(GetBtPeriod()==kNov04) maxn=nspd+nsdd+nssd;
-  TClonesArray** digits = new TClonesArray*[maxn];
-  Int_t* idig = new Int_t[maxn];
-  for(Int_t idet=0;idet<maxn;idet++){
-    digits[idet]=new TClonesArray("AliITSdigitSDD");
-    idig[idet]=0;
-  }
-
-  switch(fBtPer){
-  case kNov04:
-    fStreamer = new AliITSRawStreamSDDBeamTestNov04(fReader);
-    break;
-  case kAug04:
-    AliVMERawStream vmeStreamer(fReader);
-    fReader->RequireHeader(kFALSE);
-    while(fReader->ReadHeader()){
-      fSubEventAttributes = fReader->GetSubEventAttributes();
-    }
-    
-    fSDDEvType=GetEventType();
-    if(fSDDEvType==1) fITSHeader->SetEventTypeSDD(kReal);
-    if(fSDDEvType==2) fITSHeader->SetEventTypeSDD(kCalibration1);
-    if(fSDDEvType==3) fITSHeader->SetEventTypeSDD(kCalibration2);
-    fReader->Reset();
-    fStreamer = new AliITSRawStreamSDDBeamTest(fReader);
-    break;
-  }
-
-  fStreamer->SetLowCarlosThreshold(fThreshold,0);
-  fStreamer->SetLowCarlosThreshold(fThreshold,1);
-
-  //from raw data the signal is already decompressed..
-  //set compressed fSignal of AliITSdigitSDD to -1000
-  //set expanded fSignalExpanded of AliITSdigitSDD equal to fStreamer.GetSignal() 
-  while(fStreamer->Next()){   
-    Int_t ndet =0;
-    if(GetBtPeriod()==kNov04) ndet=fStreamer->GetChannel()+nspd;
-    if(GetBtPeriod()==kAug04) ndet=fStreamer->GetChannel();
-    Int_t anode = fStreamer->GetCoord1();
-
-    /* if we are reading only one det, two wings
-       if(fStreamer.GetChannel()==1) anode+=256; //wing 1 0-255, wing 2 256-511
-    */
-
-    /* bt august 2004 and november 2004: with only 1 carlos 
-       channel 0 for one wing of one
-       det, channel 1 for the wing of the second det*/
-
-    const Int_t kdgt[3]={anode,fStreamer->GetCoord2(),-1000};
-    const Int_t ktracks[10]={0,0,0,0,0,0,0,0,0,0};
-    const Int_t khits[10]={0,0,0,0,0,0,0,0,0,0};
-    const Float_t kcharges[10]={0,0,0,0,0,0,0,0,0,0};
-
-    new ((*digits[ndet])[idig[ndet]]) AliITSdigitSDD(0,kdgt,ktracks,khits,kcharges,fStreamer->GetSignal());
-    idig[ndet]++;
-  }
-
-  if(GetBtPeriod()==kNov04){
-    Int_t jitter=fStreamer->ReadJitter();
-    fITSHeader->SetJitterSDD(jitter);
-  }
-  for(Int_t n = 0;n<maxn;n++){
-    branch->SetAddress(&digits[n]);
-    branch->Fill();
-  
-  }
-      
-  fTreeD->SetEntries(maxn);
-  fReader->Reset();
-  fTreeD->AutoSave();
-
-  for(Int_t n=0;n<maxn;n++){
-    delete digits[n];
-  }
-
-  
-  delete[] digits;
-  delete[] idig;
-  delete fStreamer;
-}
-
-  
-//______________________________________
-Int_t AliITSBeamTestDigSDD::GetEventType(){
-
-  // defines the SDD event type:
-  // 1: physics event (kReal)
-  // 2: calibration 1 (kCalibration1, injector pulse)
-  // 3: calibration 2 (kCalibration2, test pulse)
-  fSDDEvType=0;
-  if(fSubEventAttributes[0]==0 && fSubEventAttributes[1]==0 && fSubEventAttributes[2]==0) fSDDEvType = 1;
-  if(fSubEventAttributes[0]==1 && fSubEventAttributes[1]==0 && fSubEventAttributes[2]==0) fSDDEvType = 2;
-
-  if(fSubEventAttributes[0]==2 && fSubEventAttributes[1]==0 && fSubEventAttributes[2]==0) fSDDEvType = 3;
-
-  return fSDDEvType;
-}
-
-//______________________________________________________________________
-AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(const AliITSBeamTestDigSDD &bt):AliITSBeamTestDig(bt),
-fSDDEvType(bt.fSDDEvType),
-fSubEventAttributes(bt.fSubEventAttributes),
-fBtPer(bt.fBtPer),
-fThreshold(bt.fThreshold),
-fStreamer(bt.fStreamer){
-    // Copy constructor. 
-
-}
-//______________________________________________________________________
-AliITSBeamTestDigSDD& AliITSBeamTestDigSDD::operator=(const AliITSBeamTestDigSDD &source){
-    // Assignment operator. 
-  this->~AliITSBeamTestDigSDD();
-  new(this) AliITSBeamTestDigSDD(source);
-  return *this;
-}
-
-
-
-
diff --git a/ITS/AliITSBeamTestDigSDD.h b/ITS/AliITSBeamTestDigSDD.h
deleted file mode 100644 (file)
index 4829056..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifndef ALIITSBEAMTESTDIGSDD_H
-#define ALIITSBEAMTESTDIGSDD_H
-
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  SDD beam test raw 2 dig conv.                 //
-//  Origin: E. Crescio crescio@to.infn.it         //
-//                                                //
-////////////////////////////////////////////////////
-
-#include "AliITSBeamTestDig.h"
-
-
-class AliITSRawStreamSDDBeamTest;
-
-typedef enum {kAug04,kNov04} BeamtestPeriod_t;
-
-class AliITSBeamTestDigSDD: public AliITSBeamTestDig {
- public:
-
-  AliITSBeamTestDigSDD();
-  AliITSBeamTestDigSDD(const Text_t* name, const Text_t* title);
-  AliITSBeamTestDigSDD(const AliITSBeamTestDigSDD& bt);
-  AliITSBeamTestDigSDD& operator=(const AliITSBeamTestDigSDD &source);
-
-  virtual ~AliITSBeamTestDigSDD();
-
-  void SetBtPeriod(BeamtestPeriod_t per=kNov04) {fBtPer=per;}
-  void SetThreshold(Int_t threshold) {fThreshold=threshold;}
-
-  BeamtestPeriod_t GetBtPeriod() const {return fBtPer;}
-  Int_t GetThreshold() const {return fThreshold;}
-  
-  virtual void Exec(Option_t* opt);
-
-  
- protected:      
-
-  Int_t  fSDDEvType;                 //SDD event type (real, calibration)
-  const UInt_t* fSubEventAttributes; //SDD sub-event attributes 
-  BeamtestPeriod_t fBtPer;           //beam test version 
-                                     // November 2004 = kNov04
-                                     // August 2004 = kAug04
-  Int_t fThreshold;                  // Low carlos threshold 
-  AliITSRawStreamSDDBeamTest* fStreamer;     //! SDD streamer
-
- private: 
-
-  Int_t GetEventType();
-
-
-  ClassDef(AliITSBeamTestDigSDD,2)  // An Alice SDD beam test digitizer
-
- };
-
-
-
-#endif
-
-    
diff --git a/ITS/AliITSBeamTestDigSPD.cxx b/ITS/AliITSBeamTestDigSPD.cxx
deleted file mode 100644 (file)
index 62212fb..0000000
+++ /dev/null
@@ -1,166 +0,0 @@
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  SPD beam test raw 2 dig conv.                 //
-//                                                //
-//  Origin: Jan Conrad  Jan.Conrad@cern.ch        //
-//                                                //
-////////////////////////////////////////////////////
-
-/* $Id$ */
-
-#include "AliITSdigitSPD.h"
-#include "AliRawReader.h"
-#include "AliRawReader.h"
-#include "AliRawDataHeader.h"
-#include "AliITSRawStreamSPD.h"
-#include "AliITSBeamTestDigSPD.h"
-#include "AliITSgeom.h"
-#include <TBranch.h>
-#include <TTree.h>
-#include "AliITSEventHeader.h"
-ClassImp(AliITSBeamTestDigSPD)
-
-
-
-//_____________________________________________________________
-  AliITSBeamTestDigSPD::AliITSBeamTestDigSPD(): AliITSBeamTestDig(),
-fFlagHeader(0){
-  //
-  // Constructor
-  //
-}
-
-//_____________________________________________________________
-AliITSBeamTestDigSPD::AliITSBeamTestDigSPD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title),
-fFlagHeader(0){
-  //
-  // Constructor
-  //
-}
-
-//__________________________________________________________________
-AliITSBeamTestDigSPD::~AliITSBeamTestDigSPD()
-{
-  //
-  // Destructor
-  //
-
- }
-
-
-//_______________________________________________________________________
-void AliITSBeamTestDigSPD::Exec(Option_t* /*opt*/)
-{
-  //Reads raw data for SPD, fill SPD digits tree
-
-
-  if(!fITSgeom){
-    Error("Exec","fITSgeom is null!");
-    return;
-  }
-  TBranch* branch = fTreeD->GetBranch("ITSDigitsSPD");
-
-  Int_t nsdd=0;
-  Int_t nspd=0;
-  Int_t nssd=0;
-  for(Int_t nlay=1;nlay<=fITSgeom->GetNlayers();nlay++){
-    for(Int_t nlad=1;nlad<=fITSgeom->GetNladders(nlay);nlad++){
-      for(Int_t ndet=1;ndet<=fITSgeom->GetNdetectors(nlay);ndet++){
-       Int_t index=fITSgeom->GetModuleIndex(nlay,nlad,ndet);
-       TString dtype(fITSgeom->GetModuleTypeName(index));
-       if(dtype.Contains("SPD")) nspd++;
-       if(dtype.Contains("SDD")) nsdd++;
-       if(dtype.Contains("SSD")) nssd++;
-      }
-    }
-  }
-  Int_t maxn=nspd+nsdd+nssd;
-
-  TClonesArray** newdigits = new TClonesArray*[maxn];
-
-
-  Int_t* idig = new Int_t[maxn];
-
-  for (Int_t idet =0; idet <maxn;idet++){
-     newdigits[idet]=new TClonesArray("AliITSdigitSPD");
-     idig[idet]=0;  
-   }
-  
-
-  AliITSRawStreamSPD str(fReader);
-
-  // fReader->SelectEquipment(17,0,19);
-
-  while(str.Next()){  
-
-    const AliRawDataHeader* rdh = fReader->GetDataHeader();
-    UChar_t blockAttributes = fReader->GetBlockAttributes();     
-    UInt_t statusBits = fReader->GetStatusBits();     
-    UInt_t orbitNumber = rdh->GetEventID2();                    
-    UShort_t  bunchCross = rdh->GetEventID1();      
-      // UInt_t DataSize = rdh->fSize;                               
-      //UChar_t L1TrigType = rdh->fL1TriggerType;                            
-      //UInt_t MiniEvId = rdh->GetMiniEventID();                             
-      // ULong64_t TriggerCL = rdh->GetTriggerClasses();     
-      //ULong64_t ROI = rdh->GetROI();
-      //      UChar_t Version =rdh->fVersion;                                 
-      
-
-    Int_t modID = str.GetModuleID();
-    //    Int_t triggernumber = str.GetTriggerEventNumber();
-
-    Int_t row = str.GetRow();
-    Int_t col = str.GetColumn();
-
-    const Int_t kdgt[3]={col,row,1};
-    //    newdigits = new TClonesArray*[fBt->GetNSPD()];
-
-    new ((*newdigits[modID])[idig[modID]]) AliITSdigitSPD(kdgt);
-    
-    idig[modID]++;
-    
-      fITSHeader->SetOrbitNumber(0,orbitNumber);
-      fITSHeader->SetStatusBits(0,statusBits);
-      fITSHeader->SetBlockAttributes(0,blockAttributes);
-      fITSHeader->SetBunchCross(0,bunchCross);
-      //fITSHeader->SetTriggerClass(0,TriggerCL);
-      //fITSHeader->SetSubDet(0,
-      //fITSHeader->SetMiniEvId(0,MiniEvId);
-      //fITSHeader->SetVersion(0,Version);
-      //fITSHeader->SetSubDet(0,Subdets);
-      //fITSHeader->SetL1TriggerType(0,L1TrigType);
-
-      //fITSHeader->SetOrbitNumberSPD(OrbitNumber);
-      //printf("Bunch Crossing  = %x\n ",BunchCross);
-      //if ( blockAttributes != 0x3a ) {
-      //Info("Exec","Block Attribs  = %x\n ",blockAttributes);
-      //}  
-    
-     
-    
-    } // while(str.Next());
-    
-
-    for(Int_t n=0;n<maxn;n++){
-      branch->SetAddress(&newdigits[n]);
-      branch->Fill(); 
-
-   }
-    
-    fTreeD->SetEntries(maxn);
-  
-       
-    fReader->Reset();
-    fTreeD->AutoSave();
-   
-
-    for(Int_t n=0;n<maxn;n++){
-      delete newdigits[n];
-    }
-
-    delete[] newdigits;
-    delete[] idig;
-
-}
-
-  
diff --git a/ITS/AliITSBeamTestDigSPD.h b/ITS/AliITSBeamTestDigSPD.h
deleted file mode 100644 (file)
index ac33d77..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef ALIITSBEAMTESTDIGSPD_H
-#define ALIITSBEAMTESTDIGSPD_H
-
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  SPD beam test raw 2 dig conv.                 //
-//
-//  Origin: Jan Conrad Jan.Conrad@cern.ch         //
-////////////////////////////////////////////////////
-
-#include "AliITSBeamTestDig.h"
-
-
-class AliITSBeamTestDigSPD: public AliITSBeamTestDig {
- public:
-
-  AliITSBeamTestDigSPD();
-  AliITSBeamTestDigSPD(const Text_t* name, const Text_t* title);
-  virtual ~AliITSBeamTestDigSPD();
-
-  virtual void Exec(Option_t* opt);
-  
-  
- protected:      
-  
-   
-  Bool_t fFlagHeader; // flag for the event header
-
-
-
- ClassDef(AliITSBeamTestDigSPD,0)  // An Alice SPD beam test run
-
- };
-
-
-#endif
-
-    
diff --git a/ITS/AliITSBeamTestDigSSD.cxx b/ITS/AliITSBeamTestDigSSD.cxx
deleted file mode 100644 (file)
index 52c83a1..0000000
+++ /dev/null
@@ -1,123 +0,0 @@
-/////////////////////////////////////////
-// Class for SSD raw2digits conv       //
-//                                     //
-// Author: Enrico Fragiacomo           //
-// Date: October 2004                  //
-////////////////////////////////////////
-
-#include "AliITSgeom.h"
-#include "AliITSdigitSSD.h"
-#include "AliRawReader.h"
-#include "AliITSRawStreamSSDv1.h"
-#include "AliITSBeamTestDigSSD.h"
-#include <TBranch.h>
-#include <TTree.h>
-
-ClassImp(AliITSBeamTestDigSSD)
-
-//_____________________________________________________________
-AliITSBeamTestDigSSD::AliITSBeamTestDigSSD(): AliITSBeamTestDig(),
-fFlagHeader(0) 
-{
-  //
-  // Constructor
-  //  
-}
-
-//_____________________________________________________________
-AliITSBeamTestDigSSD::AliITSBeamTestDigSSD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title),
-fFlagHeader(0){
-  //
-  // Constructor
-  //
-}
-
-//__________________________________________________________________
-AliITSBeamTestDigSSD::~AliITSBeamTestDigSSD() {
-  //
-  // Destructor
-  //
-}
-
-//_______________________________________________________________________
-void AliITSBeamTestDigSSD::Exec(Option_t* /*opt*/) {
-  //Reads raw data for SSD, fill SSD digits tree, returns 1 if real data,
-  //returns 2 if calibration (injector) data, returns 3 if calibration (test pul  //se) event
-
-  TBranch* branch = fTreeD->GetBranch("ITSDigitsSSD");
-  if(!fITSgeom){
-    Error("Exec","fITSgeom is null!");
-    return;
-  }
-
-  Int_t nsdd=0;
-  Int_t nspd=0;
-  Int_t nssd=0;
-  for(Int_t nlay=1;nlay<=fITSgeom->GetNlayers();nlay++){
-    for(Int_t nlad=1;nlad<=fITSgeom->GetNladders(nlay);nlad++){
-      for(Int_t ndet=1;ndet<=fITSgeom->GetNdetectors(nlay);ndet++){
-       Int_t index=fITSgeom->GetModuleIndex(nlay,nlad,ndet);
-       TString dtype(fITSgeom->GetModuleTypeName(index));
-       if(dtype.Contains("SPD")) nspd++;
-       if(dtype.Contains("SDD")) nsdd++;
-       if(dtype.Contains("SSD")) nssd++;
-      }
-    }
-  }
-  Int_t maxn=nspd+nsdd+nssd;
-
-  TClonesArray** newdigits = new TClonesArray*[maxn];
-
-  Int_t* idig = new Int_t[maxn];
-
-  for (Int_t idet =0; idet <maxn;idet++) {
-     newdigits[idet] = new TClonesArray("AliITSdigitSSD");
-     idig[idet]=0;  
-   }
-  
-  // this constructor sets the flag to select SSD data only 
-  // the Next method below will then jump to SSD data for this event
-  AliITSRawStreamSSDv1 str(fReader);
-
-  // no selection of equipment 
-  //fReader->SelectEquipment(-1);
-  //fReader->SelectEquipment(17,102,102);
-
-  while(str.Next()){   
-    
-    //if((str.GetADModule()!=2)&&(str.GetADModule()!=6)) continue;
-  
-    Int_t side = str.GetSideFlag();
-    Int_t strip = str.GetStrip();
-    Int_t signal = str.GetSignal();
-    Int_t module = str.GetModuleID();
-    Int_t module1= module-10+nsdd+nspd;
-     if( (module<10) || (module>13) ) continue;
-     if(module1>7) continue;
-    const Int_t kdgt[3]={side,strip,signal};
-     //  SSD modules 10, 11, 12 and 13
-    new ( (*newdigits[module1])[idig[module1]] ) AliITSdigitSSD(kdgt);    
-    idig[module1]++;
-  } // end while
-  
-  for(Int_t n=0;n<maxn;n++){
-    branch->SetAddress(&newdigits[n]);
-    branch->Fill();  
-  }
-  
-  fTreeD->SetEntries(maxn);
-    
-  fReader->Reset();
-  
-  fTreeD->AutoSave();
-  
-  for(Int_t n=0;n<maxn;n++){
-    delete newdigits[n];
-  }
-  
-  delete [] newdigits;
-  delete [] idig;
-}
-
-  
-
diff --git a/ITS/AliITSBeamTestDigSSD.h b/ITS/AliITSBeamTestDigSSD.h
deleted file mode 100644 (file)
index df03009..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef ALIITSBEAMTESTDIGSSD_H
-#define ALIITSBEAMTESTDIGSSD_H
-
-////////////////////////////////////////////////////
-//  Class to define                               //
-//  SSD beam test raw 2 dig conv.                 //
-//                                                //
-//  Origin: Enrico Fragiacomo                     //
-//                                                //
-////////////////////////////////////////////////////
-
-#include "AliITSBeamTestDig.h"
-
-
-
-
-class AliITSBeamTestDigSSD: public AliITSBeamTestDig {
- public:
-
-  AliITSBeamTestDigSSD();
-  AliITSBeamTestDigSSD(const Text_t* name, const Text_t* title);
-  virtual ~AliITSBeamTestDigSSD();
-
-  virtual void Exec(Option_t* opt);
-  
-  //  void SetRawReaderDate(AliRawReaderDate* rd) {fReaderDate=rd;}
-  // void SetHeader(Bool_t H){fFlagHeader = H;}
-
-  //void SetTree(TTree* treedig) {fTreeD=treedig;}
-    
- protected:      
-  
-   
-
-  Bool_t fFlagHeader;  //flag for the header
-
-
- ClassDef(AliITSBeamTestDigSSD,1)  // An Alice SSD beam test run
-
- };
-
-
-#endif
-
-    
-
diff --git a/ITS/AliITSBeamTestDigitizer.cxx b/ITS/AliITSBeamTestDigitizer.cxx
deleted file mode 100644 (file)
index 0cd344f..0000000
+++ /dev/null
@@ -1,321 +0,0 @@
-////////////////////////////////////////////////////
-//  Class to manage the                           //
-//  ITS beam test conversion from rawdata         //
-//  to digits. It executes the digitization for   //
-//  SPD, SDD and SSD.                             //
-//                                                //
-//                                                //
-//  Origin:  E. Crescio crescio@to.infn.it        //
-//           J. Conrad  Jan.Conrad@cern.ch        //
-////////////////////////////////////////////////////
-#include "AliHeader.h"
-#include "AliRun.h"
-#include "AliRunLoader.h"
-#include "AliITSEventHeader.h"
-#include "AliITSLoader.h"
-#include "AliITSBeamTestDigSDD.h"
-#include "AliITSBeamTestDigSPD.h"
-#include "AliITSBeamTestDigSSD.h"
-#include "AliITSBeamTestDigitizer.h"
-#include "AliRawReaderDate.h"
-#include "AliRawReaderRoot.h"
-
-const TString AliITSBeamTestDigitizer::fgkDefaultDigitsFileName="ITS.Digits.root";  
-
-ClassImp(AliITSBeamTestDigitizer)
-
-
-//_____________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask(), 
-fEvIn(0),
-fEvFin(0),
-fRunNumber(-1),
-fDATEEvType(7),
-fFlagHeader(kTRUE),
-fFlagInit(kFALSE),
-fOptDate(kFALSE),
-fDigitsFileName(0),
-fRawdataFileName(0),
-fPeriod(kNov04),
-fRunLoader(0),
-fLoader(0),
-fHeader(0){  
-  //
-  // Default constructor
-  //
-  SetFlagInit();
-  SetOptDate();
-} 
-
-//_____________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, const Char_t* opt,const char* filename):TTask(name,title),
-fEvIn(0),
-fEvFin(0),
-fRunNumber(-1),
-fDATEEvType(7),
-fFlagHeader(kTRUE),
-fFlagInit(kFALSE),
-fOptDate(kFALSE),
-fDigitsFileName(0),
-fRawdataFileName(0),
-fPeriod(kNov04),
-fRunLoader(0),
-fLoader(0),
-fHeader(0) 
-{  
-  //
-  // Standard constructor 
-  //
-  SetOptDate();
-
-  TString choice(opt);
-  Bool_t aug04 = choice.Contains("Aug04");
-  Bool_t nov04 = choice.Contains("Nov04");
-  if(aug04) fPeriod=kAug04;
-  if(nov04) fPeriod=kNov04;
-  Init(filename);
- } 
-
-//_____________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run, const Char_t* opt,const char* filename):TTask(name,title), 
-fEvIn(0),
-fEvFin(0),
-fRunNumber(run),
-fDATEEvType(7),
-fFlagHeader(kTRUE),
-fFlagInit(kFALSE),
-fOptDate(kFALSE),
-fDigitsFileName(0),
-fRawdataFileName(0),
-fPeriod(kNov04),
-fRunLoader(0),
-fLoader(0),
-fHeader(0){  
-  //
-  // Constructor 
-  //
-  SetOptDate();
-  TString choice(opt);
-  Bool_t aug04 = choice.Contains("Aug04");
-  Bool_t nov04 = choice.Contains("Nov04");
-  if(aug04) fPeriod=kAug04;
-  if(nov04) fPeriod=kNov04;
-
-  Init(filename);
- } 
-
-//___________________________________________________________
-void AliITSBeamTestDigitizer::Init(const char* filename){
-
-  //
-  //Initialization of run loader and its loader 
-  //creation of galice.root
-  //
-
-
-  fRunLoader = AliRunLoader::Open(filename,AliConfig::GetDefaultEventFolderName(),"update");
-  if (fRunLoader == 0x0)
-    {
-      Error("AliITSBeamTestDigitizer","Can not load the session %s",filename);
-      return;
-    }
-  fRunLoader->LoadgAlice();
-  gAlice = fRunLoader->GetAliRun();
-  
-  if(!gAlice) {
-    Error("AliITSBeamTestDigitizer","gAlice not found on file. Aborting.");
-    return;
-  } 
-  fRunLoader->MakeTree("E");  
-  fLoader = (AliITSLoader*)fRunLoader->GetLoader("ITSLoader");
-
-  fDigitsFileName=fgkDefaultDigitsFileName;
-  this->Add(new AliITSBeamTestDigSPD("DigSPD","SPD Digitization")); 
-  this->Add(new AliITSBeamTestDigSDD("DigSDD","SDD Digitization")); 
-  this->Add(new AliITSBeamTestDigSSD("DigSSD","SSD Digitization"));
-
-  SetFlagInit(kTRUE);
-}
-
-
-//______________________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt),
-fEvIn(bt.fEvIn),
-fEvFin(bt.fEvFin),
-fRunNumber(bt.fRunNumber),
-fDATEEvType(bt.fDATEEvType),
-fFlagHeader(bt.fFlagHeader),
-fFlagInit(bt.fFlagInit),
-fOptDate(bt.fOptDate),
-fDigitsFileName(bt.fDigitsFileName),
-fRawdataFileName(bt.fRawdataFileName),
-fPeriod(bt.fPeriod),
-fRunLoader(bt.fRunLoader),
-fLoader(bt.fLoader),
-fHeader(bt.fHeader){
-  // Copy constructor. 
-}
-//______________________________________________________________________
-AliITSBeamTestDigitizer& AliITSBeamTestDigitizer::operator=(const AliITSBeamTestDigitizer &source){
-    // Assignment operator. 
-  this->~AliITSBeamTestDigitizer();
-  new(this) AliITSBeamTestDigitizer(source);
-  return *this;
-}
-
-
-//______________________________________________________________
-AliITSBeamTestDigitizer::~AliITSBeamTestDigitizer(){
-
-  //Destructor
-  //  if(fBt) delete fBt;
-  if(fLoader) delete fLoader;
-  if(fHeader) delete fHeader;
-} 
-
-
-//_____________________________________________________________
-void AliITSBeamTestDigitizer::SetNumberOfEventsPerFile(Int_t nev)
-{
-  //Sets number of events per file
-
-  if(fRunLoader) fRunLoader->SetNumberOfEventsPerFile(nev);
-  else Warning("SetNumberOfEventsPerFile","fRunLoader is 0");
-}
-
-
-//____________________________________________________
-void AliITSBeamTestDigitizer::ExecDigitization(){
-
-  // Execution of digitisation for SPD,SDD and SSD
-
-  if(!GetFlagInit()){
-    Warning("ExecDigitization()","Run Init() please..");
-    return;
-  }
-  fLoader->SetDigitsFileName(fDigitsFileName);
-  fLoader->LoadDigits("recreate");
-  AliRawReader* rd;
-
-
-  TString strFile = fRawdataFileName;
-  strFile += Form("?EventType=%d",fDATEEvType);
-  if(GetOptDate()) rd = new AliRawReaderDate(strFile.Data(),fEvIn);
-  else rd = new AliRawReaderRoot(strFile.Data(),fEvIn);
-
-  AliHeader* header = fRunLoader->GetHeader();
-  Int_t iev=fEvIn-1;
-
-  
-  AliITSBeamTestDigSDD* digSDD = (AliITSBeamTestDigSDD*)fTasks->FindObject("DigSDD");
-  AliITSBeamTestDigSPD* digSPD = (AliITSBeamTestDigSPD*)fTasks->FindObject("DigSPD");
-  AliITSBeamTestDigSSD* digSSD = (AliITSBeamTestDigSSD*)fTasks->FindObject("DigSSD");
-
-
-  do{
-    iev++;
-    if(fEvFin!=0){
-      if(iev>fEvFin) break;
-    } 
-    AliITSEventHeader* itsh = new AliITSEventHeader("ITSHeader");
-    fRunLoader->SetEventNumber(iev);
-   
-    rd->RequireHeader(fFlagHeader);
-    digSDD->SetRawReader(rd);
-    digSPD->SetRawReader(rd);
-    digSSD->SetRawReader(rd);
-    
-    if(fLoader->TreeD() == 0x0) fLoader->MakeTree("D");
-
-    TTree* treeD = (TTree*)fLoader->TreeD();
-   
-    // Make branches outside the dig-classes
-
-    TClonesArray* digitsSPD = new TClonesArray("AliITSdigitSPD",1000);
-    treeD->Branch("ITSDigitsSPD",&digitsSPD);
-    TClonesArray* digitsSDD = new TClonesArray("AliITSdigitSDD",1000);
-    treeD->Branch("ITSDigitsSDD",&digitsSDD);
-   
-    TClonesArray* digitsSSD = new TClonesArray("AliITSdigitSSD",1000);
-    treeD->Branch("ITSDigitsSSD",&digitsSSD);
-
-
-    digSSD->SetTree(treeD);
-    digSDD->SetTree(treeD);
-    digSPD->SetTree(treeD);
-    
-    AliITSgeom* geom = fLoader->GetITSgeom();
-
-    digSSD->SetITSgeom(geom);
-    digSDD->SetITSgeom(geom);
-    digSPD->SetITSgeom(geom);
-    
-    digSSD->SetITSEventHeader(itsh);
-    digSDD->SetITSEventHeader(itsh);
-    digSPD->SetITSEventHeader(itsh);
-
-    digSDD->SetBtPeriod(GetBeamTestPeriod());
-    if(GetBeamTestPeriod()==1)digSDD->SetThreshold(16);
-    else digSDD->SetThreshold(0);
-    ExecuteTask(0);  
-
-    header->SetEventNrInRun(iev);
-    header->SetEvent(iev);
-    header->SetRun(fRunNumber);
-    fRunLoader->GetHeader()->AddDetectorEventHeader(itsh);
-    fRunLoader->TreeE()->Fill();
-    header->Reset(fRunNumber,iev);
-    
-    delete digitsSPD;
-    delete digitsSDD;
-    delete digitsSSD;
-
-   }while(rd->NextEvent());
-
-  
-  fRunLoader->WriteHeader("OVERWRITE");
-  fRunLoader->WriteRunLoader("OVERWRITE");
-
-  delete rd;
-  fLoader->UnloadDigits();
-  fLoader->UnloadRawClusters();
-  fRunLoader->UnloadHeader();
-
-  
-}
-
-
-
-//_______________________________________________
-void AliITSBeamTestDigitizer:: SetActive(const TString& subdet,Bool_t value){
-
-  //Sets active sub-tasks (detectors)
-  
-  Bool_t sdd = subdet.Contains("SDD");
-  Bool_t spd = subdet.Contains("SPD");
-  Bool_t ssd = subdet.Contains("SSD");
-
-  if(sdd){
-  AliITSBeamTestDigSDD* digSDD = (AliITSBeamTestDigSDD*)fTasks->FindObject("DigSDD");
-  digSDD->SetActive(value);
-  }
-  
- if(spd){
-  AliITSBeamTestDigSPD* digSPD = (AliITSBeamTestDigSPD*)fTasks->FindObject("DigSPD");
-  digSPD->SetActive(value);
-  
-  }
-  if(ssd){
-  AliITSBeamTestDigSSD* digSSD = (AliITSBeamTestDigSSD*)fTasks->FindObject("DigSSD");
-  digSSD->SetActive(value);
-  
-  }
-
-
-
-}
-
diff --git a/ITS/AliITSBeamTestDigitizer.h b/ITS/AliITSBeamTestDigitizer.h
deleted file mode 100644 (file)
index 7e25deb..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef ALIITSBEAMTESTDIGITIZER_H
-#define ALIITSBEAMTESTDIGITIZER_H
-
-////////////////////////////////////////////////////
-//  Class to manage the                           //
-//  ITS beam test conversion from rawdata         //
-//  to digits. It executes the digitization for   //
-//  SPD, SDD and SSD.                             //
-//  Origin:  E. Crescio crescio@to.infn.it        //
-//           J. Conrad  Jan.Conrad@cern.ch        //
-//                                                //
-//  The choice of the beam test period is by      //
-//  deafult Nov04 (Integrated ITS beam test of    //
-//  November 2004). To choose the SDD beam test   //
-//  of August 2004 call the constructor:          //
-//  AliITSBeamTestDigitizer("name","title","Aug04"//
-//                                                //
-////////////////////////////////////////////////////
-#include <TTask.h>
-
-
-class AliITSBeamTestDigSDD;
-class AliRawReaderDate;
-class AliRunLoader;
-class AliITSLoader;
-class AliITSEventHeader;
-class AliRawDataHeader;
-
-
-class AliITSBeamTestDigitizer : public TTask {
- public:
-  AliITSBeamTestDigitizer(); 
-  AliITSBeamTestDigitizer(const Text_t* name,const Text_t* title, 
-                         const Char_t* opt="Nov04",const char* filename="galice.root");
-  AliITSBeamTestDigitizer(const Text_t* name,const Text_t* title, 
-                         Int_t run, const Char_t* opt="Nov04",const char* filename="galice.root");
-  AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer& bt);
-  AliITSBeamTestDigitizer& operator=(const AliITSBeamTestDigitizer &source);
-
-  virtual ~AliITSBeamTestDigitizer();
-
-  void SetDigitsFileName(const TString& name)     {fDigitsFileName=name;}
-  void SetRawdataFileName(const TString& name) {fRawdataFileName=name;}
-  void SetNumberOfEventsPerFile(Int_t nev); 
-
-  void SetStartEventNumber(Int_t evin) {fEvIn=evin;}
-  void SetStopEventNumber(Int_t evfin) {fEvFin=evfin;}
-  void SetFlagHeader(Bool_t flag=kFALSE){fFlagHeader=flag;}
-  void SetFlagInit(Bool_t flag=kFALSE){fFlagInit=flag;}
-  void SelectEvents(Int_t eventtype) {fDATEEvType=eventtype;}
-  void SetBeamTestPeriod(BeamtestPeriod_t per=kNov04) {fPeriod=per;}
-  void SetRunNumber(Int_t run) {fRunNumber=run;}
-  void SetOptDate(Bool_t opt=kFALSE) {fOptDate=opt;}
-
-  void SetActive(const TString& subdet,Bool_t value);
-
-  void ExecDigitization();
-  void Init(const char* filename);
-  Int_t GetRunNumber()  const {return fRunNumber;}
-  Bool_t GetFlagInit()  const {return fFlagInit;}
-  Bool_t GetOptDate() const {return fOptDate;}
-  BeamtestPeriod_t GetBeamTestPeriod() const {return fPeriod;}
-
-
- protected:
-
-
-  Int_t    fEvIn;                   //starting event to be read
-  Int_t    fEvFin;                  //last event to be read
-  Int_t    fRunNumber;              //run number 
-  Int_t    fDATEEvType;             //date eventtype (JC) 
-
-  Bool_t   fFlagHeader;             //flag for the hader 
-  Bool_t   fFlagInit;               //flag for initialization
-  Bool_t   fOptDate;                //option for reading date format files
-                                    //(default: reads root files)                                    
-
-  TString  fDigitsFileName;         //Digits file name
-  TString  fRawdataFileName;        //Raw data file name
-  BeamtestPeriod_t  fPeriod;                 //Beam test period
-
-  AliRunLoader* fRunLoader;         // Local pointer to run loader
-  AliITSLoader* fLoader;            // Pointer to ITS loader
-
-  const AliRawDataHeader* fHeader;  //!current data header
-
-  static const TString fgkDefaultDigitsFileName; // default name for dig. file  
-
-  ClassDef(AliITSBeamTestDigitizer,3)  // An Alice SDD beam test digitization class 
-
-  };
-
-
-#endif
-
-    
index 64d8938..03cc2cf 100644 (file)
@@ -170,26 +170,6 @@ AliITSgeom* AliITSInitGeometry::CreateAliITSgeom(Int_t major,Int_t minor){
     //   pointer = 0 then failed to init.
 
     switch(major){
-    case kvtest:
-        SetGeometryName("AliITSvtest");
-        SetVersion(kvtest,minor);
-        break;
-    case kvSPD02:
-        SetGeometryName("AliITSvSPD02");
-        SetVersion(kvSPD02,minor);
-        break;
-    case kvSDD03:
-        SetGeometryName("AliITSvSDD03");
-        SetVersion(kvSDD03,minor);
-        break;
-    case kvSSD03:
-        SetGeometryName("AliITSvSSD03");
-        SetVersion(kvSSD03,minor);
-        break;
-    case kvITS04:
-        SetGeometryName("AliITSvBeamTest03");
-        SetVersion(kvITS04,minor);
-        break;
     case kvPPRcourseasymm:
         SetGeometryName("AliITSvPPRcourseasymm");
         SetVersion(kvPPRcourseasymm,minor);
@@ -239,22 +219,6 @@ Bool_t AliITSInitGeometry::InitAliITSgeom(AliITSgeom *geom){
         return kFALSE;
     } // end if
     switch(fMajorVersion) {
-    case kvtest: {
-        if(GetMinorVersion()==1) return InitAliITSgeomPPRasymmFMD(geom);
-        else if(GetMinorVersion()==2) return InitAliITSgeomtest2(geom);
-    } break; // end case
-    case kvSPD02: { 
-        return InitAliITSgeomSPD02(geom);
-    } break; // end case
-    case kvSDD03: { 
-        return InitAliITSgeomSDD03(geom);
-    } break; // end case
-    case kvSSD03: { 
-        return InitAliITSgeomSSD03(geom);
-    } break; // end case
-    case kvITS04: { 
-        return InitAliITSgeomITS04(geom);
-    } break; // end case
     case kvPPRasymmFMD: { 
         return InitAliITSgeomPPRasymmFMD(geom);
     } break; // end case
@@ -299,393 +263,7 @@ void AliITSInitGeometry::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
     m->SetRotation(r);
     return;
 }
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomtest2(AliITSgeom *geom){
-    // Initilizes the geometry transformation class AliITSgeom
-    // to values appropreate to this specific geometry. Now that
-    // the segmentation is part of AliITSgeom, the detector
-    // segmentations are also defined here.
-    // Inputs:
-    //   AliITSgeom *geom  A pointer to the AliITSgeom class
-    // Outputs:
-    //   AliITSgeom *geom  This pointer recreated and properly inilized.
-    // Return:
-    //   none.
-    //  const Double_t kcm2micron = 1.0E4;
-    const Int_t kItype=0; // Type of transormation defined 0=> Geant
-    const Int_t klayers = 6; // number of layers in the ITS
-    const Int_t kladders[klayers]   = {1,1,1,1,1,1}; // Number of ladders
-    const Int_t kdetectors[klayers] = {1,1,1,1,1,1};// number of detector/lad
-    const AliITSDetector kIdet[6]   = {kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
-    const TString kNames[klayers] = {
-        "/ALIC_1/ITSV_1/ITSspd1_1/ITS1_1", // lay=1
-        "/ALIC_1/ITSV_1/ITSspd2_1/ITS2_1", // lay=2
-        "/ALIC_1/ITSV_1/ITSsdd1_1/ITS3_1", // lay=3
-        "/ALIC_1/ITSV_1/ITSsdd2_1/ITS4_1", // lay=4
-        "/ALIC_1/ITSV_1/ITSssd1_1/ITS5_1", // lay=5
-        "/ALIC_1/ITSV_1/ITSssd2_1/ITS6_1"};// Lay=6
-    Int_t mod,nmods=0,lay,lad,det,cpn0,cpn1,cpn2;
-    Double_t tran[3]={0.0,0.0,0.0},rot[10]={9*0.0,1.0};
-    TArrayD shapePar;
-    TString shapeName;
-    TGeoHMatrix matrix;
-    Bool_t initSeg[3]={kFALSE,kFALSE,kFALSE};
-    TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
 
-    if(fTiming) time->Start();
-    for(mod=0;mod<klayers;mod++) nmods += kladders[mod]*kdetectors[mod];
-    geom->Init(kItype,klayers,kladders,kdetectors,nmods);
-    for(mod=0;mod<nmods;mod++){
-        DecodeDetectorLayers(mod,lay,lad,det); // Write
-        geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot);
-        RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det.
-        geom->GetGeomMatrix(mod)->SetPath(kNames[lay-1]);
-        GetTransformation(kNames[lay-1].Data(),matrix);
-        geom->SetTrans(mod,matrix.GetTranslation());
-        TransposeTGeoHMatrix(&matrix); // Transpose TGeo's rotation matrixes
-        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
-        if(initSeg[kIdet[lay-1]]) continue;
-        GetShape(kNames[lay-1],shapeName,shapePar);
-        if(shapeName.CompareTo("BOX")){
-            Error("InitITSgeom2","Geometry changed without proper code update"
-                  "or error in reading geometry. Shape is not BOX shape is %s",
-                  shapeName.Data());
-            return kFALSE;
-        } // end if
-       InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
-    } // end for module
-    if(fTiming){
-        time->Stop();
-        time->Print();
-        delete time;
-    } // end if
-    return kTRUE;
-}
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomSPD02(AliITSgeom *geom){
-    // Initilizes the geometry transformation class AliITSgeom
-    // to values appropreate to this specific geometry. Now that
-    // the segmentation is part of AliITSgeom, the detector
-    // segmentations are also defined here.
-    // Inputs:
-    //   AliITSgeom *geom  A pointer to the AliITSgeom class
-    // Outputs:
-    //   AliITSgeom *geom  This pointer recreated and properly inilized.
-    // Return:
-    //   none.
-    const Int_t kltypess=2;
-    const Int_t knlayers=5;
-    const TString knames[kltypess]=
-        {"ALIC_1/ITSV_1/ITEL_%d/IMB0_1/IMBS_1",//lay=1,2,4,5
-         "ALIC_1/ITSV_1/IDET_%d/ITS0_1/ITST_1"};// lay=3
-    const Int_t kitsGeomTreeCopys[2]={4,1};
-    const Int_t knlad[knlayers]={knlayers*1},kndet[knlayers]={knlayers*1};
-    TString path,shapeName;
-    TGeoHMatrix matrix;
-    TArrayD shapePar;
-    TArrayF shapeParF;
-    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
-    Int_t npar=3,mod,i,j,lay,lad,det,cpy;
-    Float_t par[20];
-    TStopwatch *time = 0x0;if(fTiming) time=new TStopwatch();
-
-    par[0]=0.64;par[1]=0.5*300.0E-4;par[2]=3.48;
-    mod=5;;
-    geom->Init(0,knlayers,knlad,kndet,mod);
-
-    if(fTiming) time->Start();
-    for(i=0;i<kltypess;i++)for(cpy=1;cpy<=kitsGeomTreeCopys[i];cpy++){
-        path.Form(knames[i].Data(),cpy);
-        GetTransformation(path.Data(),matrix);
-        GetShape(path.Data(),shapeName,shapePar);
-        shapeParF.Set(shapePar.GetSize());
-        for(j=0;j<shapePar.GetSize();j++) shapeParF[j]=shapePar[j];
-        lay = cpy;
-        if(i==0&&cpy>2) lay=cpy+1;
-        if(i==1) lay=3;
-        DecodeDetector(mod,kitsGeomTreeCopys[i],1,cpy,0);
-        DecodeDetectorLayers(mod,lay,lad,det);
-        geom->CreateMatrix(mod,lay,lad,det,kSPD,trans,rot);
-        geom->SetTrans(mod,matrix.GetTranslation());
-        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
-        geom->GetGeomMatrix(mod)->SetPath(path.Data());
-        if(!(geom->IsShapeDefined((Int_t)kSPD)))
-            geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(npar,par));
-    } // end for i,cpy/
-    if(fTiming){
-        time->Stop();
-        time->Print();
-        delete time;
-    } // end if
-    return kTRUE;
-}
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomSDD03(AliITSgeom *geom){
-    // Initilizes the geometry transformation class AliITSgeom
-    // to values appropreate to this specific geometry. Now that
-    // the segmentation is part of AliITSgeom, the detector
-    // segmentations are also defined here.
-    // Inputs:
-    //   AliITSgeom *geom  A pointer to the AliITSgeom class
-    // Outputs:
-    //   AliITSgeom *geom  This pointer recreated and properly inilized.
-    // Return:
-    //   none
-    const Int_t knlayers=12;
-    //   const Int_t kndeep=6;
-    const Int_t kltypess=2;
-    const AliITSDetector kidet[knlayers]={kSSD,kSDD};
-    const TString knames[kltypess]={
-        "/ALIC_1/ITSV_1/ITEL_%d/ITAI_1/IMB0_1/IMBS_1",
-        "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
-    const Int_t kitsGeomTreeCopys[kltypess]={10,2};
-    const Int_t knp=384;
-    const Float_t kpitch=50.E-4;/*cm*/
-    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
-    Int_t nlad[knlayers]={knlayers*1};
-    Int_t ndet[knlayers]={knlayers*1};
-    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
-    TString path,shapeName;
-    TGeoHMatrix matrix;
-    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
-    TArrayD shapePar;
-    TArrayF shapeParF;
-    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
-
-    geom->Init(0,knlayers,nlad,ndet,mod);
-    p[0]=-box[0];
-    n[0]=box[0];
-    // Fill in anode and cathode strip locations (lower edge)
-    for(i=1;i<knp;i++){
-        p[i] =p[i-1]+kpitch;
-        n[i] =n[i-1]-kpitch;
-    } // end for i
-    p[knp]=box[0];
-    n[knp]=-box[0];
-    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
-        DecodeDetector(mod,kitsGeomTreeCopys[i],cp0,1,2);
-        DecodeDetectorLayers(mod,lay,lad,det);
-        path.Form(knames[i].Data(),cp0);
-        GetTransformation(path.Data(),matrix);
-        GetShape(path.Data(),shapeName,shapePar);
-        shapeParF.Set(shapePar.GetSize());
-        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
-        geom->CreateMatrix(mod,lay,lad,det,kidet[i],trans,rot);
-        geom->SetTrans(mod,matrix.GetTranslation());
-        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
-        geom->GetGeomMatrix(mod)->SetPath(path.Data());
-        switch (kidet[i]){
-        case kSDD: if(!(geom->IsShapeDefined((Int_t)kSDD))){
-            geom->ReSetShape(kSDD,new AliITSgeomSDD256(shapeParF.GetSize(),
-                                                       shapeParF.GetArray()));
-            isShapeDefined[i]=kTRUE;
-        } break;
-        case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
-            geom->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
-                                                    knp+1,p,knp+1,n));
-            isShapeDefined[i]=kTRUE;
-        } break;
-        default:{} break;
-        } // end switch
-    } // end for i,cp0
-
-    return kTRUE;
-}
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomSSD03(AliITSgeom *geom){
-    // Initilizes the geometry transformation class AliITSgeom
-    // to values appropreate to this specific geometry. Now that
-    // the segmentation is part of AliITSgeom, the detector
-    // segmentations are also defined here.
-    // Inputs:
-    //   AliITSgeom *geom  A pointer to the AliITSgeom class
-    // Outputs:
-    //   AliITSgeom *geom  This pointer recreated and properly inilized.
-    // Return:
-    //   none.
-    const Int_t knlayers=5;
-    //   const Int_t kndeep=6;
-    const Int_t kltypess=3;
-    const AliITSDetector kIdet[knlayers]={kND,kSSD,kND};
-    const TString knames[kltypess]={
-        "/ALIC_1/ITSV_1/ITSA_%d/ITSS_1",
-        "/ALIC_1/ITSV_1/IGAR_%d/IAIR_1/ITST_1",
-        "/ALIC_1/ITSV_1/IFRA_%d/IFRS_1"};
-    const Int_t kitsGeomTreeCopys[kltypess]={3,1,1};
-    const Int_t kitsGeomDetTypes[kltypess]={1,2,3};
-    const Int_t knp=384;
-    const Float_t kpitch=50.E-4;//cm
-    Bool_t initSeg[3]={kFALSE, kFALSE, kFALSE};
-    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
-    Int_t nlad[knlayers]={knlayers*1};
-    Int_t ndet[knlayers]={knlayers*1};
-    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
-    TString path,shapeName;
-    TGeoHMatrix matrix;
-    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
-    TArrayD shapePar;
-    TArrayF shapeParF;
-    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
-
-    geom->Init(0,knlayers,nlad,ndet,mod);
-    p[0]=-box[0];
-    n[0]=box[0];
-    // Fill in anode and cathode strip locations (lower edge)
-    for(i=1;i<knp;i++){
-        p[i] =p[i-1]+kpitch;
-        n[i] =n[i-1]-kpitch;
-    } // end for i
-    p[knp]=box[0];
-    n[knp]=-box[0];
-    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
-        DecodeDetector(mod,kitsGeomDetTypes[i],cp0,1,0);
-        DecodeDetectorLayers(mod,lay,lad,det);
-        path.Form(knames[i].Data(),cp0);
-        GetTransformation(path.Data(),matrix);
-        GetShape(path.Data(),shapeName,shapePar);
-        shapeParF.Set(shapePar.GetSize());
-        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
-        geom->CreateMatrix(mod,lay,lad,det,kIdet[i],trans,rot);
-        geom->SetTrans(mod,matrix.GetTranslation());
-        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
-        geom->GetGeomMatrix(mod)->SetPath(path.Data());
-        switch (kIdet[i]){
-        case kSSD:if(!(geom->IsShapeDefined((Int_t)kSSD))){
-            InitGeomShapePPRasymmFMD(kIdet[lay-1],initSeg,shapePar,geom);
-            isShapeDefined[i]=kTRUE;
-        } break;
-        default:{} break;
-        } // end switch
-    } // end for i,cp0
-
-    return kTRUE;
-}
-//______________________________________________________________________
-Bool_t AliITSInitGeometry::InitAliITSgeomITS04(AliITSgeom *geom) const{
-    // Initilizes the geometry transformation class AliITSgeom
-    // to values appropreate to this specific geometry. Now that
-    // the segmentation is part of AliITSgeom, the detector
-    // segmentations are also defined here.
-    // Inputs:
-    //   AliITSgeom *geom  A pointer to the AliITSgeom class
-    // Outputs:
-    //   AliITSgeom *geom  This pointer recreated and properly inilized.
-    // Return:
-    //   none.
-
-  // We can not use AliITSvBeamTestITS04::fgk... data members because
-  // AliITSInitGeometry is part of the base library while AliITSvBeamTestITS04
-  // is part of the simulation library. This would introduce a dependance
-  // between the 2 libraries
-
-
-    const Int_t knlayers = 6;
-    Int_t nlad[knlayers], ndet[knlayers];
-    
-    nlad[0] = 1; ndet[0] = 2;
-    nlad[1] = 1; ndet[1] = 2;
-    nlad[2] = 1; ndet[2] = 1;
-    nlad[3] = 1; ndet[3] = 1;
-    nlad[4] = 1; ndet[4] = 2;
-    nlad[5] = 1; ndet[5] = 2;
-
-    Int_t nModTot = 10;
-    geom->Init(0,knlayers,nlad,ndet,nModTot);
-
-    /*
-    //=== Set default shapes 
-    const Float_t kDxyzSPD[] = {AliITSvBeamTestITS04::fgkSPDwidthSens/2,
-                                AliITSvBeamTestITS04::fgkSPDthickSens/2,
-                                AliITSvBeamTestITS04::fgkSPDlengthSens/2};  
-    if(!(geom->IsShapeDefined(kSPD)))
-       geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
-    
-    const Float_t kDxyzSDD[] = {AliITSvBeamTestITS04::fgkSDDwidthSens/2.,
-                                AliITSvBeamTestITS04::fgkSDDthickSens/2.,
-                                AliITSvBeamTestITS04::fgkSDDlengthSens/2.};
-    if(!(geom->IsShapeDefined(kSDD)))
-       geom->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
-    
-    const Float_t kDxyzSSD[] = {AliITSvBeamTestITS04::fgkSSDlengthSens/2,
-                                AliITSvBeamTestITS04::fgkSSDthickSens/2,
-                                AliITSvBeamTestITS04::fgkSSDwidthSens/2};
-    if(!(geom->IsShapeDefined(kSSD)))
-       geom->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
-    
-    // Creating the matrices in AliITSgeom for each sensitive volume
-    // (like in AliITSv11GeometrySDD) mln
-    // Here, each layer is one detector
-    
-    char layerName[30];
-    Int_t startMod = 0,mod;
-    TGeoVolume *itsmotherVolume = gGeoManager->GetVolume("ITSV");
-    // SPD
-    for (Int_t i=0; i<4;i++) {
-       sprintf(layerName, "ITSspdWafer_%i",i+1);
-       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           Int_t iLad = 1;
-           Int_t iLay = 1;
-            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
-            DecodeDetectorLayers(mod,iLay,iLad,iDet);
-           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
-           startMod++;
-       };
-    };
-    
-    // SDD
-    for (Int_t i=0; i<2;i++) {
-       sprintf(layerName, "ITSsddWafer_%i",i+4+1);
-       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           Int_t iLad = 1;
-           Int_t iLay = 1;
-            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
-            DecodeDetectorLayers(mod,iLay,iLad,iDet);
-           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
-           startMod++;
-       };
-    };
-    
-    // SSD
-    for (Int_t i=0; i<4;i++) {
-       sprintf(layerName, "ITSssdWafer_%i",i+4+2+1);
-       TGeoNode *layNode = itsmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           Int_t iLad = 1;
-           Int_t iLay = 5;
-            DecodeDetector(mod,layNode->GetNumber(),i+1,0,0);
-            DecodeDetectorLayers(mod,iLay,iLad,iDet);
-           geom->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
-           startMod++;
-       };
-    };
-
-    return kTRUE;
-  */
-    return kFALSE;
-}
 //______________________________________________________________________
 Bool_t AliITSInitGeometry::InitAliITSgeomPPRasymmFMD(AliITSgeom *geom){
     // Initilizes the geometry transformation class AliITSgeom
@@ -1422,30 +1000,9 @@ void AliITSInitGeometry::DecodeDetector(
     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
     // like them but I see not better way for the moment.
     switch (fMajorVersion){
-    case kvtest:{
-        if(GetMinorVersion()==1)
-            return DecodeDetectorvPPRasymmFMD(mod,layer,cpn0,cpn1,cpn2);
-        else if(GetMinorVersion()==2)
-            return DecodeDetectorvtest2(mod,layer,cpn0,cpn1,cpn2);
-        Warning("DecodeDetector",
-                "Geometry is kvtest minor version=%d is not defined",
-                GetMinorVersion());
-    }break;
     case kvDefault:{
         Error("DecodeDetector","Major version = kvDefault, not supported");
     }break;
-    case kvSPD02:{
-        return DecodeDetectorvSPD02(mod,layer,cpn0,cpn1,cpn2);
-    }break;
-    case kvSDD03:{
-        return DecodeDetectorvSDD03(mod,layer,cpn0,cpn1,cpn2);
-    }break;
-    case kvSSD03:{
-        return DecodeDetectorvSSD03(mod,layer,cpn0,cpn1,cpn2);
-    }break;
-    case kvITS04:{
-        return DecodeDetectorvITS04(mod,layer,cpn0,cpn1,cpn2);
-    }break;
     case kvPPRcourseasymm:{
         return DecodeDetectorvPPRcourseasymm(mod,layer,cpn0,cpn1,cpn2);
     }break;
@@ -1485,32 +1042,10 @@ void AliITSInitGeometry::RecodeDetector(Int_t mod,Int_t &cpn0,
     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
     // like them but I see not better way for the moment.
     switch (fMajorVersion){
-    case kvtest:{
-        if(GetMinorVersion()==1) 
-            return RecodeDetectorvPPRasymmFMD(mod,cpn0,cpn1,cpn2);
-        else if(GetMinorVersion()==2)
-            return RecodeDetectorvtest2(mod,cpn0,cpn1,cpn2);
-        Warning("RecodeDetector",
-                "Geometry is kvtest minor version=%d is not defined",
-                GetMinorVersion());
-        return;
-    }break;
     case kvDefault:{
         Error("RecodeDetector","Major version = kvDefault, not supported");
         return;
-    }break;
-    case kvSPD02:{
-        return RecodeDetectorvSPD02(mod,cpn0,cpn1,cpn2);
-    }break;
-    case kvSDD03:{
-        return RecodeDetectorvSDD03(mod,cpn0,cpn1,cpn2);
-    }break;
-    case kvSSD03:{
-        return RecodeDetectorvSSD03(mod,cpn0,cpn1,cpn2);
-    }break;
-    case kvITS04:{
-        return RecodeDetectorvITS04(mod,cpn0,cpn1,cpn2);
-    }break;
+    }
     case kvPPRcourseasymm:{
         return RecodeDetectorvPPRcourseasymm(mod,cpn0,cpn1,cpn2);
     }break;
@@ -1553,33 +1088,11 @@ void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
     // This is a FIXED switch yard function. I (Bjorn Nilsen) Don't 
     // like them but I see not better way for the moment.
     switch (fMajorVersion) {
-    case kvtest:{
-        if(GetMinorVersion()==1) 
-            return DecodeDetectorLayersvPPRasymmFMD(mod,layer,lad,det);
-        else if(GetMinorVersion()==2)
-            return DecodeDetectorLayersvtest2(mod,layer,lad,det);
-        Warning("DecodeDetectorLayers",
-                "Geometry is kvtest minor version=%d is not defined",
-                GetMinorVersion());
-        return;
-    } break;
     case kvDefault:{
         Error("DecodeDetectorLayers",
               "Major version = kvDefault, not supported");
         return;
     }break;
-    case kvSPD02:{
-        return DecodeDetectorLayersvSPD02(mod,layer,lad,det);
-    }break;
-    case kvSDD03:{
-        return DecodeDetectorLayersvSDD03(mod,layer,lad,det);
-    }break;
-    case kvSSD03:{
-        return DecodeDetectorLayersvSSD03(mod,layer,lad,det);
-    }break;
-    case kvITS04:{
-        return DecodeDetectorLayersvITS04(mod,layer,lad,det);
-    }break;
     case kvPPRcourseasymm:{
         return DecodeDetectorLayersvPPRcourseasymm(mod,layer,lad,det);
     }break;
@@ -1600,317 +1113,7 @@ void AliITSInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
     } // end switch
     return;
 }
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorvSPD02(
-    Int_t &mod,Int_t ncpn,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
-    // decode geometry into detector module number
-    // Inputs:
-    //    Int_t ncpn     The Number of copies of this volume
-    //    Int_t cpy0     The lowest copy number
-    //    Int_t cpy1     The middle copy number
-    //    Int_t cpy2     the highest copy number
-    // Output:
-    //    Int_t &mod     The module number assoicated with this set
-    //                   of copy numbers.
-    // Return:
-    //    none.
-
-    // detector = ladder = 1
-    if(ncpn==4 && cpy1>2) mod = cpy1; // layer = 1,2
-    else mod = cpy1-1; // layer = 4,5
-    if(ncpn==1) mod = 2; // layer=3
-    cpy0 = cpy2;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::RecodeDetectorvSPD02(Int_t mod,Int_t &cpn0,
-                                        Int_t &cpn1,Int_t &cpn2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Return:
-    //    none.
-
-    cpn2 = 0;
-    if(mod==2){
-        cpn0 = 1;
-        cpn1 = 1;
-        return;
-    } else if(mod<2){
-        cpn0 = 1;
-        cpn1 = mod+1;
-    }else{
-        cpn0 = 1;
-        cpn1 = mod;
-    } // end if
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayersvSPD02(Int_t mod,Int_t &lay,
-                                            Int_t &lad,Int_t &det) const{
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose. Note, this use of layer ladder
-    // and detector numbers are strictly for internal use of this
-    // specific code. They do not represent the "standard" layer ladder
-    // or detector numbering except in a very old and obsoleate sence.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t lay     The layer number
-    //    Int_t lad     The ladder number
-    //    Int_t det     the dettector number
-    // Return:
-    //    none.
-
-    lay = mod+1;
-    lad = det = 1;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorvSDD03(
-    Int_t &mod,Int_t ncpys,Int_t cpy0,Int_t cpy1,Int_t cpy2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t ncpys    The number of posible copies cpn1
-    //    Int_t cpy0     The lowest copy number
-    //    Int_t cpy1     The middle copy number
-    //    Int_t cpy2     the highest copy number
-    // Output:
-    //    Int_t &mod     The module number assoicated with this set
-    //                   of copy numbers.
-    // Return:
-    //    none.
 
-    if(ncpys==10){ // ITEL detectors
-        if(cpy1>4) mod = cpy1+1;
-        else mod = cpy1-1;
-    }else{ // IDET detectors
-        if(cpy1==1) mod = 4;
-        else mod = 5;
-    } // end if
-    cpy0=cpy2;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::RecodeDetectorvSDD03(Int_t mod,Int_t &cpn0,
-                                        Int_t &cpn1,Int_t &cpn2) const{
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Return:
-    //    none.
-
-    cpn0 = 1;
-    cpn2 = 0;
-    if(mod<4) cpn1 = mod+1;
-    else if(mod==4||mod==5) cpn1 = mod-3;
-    else cpn1 = mod-1;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayersvSDD03(Int_t mod,Int_t &lay,
-                                                 Int_t &lad,Int_t &det) const{
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose. Note, this use of layer ladder
-    // and detector numbers are strictly for internal use of this
-    // specific code. They do not represent the "standard" layer ladder
-    // or detector numbering except in a very old and obsoleate sence.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t lay     The layer number
-    //    Int_t lad     The ladder number
-    //    Int_t det     the dettector number
-    // Return:
-    //    none.
-
-    lad = det = 1;
-    lay = mod+1;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorvSSD03(
-    Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Output:
-    //    Int_t &mod     The module number assoicated with this set
-    //                   of copy numbers.
-    // Return:
-    //    none.
-
-    if(dtype==2){mod=2; return;}
-    if(dtype==3){mod=3; return;}
-    mod = cpn0-1;
-    if(cpn0==3) mod = 4;
-    cpn1=cpn2;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::RecodeDetectorvSSD03(Int_t mod,Int_t &cpn0,
-                                        Int_t &cpn1,Int_t &cpn2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Return:
-    //    none.
-
-    cpn1=1;
-    cpn2=0;
-    if(mod<2) cpn0=mod+1;
-    else if (mod==2||mod==3) cpn0=1;
-    else cpn0 = 3;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayersvSSD03(Int_t mod,Int_t &lay,
-                                                Int_t &lad,Int_t &det) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose. Note, this use of layer ladder
-    // and detector numbers are strictly for internal use of this
-    // specific code. They do not represent the "standard" layer ladder
-    // or detector numbering except in a very old and obsoleate sence.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t lay     The layer number
-    //    Int_t lad     The ladder number
-    //    Int_t det     the dettector number
-    // Return:
-    //    none.
-
-    lad = det = 1;
-    lay = mod+1;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorvITS04(
-    Int_t &mod,Int_t dtype,Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t dtype    The detector type 1=ITSA 2=IGAR 3=IFRA
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Output:
-    //    Int_t &mod     The module number assoicated with this set
-    //                   of copy numbers.
-    // Return:
-    //    none.
-
-    mod = dtype-1;
-    cpn0 = cpn1 = cpn2;
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::RecodeDetectorvITS04(Int_t mod,Int_t &cpn0,
-                                        Int_t &cpn1,Int_t &cpn2) const {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Return:
-    //    none.
-
-    cpn1 = cpn2 = 0;
-    switch(mod){
-    case 0:case 1:case 2:case 3:{
-        cpn0 = mod+1;
-    }break;
-    case 4: case 5:{
-        cpn0 = mod-3;
-    }break;
-    case 6:case 7:case 8:case 9:{
-        cpn0 = mod-5;
-    } break;
-    default:
-        cpn0 = 0;
-        break;
-    }// end switch
-    return;
-}
-//______________________________________________________________________
-void AliITSInitGeometry::DecodeDetectorLayersvITS04(Int_t mod,Int_t &lay,
-                                             Int_t &lad,Int_t &det) const{
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose. Note, this use of layer ladder
-    // and detector numbers are strictly for internal use of this
-    // specific code. They do not represent the "standard" layer ladder
-    // or detector numbering except in a very old and obsoleate sence.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t lay     The layer number
-    //    Int_t lad     The ladder number
-    //    Int_t det     the dettector number
-    // Return:
-    //    none.
-
-    lad = 1;
-    switch(mod){
-    case 0:case 1:case 2:case 3:{
-        lay = mod/2 +1;
-        det = mod%2 +1;
-    }break;
-    case 4: case 5:{
-        lay = mod -1;
-    }break;
-    case 6:case 7:case 8:case 9:{
-        lay = mod/2 +2;
-        det = mod%2 +1;
-    }break;
-    default:
-        lay = 0;
-        det = 0;
-        break;
-    } // end switch
-    return;
-}
 //______________________________________________________________________
 void AliITSInitGeometry::DecodeDetectorvPPRasymmFMD(Int_t &mod,Int_t layer,
                                     Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
@@ -2220,60 +1423,6 @@ void AliITSInitGeometry::DecodeDetectorv11Hybrid(Int_t &mod,Int_t layer,
   return;
 }
 
-/*
-//______________________________________________________________________
-void AliITSInitGeometry::RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,
-                                        Int_t &cpn1,Int_t &cpn2) {
-    // decode geometry into detector module number. There are two decoding
-    // Scheams. Old which does not follow the ALICE coordinate system
-    // requirements, and New which dose.
-    // Inputs:
-    //    Int_t mod      The module number assoicated with this set
-    //                   of copy numbers.
-    // Output:
-    //    Int_t cpn0     The lowest copy number
-    //    Int_t cpn1     The middle copy number
-    //    Int_t cpn2     the highest copy number
-    // Return:
-    //    none.
-    const Int_t kITSgeoTreeCopys[6][3]= {{10, 2, 4},// lay=1
-                                         {10, 4, 4},// lay=2
-                                         {14, 6, 1},// lay=3
-                                         {22, 8, 1},// lay=4
-                                         {34,22, 1},// lay=5
-                                         {38,25, 1}};//lay=6
-    const Int_t kDetPerLadderSPD[2]={2,4};
-    Int_t lay,lad,det;
-
-    cpn0 = cpn1 = cpn2 = 0;
-    DecodeDetectorLayersv11Hybrid(mod,lay,lad,det);
-    // Old encoding
-    switch (lay){
-    case 1: case 2:{
-        cpn2 = det;     // Detector 1-4
-        cpn0 = (lad+kDetPerLadderSPD[lay-1]-1)/kDetPerLadderSPD[lay-1];
-        cpn1 = (lad+kDetPerLadderSPD[lay-1]-1)%kDetPerLadderSPD[lay-1] + 1;
-    } break;
-    case 3: case 4: case 5 : case 6:{
-        cpn2 = 1;
-        cpn1 = det;
-        cpn0 = lad;
-    } break;
-    default:{
-        Error("RecodeDetector","Old: mod=%d lay=%d not 1-6.");
-        return;
-    } break;
-    } // end switch
-    if(cpn0<1||cpn1<1||cpn2<1||
-       cpn0>kITSgeoTreeCopys[lay-1][0]||
-       cpn1>kITSgeoTreeCopys[lay-1][1]||
-       cpn2>kITSgeoTreeCopys[lay-1][2])
-        Error("RecodeDetector",
-              "cpn0=%d cpn1=%d cpn2=%d mod=%d lay=%d lad=%d det=%d",
-              cpn0,cpn1,cpn2,mod,lay,lad,det);
-    return;
-}
-*/
 
 
 //______________________________________________________________________
@@ -2323,48 +1472,6 @@ void AliITSInitGeometry::RecodeDetectorv11Hybrid(Int_t mod,Int_t &cpn0,
            "mod=%d lay=%d lad=%d det=%d cpn0=%d cpn1=%d cpn2=%d\n",
            mod,lay,lad,det,cpn0,cpn1,cpn2);*/
 }
-// //______________________________________________________________________
-// void AliITSInitGeometry::DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,
-//                                               Int_t &lad,Int_t &det) {
-
-//     // decode module number into detector indices for v11Hybrid
-//     // Inputs:
-//     //    Int_t mod      The module number associated with this set
-//     //                   of copy numbers.
-//     // Output:
-//     //    Int_t lay     The layer number
-//     //    Int_t lad     The ladder number
-//     //    Int_t det     the dettector number
-//     // Return:
-//     //    none.
-
-//     const Int_t kDetPerLadder[6]={4,4,6,8,22,25};
-//     const Int_t kLadPerLayer[6]={20,40,14,22,34,38};
-//     Int_t mod2 = 0;
-//     det  = 0;
-//     lad  = 0;
-//     lay  = 0;
-
-//     do{
-//         mod2 += kLadPerLayer[lay]*kDetPerLadder[lay];
-//         lay++;
-//     } while(mod2<=mod); // end while
-//     if(lay>6||lay<1) Error("DecodeDetectorLayers","0<lay=%d>6",lay);
-//     mod2 -= kLadPerLayer[lay-1]*kDetPerLadder[lay-1];
-//     do{
-//         lad++;
-//         mod2 += kDetPerLadder[lay-1];
-//     } while(mod2<=mod); // end while
-//     if(lad>kLadPerLayer[lay-1]||lad<1) Error("DecodeDetectorLayers",
-//             "lad=%d>kLadPerLayer[lay-1=%d]=%d mod=%d mod2=%d",lad,lay-1,
-//                                             kLadPerLayer[lay-1],mod,mod2);
-//     mod2 -= kDetPerLadder[lay-1];
-//     det = mod-mod2+1;
-//     if(det>kDetPerLadder[lay-1]||det<1) Error("DecodeDetectorLayers",
-//            "det=%d>detPerLayer[lay-1=%d]=%d mod=%d mod2=%d lad=%d",det,
-//                                   lay-1,kDetPerLadder[lay-1],mod,mod2,lad);
-//     return;
-// }
 
 //______________________________________________________________________
 void AliITSInitGeometry::DecodeDetectorLayersv11Hybrid(Int_t mod,Int_t &lay,
@@ -2525,18 +1632,6 @@ Bool_t AliITSInitGeometry::ReadVersionString(const Char_t *str,Int_t length,
                        " month=%d day=%d hours=%d minuits=%d seconds=%d\n",
                        year,month,day,hours,minuits,seconds);
     switch (i){
-    case kvITS04:{
-        maj = kvITS04;
-    } break;
-    case kvSPD02:{
-        maj = kvSPD02;
-    } break;
-    case kvSDD03:{
-        maj = kvSDD03;
-    } break;
-    case kvSSD03:{
-        maj = kvSSD03;
-    } break;
     case kvPPRasymmFMD:{
         maj = kvPPRasymmFMD;
     } break;
index 8854ae7..a87579d 100644 (file)
@@ -17,10 +17,8 @@ $Id$
 #include "AliITSgeom.h"
 
 typedef enum {
-    kvtest=-1,kvDefault=0,
-    kvSPD02=1,kvSDD03=2,kvSSD03=3,kvITS04=4,
-    kvPPRcourseasymm=6,kvPPRasymmFMD=10,
-    kv11=11,kv11Hybrid=110
+  kvDefault=0,kvPPRcourseasymm=6,kvPPRasymmFMD=10,
+  kv11=11,kv11Hybrid=110
 } AliITSVersion_t;
 
 class TArrayD;
@@ -86,54 +84,6 @@ class AliITSInitGeometry : public TObject{
 
  private:
     // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersvtest2(Int_t mod,Int_t &lay,
-                                   Int_t &lad,Int_t &det) const {
-        lay=mod+1;lad=det=1;};
-    // find module number by layer, and copy numbers
-    void DecodeDetectorvtest2(Int_t &mod,Int_t lay,Int_t cpn0,
-                             Int_t cpn1,Int_t cpn2) const{
-        mod=lay-1;cpn0=cpn1=cpn2=1;};
-    // Given module number, find copy numbers.
-    void RecodeDetectorvtest2(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                             Int_t &cpn2) const {
-        mod=cpn0=cpn1=cpn2=1;};
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersvSPD02(Int_t mod,Int_t &lay,
-                                   Int_t &lad,Int_t &det) const;
-    // find module number by layer, and copy numbers
-    void DecodeDetectorvSPD02(Int_t &mod,Int_t lay,Int_t cpn0,
-                             Int_t cpn1,Int_t cpn2) const;
-    // Given module number, find copy numbers.
-    void RecodeDetectorvSPD02(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                             Int_t &cpn2) const;
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersvSDD03(Int_t mod,Int_t &lay,
-                                   Int_t &lad,Int_t &det) const;
-    // find module number by layer, and copy numbers
-    void DecodeDetectorvSDD03(Int_t &mod,Int_t lay,Int_t cpn0,
-                             Int_t cpn1,Int_t cpn2) const;
-    // Given module number, find copy numbers.
-    void RecodeDetectorvSDD03(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                             Int_t &cpn2) const;
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersvSSD03(Int_t mod,Int_t &lay,
-                                   Int_t &lad,Int_t &det) const;
-    // find module number by layer, and copy numbers
-    void DecodeDetectorvSSD03(Int_t &mod,Int_t lay,Int_t cpn0,
-                             Int_t cpn1,Int_t cpn2) const;
-    // Given module number, find copy numbers.
-    void RecodeDetectorvSSD03(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                             Int_t &cpn2) const;
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersvITS04(Int_t mod,Int_t &lay,
-                                   Int_t &lad,Int_t &det) const;
-    // find module number by layer, and copy numbers
-    void DecodeDetectorvITS04(Int_t &mod,Int_t lay,Int_t cpn0,
-                             Int_t cpn1,Int_t cpn2) const;
-    // Given module number, find copy numbers.
-    void RecodeDetectorvITS04(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                             Int_t &cpn2) const;
-    // Decode module number into old layer, ladder, and detector numbers
     void DecodeDetectorLayersvPPRcourseasymm(Int_t mod,Int_t &lay,
                                    Int_t &lad,Int_t &det) const {
         lay=lad=det=mod;/*Dummy*/};
@@ -177,11 +127,6 @@ class AliITSInitGeometry : public TObject{
                                     Int_t &det);
                   
     // Virtual MC code reproduction
-    Bool_t InitAliITSgeomSPD02(AliITSgeom *geom);
-    Bool_t InitAliITSgeomSDD03(AliITSgeom *geom);
-    Bool_t InitAliITSgeomSSD03(AliITSgeom *geom);
-    Bool_t InitAliITSgeomITS04(AliITSgeom *geom) const;
-    Bool_t InitAliITSgeomtest2(AliITSgeom *geom);
     Bool_t InitAliITSgeomPPRasymmFMD(AliITSgeom *geom);
     Bool_t InitAliITSgeomV11Hybrid(AliITSgeom *geom);
     Bool_t InitAliITSgeomV11(AliITSgeom *geom);
diff --git a/ITS/AliITSL2GConvertPointsV1.C b/ITS/AliITSL2GConvertPointsV1.C
deleted file mode 100644 (file)
index 86a6d1c..0000000
+++ /dev/null
@@ -1,114 +0,0 @@
-// 
-// Macro to convert ITS local-coordinate points
-// into globa lones
-// 
-
-Int_t AliITSL2GConvertPoints 
-(const char* in_name = "ITS.RecPoints.root", 
- const char* out_name = "ITS.Neural.PointsV1.root", Int_t nev = 0)
-{
-       TStopwatch timer;
-
-       // Open output file
-       TFile *in = new TFile(in_name);
-       TFile *out = new TFile(out_name, "recreate");
-       
-       // Load event files
-       if (gAlice) {
-               delete AliRunLoader::Instance();
-               delete gAlice;
-               gAlice=0;
-       } 
-       AliRunLoader* rl = AliRunLoader::Open("galice.root");
-    if (rl == 0x0) {
-               cerr << "AliITSL2GConvertPoints.C : Can not open session." << endl;
-               return 3;
-       }
-    Int_t retval = rl->LoadgAlice();
-       if (retval) {
-               cerr << "AliITSL2GConvertPoints.C : LoadgAlice returned error" << endl;
-               return 3;
-       }
-       gAlice=rl->GetAliRun();
-       AliITSLoader* gime = (AliITSLoader*)rl->GetLoader("ITSLoader");
-       if (gime == 0x0) {
-               cerr << "AliITSL2GConvertPoints.C : can not get ITS loader" << endl;
-               return 3;
-       }
-       AliITS *ITS = (AliITS*)gAlice->GetDetector("ITS");
-       if (!ITS) {
-               cerr << "AliITSL2GConvertPoints.C : AliITS object not found on file" << endl;
-               return 3;
-       }  // end if !ITS
-       AliITSgeom *geom = (AliITSgeom*)ITS->GetITSgeom();
-       if(!geom) {
-               cerr << "AliITSL2GConvertPoints.C : AliITSgeom not found." << endl;
-               return 4;
-       } // end if
-       
-       // Tree of recpoints
-       Int_t nModules = 0;
-       TTree *TR = (TTree*)in->Get(Form("Event%d/TreeR", nev));
-       if (!TR) {
-               cout << "TreeR not found" << endl;
-               return;
-       }
-       nModules = (Int_t)TR->GetEntries();
-       if (!nModules) {
-               cout << "Empty TreeR!!!" << endl;
-               return;
-       }
-
-       timer.Start();
-       
-       // Converts and stores the ITS points into global coordinate format
-       Int_t pos = 0;
-       AliITSRecPoint *local = 0;
-       AliITSNeuralPoint *global = 0;
-       TTree *TP = new TTree("TreeP", "Event points in global coords");
-       TP->Branch("pos", &pos, "pos/I");
-       TP->Branch("Points", "AliITSNeuralPoint", &global);
-       
-       TObjArray *localArray = 0;
-       TR->SetBranchAddress("ITSRecPoints", &localArray);
-       Int_t module, layer, i, j, count, index;
-       Double_t locPos[3], globPos[3], locErr[3][3], globErr[3][3];
-       
-       for(module = 0; module < nModules; module++) {
-               TR->GetEvent(module);
-               if (module > geom->GetLastSSD()) {
-                       cout << "Strange behavior: an entry greater than the last SSD index!" << endl;
-                       continue;
-               }
-               AliITSgeomMatrix *gm = geom->GetGeomMatrix(module);
-               geom->GetModuleId(module, layer, i, j);
-               count = (Int_t)localArray->GetEntriesFast();
-               layer--;
-               if (layer < 0 || layer > 5) {
-                       cout << "STRANGE layer value: " << layer << endl;
-                       continue;
-               }
-               for (index = 0; index < count; index++) {
-                       local = (AliITSRecPoint*)localArray->At(index);
-                       global = new AliITSNeuralPoint(local, gm);
-                       global->SetLayer(layer);
-                       global->SetModule(module);
-                       global->SetIndex(index);
-                       global->SetUser(-1);
-                       global->ConfMap(0.0, 0.0);
-                       TP->Fill();
-                       pos++;
-               }
-       }
-
-       timer.Stop();
-       timer.Print();
-       cout << TP->GetEntries() << " points collected" << endl;
-       
-       out->cd();
-       out->mkdir(Form("Event%d", nev));
-       out->cd(Form("Event%d", nev));
-       TP->Write(Form("TreeP", nev));
-       out->Close();
-}
-
diff --git a/ITS/AliITSRawStreamSDDBeamTest.cxx b/ITS/AliITSRawStreamSDDBeamTest.cxx
deleted file mode 100644 (file)
index 46dab01..0000000
+++ /dev/null
@@ -1,161 +0,0 @@
-/**************************************************************************
- * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id: $*/
-
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to ITS SDD digits in beam test raw data
-///
-///////////////////////////////////////////////////////////////////////////////
-
-#include "AliLog.h"
-#include "AliITSRawStreamSDDBeamTest.h"
-#include "AliRawReader.h"
-
-
-ClassImp(AliITSRawStreamSDDBeamTest)
-  
-const UInt_t AliITSRawStreamSDDBeamTest::fgkCodeLength[8] =  {8, 18, 2, 3, 4, 5, 6, 7};
-
-//______________________________________________________________________
-AliITSRawStreamSDDBeamTest::AliITSRawStreamSDDBeamTest(AliRawReader* rawReader) :
-  AliITSRawStream(rawReader),
-fData(0),
-fSkip(0),
-fEventId(0),
-fCarlosId(-1),
-fChannel(0),
-fJitter(0)
-{
-// create an object to read ITS SDD raw digits
-  fRawReader->Reset();
-  fRawReader->SelectEquipment(17, 204, 204);
-
-
-}
-
-//______________________________________________________________________
-UInt_t AliITSRawStreamSDDBeamTest::ReadBits()
-{
-// read bits from the given channel
-  UInt_t result = (fChannelData[fCarlosId][fChannel] & ((1<<fReadBits[fCarlosId][fChannel]) - 1));
-  fChannelData[fCarlosId][fChannel] >>= fReadBits[fCarlosId][fChannel]; 
-  fLastBit[fCarlosId][fChannel] -= fReadBits[fCarlosId][fChannel];
-  return result;
-}
-
-//______________________________________________________________________
-Int_t AliITSRawStreamSDDBeamTest::DecompAmbra(Int_t value) const
-{
-  // AMBRA decompression (from 8 to 10 bit)
-  
-  if ((value & 0x80) == 0) {
-    return value & 0x7f;
-  } else if ((value & 0x40) == 0) {
-    return 0x081 + ((value & 0x3f) << 1);
-  } else if ((value & 0x20) == 0) {
-    return 0x104 + ((value & 0x1f) << 3);
-  } else {
-    return 0x208 + ((value & 0x1f) << 4);
-  }
-  
-}
-
-//______________________________________________________________________
-Bool_t AliITSRawStreamSDDBeamTest::Next()
-{
-// read the next raw digit
-// returns kFALSE if there is no digit left
-
-  // skip the first 8 words
-  while (fSkip < 8) {
-    if (!fRawReader->ReadNextInt(fData)) return kFALSE;
-    if ((fData >> 30) == 0x01) continue;  // JTAG word
-    if (fSkip == 4) {
-      if (fData != 0) {
-       Error("Next", "data not valid: %8.8d", fData);
-       return kFALSE;
-      }
-    }
-    fSkip++;
-  }
-
-  while (kTRUE) {
-    if ((fChannel < 0) || (fLastBit[0][fChannel] < fReadBits[0][fChannel])) {
-      if (!fRawReader->ReadNextInt(fData)) return kFALSE;  // read next word
-
-      fChannel = -1;
-      if ((fData >> 28) == 0x02) {           // header
-       fEventId = (fData >> 3) & 0x07FF;
-       fCarlosId = (fData >> 1) & 0x03;
-      } else if ((fData >> 28) == 0x03) {    // footer
-       // ignored
-      } else if ((fData >> 29) == 0x00) {    // error
-       if ((fData & 0x1FFFFFFF) != 0) {
-         Error("Next", "error codes = %x, %x\n", 
-               (fData >> 0) & 0x3FFF, (fData >> 14) & 0x3FFF);
-         return kFALSE;
-       }
-      } else if ((fData >> 30) == 0x01) {    // JTAG word
-       // ignored
-      } else if ((fData >> 30) == 0x02) {    // channel 0 data
-       fChannel = 0;
-      } else if ((fData >> 30) == 0x03) {    // channel 1 data
-       fChannel = 1;
-      } else {                               // unknown data format
-       Error("Next", "invalid data: %8.8x\n", fData);
-       return kFALSE;
-      }
-
-      if (fChannel >= 0) {          // add read word to the data
-       fChannelData[0][fChannel] += 
-         (ULong64_t(fData & 0x3FFFFFFF) << fLastBit[0][fChannel]);
-       fLastBit[0][fChannel] += 30;
-      }
-
-    } else {  // decode data
-      if (fReadCode[0][fChannel]) {    // read the next code word
-       fChannelCode[0][fChannel] = ReadBits();
-       fReadCode[0][fChannel] = kFALSE;
-       fReadBits[0][fChannel] = fgkCodeLength[fChannelCode[0][fChannel]];
-
-      } else {                      // read the next data word
-       UInt_t data = ReadBits();
-       fReadCode[0][fChannel] = kTRUE;
-       fReadBits[0][fChannel] = 3;
-       if (fChannelCode[0][fChannel] == 0) {         // set the time bin
-         fTimeBin[0][fChannel] = data;
-       } else if (fChannelCode[0][fChannel] == 1) {  // next anode
-         fTimeBin[0][fChannel] = 0;
-         fAnode[0][fChannel]++;
-       } else {                                   // ADC signal data
-         fSignal = DecompAmbra(data + (1 << fChannelCode[0][fChannel]) + 
-           fLowThreshold[fChannel]);
-         fCoord1 = fAnode[0][fChannel];
-         fCoord2 = fTimeBin[0][fChannel];
-         fTimeBin[0][fChannel]++;
-         return kTRUE;
-       }
-      }
-    }
-  }
-
-  return kFALSE;
-}
-
-
-
-
diff --git a/ITS/AliITSRawStreamSDDBeamTest.h b/ITS/AliITSRawStreamSDDBeamTest.h
deleted file mode 100644 (file)
index 7f68ca8..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef ALIITSRAWSTREAMSDDBEAMTEST_H
-#define ALIITSRAWSTREAMSDDBEAMTEST_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id: $ */
-
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to ITS SDD digits in raw data 
-/// (default=simulated data).
-///////////////////////////////////////////////////////////////////////////////
-
-#include "AliITSRawStream.h"
-
-class AliRawReader;
-
-
-class AliITSRawStreamSDDBeamTest: public AliITSRawStream {
-  public :
-    AliITSRawStreamSDDBeamTest(AliRawReader* rawReader);
-
-    virtual ~AliITSRawStreamSDDBeamTest(){};
-
-    virtual Bool_t   Next();
-
-    virtual Int_t    GetAnode() const {return fCoord1;}
-    virtual Int_t    GetTime() const {return fCoord2;}
-    virtual Int_t    GetChannel() const {return fChannel;}
-    virtual Int_t    GetCarlosId() const {return fCarlosId;}
-    virtual Int_t    GetEventId() const {return fEventId;}
-
-    virtual Int_t    ReadJitter(){
-      AliError("Method implemented in only for Nov04 beam test");
-      fJitter=0;
-      return fJitter;
-    }
-    virtual void     SetLowCarlosThreshold(Int_t th, Int_t i)
-      {fLowThreshold[i]=th;}
-
-  protected:
-    virtual UInt_t   ReadBits();
-    virtual Int_t    DecompAmbra(Int_t value) const;
-
-    enum {kModulesPerDDL = 12};    // number of modules in each DDL 
-
-    static const UInt_t fgkCodeLength[8]; //code length
-
-    UInt_t           fData;         // data read for file
-    Int_t            fSkip;     // counter of header words to be skipped
-    Int_t            fEventId;      // event ID from header
-    Int_t            fCarlosId;     // carlos ID
-    Int_t            fChannel;      // current channel
-    Int_t            fJitter;          // jitter between L0 and pascal stop (x25ns)
-    ULong64_t        fChannelData[kModulesPerDDL][2];// packed data for the 2 channels
-    UInt_t           fLastBit[kModulesPerDDL][2];    // last filled bit in fChannelData
-    UInt_t           fChannelCode[kModulesPerDDL][2];// current channel code
-    Bool_t           fReadCode[kModulesPerDDL][2];   // next bits are code or data
-    UInt_t           fReadBits[kModulesPerDDL][2];   // number of bits to read
-
-    Int_t            fLowThreshold[2];    // carlos low threshold
-    Int_t            fTimeBin[kModulesPerDDL][2];  // current timebin [ncarlos][nchannels]
-    Int_t            fAnode[kModulesPerDDL][2]; // current anode [ncarlos][nchannels]
-
-    ClassDef(AliITSRawStreamSDDBeamTest, 1) // class for reading ITS SDD raw digits from beam tests
-};
-
-#endif
diff --git a/ITS/AliITSRawStreamSDDBeamTestNov04.cxx b/ITS/AliITSRawStreamSDDBeamTestNov04.cxx
deleted file mode 100644 (file)
index f5e554c..0000000
+++ /dev/null
@@ -1,166 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to ITS SDD digits in test beam raw data.
-//  for beam test of November 2004
-///
-///////////////////////////////////////////////////////////////////////////////
-
-/*
-       Error Flag words: (http://www.bo.infn.it/~falchier/alice.html)
-        with multi-event buffer
-          
-bits 31-14: all zeros
-bit  13   : L0 ack
-bit  12   : L1 reject ack
-bit  11   : L2 reject ack
-bit  10   : prepulse ack
-bit   9   : testpulse ack
-bit   8   : flush
-bit   7   : busy
-bit   6   : flag error ch 1
-bit   5   : flag error ch 0
-bit   4   : disable trigger mismatch ack
-bit   3   : parity error right hybrid
-bit   2   : parity error left hybrid
-bit   1   : parity error CARLOS ch 1
-bit   0   : parity error CARLOS ch 2
-*/
-#include "AliITSRawStreamSDDBeamTestNov04.h"
-#include "AliRawReader.h"
-
-ClassImp(AliITSRawStreamSDDBeamTestNov04)
-
-
-
-
-
-AliITSRawStreamSDDBeamTestNov04::AliITSRawStreamSDDBeamTestNov04(AliRawReader* rawReader) :
-  AliITSRawStreamSDDBeamTest(rawReader)
-{
-// create an object to read ITS SDD raw digits
-
-
-  fRawReader->Reset();
-  fRawReader->SelectEquipment(17, 204, 204);
-}
-
-
-Bool_t AliITSRawStreamSDDBeamTestNov04::Next()
-{
-// read the next raw digit
-// returns kFALSE if there is no digit left
-  // skip the first 8 words
-  while (fSkip < 9) {
-    if (!fRawReader->ReadNextInt(fData)) return kFALSE;
-    if ((fData >> 30) == 0x01) continue;  // JTAG word
-    fSkip++;
-  }
-
-  Int_t countFoot=0;   
-  while (kTRUE) {
-    if ((fChannel < 0) || (fLastBit[0][fChannel] < fReadBits[0][fChannel])) {
-      if (!fRawReader->ReadNextInt(fData)) return kFALSE;  // read next word
-      fChannel = -1;
-      if ((fData >> 28) == 0x02) {           // header
-       fEventId = (fData >> 3) & 0x07FF;
-       fCarlosId = (fData >> 1) & 0x03;
-      } else if ((fData >> 28) == 0x03) {    // footer
-        countFoot++; // stop before the last word (last word=jitter)
-        if(countFoot==3) return kFALSE;         
-      } else if ((fData >> 29) == 0x00) {    // error
-
-       if ((fData & 0x00000163) != 0) {
-         Error("Next", "error codes = %8.8x",fData);
-         return kFALSE; 
-       }
-      } else if ((fData >> 30) == 0x01) {    // JTAG word
-       // ignored
-      } else if ((fData >> 30) == 0x02) {    // channel 0 data
-       fChannel = 0;
-      } else if ((fData >> 30) == 0x03) {    // channel 1 data
-       fChannel = 1;
-      } else {                               // unknown data format
-       Error("Next", "invalid data: %8.8x\n", fData);
-       return kFALSE;
-      }
-      
-
-      if (fChannel >= 0) {          // add read word to the data
-       fChannelData[0][fChannel] += 
-         (ULong64_t(fData & 0x3FFFFFFF) << fLastBit[0][fChannel]);
-       fLastBit[0][fChannel] += 30;
-      }
-
-    } else {  // decode data
-      if (fReadCode[0][fChannel]) {    // read the next code word
-       fChannelCode[0][fChannel] = ReadBits();
-       fReadCode[0][fChannel] = kFALSE;
-       fReadBits[0][fChannel] = fgkCodeLength[fChannelCode[0][fChannel]];
-
-      } else {                      // read the next data word
-       UInt_t data = ReadBits();
-       fReadCode[0][fChannel] = kTRUE;
-       fReadBits[0][fChannel] = 3;
-       if (fChannelCode[0][fChannel] == 0) {         // set the time bin
-         fTimeBin[0][fChannel] = data;
-       } else if (fChannelCode[0][fChannel] == 1) {  // next anode
-         fTimeBin[0][fChannel] = 0;
-         fAnode[0][fChannel]++;
-       } else {                                   // ADC signal data
-         fSignal = DecompAmbra(data + (1 << fChannelCode[0][fChannel]) + 
-           fLowThreshold[fChannel]);
-         fCoord1 = fAnode[0][fChannel];
-         fCoord2 = fTimeBin[0][fChannel];
-         fTimeBin[0][fChannel]++;
-         return kTRUE;
-       }
-      }
-    }
-  }
-  return kFALSE;
-}
-
-
-Int_t AliITSRawStreamSDDBeamTestNov04::ReadJitter() {
-
-  // Reads the value of the jitter between L0 and pascal stop
-  // written in the last word of the buffer
-
-     if (!fRawReader->ReadNextInt(fData)){
-       Error("ReadJitter","Jitter word not found!!");
-       return -1;  // read last word
-     }
-     if ( (fData&0xff000000) != 0xff000000) {
-       Error("ReadJitter","wrong mask on Jitter word (0xffxxxxxx): %8.8x",fData);
-       return -1;  // read last word
-     }
-     fJitter = fData&0x000000ff;
-     if (fJitter<0x7 || fJitter>0xe) {
-       Warning("ReadJitter","Unexpected jitter value %2.2x (%8.8x)",fJitter,fData);
-       return fJitter;  // read last word
-     }
-
-     if (fRawReader->ReadNextInt(fData)){
-       Error("ReadJitter","The equipment payload contains something after jitter");
-       return -1;  // read last word
-     }
-     return fJitter;
-}
-
-
diff --git a/ITS/AliITSRawStreamSDDBeamTestNov04.h b/ITS/AliITSRawStreamSDDBeamTestNov04.h
deleted file mode 100644 (file)
index 65a4b00..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef ALIITSRAWSTREAMSDDBEAMTESTNOV04_H
-#define ALIITSRAWSTREAMSDDBEAMTESTNOV04_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id: */
-
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to ITS SDD digits in test beam raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
-
-#include "AliITSRawStreamSDDBeamTest.h"
-
-class AliRawReader;
-
-
-class AliITSRawStreamSDDBeamTestNov04: public AliITSRawStreamSDDBeamTest {
-  public :
-    AliITSRawStreamSDDBeamTestNov04(AliRawReader* rawReader);
-    virtual ~AliITSRawStreamSDDBeamTestNov04() {};
-
-    virtual Bool_t   Next();
-    virtual Int_t    ReadJitter();
-  private :
-
-
-    ClassDef(AliITSRawStreamSDDBeamTestNov04, 1) // class for reading ITS SDD raw digits
-};
-
-#endif
diff --git a/ITS/AliITSRawStreamSPD_OLDGEO.cxx b/ITS/AliITSRawStreamSPD_OLDGEO.cxx
deleted file mode 100644 (file)
index ad5852c..0000000
+++ /dev/null
@@ -1,532 +0,0 @@
-/**************************************************************************
- * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to ITS SPD digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
-
-#include "AliITSRawStreamSPD.h"
-#include "AliRawReader.h"
-#include "AliLog.h"
-
-ClassImp(AliITSRawStreamSPD)
-
-const Int_t AliITSRawStreamSPD::fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL] = {
-  { 0, 1, 4, 5, 80, 81, 84, 85, 88, 89, 92, 93},
-  { 8, 9,12,13, 96, 97,100,101,104,105,108,109},
-  {16,17,20,21,112,113,116,117,120,121,124,125},
-  {24,25,28,29,128,129,132,133,136,137,140,141},
-  {32,33,36,37,144,145,148,149,152,153,156,157},
-  {40,41,44,45,160,161,164,165,168,169,172,173},
-  {48,49,52,53,176,177,180,181,184,185,188,189},
-  {56,57,60,61,192,193,196,197,200,201,204,205},
-  {64,65,68,69,208,209,212,213,216,217,220,221},
-  {72,73,76,77,224,225,228,229,232,233,236,237},
-  { 2, 3, 6, 7, 82, 83, 86, 87, 90, 91, 94, 95},
-  {10,11,14,15, 98, 99,102,103,106,107,110,111},
-  {18,19,22,23,114,115,118,119,122,123,126,127},
-  {26,27,30,31,130,131,134,135,138,139,142,143},
-  {34,35,38,39,146,147,150,151,154,155,158,159},
-  {42,43,46,47,162,163,166,167,170,171,174,175},
-  {50,51,54,55,178,179,182,183,186,187,190,191},
-  {58,59,62,63,194,195,198,199,202,203,206,207},
-  {66,67,70,71,210,211,214,215,218,219,222,223},
-  {74,75,78,79,226,227,230,231,234,235,238,239}
-};
-//__________________________________________________________________________
-AliITSRawStreamSPD::AliITSRawStreamSPD(AliRawReader* rawReader) :
-  AliITSRawStream(rawReader),
-  fEventCounter(-1),fChipAddr(0),fHalfStaveNr(0),fCol(0),fRow(0),
-  fData(0),fOffset(0),fHitCount(0),
-  fDataChar1(0),fDataChar2(0),fDataChar3(0),fDataChar4(0),
-  fFirstWord(kTRUE),fPrevEventId(0xffffffff),
-  fEqPLBytesRead(0),fEqPLChipHeadersRead(0),fEqPLChipTrailersRead(0),
-  fHeaderOrTrailerReadLast(kFALSE),fExpectedHeaderTrailerCount(0),
-  fFillOutOfSynch(kFALSE),fDDLID(-1),fLastDDLID(-1),fAdvancedErrorLog(kFALSE),
-  fAdvLogger(NULL)
-{
-  // create an object to read ITS SPD raw digits
-  fRawReader->Select("ITSSPD");
-  // reset calib header words
-  for (UInt_t iword=0; iword<kCalHeadLenMax; iword++) {
-    fCalHeadWord[iword]=0xffffffff;
-  }
-  NewEvent();
-}
-//__________________________________________________________________________
-AliITSRawStreamSPD::AliITSRawStreamSPD(const AliITSRawStreamSPD& rstream) :
-  AliITSRawStream(rstream.fRawReader),
-  fEventCounter(-1),fChipAddr(0),fHalfStaveNr(0),fCol(0),fRow(0),
-  fData(0),fOffset(0),fHitCount(0),
-  fDataChar1(0),fDataChar2(0),fDataChar3(0),fDataChar4(0),
-  fFirstWord(kTRUE),fPrevEventId(0xffffffff),
-  fEqPLBytesRead(0),fEqPLChipHeadersRead(0),fEqPLChipTrailersRead(0),
-  fHeaderOrTrailerReadLast(kFALSE),fExpectedHeaderTrailerCount(0),
-  fFillOutOfSynch(kFALSE),fDDLID(-1),fLastDDLID(-1),fAdvancedErrorLog(kFALSE),
-  fAdvLogger(NULL)
-{
-  // copy constructor
-  AliError("Copy constructor should not be used.");
-}
-//__________________________________________________________________________
-AliITSRawStreamSPD& AliITSRawStreamSPD::operator=(const AliITSRawStreamSPD& rstream) {
-  // assignment operator
-  if (this!=&rstream) {}
-  AliError("Assignment opertator should not be used.");
-  return *this;
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::ReadNextShort() {
-  // read next 16 bit word into fData
-  if (fFirstWord) {
-    Bool_t b1 = fRawReader->ReadNextChar(fDataChar1);
-    if (!b1) return kFALSE;
-    Bool_t  b2, b3, b4;
-    b2 = fRawReader->ReadNextChar(fDataChar2);
-    b3 = fRawReader->ReadNextChar(fDataChar3);
-    b4 = fRawReader->ReadNextChar(fDataChar4);
-    if (!(b2 && b3 && b4)) {
-      return kFALSE;
-    }
-    fData = fDataChar3+(fDataChar4<<8);
-    if ((*fRawReader->GetEventId())!=fPrevEventId) { // if new event...
-      NewEvent();
-      fPrevEventId=(*fRawReader->GetEventId());
-    }
-    fFirstWord=kFALSE;
-  }
-  else {
-    fFirstWord=kTRUE;
-    fData = fDataChar1+(fDataChar2<<8);
-  }
-  fEqPLBytesRead+=2;
-  
-  return kTRUE;
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::ReadNextInt() {
-  // reads next 32 bit into fDataChar1..4 
-  // (if first 16 bits read already, just completes the present word)
-  if (fFirstWord) {
-    if (ReadNextShort() && ReadNextShort()) {
-      return kTRUE;
-    }
-  }
-  else {
-    if (ReadNextShort()) {
-      return kTRUE;
-    }
-  }
-  return kFALSE;
-}
-//__________________________________________________________________________
-void AliITSRawStreamSPD::NewEvent() {
-  // call this to reset flags for a new event
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    fCalHeadRead[eqId]=kFALSE;
-  }
-  fEventCounter = -1;
-  fDDLID = -1;
-  fLastDDLID = -1;
-}
-//__________________________________________________________________________
-Int_t AliITSRawStreamSPD::ReadCalibHeader() {
-  // read the extra calibration header
-  // returns the length of the header if it is present, -1 otherwise
-
-  Int_t ddlID = fRawReader->GetDDLID();
-  if (ddlID==-1) { // we may need to read one word to get the blockAttr
-    if (!ReadNextShort()) return -1;
-    ddlID = fRawReader->GetDDLID();
-  }
-  // reset flags and counters
-  fEqPLBytesRead = 2;
-  fEqPLChipHeadersRead = 0;
-  fEqPLChipTrailersRead = 0;
-  fHeaderOrTrailerReadLast = kFALSE;
-  fFillOutOfSynch = kFALSE;
-
-  // check what number of chip headers/trailers to expect
-  fExpectedHeaderTrailerCount = 0;
-  for (UInt_t hs=0; hs<6; hs++) {
-    if (!fRawReader->TestBlockAttribute(hs)) fExpectedHeaderTrailerCount+=10;
-  }
-
-  if (ddlID>=0 && ddlID<20) fCalHeadRead[ddlID]=kTRUE;
-  if (fRawReader->TestBlockAttribute(6)) { // is the calib header present?
-    if (ReadNextInt()) {
-      // length of cal header:
-      UInt_t calLen = fDataChar1+(fDataChar2<<8)+(fDataChar3<<16)+(fDataChar4<<24);
-      if (calLen>kCalHeadLenMax) {
-       TString errMess = Form("Header length %d > max = %d",calLen,kCalHeadLenMax);
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kCalHeaderLengthErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kCalHeaderLengthErr,ddlID,-1,-1,errMess.Data());
-       return -1;
-      }
-      else {
-       for (UInt_t iword=0; iword<calLen; iword++) {
-         if (ReadNextInt()) {
-           fCalHeadWord[iword] = fDataChar1+(fDataChar2<<8)+(fDataChar3<<16)+(fDataChar4<<24);
-         }
-         else {
-           TString errMess = "Header length problem";
-           AliError(errMess.Data());
-           fRawReader->AddMajorErrorLog(kCalHeaderLengthErr,errMess.Data());
-           if (fAdvancedErrorLog) fAdvLogger->ProcessError(kCalHeaderLengthErr,ddlID,-1,-1,errMess.Data());
-           return -1;
-         }
-       }
-       return calLen;
-      }
-    }
-  }
-
-  return -1;
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::Next() {
-// read the next raw digit
-// returns kFALSE if there is no digit left
-
-  fPrevModuleID = fModuleID;
-
-  while (ReadNextShort()) {
-
-    fLastDDLID = fDDLID;
-    fDDLID = fRawReader->GetDDLID();
-    if (fDDLID>=0 && fDDLID<20) {
-      if (!fCalHeadRead[fDDLID]) {
-       if (fLastDDLID!=-1) {  // if not the first equipment for this event
-         fEqPLBytesRead -= 2;
-         CheckHeaderAndTrailerCount(fLastDDLID);
-       }
-       if (ReadCalibHeader()>=0) continue;
-      }
-    }
-    else {
-      TString errMess = Form("Error in DDL number (=%d) , setting it to 19",fDDLID);
-      AliError(errMess.Data());
-      fRawReader->AddMajorErrorLog(kDDLNumberErr,errMess.Data()); 
-      if (fAdvancedErrorLog) fAdvLogger->AddMessage(errMess.Data());
-      fDDLID=19;
-    }
-
-    if ((fData & 0xC000) == 0x4000) {         // header
-      if (fHeaderOrTrailerReadLast) {
-       TString errMess = "Chip trailer missing";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kTrailerMissingErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kTrailerMissingErr,fLastDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-      }
-      fHeaderOrTrailerReadLast = kTRUE;
-      fEqPLChipHeadersRead++;
-      fHitCount = 0;
-      UShort_t eventCounter = (fData >> 4) & 0x007F;
-      if (fEventCounter < 0) {
-       fEventCounter = eventCounter;
-      } 
-      else if (eventCounter != fEventCounter) {
-       TString errMess;
-       if (fEqPLChipHeadersRead==1) {
-         errMess = Form("Mismatching event counters between this equipment and the previous: %d != %d",
-                        eventCounter,fEventCounter);
-       }
-       else {
-         errMess = Form("Mismatching event counters between this chip header and the previous: %d != %d",
-                        eventCounter,fEventCounter);
-       }
-       fEventCounter = eventCounter;
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kEventCounterErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kEventCounterErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-      }
-      fChipAddr = fData & 0x000F;
-      if (fChipAddr>9) {
-       TString errMess = Form("Overflow chip address %d - set to 0",fChipAddr);
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kChipAddrErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kChipAddrErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-       fChipAddr=0;
-      }
-      fHalfStaveNr = (fData & 0x3800)>>11;
-      if (fHalfStaveNr>5 || fRawReader->TestBlockAttribute(fHalfStaveNr)) {
-       TString errMess = Form("Half stave number error: %d - set to 0",fHalfStaveNr);
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kHSNumberErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kHSNumberErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-       fHalfStaveNr=0;
-      }
-      // translate  ("online") ddl, hs, chip nr  to  ("offline") module id :
-      fModuleID = GetOfflineModuleFromOnline(fDDLID,fHalfStaveNr,fChipAddr);
-    } 
-    else if ((fData & 0xC000) == 0x0000) {    // trailer
-      if ( (fEqPLBytesRead+fFillOutOfSynch*2)%4 != 0 ) {
-       TString errMess = "Fill word is missing";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kFillMissingErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kFillMissingErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-       if (fFillOutOfSynch) fFillOutOfSynch = kFALSE;
-       else fFillOutOfSynch = kTRUE;
-      }
-      if (!fHeaderOrTrailerReadLast) {
-       TString errMess = "Trailer without previous header";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kTrailerWithoutHeaderErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kTrailerWithoutHeaderErr,fLastDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-      }
-      fHeaderOrTrailerReadLast = kFALSE;
-      fEqPLChipTrailersRead++;
-      UShort_t hitCount = fData & 0x1FFF;
-      if (hitCount != fHitCount){
-       TString errMess = Form("Number of hits %d, while %d expected",fHitCount,hitCount);
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kNumberHitsErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kNumberHitsErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-      }
-    }
-    else if ((fData & 0xC000) == 0x8000) {    // pixel hit
-      if (!fHeaderOrTrailerReadLast) {
-       TString errMess = "Chip header missing";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kHeaderMissingErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kHeaderMissingErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-       fHeaderOrTrailerReadLast = kTRUE;
-      }
-      fHitCount++;
-      fCol = (fData & 0x001F);
-      fRow = (fData >> 5) & 0x00FF;
-
-      fCoord1 = GetOfflineColFromOnline(fDDLID,fHalfStaveNr,fChipAddr,fCol);
-      fCoord2 = GetOfflineRowFromOnline(fDDLID,fHalfStaveNr,fChipAddr,fRow);
-
-      return kTRUE;
-    } 
-    else {                                    // fill word
-      if ((fData & 0xC000) != 0xC000) {
-       TString errMess = "Wrong fill word!";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kWrongFillWordErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kWrongFillWordErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-      }
-      if ( (fEqPLBytesRead+fFillOutOfSynch*2)%4 != 2 ) {
-       TString errMess = "Fill word is unexpected";
-       AliError(errMess.Data());
-       fRawReader->AddMajorErrorLog(kFillUnexpectErr,errMess.Data());
-       if (fAdvancedErrorLog) fAdvLogger->ProcessError(kFillUnexpectErr,fDDLID,fEqPLBytesRead,fEqPLChipHeadersRead,errMess.Data());
-       if (fFillOutOfSynch) fFillOutOfSynch = kFALSE;
-       else fFillOutOfSynch = kTRUE;
-      }
-    }
-
-  }
-  if (fDDLID>=0 && fDDLID<20) {
-    CheckHeaderAndTrailerCount(fDDLID);
-  }
-  return kFALSE;
-}
-//__________________________________________________________________________
-void AliITSRawStreamSPD::CheckHeaderAndTrailerCount(Int_t ddlID) {
-  // Checks that the number of header and trailers found for the ddl are as expected
-  if (fEqPLChipHeadersRead != fExpectedHeaderTrailerCount) {
-    TString errMess = Form("Chip header count inconsistent %d != %d (expected) for ddl %d",
-                          fEqPLChipHeadersRead,fExpectedHeaderTrailerCount,ddlID);
-    AliError(errMess.Data());
-    fRawReader->AddMajorErrorLog(kHeaderCountErr,errMess.Data());
-    if (fAdvancedErrorLog) fAdvLogger->ProcessError(kHeaderCountErr,ddlID,-1,-1,errMess.Data());
-  }
-  if (fEqPLChipTrailersRead != fExpectedHeaderTrailerCount) {
-    TString errMess = Form("Chip trailer count inconsistent %d != %d (expected) for ddl %d",
-                          fEqPLChipTrailersRead,fExpectedHeaderTrailerCount,ddlID);
-    AliError(errMess.Data());
-    fRawReader->AddMajorErrorLog(kHeaderCountErr,errMess.Data());
-    if (fAdvancedErrorLog) fAdvLogger->ProcessError(kHeaderCountErr,ddlID,-1,-1,errMess.Data());
-  }
-}
-//__________________________________________________________________________
-void AliITSRawStreamSPD::ActivateAdvancedErrorLog(Bool_t activate, AliITSRawStreamSPDErrorLog* advLogger) {
-  // Activate the advanced error logging.
-  // Logger object has to be created elsewhere and a pointer sent here.
-  fAdvancedErrorLog=activate;
-  if (activate && advLogger!=NULL) {
-    fAdvLogger = advLogger;
-  }
-  if (fAdvLogger==NULL) {
-    fAdvancedErrorLog=kFALSE;
-  }
-}
-//__________________________________________________________________________
-const Char_t* AliITSRawStreamSPD::GetErrorName(UInt_t errorCode) {
-  // Returns a string for each error code
-  if      (errorCode==kTotal)                   return "All Errors";
-  else if (errorCode==kHeaderMissingErr)        return "Header Missing";
-  else if (errorCode==kTrailerMissingErr)       return "Trailer Missing";
-  else if (errorCode==kTrailerWithoutHeaderErr) return "Trailer Unexpected";
-  else if (errorCode==kHeaderCountErr)          return "Header Count Wrong";
-  else if (errorCode==kTrailerCountErr)         return "Trailer Count Wrong";
-  else if (errorCode==kFillUnexpectErr)         return "Fill Unexpected";
-  else if (errorCode==kFillMissingErr)          return "Fill Missing";
-  else if (errorCode==kWrongFillWordErr)        return "Fill Word Wrong";
-  else if (errorCode==kNumberHitsErr)           return "Hit Count Wrong";
-  else if (errorCode==kEventCounterErr)         return "Event Counter Error";
-  else if (errorCode==kDDLNumberErr)            return "DDL Number Error";
-  else if (errorCode==kHSNumberErr)             return "HS Number Error";
-  else if (errorCode==kChipAddrErr)             return "Chip Address Error";
-  else if (errorCode==kCalHeaderLengthErr)      return "Calib Header Length Error";
-  else return "";
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::GetHalfStavePresent(UInt_t hs) {
-  // Reads the half stave present status from the block attributes
-  Int_t ddlID = fRawReader->GetDDLID();
-  if (ddlID==-1) {
-    AliWarning("DDL ID = -1. Cannot read block attributes. Return kFALSE.");
-    return kFALSE;
-  }
-  else {
-    if (hs>=6) {
-      AliWarning(Form("HS >= 6 requested (%d). Return kFALSE.",hs));
-      return kFALSE;
-    }
-    UChar_t attr = fRawReader->GetBlockAttributes();
-    if (((attr>>hs) & 0x01) == 0x01) { // bit set means not present
-      return kFALSE;
-    }
-    else {
-      return kTRUE;
-    }
-  }
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::GetHhalfStaveScanned(UInt_t hs) const {
-  if (hs<6) return (Bool_t)((fCalHeadWord[0]>>(6+hs)) & (0x00000001));
-  else return kFALSE;
-}
-Bool_t AliITSRawStreamSPD::GetHchipPresent(UInt_t hs, UInt_t chip) const {
-  if (hs<6 && chip<10) return ((( fCalHeadWord[hs/3+3]>>((hs%3)*10+chip)) & 0x00000001) == 1);
-  else return kFALSE;
-}
-UInt_t AliITSRawStreamSPD::GetHdacHigh(UInt_t hs) const {
-  if (hs<6) return (fCalHeadWord[hs/2+7]>>(24-16*(hs%2)) & 0x000000ff);
-  else return 0;
-}
-UInt_t AliITSRawStreamSPD::GetHdacLow(UInt_t hs) const {
-  if (hs<6) return (fCalHeadWord[hs/2+7]>>(16-16*(hs%2)) & 0x000000ff);
-  else return 0;
-}
-UInt_t AliITSRawStreamSPD::GetHTPAmp(UInt_t hs) const {
-  if (hs<6) return fCalHeadWord[hs+10];
-  else return 0;
-}
-Bool_t AliITSRawStreamSPD::GetHminTHchipPresent(UInt_t chip) const {
-  if (chip<10) return ((( fCalHeadWord[7]>>(16+chip)) & 0x00000001) == 1);
-  else return kFALSE;
-}
-//__________________________________________________________________________
-Int_t AliITSRawStreamSPD::GetModuleNumber(UInt_t iDDL, UInt_t iModule) {
-  if (iDDL<20 && iModule<12) return fgkDDLModuleMap[iDDL][iModule];
-  else return 240;
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::OfflineToOnline(UInt_t module, UInt_t colM, UInt_t rowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row) {
-  // converts offline coordinates to online
-  eq = GetOnlineEqIdFromOffline(module);
-  hs = GetOnlineHSFromOffline(module);
-  chip = GetOnlineChipFromOffline(module,colM);
-  col = GetOnlineColFromOffline(module,colM);
-  row = GetOnlineRowFromOffline(module,rowM);
-  if (eq>=20 || hs>=6 || chip>=10 || col>=32 || row>=256) return kFALSE;
-  else return kTRUE;
-}
-//__________________________________________________________________________
-Bool_t AliITSRawStreamSPD::OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM) {
-  // converts online coordinates to offline
-  module = GetOfflineModuleFromOnline(eq,hs,chip);
-  colM = GetOfflineColFromOnline(eq,hs,chip,col);
-  rowM = GetOfflineRowFromOnline(eq,hs,chip,row);
-  if (module>=240 || colM>=160 || rowM>=256) return kFALSE;
-  else return kTRUE;
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOnlineEqIdFromOffline(UInt_t module) {
-  // offline->online (eq)
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    for (UInt_t iModule=0; iModule<12; iModule++) {
-      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return eqId;
-    }
-  }
-  return 20; // error
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOnlineHSFromOffline(UInt_t module) {
-  // offline->online (hs)
-  for (UInt_t eqId=0; eqId<20; eqId++) {
-    for (UInt_t iModule=0; iModule<12; iModule++) {
-      if (GetModuleNumber(eqId,iModule)==(Int_t)module) return iModule/2;
-    }
-  }
-  return 6; // error
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOnlineChipFromOffline(UInt_t module, UInt_t colM) {
-  // offline->online (chip)
-  for (UInt_t eq=0; eq<20; eq++) {
-    for (UInt_t iModule=0; iModule<12; iModule++) {
-      if (GetModuleNumber(eq,iModule)==(Int_t)module) {
-       return colM/32 + 5*(iModule%2);
-      }
-    }
-  }
-  return 10; // error
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOnlineColFromOffline(UInt_t module, UInt_t colM) {
-  // offline->online (col)
-  if (colM<160) return colM%32;
-  else return 32; // error
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOnlineRowFromOffline(UInt_t module, UInt_t rowM) {
-  // offline->online (row)
-  if (rowM<256) return rowM;
-  else return 256; // error
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip) {
-  // online->offline (module)
-  if (eqId<20 && hs<6 && chip<10) return fgkDDLModuleMap[eqId][hs*2+chip/5];
-  else return 240;
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col) {
-  // online->offline (col)
-  if (eqId>=20 || hs>=6 || chip>=10 || col>=32) return 160; // error
-  UInt_t offset = 32 * (chip % 5);
-  return col+offset;
-}
-//__________________________________________________________________________
-UInt_t AliITSRawStreamSPD::GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row) {
-  // online->offline (row)
-  if (eqId>=20 || hs>=6 || chip>=10 || row>=256) return 256; // error
-  return row;
-}
-
-
-
-
diff --git a/ITS/AliITSTrackV1.cxx b/ITS/AliITSTrackV1.cxx
deleted file mode 100644 (file)
index 80ca853..0000000
+++ /dev/null
@@ -1,802 +0,0 @@
-//   ITS Track Class
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// It contain all the usefull information for the track and the method to calculate, modify or extract them
-// The track is mainly caracterized by the state vector of elements (fX0, fX1, fX2, fX3, fX4) and the
-// corresponding covariance matrix of elements (C00, C10, ..... C44) that is triangular
-//
-#include <Riostream.h>
-#include <TMath.h>
-#include <TVector.h>
-#include <TObjArray.h>
-#include "AliRun.h"
-#include "AliITSRad.h"
-#include "AliITSTrackV1.h"
-#include "AliGenerator.h"
-//#include "AliMagF.h"
-
-
-ClassImp(AliITSTrackV1)
-
-AliITSTrackV1::AliITSTrackV1() {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it 
-// default constructor   
-  fTPCtrack = 0;
-  fC00=fC10=fC11=fC20=fC21=fC22=fC30=fC31=fC32=fC33=fC40=fC41=fC42=fC43=fC44=0.;
-  flistCluster = 0;   
-  fNumClustInTrack =0;
-  fChi2=-1;
-  flabel =0;
-  fLayer = -1; 
-  fClusterInTrack = 0; 
-  frtrack=0.;
-  fnoclust=0;
-  fMass=0.13956995; //a pion by default
-  fFieldFactor = 0.0;
-  fdEdx = 0.;                          // oggi
-  Int_t ia=0;                          // oggi
-  for( ia=0; ia<4; ia++) fcor[ia]=0.;  // oggi
-  
-}
-AliITSTrackV1::AliITSTrackV1(Double_t fieldfactor) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it 
-// default constructor   
-  fTPCtrack = 0;
-  fC00=fC10=fC11=fC20=fC21=fC22=fC30=fC31=fC32=fC33=fC40=fC41=fC42=fC43=fC44=0.;
-  flistCluster = 0;   
-  fNumClustInTrack =0;
-  fChi2=-1;
-  flabel =0; 
-  fVertex.ResizeTo(3); 
-  fErrorVertex.ResizeTo(3);
-  fLayer = -1; 
-  fClusterInTrack = 0; 
-  frtrack=0.;
-  fnoclust=0;     
-  fd2.ResizeTo(6);
-  ftgl2.ResizeTo(6); 
-  fdtgl.ResizeTo(6);
-  fMass=0.13956995; //a pion by default
-  fdEdx = 0.;
-  Int_t ia=0;
-  for( ia=0; ia<4; ia++) fcor[ia]=0.;   
-
-  
-//////////////////////////////////////// gets magnetic field factor ////////////////////////////////
-
- // AliMagF * fieldPointer = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField());
-  // fFieldFactor =(Double_t)fieldPointer-> SolenoidField()/10/.2;
-    fFieldFactor = fieldfactor;
-  //cout<< " field factor = "<<fFieldFactor<<"\n"; getchar();
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////
-   
-}
-
-
-AliITSTrackV1::AliITSTrackV1(const AliITSTrackV1 &cobj) : TObject(cobj) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// copy constructor    
-
-  fClusterInTrack = new TMatrix(6,9);
-  Int_t i,j;
-  for(i=0; i<6; i++){
-  for(j=0; j<9; j++) (*fClusterInTrack)(i,j)=-1.;   
-  }  
-  flistCluster = new TObjArray; 
-  fVertex.ResizeTo(3); 
-  fErrorVertex.ResizeTo(3);
-  fVertex = cobj.fVertex;
-  fErrorVertex = cobj.fErrorVertex;
-  flabel = cobj.flabel;
-  fLayer=cobj.fLayer;
-  fTPCtrack = cobj.fTPCtrack;
-  fNumClustInTrack = cobj.fNumClustInTrack; 
-  fChi2= cobj.fChi2;
-  fX0=cobj.fX0; fX1=cobj.fX1; fX2=cobj.fX2; fX3=cobj.fX3; fX4=cobj.fX4; 
-  frtrack=cobj.frtrack;
-  fDv=cobj.fDv;
-  fZv=cobj.fZv;
-  fsigmaDv=cobj.fsigmaDv;
-  fsigmaZv=cobj.fsigmaZv;
-  fd2.ResizeTo(6);
-  ftgl2.ResizeTo(6); 
-  fdtgl.ResizeTo(6); 
-  fd2=cobj.fd2;
-  ftgl2=cobj.ftgl2;
-  fdtgl=cobj.fdtgl;
-  fnoclust=cobj.fnoclust; 
-  fdEdx = cobj.fdEdx;
-  Int_t ia=0;
-  for( ia=0; ia<4; ia++) fcor[ia]=cobj.fcor[ia];    
-
-    
-  fC00=cobj.fC00; fC10=cobj.fC10; fC11=cobj.fC11; fC20=cobj.fC20; fC21=cobj.fC21;
-  fC22=cobj.fC22; fC30=cobj.fC30; fC31=cobj.fC31; fC32=cobj.fC32; fC33=cobj.fC33; 
-  fC40=cobj.fC40; fC41=cobj.fC41; fC42=cobj.fC42; fC43=cobj.fC43; fC44=cobj.fC44; 
-  *fClusterInTrack = *cobj.fClusterInTrack;
-  
-  fFieldFactor=cobj.fFieldFactor;
-  fMass=cobj.fMass; 
-   
-  for(i=0; i<cobj.flistCluster->GetSize(); i++) 
-    flistCluster->AddLast(cobj.flistCluster->At(i));
-}
-
-AliITSTrackV1::AliITSTrackV1(AliTPCtrack &obj, Double_t fieldfactor)
-{ 
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it 
-// special constructor to convert a TPC track into an ITS track
-
-//////////////////////////////////////// gets magnetic field factor ////////////////////////////////
-
-   // AliMagF * fieldPointer = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField());
-  // fFieldFactor =(Double_t)fieldPointer-> SolenoidField()/10/.2;
-    fFieldFactor = fieldfactor;
- // cout<< " field factor dentro alitrack = "<<fFieldFactor<<"\n";/* getchar();*/
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-  fTPCtrack = &obj;
-  fVertex.ResizeTo(3); 
-  fErrorVertex.ResizeTo(3);
-
-  fd2.ResizeTo(6);
-  ftgl2.ResizeTo(6); 
-  fdtgl.ResizeTo(6); 
-  AliGenerator *gener = gAlice->Generator();
-  Float_t vxg,vyg,vzg;
-  gener->GetOrigin(vxg,vyg,vzg);
-  
-  fVertex(0)=(Double_t)vxg;
-  fVertex(1)=(Double_t)vyg; 
-  fVertex(2)=(Double_t)vzg;    
-  
-  fLayer = 7;
-  fClusterInTrack = new TMatrix(6,9);
-  
-  Int_t i,j;
-  for(i=0; i<6; i++){
-  for(j=0; j<9; j++) (*fClusterInTrack)(i,j)=-1.;   
-  }  
-  flistCluster = new TObjArray; 
-  fNumClustInTrack = 0;
-  fnoclust=0;
-  fdEdx = 0.;
-  Int_t ia=0;
-  for( ia=0; ia<4; ia++) fcor[ia]=0.;          
-  LmTPC(); 
-
-}
-
-
-AliITSTrackV1::~AliITSTrackV1() {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it 
-//destructor
-  if(flistCluster) {
-    flistCluster->Delete();
-    delete flistCluster;
-  }
-  if(fClusterInTrack) delete fClusterInTrack;
-
-}     
-
-void AliITSTrackV1::PutCElements(Double_t C00, Double_t C10, Double_t C11, Double_t C20, Double_t C21, 
-Double_t C22, Double_t C30, Double_t C31, Double_t C32, Double_t C33, Double_t C40, 
-Double_t C41, Double_t C42, Double_t C43, Double_t C44){
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// puts elements of covariance matrix
-
-  fC00=C00; fC10=C10; fC11=C11; fC20=C20; fC21=C21; fC22=C22; fC30=C30; fC31=C31; fC32=C32; fC33=C33;
-  fC40=C40; fC41=C41; fC42=C42; fC43=C43; fC44=C44; 
-}
-  
-void AliITSTrackV1::GetCElements(Double_t &C00, Double_t &C10, Double_t &C11, Double_t &C20, Double_t &C21, 
-Double_t &C22, Double_t &C30, Double_t &C31, Double_t &C32, Double_t &C33, Double_t &C40, 
-Double_t &C41, Double_t &C42, Double_t &C43, Double_t &C44) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// gets elements of covariance matrix
-
-
-  C00=fC00; C10=fC10; C11=fC11; C20=fC20; C21=fC21; C22=fC22; C30=fC30; C31=fC31; C32=fC32; C33=fC33;
-  C40=fC40; C41=fC41; C42=fC42; C43=fC43; C44=fC44; 
-
-}
-
-void AliITSTrackV1::GetXElements(Double_t &X0, Double_t &X1, Double_t &X2, Double_t &X3, Double_t &X4) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// gets the elements of the state vector
-  X0=fX0; X1=fX1; X2=fX2; X3=fX3; X4=fX4; 
-}
-
-void AliITSTrackV1::PutXElements(Double_t X0, Double_t X1, Double_t X2, Double_t X3, Double_t X4){
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// puts the elements of the state vector
-  fX0=X0; fX1=X1; fX2=X2; fX3=X3; fX4=X4; 
-}   
-
-void AliITSTrackV1::LmTPC() {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// Transform the TPC state vector from TPC-local to master and build a new state vector ITS-type
-// The covariance matrix is also modified accordingly      
-
-   
-  Double_t alpha = fTPCtrack->GetAlpha(); 
-  //printf("LmTPC: alpha %f\n",alpha); 
-
-  Double_t yTPC   = fTPCtrack->GetY();
-  Double_t zTPC   = fTPCtrack->GetZ();
-  Double_t cTPC   = fTPCtrack->GetC();
-  Double_t etaTPC = fTPCtrack->GetEta();
-  Double_t tglTPC = fTPCtrack->GetTgl();
-  
-
-  Double_t xm, ym, zm;
-  Double_t sina = TMath::Sin(alpha);
-  Double_t cosa = TMath::Cos(alpha);
-  Double_t xl= fTPCtrack->GetX();
-  xm = xl * cosa - yTPC*sina;
-  ym = xl * sina + yTPC*cosa;
-  zm = zTPC;  
-  //cout<<" xl e alpha = "<<xl<<" "<<alpha<<"\n"; getchar(); 
-
-  Double_t x0m,y0m;
-
-  ///////////////////////////////////// determine yo //////////////////////////////////////////////////
-  
-  Double_t vxl=fVertex(0)*cosa+fVertex(1)*sina;
-  Double_t vyl= -fVertex(0)*sina+fVertex(1)*cosa;
-  Double_t xo,yo, signy;
-  Double_t r = 1./cTPC;
-  xo =  etaTPC / cTPC;
-  Double_t yo1, yo2, diffsq1, diffsq2;  
-  yo1 = yTPC +  TMath::Sqrt((r-(xl-xo))*(r+(xl-xo))); 
-  yo2 = yTPC -  TMath::Sqrt((r-(xl-xo))*(r+(xl-xo)));   
-  diffsq1=TMath::Abs((yo1-vyl)*(yo1-vyl)+((xo-vxl)-r)*((xo-vxl)+r));
-  diffsq2=TMath::Abs((yo2-vyl)*(yo2-vyl)+((xo-vxl)-r)*((xo-vxl)+r));
-  if(diffsq1<diffsq2) {yo=yo1; signy=1.;} else {yo=yo2; signy=-1.;};
-  
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-
-  x0m = xo * cosa - yo * sina;
-  y0m = xo * sina + yo * cosa;  
-
-  frtrack=TMath::Sqrt(xm*xm+ym*ym);
-       
-  Double_t phi=TMath::ATan2(ym,xm);  if(phi<0) phi=2.*TMath::Pi()+phi;     
-
-  fX0=phi;
-  fX1=zm;
-  fX3=tglTPC;
-  fX4=cTPC;
-
-  
-  Double_t dd=TMath::Sqrt((x0m-fVertex(0))*(x0m-fVertex(0))+(y0m-fVertex(1))*(y0m-fVertex(1)));
-  Double_t signdd;
-  if (r>0) signdd=1.; else signdd=-1.;
-  fX2=signdd*dd-r;
-  //cout<<" fvertex = "<<fVertex(0)<<" "<<fVertex(1)<<" "<<fVertex(2)<<"\n";
-      
-  Double_t cov[15];
-  fTPCtrack->GetCovariance(cov);
-
-  Double_t  dfidy, dDdy, dDdC, dDdeta;
-
-  dfidy=(xm*cosa+ym*sina)/(frtrack*frtrack);
-  dDdy=signdd*((y0m-fVertex(1))*cosa-(x0m-fVertex(0))*sina)/dd;
-  Double_t dyodr=signy*(r+(xl-xo)*etaTPC)/TMath::Sqrt((r-(xl-xo))*(r+(xl-xo)));
-  Double_t dyomdr=sina*etaTPC+cosa*dyodr;
-  Double_t dxomdr=cosa*etaTPC-sina*dyodr;
-  Double_t ddddR=((x0m-fVertex(0))*dxomdr+(y0m-fVertex(1))*dyomdr)/dd;
-  dDdC=-r*r*(signdd*ddddR-1.);
-  Double_t dyoldxol=signy*(xl-xo)/TMath::Sqrt((r-(xl-xo))*(r+(xl-xo)));
-  Double_t dxomdeta=r*(cosa-sina*dyoldxol);
-  Double_t dyomdeta=r*(sina+cosa*dyoldxol);
-  dDdeta=signdd*((x0m-fVertex(0))*dxomdeta+(y0m-fVertex(1))*dyomdeta)/dd;
-  
-  Double_t f00=dfidy;
-  Double_t f20=dDdy;    
-  Double_t f22=dDdC;    
-  Double_t f23=dDdeta;
-  
-  Double_t t00=cov[0]*f00;
-  Double_t t02=cov[0]*f20+cov[6]*f22+cov[3]*f23;
-  Double_t t20=cov[6]*f00;
-  Double_t t22=cov[6]*f20+cov[9]*f22+cov[8]*f23;
-  
-  fC00=f00*t00;
-  fC10=cov[1]*f00;
-  fC11=cov[2];
-  fC20=f20*t00+f22*t20+f23*cov[3]*f00;
-  fC21=f20*cov[1]+f22*cov[7]+f23*cov[4];
-  fC22=f20*t02+f22*t22+f23*(cov[3]*f20+cov[8]*f22+cov[5]*f23);
-  fC30=cov[10]*f00;
-  fC31=cov[11];
-  fC32=cov[10]*f20+cov[13]*f22+cov[12]*f23;
-  fC33=cov[14];
-  fC40=t20;
-  fC41=cov[7];
-  fC42=t22;
-  fC43=cov[13];
-  fC44=cov[9];
-  
-   
-}
-
-
-AliITSTrackV1 &AliITSTrackV1::operator=(AliITSTrackV1 obj) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-// assignement operator
-
-  if (flistCluster) {
-    flistCluster->Delete();
-    delete flistCluster;
-  }
-  delete fClusterInTrack;
-  fClusterInTrack = new TMatrix(6,9);
-  flistCluster = new TObjArray; 
-  flabel = obj.flabel;
-  fTPCtrack = obj.fTPCtrack; 
-  fNumClustInTrack = obj.fNumClustInTrack; 
-  fChi2= obj.fChi2;
-  fVertex=obj.fVertex;
-  fErrorVertex=obj.fErrorVertex;
-  fX0=obj.fX0; fX1=obj.fX1; fX2=obj.fX2; fX3=obj.fX3; fX4=obj.fX4;  
-  fLayer=obj.fLayer;
-  frtrack=obj.frtrack;
-  fDv=obj.fDv;
-  fZv=obj.fZv;
-  fsigmaDv=obj.fsigmaDv;
-  fsigmaZv=obj.fsigmaZv;
-  fd2=obj.fd2;
-  ftgl2=obj.ftgl2; 
-  fdtgl=obj.fdtgl;
-  fnoclust=obj.fnoclust; 
-  
-  fC00=obj.fC00; fC10=obj.fC10; fC11=obj.fC11; fC20=obj.fC20; fC21=obj.fC21;
-  fC22=obj.fC22; fC30=obj.fC30; fC31=obj.fC31; fC32=obj.fC32; fC33=obj.fC33; 
-  fC40=obj.fC40; fC41=obj.fC41; fC42=obj.fC42; fC43=obj.fC43; fC44=obj.fC44;
-   
-  fMass=obj.fMass; 
-  fdEdx = obj.fdEdx; 
-  Int_t ia=0;
-  for( ia=0; ia<4; ia++) fcor[ia]=obj.fcor[ia];   
-
-  
-  *fClusterInTrack = *obj.fClusterInTrack;
-  Int_t i;
-  for(i=0; i<obj.flistCluster->GetSize(); i++) flistCluster->AddLast(obj.flistCluster->At(i));
-
-  return *this;
-  
-}
-
-void AliITSTrackV1::PutCluster(Int_t layerc, TVector vecclust) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// put information for clusters
-  
-  (*fClusterInTrack)(layerc,0) = vecclust(0);
-  (*fClusterInTrack)(layerc,1) = vecclust(1);
-  (*fClusterInTrack)(layerc,2) = vecclust(2);
-  (*fClusterInTrack)(layerc,3) = vecclust(3);
-  (*fClusterInTrack)(layerc,4) = vecclust(4);  
-  (*fClusterInTrack)(layerc,5) = vecclust(5);
-  (*fClusterInTrack)(layerc,6) = vecclust(6);
-  (*fClusterInTrack)(layerc,7) = vecclust(7);
-  (*fClusterInTrack)(layerc,8) = vecclust(8);
-
-}
-
-
-void AliITSTrackV1::GetClusters() {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// prints the clusters belonging to the current track
-
-  TMatrix a(*fClusterInTrack);
-  TMatrix b(6,3);
-  Int_t i;
-  for(i=0;i<6; i++){
-   b(i,0)=a(i,6); b(i,1)=a(i,7); b(i,2)=a(i,8); 
-  }
-  a.Print();
- // b.Print(); 
-}
-
-
-TVector AliITSTrackV1::GetLabTrack(Int_t lay) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// gets the label of the track
-
-  TVector vecLabel(3);
-  vecLabel(0)=( (Float_t) (*fClusterInTrack)(lay,6) );
-  vecLabel(1)=( (Float_t) (*fClusterInTrack)(lay,7) );
-  vecLabel(2)=( (Float_t) (*fClusterInTrack)(lay,8) );
-  return vecLabel;
-}
-
-void AliITSTrackV1::Search(TVector VecTotLabref, Long_t &labref, Int_t &freq){
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-// define label
-
-  Int_t vecfreq[18];
-  
-  Int_t i,j;
-  for(i=0; i<18; i++) vecfreq[i]=0;
-  
-  for(i=0; i<18; i++) {
-    for(j=0; j<18; j++) {
-     // if(VecTotLabref(i) == 0.) VecTotLabref(i)=-3.;  //commentato il 5-3-2001
-      if( (VecTotLabref(i)>=0.) && (VecTotLabref(i)==VecTotLabref(j)) ) vecfreq[i]++;    
-    }  
-  }
-  Int_t imax=-1000;
-  Long_t  labdefault= (Long_t)1000000.;
-  freq=0;
-  for(i=0; i<18; i++) {
-    if(vecfreq[i]>freq) {freq=vecfreq[i]; imax=i;}  
-  }
-  if(imax<0) labref=labdefault; else labref=(Long_t) VecTotLabref(imax);
-} 
-
-
-void AliITSTrackV1::Propagation(Double_t rk) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-//Propagation of track 
-  Double_t duepi=2.*TMath::Pi();
-  Double_t rkm1=frtrack;
-//cout<<" rk e rkm1 dentro Propagation   "<<rk<<" "<<rkm1<<"\n";
-  
-  //
-  Double_t aAk=ArgA(rk), aAkm1=ArgA(rkm1);
-  Double_t ak=Arga(rk), akm1=Arga(rkm1);
-  fX0+=TMath::ASin(aAk)-TMath::ASin(aAkm1);
-
-  if(fX0>duepi) fX0-=duepi;
-  if(fX0<0.) fX0+=duepi;
-       
-  Double_t tgl=fX3;
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2;
-  fX1+=tgl/cy*(TMath::ASin(ak)-TMath::ASin(akm1));  
-  frtrack=rk;
-
-       
-  Double_t bk=ArgB(rk), bkm1=ArgB(rkm1);       
-  Double_t ck=ArgC(rk), ckm1=ArgC(rkm1);  
-
-  Double_t f02=ck/TMath::Sqrt((1.-aAk)*(1.+aAk)) - ckm1/TMath::Sqrt((1.-aAkm1)*(1.+aAkm1));
-  Double_t f04=bk/TMath::Sqrt((1.-aAk)*(1.+aAk)) - bkm1/TMath::Sqrt((1.-aAkm1)*(1.+aAkm1));    
-  Double_t f12=tgl*d*(1./rk - 1./rkm1);
-  Double_t f13=rk - rkm1;
-  
-
-  Double_t c00=fC00;
-  Double_t c10=fC10;
-  Double_t c11=fC11;
-  Double_t c20=fC20;
-  Double_t c21=fC21;
-  Double_t c22=fC22;
-  Double_t c30=fC30;
-  Double_t c31=fC31;
-  Double_t c32=fC32;
-  Double_t c33=fC33;
-  Double_t c40=fC40;
-  Double_t c41=fC41;
-  Double_t c42=fC42;
-  Double_t c43=fC43;
-  Double_t c44=fC44;
-  
-  Double_t r10=c10+c21*f02+c41*f04;
-  Double_t r20=c20+c22*f02+c42*f04;
-  Double_t r30=c30+c32*f02+c43*f04;
-  Double_t r40=c40+c42*f02+c44*f04;
-  Double_t r21=c21+c22*f12+c32*f13;
-  Double_t r31=c31+c32*f12+c33*f13;                                                                    
-  Double_t r41=c41+c42*f12+c43*f13;
-
-  fC00=c00+c20*f02+c40*f04+f02*r20+f04*r40;
-  fC10=r10+f12*r20+f13*r30;
-  fC11=c11+c21*f12+c31*f13+f12*r21+f13*r31;
-  fC20=r20;
-  fC21=r21;
-  fC30=r30;
-  fC31=r31;
-  fC40=r40;
-  fC41=r41;
-  
-}
-
-void AliITSTrackV1::AddEL(Double_t signdE, Bool_t flagtot, Double_t mass) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-//  add energy loss
-// AliITSRad *rl was passed as argument. Now rl has been commented out
-
-  mass=fMass;  
-  
-  TVector s(6);  
-  s(0)=0.0026+0.00283; s(1)=0.018; s(2)=0.0094; s(3)=0.0095; s(4)=0.0091; s(5)=0.0087;
-  //s(0)=0.0026+0.00283*2.; s(1)=0.018*2.; s(2)=0.0094; s(3)=0.0095; s(4)=0.0091; s(5)=0.0087;
-  //0.00277 is added in the first layer to take into account the energy loss in the beam pipe
-
-  //for(int k=0; k<6; k++) cout<<s(k)<<" "; cout<<"\n";
-  Int_t k;
-  //for(k=0; k<6; k++) s(k)=s(k)*1.6;    //forint
-  for(k=0; k<6; k++) s(k)=s(k)*1.7;    //forint
-  
-  Double_t phi=fX0;
-  
-  if(phi<0.174 ) s(5)=s(5)+0.012; 
-  if(phi>6.1 ) s(5)=s(5)+0.012; // to take into account rail 
-  if(phi>2.96 && phi<3.31 ) s(5)=s(5)+0.012;   
-  
-  /* 
-  Double_t tgl=fX3;
-  Double_t theta=((TMath::Pi())/2.)-TMath::ATan(tgl);
-  //phi*=180./TMath::Pi();
-  //theta*=180./TMath::Pi();
-  //Double_t rad90=(TMath::Pi())/2.;
-  Double_t rad40=(TMath::Pi())*40./180.;
-  Double_t rad100=(TMath::Pi())*100/180;
-  Double_t rad360=(TMath::Pi())*2.;
-  Int_t imax=rl->Getimax();
-  Int_t jmax=rl->Getjmax();
-  Int_t i=(Int_t) ( (theta-rad40)/rad100*imax);
-  Int_t j=(Int_t) ( phi/rad360*jmax );
-  //Int_t i=(Int_t)( ((theta-((TMath::Pi())/4.))/((TMath::Pi())/2.))*imax );
-  //Int_t j=(Int_t)( (phi/((TMath::Pi())*2.))*jmax );
-  if(i<0) i=0;
-  if(i>=imax) i=imax-1;
-  if(j<0) j=0;
-  if(j>=jmax) j=jmax-1;
-  
-  s(0) = 0.0028/TMath::Sin(theta)+( rl->GetRadMatrix1() )(i,j);   // 0.0028 takes into account the beam pipe
-  s(1) = ( rl->GetRadMatrix2() )(i,j);
-  s(2) = ( rl->GetRadMatrix3() )(i,j);
-  s(3) = ( rl->GetRadMatrix4() )(i,j);
-  s(4) = ( rl->GetRadMatrix5() )(i,j);
-  s(5) = ( rl->GetRadMatrix6() )(i,j);
-  
-
-  */  
-  
-  //for(int k=0; k<6; k++) cout<<s(k)<<" "; getchar();
-    
-  //if(phi>60) {cout<<" phi = "<<phi<<"\n"; getchar();}
-  //if(theta<45 || theta>135) {cout<<" theta = "<<theta<<"\n"; getchar();}
-  //cout<<" dentro AddEl: phi, theta = "<<phi<<" "<<theta<<"\n"; getchar(); 
-    
-  Double_t cl=1.+fX3*fX3;  // cl=1/(cosl)**2 = 1 + (tgl)**2
-  Double_t sqcl=TMath::Sqrt(cl);
-  Double_t pt=GetPt();
-     
-  Double_t p2=pt*pt*cl;
-  Double_t e=TMath::Sqrt(p2+mass*mass);
-  Double_t beta2=p2/(p2+mass*mass);
-  
-  Double_t dE;
-  if(flagtot) {
-    Double_t stot=s(0)+s(1)+s(2)+s(3)+s(4)+s(5);
-    dE=0.153/beta2*(log(5940*beta2/(1-beta2)) - beta2)*stot*21.82*sqcl;
-  } else {
-    dE=0.153/beta2*(log(5940*beta2/(1-beta2)) - beta2)*s(fLayer-1)*21.82*sqcl;
-  }   
-  dE=signdE*dE/1000.; 
-         
-  e+=dE;
-  Double_t p=TMath::Sqrt((e-mass)*(e+mass));   
-  Double_t sign=1.;
-  if(fX4 < 0.) sign=-1.; 
-  pt=sign*p/sqcl; 
-  Double_t cc=(0.299792458*0.2*fFieldFactor)/(pt*100.);
-  fX4=cc;
-  
-}
-
-void  AliITSTrackV1::Correct(Double_t rk) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-// correct track to take into account real geometry detector
-
-  Double_t duepi=2.*TMath::Pi();
-  Double_t rkm1=frtrack;
-  Double_t aAk=ArgA(rk), aAkm1=ArgA(rkm1);
-  Double_t ak=Arga(rk), akm1=Arga(rkm1);
-
-  fX0+=TMath::ASin(aAk)-TMath::ASin(aAkm1);
-  if(fX0>duepi) fX0-=duepi;
-  if(fX0<0.) fX0+=duepi;
-       
-  Double_t tgl=fX3;
-  Double_t c=fX4;
-  Double_t cy=c/2;
-  fX1+=tgl/cy*(TMath::ASin(ak)-TMath::ASin(akm1));
-  frtrack=rk;
-               
-}
-
-void AliITSTrackV1::AddMS(Double_t mass) {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it       
-//////////   Modification of the covariance matrix to take into account multiple scattering  ///////////     
-   
-  mass=fMass;
-  TVector s(6);
-
-  s(0)=0.0026+0.00283; s(1)=0.018; s(2)=0.0094; s(3)=0.0095; s(4)=0.0091; s(5)=0.0087;
- //  s(0)=0.0026+0.00283*2.; s(1)=0.018*2.; s(2)=0.0094; s(3)=0.0095; s(4)=0.0091; s(5)=0.0087;
-//0.00277 is added in the first layer to take into account the energy loss in the beam pipe 
-
-  Int_t k;
-  //for(k=0; k<6; k++) s(k)=s(k)*1.6;   // forint
-  for(k=0; k<6; k++) s(k)=s(k)*1.7;   // forint
-  
-  Double_t phi=fX0;
- if(phi<0.174 ) s(5)=s(5)+0.012; //aggiunta provvisoria
-  if(phi>6.1 ) s(5)=s(5)+0.012; //aggiunta provvisoria  
-   if(phi>2.96 && phi< 3.31) s(5)=s(5)+0.012; //aggiunta provvisoria 
-  
-      
-  Double_t tgl=fX3;
-  /*
-  Double_t theta=((TMath::Pi())/2.)-TMath::ATan(tgl);
-  Double_t rad40=(TMath::Pi())*40./180.;      // rivedere
-  Double_t rad100=(TMath::Pi())*100/180;
-  Double_t rad360=(TMath::Pi())*2.;
-  Int_t imax=rl->Getimax();
-  Int_t jmax=rl->Getjmax();
-  Int_t i=(Int_t) ( (theta-rad40)/rad100*imax);
-  Int_t j=(Int_t) ( phi/rad360*jmax);
-
-  if(i<0) i=0;
-  if(i>=imax) i=imax-1;
-  if(j<0) j=0;
-  if(j>=jmax) j=jmax-1;
-  
-  s(0) = 0.0028/TMath::Sin(theta)+( rl->GetRadMatrix1() )(i,j);   // 0.0028 takes into account the beam pipe
-  s(1) = ( rl->GetRadMatrix2() )(i,j);
-  s(2) = ( rl->GetRadMatrix3() )(i,j);
-  s(3) = ( rl->GetRadMatrix4() )(i,j);
-  s(4) = ( rl->GetRadMatrix5() )(i,j);
-  s(5) = ( rl->GetRadMatrix6() )(i,j);
-   */   
-  //Double_t mass=0.1396;
-  Int_t layer=(Int_t)GetLayer();
-  
-  Double_t cosl=TMath::Cos(TMath::ATan(tgl));  
-  Double_t d=fX2;
-  Double_t c=fX4;
-  Double_t cy=c/2.;
-  Double_t q20=1./(cosl*cosl);  
-  Double_t q30=c*tgl;
-   
-  Double_t q40=cy*(frtrack*frtrack-d*d)/(1.+ 2.*cy*d);
-  Double_t dd=d+cy*d*d-cy*frtrack*frtrack;
-  Double_t dprova=frtrack*frtrack - dd*dd;
-  Double_t q41=0.;
-  if(dprova>0.) q41=-1./cosl*TMath::Sqrt(dprova)/(1.+ 2.*cy*d);
-               
-  Double_t p2=(GetPt()*GetPt())/(cosl*cosl);
-  Double_t beta2=p2/(p2+mass*mass);
- // Double_t theta2=14.1*14.1/(beta2*p2*1.e6)*(s(layer-1)/cosl);
-   Double_t theta2=14.1*14.1/(beta2*p2*1.e6)*(s(layer-1)/TMath::Abs(cosl));
-
-  fC22+=theta2*(q40*q40+q41*q41);
-  fC32+=theta2*q20*q40;
-  fC33+=theta2*q20*q20;
-  fC42+=theta2*q30*q40;
-  fC43+=theta2*q30*q20;
-  fC44+=theta2*q30*q30;
-    
-}
-void AliITSTrackV1::PrimaryTrack() {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-// calculation of part of covariance matrix for vertex constraint
-
-  Double_t rlayer[6];
-       
-  rlayer[0]=4.; rlayer[1]=7.;  rlayer[2]=14.9;  rlayer[3]=23.8;  
-  rlayer[4]=39.1;  rlayer[5]=43.6;
-       
-  Double_t cy=fX4/2.;  
-  Double_t tgl=(fX1-fZv)*cy/TMath::ASin(cy*frtrack);
-  Double_t frtrack=1.; 
-  fX0=0.;
-  fX1=frtrack*tgl; 
-  fX2=fDv;
-  fX3=tgl; 
-
-  fC00=fC10=fC11=fC20=fC21=fC22=fC30=fC31=fC32=fC33=fC40=fC41=fC42=fC43=0.;
-
-  AddEL(1.,1);
-  fLayer=0;
-  Int_t i;
-  for (i=0; i<6; i++) {
-    Propagation(rlayer[i]);
-    fLayer++;
-    fd2(i)=fC22;
-    ftgl2(i)=fC33;
-    fdtgl(i)=fC32; 
-    AddMS();    
-    AddEL(-1,0);          
-  }            
-}      
-  
-Int_t AliITSTrackV1::DoNotCross(Double_t rk) const{
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-// determine if the track cross a layer
-
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2.;
-  return (TMath::Abs((cy*rk+(1.+cy*d)*d/rk)/(1.+2.*cy*d))>=1.)?1:0;
-}
-  
-
-Double_t AliITSTrackV1::ArgA(Double_t rk) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// quantity usefull in Propagation  
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2.;
-  Double_t arg=(cy*rk + (1 + cy*d)*d/rk)/(1.+ 2.*cy*d);                
-  if (TMath::Abs(arg) < 1.) return arg;
-  //cout<<"class AliITSTrack: ArgA out of range !\n";/* getchar();*/
-  return (arg>0) ? 0.99999999999 : -0.9999999999;
-}
-   
-Double_t AliITSTrackV1::Arga(Double_t rk) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// quantity usefull in Propagation 
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2.;
-  Double_t arg=(rk*rk - d*d)/(1.+ 2.*cy*d);            
-  if (arg<0.) {/*cout<<"class AliITSTrack: Arga out of range !\n";*/ arg=0.;} 
-  return cy*TMath::Sqrt(arg);
-}
-       
-Double_t AliITSTrackV1::ArgB(Double_t rk) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// quantity usefull in Propagation 
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2.;       
-  return (rk*rk - d*d)/(rk*(1.+ 2.*cy*d)*(1.+ 2.*cy*d));
-}
-   
-Double_t AliITSTrackV1::ArgC(Double_t rk) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// quantity usefull in Propagation 
-  Double_t c=fX4;
-  Double_t d=fX2;
-  Double_t cy=c/2.;            
-  return  (1./rk - 2.*cy*ArgA(rk)/(1.+ 2.*cy*d));
-}
-
-
-Double_t AliITSTrackV1::GetPredChi2(Double_t m[2], Double_t sigma[2] ) const {
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// This function calculates a predicted chi2 increment.
-  Double_t r00=sigma[0], r01=0., r11=sigma[1];
-  r00+=fC00; r01+=fC10; r11+=fC11;
-  Double_t det=r00*r11-r01*r01;
-  if(TMath::Abs(det) < 1.e-15) {cout<<" Problems on matrix in GetPredChi2 "<<det<<"\n";
-  return 1e10;}
-  Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-  Double_t dphi=m[0]-fX0; 
-  Double_t dz=m[1]-fX1;
-  Double_t chi2 = (dphi*r00*dphi +2.*r01*dphi*dz + dz*r11*dz)/det;
-  return chi2;
-  
-}
diff --git a/ITS/AliITSTrackV1.h b/ITS/AliITSTrackV1.h
deleted file mode 100644 (file)
index ae86daa..0000000
+++ /dev/null
@@ -1,178 +0,0 @@
-#ifndef ALIITSTRACKV1_H
-#define ALIITSTRACKV1_H
-//   ITS Track Class
-//Origin  A. Badala' and G.S. Pappalardo:  e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-// It contain all the usefull information for the track and the method to calculate, modify or extract them
-#include <TObject.h>
-#include <TMatrix.h>
-#include <TVector.h>
-
-#include "../TPC/AliTPCtrack.h"
-
-class TObjArray;
-class AliITSRad;
-
-class AliITSTrackV1 : public TObject { 
-
-public:
-
-  AliITSTrackV1();  // default constructor
-  //AliITSTrackV1(const char *opt);  // Standard constructor
-  AliITSTrackV1(Double_t fieldfactor);  // Standard constructor
-  //AliITSTrackV1(AliTPCtrack &obj);  // Standard constructor
-  AliITSTrackV1(AliTPCtrack &obj, Double_t fieldfactor);  // Standard constructor
-  AliITSTrackV1(const AliITSTrackV1 &cobj);  // copy constructor
-  AliITSTrackV1 &operator=(AliITSTrackV1 obj);  // operator =
-  ~AliITSTrackV1(); // default destructor
-  Int_t GetNumClust() const { return fNumClustInTrack;}  // gets the num of cluster in a track
-  void AddClustInTrack() { fNumClustInTrack++;}  // adds a cluster in track
-  TObjArray *GetListOfCluster() const { return flistCluster;}  // gets the list of cluster in the track
-  void SetChi2(Double_t chi2) { fChi2 = chi2;}   // sets the chisquare value for the track
-  Double_t GetChi2() const { return fChi2;}            // gets the chisquare value for the track
-  Double_t GetZ() const {return fX1;}            // gets the Z value for the track
-  Double_t GetTgl() const {return fX3;}          // gets the tgl value for the track
-  Double_t Getrtrack() const{return frtrack;}    // gets the raius value for the current track
-  Double_t Getphi()  const{return fX0;}          // gets the phi value for the track
-  Double_t GetC() const {return fX4;}            // gets the curvature value for the track
-  Double_t GetD() const{return fX2;}             // gets the radial impact parameter for the track
-  Double_t GetPt() const {return 0.299792458*0.2*fFieldFactor/(fX4*100.);} // gets the transvers momentum 
-  Float_t GetdEdx() const {return fdEdx;}        //gets fdEdx    // oggi
-
-                                                                           // value for the track           
-  void SetVertex(TVector &vert) { for(Int_t i=0;i<3;i++) fVertex(i) = vert(i);} // sets the vertex
-                                                                                // cohordinates
-  void SetErrorVertex(TVector &evert) {for(Int_t i=0;i<3;i++) fErrorVertex(i) = evert(i);} // sets the errors
-                                                                                    //for vertex cohordinates
-
-  void LmTPC(); // trasform state vector and covariance matrix from local TPC to master
-  TVector GetVertex() const { return fVertex;}
-  TVector GetErrorVertex() const { return fErrorVertex;}
-  Long_t  GetLabel() const { return flabel;}
-  void SetLabel(Long_t label) { flabel = label;}
-  Int_t  GetLayer() const { return fLayer;}
-  
-
-  void PutCElements(Double_t C00, Double_t C10, Double_t C11, Double_t C20, Double_t C21, 
-  Double_t C22, Double_t C30, Double_t C31, Double_t C32, Double_t C33, Double_t C40, 
-  Double_t C41, Double_t C42, Double_t C43, Double_t C44);  // put elements of covariance matrix
-  
-  void GetCElements(Double_t &C00, Double_t &C10, Double_t &C11, Double_t &C20, Double_t &C21, 
-  Double_t &C22, Double_t &C30, Double_t &C31, Double_t &C32, Double_t &C33, Double_t &C40, 
-  Double_t &C41, Double_t &C42, Double_t &C43, Double_t &C44) const;  // get elements of covariance matrix
-   
-  void GetXElements(Double_t &X0, Double_t &X1, Double_t &X2, Double_t &X3, Double_t &X4) const; // get elements
-                                                                                           // of state vector
-  void PutXElements(Double_t X0, Double_t X1, Double_t X2, Double_t X3, Double_t X4);  // put elements
-  void PutMass(Double_t mass) {fMass=mass;} // put the particle mass
-  Double_t GetMass() const {return fMass;}  // get the particle mass   // oggi                                                                                      // of state vector
-
-    
-  void SetLayer(Int_t layer) { fLayer = layer;}      // set current layer
-  AliTPCtrack *GetTPCtrack() const { return fTPCtrack;}    // get hte TPC track
-
-  void PutCluster(Int_t layerc, TVector vecclust);   // put information for clusters
-  TVector GetLabTrack(Int_t lay);                    // get the label of the track
-  void Search(TVector VecTotLabref, Long_t &labref, Int_t &freq); // determine the label and the frequency of
-                                                                  // it for the current track
-  Float_t GetZclusterTrack(Int_t lay) {return ((Float_t) (*fClusterInTrack)(lay,2));} // get the Z
-                             //cohordinate of the cluster gelonging to the track for a given layer
-  void GetClusters();     // prints the clusters belonging to the current track
-  Int_t GetLabTPC() const {return (*fTPCtrack).GetLabel();}  // get the TPC label for the current track
-  Int_t GetIdPoint(Int_t lay) {return ((Int_t) (*fClusterInTrack)(lay,4));}  // get the label identifiing the
-                                                                             //point of the track
-  Int_t GetIdModule(Int_t lay) {return ((Int_t) (*fClusterInTrack)(lay,5));} // get the label identifiing the
-                                                                             // module of the track
-  Float_t GetIdParticle(Int_t lay) {return (*fClusterInTrack)(lay,3);}       // get the label to identify
-                                                                             // the particle      
-  Int_t DoNotCross(Double_t rk) const;  // determine if the track cross a layer 
-  Double_t ArgA(Double_t rk) const;     // quantity usefull in propagation
-  Double_t Arga(Double_t rk) const;     // quantity usefull in propagation
-  Double_t ArgB(Double_t rk) const;     // quantity usefull in propagation
-  Double_t ArgC(Double_t rk) const;     // quantity usefull in propagation             
-  void  Propagation(Double_t rk) ;      // propagation of the track to a layer of radius rk
-
-  Double_t GetSigmaphi() const{return fC00;}    // gets the phi variance
-  Double_t GetSigmaZ() const{return  fC11;}     // gets the Z variance
-  void AddEL(Double_t signdE,  Bool_t flagtot, Double_t mass=0.1396);  // adds the energy loss
-  void AddMS(Double_t mass=0.1396);  // modify the covariance matrix to take into account the multiple scattering
-  void Correct(Double_t rk);  // correct the track to take into account the real detector geometry
-  void SetDv(Double_t x) {fDv=x;}  // sets the radial impact parameter for vertex constraint 
-  void SetZv(Double_t x) {fZv=x;}  // sets longitudinal impact parameter for vertex constraint
-  Double_t GetDv() const {return fDv;}   // gets the radial impact parameter for vertex constraint 
-  Double_t GetZv() const {return fZv;}   // gets longitudinal impact parameter for vertex constraint
-  void SetsigmaDv( Double_t x) {fsigmaDv=x;} // sets sigma for Dv extraction
-  void SetsigmaZv( Double_t x) {fsigmaZv=x;} // sets sigma for Zv extraction
-  void Setfnoclust() {fnoclust++;}          //modify fnoclust 
-  Double_t GetsigmaDv() const {return fsigmaDv;}   // gets sigma for Dv extraction
-  Double_t GetsigmaZv() const {return fsigmaZv;}   // gets sigma for Zv extraction
-  void PrimaryTrack();   // calculation of part of covariance matrix for vertex constraint
-  void Setd2(TVector &x) {for(Int_t i=0; i<6; i++){fd2(i)=x(i);}} // sets the vector fd2
-  void Settgl2(TVector &x) {for(Int_t i=0; i<6; i++){ftgl2(i)=x(i);}}  // sets the vector ftgl2
-  void Setdtgl(TVector &x) {for(Int_t i=0; i<6; i++){fdtgl(i)=x(i);}}  // sets the vector fdtgl
-  TVector Getd2() const { return fd2;}  // gets the vector fd2
-  TVector Gettgl2() const { return ftgl2;}  // gets the vector ftgl2
-  TVector Getdtgl() const { return fdtgl;}  // gets the vector dtgl
-  Double_t Getd2(Int_t i){return (Double_t)fd2(i);}     // gets the i element of the vector fd2
-  Double_t Gettgl2(Int_t i){return (Double_t)ftgl2(i);} // gets the i element of the vector tgl2
-  Double_t Getdtgl(Int_t i){return (Double_t)fdtgl(i);} // gets the i element of the vector fdtgl
-  //Double_t GetxoTPC() const {return fxoTPC;}  // gets fxoTPC
-  Int_t  Getfnoclust() const {return fnoclust;}  //gets fnoclust 
-  Double_t GetPredChi2(Double_t m[2], Double_t sigma[2]) const; //get predicted chi2
-  void Setfcor()                  //set correction for layer                // oggi
-   {if(fLayer>=3) fcor[fLayer-3] = 1./TMath::Sqrt(1.+ fX3*fX3);}            // oggi
-  Float_t Getfcor(Int_t i) {return fcor[i];}  //return correction for layer // oggi
-
-                       
-//////////////////////////////////////////////////////////////////////////////////////// 
-
- private:  
-   
-  AliTPCtrack     *fTPCtrack;           // reference to TPC track
-
-  Double_t        fX0,fX1,fX2,fX3,fX4;  // state vector: |phi/z/D/tgl/C 
-  Double_t        frtrack;               // radius of courrent layer     
-  
-  Double_t        fC00, fC10, fC11,     // Covariance Matrix
-                  fC20, fC21, fC22,     //      "       "
-                                               fC30, fC31, fC32,     //      "       " 
-                                               fC33, fC40, fC41,     //      "       " 
-                                               fC42, fC43, fC44;     //      "       "
-      
-  Double_t        fChi2;                // fChi^2 of track         
-  TObjArray       *flistCluster;        // list of clusters of the track
-  Int_t           fNumClustInTrack;     // total number of clusters
-  Long_t          flabel;               // label of the track
-  TVector         fVertex;              // vertex coordinates of the track
-  TVector         fErrorVertex;         // error on the vertex coordinates
-  Int_t           fLayer;               // current Layer of the track
-  TMatrix        *fClusterInTrack;      // matrix of clusters belonging to the  track
-                                        // row index = layer-1; 
-                                        // cols index = master coordinates of the clusters
-
-  Double_t        fFieldFactor;         // magnetic field factor
-  Double_t          fDv;                // radial impact parameter for vertex  constraint
-  Double_t          fZv;                // longitudinal impact parameter for vertex constraint
-  Double_t          fsigmaDv;           // sigma for Dv extraction
-  Double_t          fsigmaZv;           // sigma for Zv extraction
-  TVector           fd2;                // C(2,2)  for primary track
-  TVector           ftgl2;              // C(3,3)  for primary track
-  TVector           fdtgl;              // C(2,3)  for primary track
-
-  Double_t          fMass;         //  tracking particle mass
-  
-  Float_t           fdEdx ;         // energy loss                  // oggi
-  Float_t           fcor[4];          // corrections for dE/dx      // oggi
-  
-  Int_t   fnoclust;  //nm of layers in which tracking doesn't add a cluster to the track
-                  
-  
-
-  ClassDef(AliITSTrackV1, 1)
-   
-};
-
-#endif
-
diff --git a/ITS/AliITSTrackerV1.cxx b/ITS/AliITSTrackerV1.cxx
deleted file mode 100644 (file)
index 0fbd463..0000000
+++ /dev/null
@@ -1,1716 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-/* $Id$ */
-
-// The purpose of this class is to permorm the ITS tracking. The 
-// constructor has the task to inizialize some private members. The method 
-// DoTracking is written to be called by a macro. It gets the event number,
-// the minimum and maximum order number of TPC tracks that are to be tracked
-// trough the ITS, and the file where the recpoints are registered. The 
-// method Recursivetracking is a recursive function that performs the 
-// tracking trough the ITS The method Intersection found the layer, ladder 
-// and detector whre the intersection take place and caluclate the 
-// cohordinates of this intersection. It returns an integer that is 0 if the 
-// intersection has been found successfully. The two mwthods Kalmanfilter 
-// and kalmanfiltervert operate the kalmanfilter without and with the vertex
-// imposition respectively. The authors thank Mariana Bondila to have help 
-// them to resolve some problems.  July-2000
-
-#include <Riostream.h>
-#include <TMath.h>
-#include <TBranch.h>
-#include <TVector.h>
-#include <TFile.h>
-#include <TRandom.h>
-#include <TTree.h>
-
-#include "TParticle.h"
-#include "AliRun.h"
-#include "AliITSDetTypeRec.h"
-#include "AliITSgeomSPD.h"
-#include "AliITSgeomSDD.h"
-#include "AliITSgeomSSD.h"
-#include "AliITSgeom.h"
-#include "AliITSRecPoint.h"
-#include "AliKalmanTrack.h" 
-#include "AliMagF.h"
-#include "AliITSTrackV1.h"
-#include "AliITSIOTrack.h"
-#include "AliITSRad.h"   
-#include "AliTPCtracker.h"
-#include "AliITSTrackerV1.h"
-#include "AliITSPid.h"
-#include "AliMC.h"
-
-ClassImp(AliITSTrackerV1)
- //______________________________________________________________________
-AliITSTrackerV1::AliITSTrackerV1() {
-  //Default constructor
-  //fITS = 0;
-  fresult = 0;
-  fPtref=0.;
-  fChi2max=0.;
-  //fepsphi=0.;
-  //fepsz=0.;
-  frecPoints = 0;
-  fvettid = 0;
-  fflagvert=0;
-  frl = 0;
-  Int_t ia;
-  for(ia=0; ia<6; ia++) {
-  fNlad[ia]=0;
-  fNdet[ia]=0;
-  fAvrad[ia]=0.;
-  fDetx[ia]=0.;
-  fDetz[ia]=0.; 
-  } // end for ia  
-  fzmin = 0;
-  fzmax = 0;
-  fphimin = 0;
-  fphimax = 0;
-  fphidet = 0;
-  fNRecPoints=0;
-  fRecCylR=0;
-  fRecCylPhi=0;
-  fRecCylZ=0;
-  fFieldFactor=0;
-  fDetTypeRec = 0;
-}
-//______________________________________________________________________
-AliITSTrackerV1::AliITSTrackerV1(Int_t evnumber, Bool_t flag) {
-    //Origin   A. Badala' and G.S. Pappalardo:  
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // Class constructor. It does some initializations.
-
-  //PH Initialisation taken from the default constructor
-  //fITS      = IITTSS;
-  fresult = 0;
-  fPtref    = 0.;
-  fChi2max  =0.; 
-  frecPoints = 0;               
-  fvettid = 0;
-  fflagvert = flag;     
-  frl = 0;
-  fzmin = 0;
-  fzmax = 0;
-  fphimin = 0;
-  fphimax = 0;
-  fphidet = 0;
-  
-  Int_t imax = 200,jmax = 450;
-  frl       = new AliITSRad(imax,jmax);
-  
-  //////////  gets information on geometry /////////////////////////////
-  AliRunLoader* rl = AliRunLoader::Open("galice.root");
-  AliITSLoader* loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
-  if (!loader) {
-    Error("AliITSTrackerV1", "ITS loader not found");
-    return;
-  }
-  fDetTypeRec = new AliITSDetTypeRec(loader);
-  AliITSgeom* g1 = loader->GetITSgeom();
-
-  Int_t ll=1, dd=1;
-  TVector det(9);
-  
-  Int_t ia;
-  for(ia=0; ia<6; ia++) {
-    fNlad[ia]=g1->GetNladders(ia+1);
-    fNdet[ia]=g1->GetNdetectors(ia+1);
-    //cout<<fNlad[i]<<" "<<fNdet[i]<<"\n"; 
-  } // end for ia
-  
-    //cout<<" mean radius = ";
-  Int_t ib;
-  for(ib=0; ib<6; ib++) {  
-    g1->GetCenterThetaPhi(ib+1,ll,dd,det);
-    Double_t r1=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
-    g1->GetCenterThetaPhi(ib+1,ll,dd+1,det);
-    Double_t r2=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
-    fAvrad[ib]=(r1+r2)/2.;
-    //cout<<fAvrad[ib]<<" ";
-  } // end for ib
-    //cout<<"\n"; getchar();
-  
-  fDetx[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDx();
-  fDetz[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDz();
-  
-  fDetx[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDx();
-  fDetz[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDz();
-
-    fDetx[2] = ((AliITSgeomSDD*)(g1->GetShape(3, ll, dd)))->GetDx();
-    fDetz[2] = ((AliITSgeomSDD*)(g1->GetShape(3, ll, dd)))->GetDz();
-
-    fDetx[3] = ((AliITSgeomSDD*)(g1->GetShape(4, ll, dd)))->GetDx();
-    fDetz[3] = ((AliITSgeomSDD*)(g1->GetShape(4, ll, dd)))->GetDz();
-
-    fDetx[4] = ((AliITSgeomSSD*)(g1->GetShape(5, ll, dd)))->GetDx();
-    fDetz[4] = ((AliITSgeomSSD*)(g1->GetShape(5, ll, dd)))->GetDz();
-
-    fDetx[5] = ((AliITSgeomSSD*)(g1->GetShape(6, ll, dd)))->GetDx();
-    fDetz[5] = ((AliITSgeomSSD*)(g1->GetShape(6, ll, dd)))->GetDz();
-    //cout<<"    Detx     Detz\n";
-    //for(Int_t la=0; la<6; la++) cout<<"    "<<fDetx[la]<<"     "<<
-    //                                 fDetz[la]<<endl;
-    //getchar();
-        
-    // allocate memory and define matrices fzmin, fzmax, fphimin and fphimax //
-    Double_t epsz=1.2;
-    Double_t epszdrift=0.05;
-
-    fzmin = new Double_t*[6]; fzmax = new Double_t*[6];
-    Int_t im1, im2, im2max;
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       fzmin[im1] = new Double_t[im2max]; fzmax[im1] = new Double_t[im2max];
-    } // end for im1
-
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       for(im2=0; im2<im2max; im2++) {
-           g1->GetCenterThetaPhi(im1+1,1,im2+1,det);
-           if(im2!=0) fzmin[im1][im2]=det(2)-fDetz[im1];
-           else   
-               fzmin[im1][im2]=det(2)-(fDetz[im1])*epsz;
-           if(im2!=(im2max-1)) fzmax[im1][im2]=det(2)+fDetz[im1];
-           else
-               fzmax[im1][im2]=det(2)+fDetz[im1]*epsz;
-           if(im1==2 || im1==3) {
-               fzmin[im1][im2]-=epszdrift;
-               fzmax[im1][im2]+=epszdrift;
-           } // end if im1==2 || im1==3
-       } // end for im2
-    } // end for im1
-
-    fphimin = new Double_t*[6]; fphimax = new Double_t*[6];
-    for(im1=0;im1<6;im1++) {
-       im2max=fNlad[im1];
-       fphimin[im1] = new Double_t[im2max]; 
-       fphimax[im1] = new Double_t[im2max];
-    } // end for im1
-  
-    fphidet = new Double_t*[6];
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       fphidet[im1] = new Double_t[im2max];
-    } // end for im1
-
-       Double_t global[3],local[3];
-    Double_t pigre=TMath::Pi();
-    Double_t xmin,ymin,xmax,ymax;
-
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       for(im2=0; im2<im2max; im2++) {
-           Int_t idet=2;
-           g1->GetCenterThetaPhi(im1+1,im2+1,idet,det);
-           fphidet[im1][im2] = TMath::ATan2(Double_t(det(1)),
-                                            Double_t(det(0))); 
-           if(fphidet[im1][im2]<0.) fphidet[im1][im2]+=2.*pigre;  
-           local[1]=local[2]=0.;  
-           local[0]= -(fDetx[im1]);    
-           if(im1==0) local[0]= (fDetx[im1]); //to take into account 
-                                              // different reference system
-           g1->LtoG(im1+1,im2+1,idet,local,global);
-           xmax=global[0]; ymax=global[1];
-           local[0]= (fDetx[im1]);   
-           if(im1==0) local[0]= -(fDetx[im1]);//take into account different 
-                                              // reference system
-           g1->LtoG(im1+1,im2+1,idet,local,global);
-           xmin=global[0]; ymin=global[1];
-           fphimin[im1][im2]= TMath::ATan2(ymin,xmin);
-           if(fphimin[im1][im2]<0.) fphimin[im1][im2]+=2.*pigre; 
-           fphimax[im1][im2]= TMath::ATan2(ymax,xmax);
-           if(fphimax[im1][im2]<0.) fphimax[im1][im2]+=2.*pigre;
-       } // end for im2
-    } // end for im1
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////// allocate memory and define vector fNRecPoints and matrices fRecCylR, fRecCylPhi, fRecCylZ /////////////
-       gAlice->GetEvent(evnumber);
-  Int_t numOfModules = g1->GetIndexMax();
-  fRecCylR = new Double_t *[numOfModules];
-  fRecCylPhi = new Double_t *[numOfModules]; 
-  fRecCylZ = new Double_t *[numOfModules];
-  AliITSRecPoint *recp;
-  fNRecPoints = new Int_t[numOfModules];
-   
-                for(Int_t module=0; module<numOfModules; module++) {                           
-                 fDetTypeRec->ResetRecPoints();                     
-                 gAlice->TreeR()->GetEvent(module);              
-                 frecPoints=fDetTypeRec->RecPoints();
-                 Int_t nRecPoints=fNRecPoints[module]=frecPoints->GetEntries();
-                 fRecCylR[module] = new Double_t[nRecPoints];
-                 fRecCylPhi[module] = new Double_t[nRecPoints];
-                 fRecCylZ[module] = new  Double_t[nRecPoints];           
-                 Int_t ind;
-                 for(ind=0; ind<fNRecPoints[module]; ind++) {    
-                   recp=(AliITSRecPoint*)frecPoints->UncheckedAt(ind);                                          
-                       // Float_t global[3], local[3];
-                        Double_t global[3], local[3];
-              local[0]=recp->GetX();
-              local[1]=0.;
-              local[2]= recp->GetZ();                                  
-                        g1->LtoG(module,local,global);
-                                                                                        
-                        Double_t r = TMath::Sqrt(global[0]*global[0]+global[1]*global[1]);                     // r hit
-                        Double_t phi = TMath::ATan2(global[1],global[0]); if(phi<0.) phi+=2.*TMath::Pi();      // phi hit                      
-                Double_t z = global[2];                                                                // z hit
-                                                                                                                                                                                                                                    
-                        fRecCylR[module][ind]=r;
-                        fRecCylPhi[module][ind]=phi;
-                        fRecCylZ[module][ind]=z;                        
-                 }             
-               }        
-        //}  
-  //}
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-        
-
-    ////////// gets magnetic field factor //////////////////////////////
-    AliMagF * fieldPointer = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
-    fFieldFactor =  fieldPointer ? fieldPointer->SolenoidField()/10/.2 : 0;
-   // cout<< " field factor = "<<fFieldFactor<<"\n"; getchar();
-    delete rl;
-    
-}
-//______________________________________________________________________
-AliITSTrackerV1::AliITSTrackerV1(const AliITSTrackerV1 &cobj) : TObject(cobj) {
-    // Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // copy constructor
-        
-  //    *fITS = *cobj.fITS;
-    *fresult = *cobj.fresult;
-    fPtref = cobj.fPtref;
-    fChi2max = cobj.fChi2max;    
-    **fvettid = **cobj.fvettid;
-    fflagvert = cobj.fflagvert;
-    Int_t imax=200,jmax=450;
-    frl = new AliITSRad(imax,jmax);     
-    *frl = *cobj.frl;
-    fFieldFactor = cobj.fFieldFactor;
-    Int_t i,im1,im2,im2max;
-    for(i=0; i<6; i++) {
-       fNlad[i] = cobj.fNlad[i];
-       fNdet[i] = cobj.fNdet[i]; 
-       fAvrad[i] = cobj.fAvrad[i];
-       fDetx[i] = cobj.fDetx[i];
-       fDetz[i] = cobj.fDetz[i];
-    } // end or i
-    fzmin = new Double_t*[6]; fzmax = new Double_t*[6];
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       fzmin[im1] = new Double_t[im2max];
-       fzmax[im1] = new Double_t[im2max];
-    } // end for im1
-    fphimin = new Double_t*[6]; fphimax = new Double_t*[6];
-    for(im1=0;im1<6;im1++) {
-       im2max=fNlad[im1];
-       fphimin[im1] = new Double_t[im2max];
-       fphimax[im1] = new Double_t[im2max];
-    } // end for im1
-  
-    fphidet = new Double_t*[6];
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       fphidet[im1] = new Double_t[im2max];
-    } // end for im1
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       for(im2=0; im2<im2max; im2++) {
-           fzmin[im1][im2]=cobj.fzmin[im1][im2];
-           fzmax[im1][im2]=cobj.fzmax[im1][im2];
-       } // end for im2
-    } // end for im1
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       for(im2=0; im2<im2max; im2++) {
-           fphimin[im1][im2]=cobj.fphimin[im1][im2];
-           fphimax[im1][im2]=cobj.fphimax[im1][im2];
-           fphidet[im1][im2]=cobj.fphidet[im1][im2];  
-       } // end for im2
-    } // end for im2
-
-
-    AliRunLoader* rl = AliRunLoader::Open("galice.root");
-    rl->CdGAFile();
-    AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
-
-   Int_t numOfModules = g1->GetIndexMax();
-       /*
-  fRecCylR = new Float_t *[numOfModules];
-  fRecCylPhi = new Float_t *[numOfModules]; 
-  fRecCylZ = new Float_t *[numOfModules];
-  */
-  fRecCylR = new Double_t *[numOfModules];
-  fRecCylPhi = new Double_t *[numOfModules]; 
-  fRecCylZ = new Double_t *[numOfModules];  
-  fNRecPoints = new Int_t[numOfModules];       
-               for(Int_t module=0; module<numOfModules; module++) {            
-                 Int_t nRecPoints=fNRecPoints[module]=cobj.fNRecPoints[module];
-                 /*
-                 fRecCylR[module] = new Float_t[nRecPoints];
-                 fRecCylPhi[module] = new Float_t[nRecPoints];
-                 fRecCylZ[module] = new Float_t[nRecPoints];
-                 */
-                 fRecCylR[module] = new Double_t[nRecPoints];
-                 fRecCylPhi[module] = new Double_t[nRecPoints];
-                 fRecCylZ[module] = new Double_t[nRecPoints];            
-                 Int_t ind;    
-                 for(ind=0; ind<nRecPoints; ind++) {       
-                        fRecCylR[module][ind]=cobj.fRecCylR[module][ind];
-                        fRecCylPhi[module][ind]=cobj.fRecCylPhi[module][ind];
-                        fRecCylZ[module][ind]=cobj.fRecCylZ[module][ind];                       
-                 }             
-               }        
-               delete rl;
-}
-/*
-//______________________________________________________________________
-void AliITSTrackerV1::DelMatrix(Int_t numOfModules) {
-  // cleanup of some data members
-  for(Int_t mod=0; mod<numOfModules; mod++) {
-    delete fRecCylR[mod];
-        delete fRecCylPhi[mod];
-        delete fRecCylZ[mod];
-  }
-    delete fRecCylR;
-        delete fRecCylPhi;
-        delete fRecCylZ;
-}
-*/
-//______________________________________________________________________
-AliITSTrackerV1::~AliITSTrackerV1(){
-    // Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-    // class destructor         
-  delete frl;
-  delete fNRecPoints;
-  for(Int_t i=0; i<6; i++) {
-    delete fzmin[i];
-        delete fzmax[i];
-        delete fphimin[i];
-        delete fphimax[i];
-        delete fphidet[i];
-  }
-
-  delete fzmin;
-  delete fzmax;
-  delete fphimin;
-  delete fphimax;
-  delete fphidet;
-        
-}
-//______________________________________________________________________
-AliITSTrackerV1 &AliITSTrackerV1::operator=(const AliITSTrackerV1 &obj) {
-    // Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it  
-    // assignement operator
-
-  //    *fITS = *obj.fITS;
-    *fresult = *obj.fresult;
-    fPtref = obj.fPtref;
-    fChi2max = obj.fChi2max;      
-    **fvettid = **obj.fvettid;
-    fflagvert = obj.fflagvert;
-    Int_t imax=200,jmax=450;
-    frl = new AliITSRad(imax,jmax);     
-    *frl = *obj.frl;
-    fFieldFactor = obj.fFieldFactor;
-    Int_t i;
-    for(i=0; i<6; i++) {
-       fNlad[i] = obj.fNlad[i];
-       fNdet[i] = obj.fNdet[i]; 
-       fAvrad[i] = obj.fAvrad[i];
-       fDetx[i] = obj.fDetx[i];
-       fDetz[i] = obj.fDetz[i];
-    } // end for i
-    fzmin = new Double_t*[6];
-    fzmax = new Double_t*[6];
-    Int_t im1, im2, im2max;
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       fzmin[im1] = new Double_t[im2max]; fzmax[im1] = new Double_t[im2max];
-    } // end for im1
-    fphimin = new Double_t*[6]; fphimax = new Double_t*[6];
-    for(im1=0;im1<6;im1++) {
-       im2max=fNlad[im1];
-       fphimin[im1] = new Double_t[im2max];
-       fphimax[im1] = new Double_t[im2max];
-    } // end for im1
-
-    fphidet = new Double_t*[6];
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       fphidet[im1] = new Double_t[im2max];
-    } // end for im1
-    for(im1=0; im1<6; im1++) {
-       im2max=fNdet[im1];
-       for(im2=0; im2<im2max; im2++) {
-           fzmin[im1][im2]=obj.fzmin[im1][im2];
-           fzmax[im1][im2]=obj.fzmax[im1][im2];
-       } // end for im2
-    } // end for im1
-    for(im1=0; im1<6; im1++) {
-       im2max=fNlad[im1];
-       for(im2=0; im2<im2max; im2++) {
-           fphimin[im1][im2]=obj.fphimin[im1][im2];
-           fphimax[im1][im2]=obj.fphimax[im1][im2];
-           fphidet[im1][im2]=obj.fphidet[im1][im2];  
-       } // end for im2
-    } // end for im1
-
-    AliRunLoader* rl = AliRunLoader::Open("galice.root");
-    rl->CdGAFile();
-    AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
-    // AliITSgeom *g1 = fITS->GetITSgeom();  
-   Int_t numOfModules = g1->GetIndexMax();
-  fRecCylR = new Double_t *[numOfModules];
-  fRecCylPhi = new Double_t *[numOfModules]; 
-  fRecCylZ = new Double_t *[numOfModules];  
-  fNRecPoints = new Int_t[numOfModules];  
-         for(Int_t module=0; module<numOfModules; module++) {            
-                 Int_t nRecPoints=fNRecPoints[module]=obj.fNRecPoints[module];
-                 fRecCylR[module] = new Double_t[nRecPoints];
-                 fRecCylPhi[module] = new Double_t[nRecPoints];
-                 fRecCylZ[module] = new Double_t[nRecPoints];            
-                 Int_t ind;
-                 for(ind=0; ind<nRecPoints; ind++) {     
-                        fRecCylR[module][ind]=obj.fRecCylR[module][ind];
-                        fRecCylPhi[module][ind]=obj.fRecCylPhi[module][ind];
-                        fRecCylZ[module][ind]=obj.fRecCylZ[module][ind];                        
-                 }             
-               }        
-         
-        
-         delete rl;
-    return *this;
-}
-//______________________________________________________________________
-void AliITSTrackerV1::DoTracking(Int_t evNumber,Int_t minTr,Int_t maxTr,
-                                TFile *file, Bool_t realmass) {
-    // Origin   A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // The method needs the event number, the minimum and maximum order
-    // number of TPC tracks that 
-    // are to be tracked trough the ITS, and the file where the recpoints
-    // are registered.
-    // The method can be called by a macro. It preforms the tracking for
-    // all good TPC tracks
-
-    printf("begin DoTracking - file %p\n",(void*)file);
-
-    gAlice->GetEvent(evNumber);  //modificato per gestire hbt
-    TFile *cf=TFile::Open("AliTPCclusters.root");  
-    AliTPCParam *digp= (AliTPCParam*)cf->Get("75x40_100x60_150x60");
-    if (!digp) { cerr<<"TPC parameters have not been found !\n"; getchar();}
-
-    cf->cd();
-    AliRunLoader* rl = AliRunLoader::Open("galice.root");
-    AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
-    TString foldname(itsl->GetEventFolder()->GetName());
-    //TString foldname(fITS->GetLoader()->GetEventFolder()->GetName());
-    delete rl;   
-    printf("This method is not converted to the NewIO !\n");  //I.B.
-    return; //I.B.
-    AliTPCtracker *tracker = new AliTPCtracker(digp);            //I.B.
-    //PH    tracker->SetEventNumber(evNumber);                           //I.B.
-
-    // Load clusters
-    printf("This method is not converted to the NewIO !\n");  //I.B.
-    return; //I.B.
-    tracker->LoadClusters(0);       //I.B.
-
-    // Load tracks
-    TFile *tf=TFile::Open("AliTPCtracksSorted.root");  
-    if (!tf->IsOpen()) {
-       cerr<<"Can't open AliTPCtracksSorted.root !\n";
-       return ;
-    } // end if
-    TObjArray tracks(200000);
-    char tname[100];                 
-    sprintf(tname,"TreeT_TPC_%d",evNumber);
-
-    TTree *tracktree=(TTree*)tf->Get(tname);   
-    if (!tracktree) {cerr<<"Can't get a tree with TPC tracks !\n";}   
-    TBranch *tbranch=tracktree->GetBranch("tracks");
-    Int_t nentr=(Int_t)tracktree->GetEntries();
-    Int_t kk;
-
-    AliITSRecPoint *recp;    // oggi
-       AliTPCtrack *ioTrackTPC=0;    
-    for (kk=0; kk<nentr; kk++) {
-       ioTrackTPC=new AliTPCtrack; 
-       tbranch->SetAddress(&ioTrackTPC);
-       tracktree->GetEvent(kk);    
-       tracker->CookLabel(ioTrackTPC,0.1);       
-       tracks.AddLast(ioTrackTPC);         
-    } // end for kk
-    delete tracker;      
-    tf->Close();
-
-    Int_t nt = tracks.GetEntriesFast();
-    cerr<<"Number of found tracks "<<nt<<endl;
-
-    TVector vec(5);
-    TTree *tr=gAlice->TreeR();
-    Int_t nent=(Int_t)tr->GetEntries();  
-    frecPoints = fDetTypeRec->RecPoints();
-
-    Int_t numbpoints;
-    Int_t totalpoints=0;
-    Int_t *np = new Int_t[nent];
-    fvettid = new Int_t* [nent];
-    Int_t mod;
-
-    for (mod=0; mod<nent; mod++) {
-       fvettid[mod]=0;
-       fDetTypeRec->ResetRecPoints();  
-       gAlice->TreeR()->GetEvent(mod); 
-       numbpoints = frecPoints->GetEntries();
-       totalpoints+=numbpoints;
-       np[mod] = numbpoints;
-       //cout<<" mod = "<<mod<<"   numbpoints = "<<numbpoints<<"\n";getchar();
-       fvettid[mod] = new Int_t[numbpoints];
-       Int_t ii;
-       for (ii=0;ii<numbpoints; ii++) *(fvettid[mod]+ii)=0;
-    } // end for mod
-
-    AliTPCtrack *track=0;
-
-    if(minTr < 0) {minTr = 0; maxTr = nt-1;}   
-
-    TVector vgeant(3);
-
-    TTree tracktree1("TreeT","Tree with ITS tracks");
-    AliITSIOTrack *ioTrack=0;
-       AliITSPid *pid=new AliITSPid(1000);  // oggi
-
-    tracktree1.Branch("ITStracks","AliITSIOTrack",&ioTrack,32000,0);
-  
-    TDatabasePDG * db = new TDatabasePDG;   
-  
-    Int_t j;       
-    for (j=minTr; j<=maxTr; j++) {     
-       track=(AliTPCtrack*)tracks.UncheckedAt(j);
-       if (!track) continue;
-       
-       ///   mass definition ////////////////////////
-    Double_t mass=0.13956995;
-        Int_t pcode=211;  // a pion by default
-        
-        if(realmass) {
-       if(TMath::Abs(pcode)<20443) mass=db->GetParticle(pcode)->Mass();
-        }
-        else {
-                mass = track->GetMass();
-//              cout << "Mass = " << mass << endl;
-        }
-        
-       
-       
-        //   new propagation to the end of TPC
-    Double_t xk=80.;
-   // track->PropagateTo(xk,0.,0.); //Ne if it's still there   //attenzione funziona solo se modifica in TPC
-       // Double_t xk=77.415;   
-        track->PropagateTo(xk, 28.94, 1.204e-3);
-    xk-=0.005;
-    track->PropagateTo(xk, 44.77,1.71); //Tedlar        
-    xk-=0.02;
-    track->PropagateTo(xk, 44.86, 1.45);   //Kevlar
-    xk-=2.0;
-    track->PropagateTo(xk, 41.28, 0.029);//Nomex
-    xk-=0.02;
-    track->PropagateTo(xk, 44.86, 1.45);   //Kevlar
-    xk-=0.005;
-    track->PropagateTo(xk, 44.77, 1.71); //Tedlar
-
-    xk=61.;
-   // track->PropagateTo(xk,0.,0.); //C02
-        track->PropagateTo(xk,36.2,1.98e-3); //C02        //attenzione funziona solo se modifica in TPC
-
-    xk -=0.005;
-    track->PropagateTo(xk, 24.01, 2.7);    //Al    
-    xk -=0.005;
-    track->PropagateTo(xk, 44.77, 1.71);  //Tedlar
-    xk -=0.02;
-    track->PropagateTo(xk, 44.86, 1.45);    //Kevlar
-    xk -=0.5;
-    track->PropagateTo(xk, 41.28, 0.029);  //Nomex    
-    xk -=0.02;
-    track->PropagateTo(xk, 44.86, 1.45);    //Kevlar
-    xk -=0.005;
-    track->PropagateTo(xk, 44.77, 1.71);  //Tedlar
-    xk -=0.005;
-    track->PropagateTo(xk, 24.01, 2.7);    //Al 
-    
-       ////////////////////////////////////////////////////////////////////////////////////////////////////////        
-       //AliITSTrackV1 trackITS(*track);
-       AliITSTrackV1 trackITS(*track, fFieldFactor);
-       //cout<<" fFieldFactor = "<<fFieldFactor<<"\n";      
-       trackITS.PutMass(mass);   //new to add mass to track
-       if(fresult){ delete fresult; fresult=0;}         
-       fresult = new AliITSTrackV1(trackITS);   
-
-       AliITSTrackV1 primaryTrack(trackITS);
-       vgeant=(*fresult).GetVertex();
-
-       // Definition of dv and zv for vertex constraint        
-       Double_t sigmaDv=0.0050;  Double_t sigmaZv=0.010;       
-       //Double_t sigmaDv=0.0015;  Double_t sigmaZv=0.0015;
-       Double_t uniform= gRandom->Uniform();
-       Double_t signdv;
-       if(uniform<=0.5) signdv=-1.;
-       else
-           signdv=1.;
-
-       Double_t vr=TMath::Sqrt(vgeant(0)*vgeant(0)+ vgeant(1)*vgeant(1));
-       Double_t dv=gRandom->Gaus(signdv*vr,(Float_t)sigmaDv); 
-       Double_t zv=gRandom->Gaus(vgeant(2),(Float_t)sigmaZv);          
-       //cout<<" Dv e Zv = "<<dv<<" "<<zv<<"\n";
-       trackITS.SetDv(dv);
-       trackITS.SetZv(zv);
-       trackITS.SetsigmaDv(sigmaDv);
-       trackITS.SetsigmaZv(sigmaZv); 
-       (*fresult).SetDv(dv);
-       (*fresult).SetZv(zv);
-       (*fresult).SetsigmaDv(sigmaDv);
-       (*fresult).SetsigmaZv(sigmaZv);
-       primaryTrack.SetDv(dv);
-       primaryTrack.SetZv(zv);
-       primaryTrack.SetsigmaDv(sigmaDv);
-       primaryTrack.SetsigmaZv(sigmaZv);
-       primaryTrack.PrimaryTrack();
-       TVector  d2=primaryTrack.Getd2();
-       TVector  tgl2=primaryTrack.Gettgl2();
-       TVector  dtgl=primaryTrack.Getdtgl();
-       trackITS.Setd2(d2); trackITS.Settgl2(tgl2);
-       trackITS.Setdtgl(dtgl); 
-       (*fresult).Setd2(d2); (*fresult).Settgl2(tgl2);
-       (*fresult).Setdtgl(dtgl);
-       /*
-         trackITS.SetVertex(vertex); trackITS.SetErrorVertex(ervertex);
-         (*result).SetVertex(vertex);   (*result).SetErrorVertex(ervertex);   
-       */
-       TList *list= new TList();
-
-       list->AddLast(&trackITS);
-  
-       fPtref=TMath::Abs( (trackITS).GetPt() );
-       //cout<<" fPtref = " <<fPtref<<"\n";
-       if(fPtref>1.0) fChi2max=40.;         
-       if(fPtref<=1.0) fChi2max=20.;
-       if(fPtref<0.4 ) fChi2max=100.;
-       if(fPtref<0.2 ) fChi2max=40.;             
-       // if(fPtref<0.4 ) fChi2max=30.;                                 
-       // if(fPtref<0.2 ) fChi2max=20.;
-       //if(fPtref<0.2 ) fChi2max=10.;
-       //if(fPtref<0.1 ) fChi2max=5.;
-       //cout << "\n Pt = " << fPtref <<"\n";  //stampa
-       RecursiveTracking(list);   
-       list->Delete();
-       delete list;
-
-       Int_t itot=-1;
-       TVector vecTotLabRef(18);
-       Int_t lay, k;
-       for(lay=5; lay>=0; lay--) {
-           TVector vecLabRef(3); 
-           vecLabRef=(*fresult).GetLabTrack(lay);
-           Float_t clustZ=(*fresult).GetZclusterTrack( lay);   
-           for(k=0; k<3; k++){  
-               Int_t lpp=(Int_t)vecLabRef(k);
-               if(lpp>=0) {
-                   TParticle *p=(TParticle*) gAlice->GetMCApp()->Particle(lpp);
-                   Int_t pcode=p->GetPdgCode();
-                   if(pcode==11) vecLabRef(k)=p->GetFirstMother();
-               } // end if
-               itot++; vecTotLabRef(itot)=vecLabRef(k);
-               if(vecLabRef(k)==0. && clustZ == -1.) vecTotLabRef(itot) =-3.;
-           } // end for k
-       } // end for lay
-       Long_t labref;
-       Int_t freq;  
-       (*fresult).Search(vecTotLabRef, labref, freq);
-
-       //if(freq < 6) labref=-labref;        // cinque - sei
-       if(freq < 5) labref=-labref;        // cinque - sei     
-       (*fresult).SetLabel(labref);
-
-       // cout<<" progressive track number = "<<j<<"\r";
-       // cout<<j<<"\r";
-       Int_t numOfCluster=(*fresult).GetNumClust();  
-       //cout<<" progressive track number = "<<j<<"\n";    // stampa
-       Long_t labITS=(*fresult).GetLabel();
-       //cout << " ITS track label = " << labITS << "\n";      // stampa           
-       Int_t lab=track->GetLabel();                
-       //cout << " TPC track label = " << lab <<"\n";      // stampa
-       //propagation to vertex
-
-       Double_t rbeam=3.;
-       if((*fresult).DoNotCross(rbeam)) continue;  //no intersection with beampipe     
-       (*fresult).Propagation(rbeam);
-       Double_t c00,c10,c11,c20,c21,c22,c30,c31,c32,c33,c40,c41,c42,c43,c44;
-       (*fresult).GetCElements(c00,
-                               c10,c11,
-                               c20,c21,c22,
-                               c30,c31,c32,c33,
-                               c40,c41,c42,c43,c44);
-                
-       Double_t pt=TMath::Abs((*fresult).GetPt());
-       Double_t dr=(*fresult).GetD();
-       Double_t z=(*fresult).GetZ();
-       Double_t tgl=(*fresult).GetTgl();
-       Double_t c=(*fresult).GetC();
-       Double_t cy=c/2.;
-       Double_t dz=z-(tgl/cy)*TMath::ASin((*fresult).Arga(rbeam));
-       dz-=vgeant(2);
-       // cout<<" dr e dz alla fine = "<<dr<<" "<<dz<<"\n"; getchar();
-       Double_t phi=(*fresult).Getphi();
-       Double_t phivertex = phi - TMath::ASin((*fresult).ArgA(rbeam));
-       Double_t duepi=2.*TMath::Pi();   
-       if(phivertex>duepi) phivertex-=duepi;
-       if(phivertex<0.) phivertex+=duepi;
-       /////////////////////////////////////////////////////////////
-       Int_t idmodule,idpoint;
-       if(numOfCluster >=5)  {            // cinque - sei
-           //if(numOfCluster ==6)  {            // cinque - sei
-           AliITSIOTrack outTrack;
-           ioTrack=&outTrack;
-           ioTrack->SetStatePhi(phi);
-           ioTrack->SetStateZ(z);
-           ioTrack->SetStateD(dr);
-           ioTrack->SetStateTgl(tgl);
-           ioTrack->SetStateC(c);
-           Double_t radius=(*fresult).Getrtrack();
-           ioTrack->SetRadius(radius);
-           Int_t charge;
-           if(c>0.) charge=-1;  else charge=1;
-           ioTrack->SetCharge(charge);
-               Double_t trackmass=(*fresult).GetMass();         // oggi
-               ioTrack->SetMass(trackmass);                     // oggi
-           ioTrack->SetCovMatrix(c00,
-                                 c10,c11,
-                                 c20,c21,c22,
-                                 c30,c31,c32,c33,
-                                 c40,c41,c42,c43,c44);
-           Double_t px=pt*TMath::Cos(phivertex);
-           Double_t py=pt*TMath::Sin(phivertex);
-           Double_t pz=pt*tgl;
-           Double_t xtrack=dr*TMath::Sin(phivertex);
-           Double_t ytrack=dr*TMath::Cos(phivertex);
-           Double_t ztrack=dz+vgeant(2);
-           ioTrack->SetPx(px);
-           ioTrack->SetPy(py);
-           ioTrack->SetPz(pz);
-           ioTrack->SetX(xtrack);
-           ioTrack->SetY(ytrack);
-           ioTrack->SetZ(ztrack);
-           ioTrack->SetLabel(labITS);
-           ioTrack->SetTPCLabel(lab);
-                ioTrack->SetDz(dz);
-           Int_t il;           
-           /*
-               for(il=0;il<6; il++){
-               ioTrack->SetIdPoint(il,(*fresult).GetIdPoint(il));
-               ioTrack->SetIdModule(il,(*fresult).GetIdModule(il));
-           } // end for il
-           */
-           //tracktree1.Fill();
-               Float_t q[4]={-1.,-1.,-1.,-1.};
-           Float_t  globaldedx=0.;        
-           for (il=0;il<6;il++) {
-               idpoint=(*fresult).GetIdPoint(il);
-               idmodule=(*fresult).GetIdModule(il);
-               if(idmodule>0.) *(fvettid[idmodule]+idpoint)=1;
-                                                              
-               ioTrack->SetIdPoint(il,idpoint);
-               ioTrack->SetIdModule(il,idmodule);
-               ////  for q definition
-               if(il>1){
-                 if(idmodule>0.){                      
-                   fDetTypeRec->ResetRecPoints();
-                   gAlice->TreeR()->GetEvent(idmodule);
-                   recp=(AliITSRecPoint*)frecPoints->UncheckedAt(idpoint);
-                   q[il-2]=recp->GetQ()*(*fresult).Getfcor(il-2);
-                 }
-               }                               
-           } // end for il      
-               q[0]/=280.; q[1]/=280.;
-           q[2]/=38.; q[3]/=38.;
-
- // cout<<" q prima = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar(); 
-     
-     Int_t swap;
-  do{
-    swap=0;   
-    for (il=0; il<3; il++) {
-      if (q[il]<=q[il+1]) continue;
-      Float_t tmp=q[il];
-      q[il]=q[il+1]; q[il+1]=tmp;
-      swap++;
-    }
-  } while(swap); 
-
-  // cout<<" q dopo = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar();
-      
-    if(q[0]<0.) {
-      q[0]=q[1];
-      q[1]=q[2];
-      q[2]=q[3];
-      q[3]=-1.;            
-    } 
-  // cout<<" q  dopo if = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar(); 
-     
-    globaldedx=(q[0]+q[1])/2.;
-    
-   // if(q[3]> 0.) globaldedx=(q[0]+q[1]+q[2]+q[3])/4.;
-   //      else    globaldedx=(q[0]+q[1]+q[2])/3.; 
-   
-    ioTrack->SetdEdx(globaldedx);
-    ioTrack->SetPid(pid->GetPcode(ioTrack));
-           
-           tracktree1.Fill();         
-       } // end if on numOfCluster
-       //gObjectTable->Print();    // stampa memoria     
-    }  //  end for (int j=minTr; j<=maxTr; j++)
-    delete db;          
-    static Bool_t first=kTRUE;
-    static TFile *tfile;
-    if(first) {
-       tfile=new TFile("itstracks.root","RECREATE");
-       //cout<<"I have opened itstracks.root file "<<endl;
-    } // end if            
-    first=kFALSE;
-    tfile->cd();
-    tfile->ls();
-    char hname[30];
-    sprintf(hname,"TreeT%d",evNumber);
-       cout << "Number of saved ITS tracks " << tracktree1.GetEntries() << endl;
-    tracktree1.Write(hname);
-  
-    TTree *fAli=gAlice->TreeK();
-    TFile *fileAli=0;
-    if (fAli) fileAli =fAli->GetCurrentFile();
-    fileAli->cd();
-    ////////////////////////////////////////////////////////////////////
-
-    printf("delete vectors\n");
-    if(np) delete [] np;
-    if(fvettid) delete [] fvettid;
-    if(fresult) {delete fresult; fresult=0;}
-}
-//______________________________________________________________________
-void AliITSTrackerV1::RecursiveTracking(TList *trackITSlist) {
-    //   This function perform the recursive tracking in ITS detectors
-    // reference is a pointer to the final best track
-    // Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // The authors thank Mariana Bondila to have help them to resolve some
-    // problems.  July-2000
-
-    //Rlayer[0]=4.; Rlayer[1]=7.;  Rlayer[2]=14.9;
-    // Rlayer[3]=23.8;  Rlayer[4]=39.1;  Rlayer[5]=43.6; //vecchio
-
-    ////////////////////// 
-    Float_t sigmaphil[6], sigmazl[6];
-    sigmaphil[0]=1.44e-6/(fAvrad[0]*fAvrad[0]);
-    sigmaphil[1]=1.44e-6/(fAvrad[1]*fAvrad[1]);
-    sigmaphil[2]=1.444e-5/(fAvrad[2]*fAvrad[2]);
-    sigmaphil[3]=1.444e-5/(fAvrad[3]*fAvrad[3]);
-    sigmaphil[4]=4e-6/(fAvrad[4]*fAvrad[4]);
-    sigmaphil[5]=4e-6/(fAvrad[5]*fAvrad[5]);
-    sigmazl[0]=1e-2;
-    sigmazl[1]=1e-2;
-    sigmazl[2]=7.84e-4;
-    sigmazl[3]=7.84e-4;
-    sigmazl[4]=0.6889;
-    sigmazl[5]=0.6889; 
-    ///////////////////////////////////////////////////////////
-    Int_t index; 
-    AliRunLoader* rl = AliRunLoader::Open("galice.root");
-    rl->CdGAFile();
-    AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
-
-    AliITSRecPoint *recp;        
-    for(index =0; index<trackITSlist->GetSize(); index++) {
-       AliITSTrackV1 *trackITS = (AliITSTrackV1 *) trackITSlist->At(index);
-       if((*trackITS).GetLayer()==7) fresult->SetChi2(10.223e140);
-       // cout <<" Layer inizio = "<<(*trackITS).GetLayer()<<"\n";
-       //  cout<<"fvtrack =" <<"\n";
-       //  cout << (*trackITS)(0) << " "<<(*trackITS)(1)<<" "
-       //       <<(*trackITS)(2)<<" "<<(*trackITS)(3)<<" "
-       //       <<(*trackITS)(4)<<"\n";
-       //  cout<< " rtrack = "<<(*trackITS).Getrtrack()<<"\n";
-       //  cout<< " Pt = "<<(*trackITS).GetPt()<<"\n";
-       //  getchar();    
-       Double_t chi2Now, chi2Ref;
-       Float_t numClustRef = fresult->GetNumClust();            
-       if((*trackITS).GetLayer()==1 ) {
-           chi2Now = trackITS->GetChi2();
-           Float_t numClustNow = trackITS->GetNumClust();
-           if(trackITS->GetNumClust()) 
-               chi2Now /= (Double_t)trackITS->GetNumClust();
-           chi2Ref = fresult->GetChi2();
-           if(fresult->GetNumClust()) 
-               chi2Ref /= (Double_t)fresult->GetNumClust();
-           //cout<<" chi2Now and chi2Ref = "<<chi2Now<<" "<<chi2Ref<<"\n";
-           if( numClustNow > numClustRef ) {*fresult = *trackITS;} 
-           if((numClustNow == numClustRef )&& 
-              (chi2Now < chi2Ref))  {
-               *fresult = *trackITS;
-           } // end if
-           continue;   
-       } // end if
-
-       if(trackITS->Getfnoclust()>=2)  continue;      
-       Float_t numClustNow = trackITS->GetNumClust();
-       if(numClustNow) { 
-           chi2Now = trackITS->GetChi2();
-
-           if(numClustNow<numClustRef && chi2Now>fresult->GetChi2()) continue;
-           //cout<<" chi2Now =  "<<chi2Now<<"\n";   
-             
-           chi2Now/=numClustNow;
-           if(fPtref > 1.0 && chi2Now > 30.) continue; 
-           if((fPtref >= 0.6 && fPtref<=1.0) && chi2Now > 40.) continue;
-           // if((fPtref <= 0.6 && fPtref>0.2)&& chi2Now > 40.) continue;
-           // if(fPtref <= 0.2 && chi2Now > 8.) continue;
-           if((fPtref <= 0.6 && fPtref>0.2)&& chi2Now > 30.) continue;
-           if(fPtref <= 0.2 && chi2Now > 7.) continue;     
-           /////////////////////////////
-       } // end if
-
-       Int_t layerInit = (*trackITS).GetLayer();
-       Int_t layernew = layerInit - 2;// -1 for new layer, -1 for matrix index
-       TList listoftrack;
-       Int_t ladp, ladm, detp,detm,ladinters,detinters;        
-       Int_t layerfin=layerInit-1;
-       // cout<<"Prima di intersection \n";
-       Int_t  outinters=Intersection(*trackITS,layerfin,ladinters,detinters);
-       // cout<<" outinters = "<<outinters<<"\n";
-       //  cout<<" Layer ladder detector intersection ="
-       //      <<layerfin<<" "<<ladinters<<" "<<detinters<<"\n";
-       //  cout << " phiinters zinters = "<<(*trackITS)(0) 
-       //       << " "<<(*trackITS)(1)<<"\n"; getchar();
-       if(outinters==-1) continue;
-       Int_t flaghit=0;
-       (*trackITS).SetLayer(layerfin);  // oggi
-       (*trackITS).Setfcor();           // oggi
-       if(outinters==0){
-           TVector toucLad(9), toucDet(9);      
-           Int_t lycur=layerfin;
-           ladp=ladinters+1;
-           ladm=ladinters-1;
-           if(ladm <= 0) ladm=fNlad[layerfin-1];    
-           if(ladp > fNlad[layerfin-1]) ladp=1;  
-           detp=detinters+1;
-           detm=detinters-1;
-           Int_t idetot=1;
-           /*
-             toucLad(0)=ladinters; toucLad(1)=ladm; toucLad(2)=ladp;
-             toucLad(3)=ladinters; toucLad(4)=ladm; toucLad(5)=ladp;
-             toucLad(6)=ladinters; toucLad(7)=ladm; toucLad(8)=ladp;
-             toucDet(0)=detinters; toucDet(1)=detinters; toucDet(2)=detinters;
-             if(detm > 0 && detp <= fNdet[layerfin-1]) {     
-                  idetot=9;
-                  toucDet(3)=detm; toucDet(4)=detm; toucDet(5)=detm;      
-                  toucDet(6)=detp; toucDet(7)=detp; toucDet(8)=detp;
-             } // end if
-             if(detm > 0 && detp > fNdet[layerfin-1]) {   
-                  idetot=6;
-                  toucDet(3)=detm; toucDet(4)=detm; toucDet(5)=detm;
-            } // end if
-            if(detm <= 0 && detp <= fNdet[layerfin-1]) {   
-                 idetot=6;
-                 toucDet(3)=detp; toucDet(4)=detp; toucDet(5)=detp;
-            } // end if
-           */
-           Float_t epsphi=5.0, epsz=5.0;                  
-           if(fPtref<0.2) {epsphi=3.; epsz=3.;}     
-           // new definition of idetot e toucLad e toucDet to be
-           // transformed in a method
-           // these values could be modified
-           Float_t pigre=TMath::Pi();
-           Float_t rangephi=5., rangez=5.;
-           if(layerfin==1 || layerfin ==2){
-               rangephi=40.*epsphi*TMath::Sqrt(sigmaphil[layerfin-1]+
-                                               (*trackITS).GetSigmaphi());
-               rangez = 40.*epsz*TMath::Sqrt(sigmazl[layerfin-1]+
-                                             (*trackITS).GetSigmaZ());
-           } // end if
-           if(layerfin==3 || layerfin ==4){
-               //rangephi=30.*fepsphi*TMath::Sqrt(sigmaphil[layerfin-1]+
-               //                                 (*trackITS).GetSigmaphi());
-               //rangez = 40.*fepsz*TMath::Sqrt(sigmazl[layerfin-1]+
-               //                               (*trackITS).GetSigmaZ());
-               rangephi=40.*epsphi*TMath::Sqrt(sigmaphil[layerfin-1]+
-                                               (*trackITS).GetSigmaphi());
-               rangez = 50.*epsz*TMath::Sqrt(sigmazl[layerfin-1]+
-                                             (*trackITS).GetSigmaZ());
-           } // end if
-           if(layerfin==5 || layerfin ==6){
-               rangephi=20.*epsphi*TMath::Sqrt(sigmaphil[layerfin-1]+
-                                               (*trackITS).GetSigmaphi());
-               rangez =5.*epsz*TMath::Sqrt(sigmazl[layerfin-1]+
-                                           (*trackITS).GetSigmaZ());
-           } // end if
-           Float_t phinters, zinters;
-           phinters=(*trackITS).Getphi();
-           zinters=(*trackITS).GetZ();
-           Float_t distz = 0.0;
-           Float_t phicm, phicp, distphim, distphip;
-           phicm=phinters;
-                if(phinters>fphimax[layerfin-1][ladm-1]) phicm=phinters-2*pigre;  //corretto il 20-11-2001
-                distphim=TMath::Abs(phicm-fphimax[layerfin-1][ladm-1]);  //corretto il 20-11-2001
-           phicp=phinters;
-                //cout<<" fNlad[layerfin-1] e ladp = "<<fNlad[layerfin-1]<<" "<<ladp<<endl;
-                if(phinters>fphimin[layerfin-1][ladp-1]) phicp=phinters-2.*pigre;   //corretto il 20-11-2001
-                distphip=TMath::Abs(phicp-fphimin[layerfin-1][ladp-1]);      //corretto il 20-11-2001
-           Int_t flagzmin=0;
-           Int_t flagzmax=0;
-           idetot=1;
-           toucLad(0)=ladinters; toucDet(0)=detinters;
-           if(detm>0) distz=TMath::Abs(zinters-fzmax[layerfin-1][detm-1]);
-           if(detm>0 && rangez>=distz){
-               flagzmin=1; 
-               idetot++; toucLad(idetot-1)=ladinters; toucDet(idetot-1)=detm;
-               if(rangephi>=distphim){
-                   idetot++; 
-                   toucLad(idetot-1)=ladm;
-                   toucDet(idetot-1)=detinters;
-                   idetot++;
-                   toucLad(idetot-1)=ladm;
-                   toucDet(idetot-1)=detm;
-               } // end if
-               if(rangephi>=distphip){
-                   idetot++;
-                   toucLad(idetot-1)=ladp;
-                   toucDet(idetot-1)=detinters;
-                   idetot++;
-                   toucLad(idetot-1)=ladp;
-                   toucDet(idetot-1)=detm;
-               } // end if
-           }  //end detm>0....          
-           if(detp<=fNdet[layerfin-1]) 
-               distz=TMath::Abs(zinters-fzmin[layerfin-1][detp-1]);
-           if(detp<=fNdet[layerfin-1] && rangez>=distz){
-               flagzmax=1;
-               idetot++; toucLad(idetot-1)=ladinters; toucDet(idetot-1)=detp;
-               if(rangephi>=distphim){
-                   idetot++; toucLad(idetot-1)=ladm; toucDet(idetot-1)=detp;
-                   if(flagzmin == 0) {
-                       idetot++;
-                       toucLad(idetot-1)=ladm;
-                       toucDet(idetot-1)=detinters;
-                   } // end if
-               } // end if
-               if(rangephi>=distphip){
-                   idetot++;
-                   toucLad(idetot-1)=ladp;
-                   toucDet(idetot-1)=detp;
-                   if(flagzmin == 0) {
-                       idetot++;
-                       toucLad(idetot-1)=ladp; 
-                       toucDet(idetot-1)=detinters;
-                   } // end if
-               } // end if
-           }  //end detm<fNdet[.......
-
-           if(flagzmin == 0 && flagzmax==0){
-               if(rangephi>=distphim){
-                   idetot++; 
-                   toucLad(idetot-1)=ladm;
-                   toucDet(idetot-1)=detinters;
-               } // end if     
-               if(rangephi>=distphip){
-                   idetot++; 
-                   toucLad(idetot-1)=ladp;
-                   toucDet(idetot-1)=detinters;
-               } // end if       
-           } // end if
-           ////////////////////////////////////////////////////////////
-           Int_t iriv;
-           for (iriv=0; iriv<idetot; iriv++) {  //for on detectors
-               ///////////////////////////////////////////////////////
-               /*** Rec points sorted by module *****/
-               /**************************************/
-               Int_t indexmod;       
-               indexmod = g1->GetModuleIndex(lycur,(Int_t)toucLad(iriv),
-                                             (Int_t)toucDet(iriv)); 
-               fDetTypeRec->ResetRecPoints();   
-               gAlice->TreeR()->GetEvent(indexmod); 
-               Int_t npoints=frecPoints->GetEntries();
-       
-               Int_t indnew;
-               for(indnew=0; indnew<npoints; indnew++){
-                   if (*(fvettid[indexmod]+indnew)==0)
-                       recp =(AliITSRecPoint*)frecPoints->UncheckedAt(indnew);
-                   else
-                       continue;
-                   TVector cluster(3),vecclust(9);
-                   //vecclust(6)=vecclust(7)=vecclust(8)=-1.;
-                   Double_t sigma[2];
-  // now vecclust is with cylindrical cohordinates
-              vecclust(0)=(Float_t)fRecCylR[indexmod][indnew];     
-              vecclust(1)=(Float_t)fRecCylPhi[indexmod][indnew];
-              vecclust(2)=(Float_t)fRecCylZ[indexmod][indnew];                          
-                   vecclust(3) = (Float_t)recp->fTracks[0]; 
-                   vecclust(4) = (Float_t)indnew;                       
-                   vecclust(5) = (Float_t)indexmod;    
-                   vecclust(6) = (Float_t)recp->fTracks[0];
-                   vecclust(7) = (Float_t)recp->fTracks[1];
-                   vecclust(8) = (Float_t)recp->fTracks[2];
-                   sigma[0] = (Double_t)  recp->GetSigmaX2();     
-                   sigma[1] = (Double_t) recp->GetSigmaZ2();
-                        
-                        cluster(0)=fRecCylR[indexmod][indnew];
-          cluster(1)=fRecCylPhi[indexmod][indnew];
-                        cluster(2)=fRecCylZ[indexmod][indnew];
-                        
-                   // cout<<" layer = "<<play<<"\n";
-                   // cout<<" cluster prima = "<<vecclust(0)<<" "
-                   //     <<vecclust(1)<<" "
-                   //     <<vecclust(2)<<"\n"; getchar();    
-
-                   Float_t sigmatotphi, sigmatotz;  
-                   // Float_t epsphi=5.0, epsz=5.0;                 
-                   //if(fPtref<0.2) {epsphi=3.; epsz=3.;}
-                   Double_t rTrack=(*trackITS).Getrtrack();
-                   Double_t sigmaphi=sigma[0]/(rTrack*rTrack);
-                   sigmatotphi=epsphi*TMath::Sqrt(sigmaphi + 
-                                                  (*trackITS).GetSigmaphi());
-                   sigmatotz=epsz*TMath::Sqrt(sigma[1] + 
-                                              (*trackITS).GetSigmaZ());
-                   //cout<<"cluster e sigmatotphi e track = "<<cluster(0)
-                   //    <<" "<<cluster(1)<<" "<<sigmatotphi<<" "
-                   //    <<vecclust(3)<<"\n";
-                   //if(vecclust(3)==481) getchar();
-                   if(cluster(1)<6. && (*trackITS).Getphi()>6.) 
-                       cluster(1)=cluster(1)+(2.*TMath::Pi());
-                   if(cluster(1)>6. && (*trackITS).Getphi()<6.) 
-                       cluster(1)=cluster(1)-(2.*TMath::Pi());
-                   if(TMath::Abs(cluster(1)-(*trackITS).Getphi())>sigmatotphi)
-                       continue;
-                   // cout<<" supero sigmaphi \n";      
-                   AliITSTrackV1 *newTrack = new AliITSTrackV1((*trackITS));
-                   //(*newTrack).SetLayer((*trackITS).GetLayer()-1);
-                   if (TMath::Abs(rTrack-cluster(0))/rTrack>1e-6) 
-                       (*newTrack).Correct(Double_t(cluster(0)));      
-                   //cout<<" cluster(2) e(*newTrack).GetZ()="<<cluster(2)<<" "
-                   //    << (*newTrack).GetZ()<<"\n";
-                   if(TMath::Abs(cluster(2)-(*newTrack).GetZ()) > sigmatotz){ 
-                       delete newTrack;
-                       continue;
-                   } // end if
-                   Double_t sigmanew[2];
-                   sigmanew[0]= sigmaphi;
-                   sigmanew[1]=sigma[1];
-                   Double_t m[2];
-                   m[0]=cluster(1);
-                   m[1]=cluster(2);
-                   //  Double_t chi2pred=newTrack->GetPredChi2(m,sigmanew);   
-                   // cout<<" chi2pred = "<<chi2pred<<"\n";
-                   // if(chi2pred>fChi2max) continue; //aggiunto il 30-7-2001
-                   if(iriv == 0) flaghit=1;
-                   (*newTrack).AddMS();  // add the multiple scattering 
-                                            //matrix to the covariance matrix 
-                   (*newTrack).AddEL(1.,0);
-
-                   if(fflagvert){
-                       KalmanFilterVert(newTrack,cluster,sigmanew);
-                       //KalmanFilterVert(newTrack,cluster,sigmanew,chi2pred);
-                   }else{
-                       KalmanFilter(newTrack,cluster,sigmanew);
-                   } // end if
-                   (*newTrack).PutCluster(layernew, vecclust);
-                   newTrack->AddClustInTrack();
-                   listoftrack.AddLast(newTrack);
-               }   // end for indnew
-           }  // end of for on detectors (iriv)
-       }//end if(outinters==0)
-
-       if(flaghit==0 || outinters==-2) {
-           AliITSTrackV1 *newTrack = new AliITSTrackV1(*trackITS);
-           (*newTrack).Setfnoclust();           
-           //(*newTrack).SetLayer((*trackITS).GetLayer()-1); 
-           (*newTrack).AddMS();  // add the multiple scattering matrix
-                                    // to the covariance matrix  
-           (*newTrack).AddEL(1.,0);
-           listoftrack.AddLast(newTrack);
-       } // end if
-
-       //gObjectTable->Print();   // stampa memoria
-        
-       RecursiveTracking(&listoftrack);          
-       listoftrack.Delete();
-    } // end of for on tracks (index)
-
-    //gObjectTable->Print();   // stampa memoria
-     delete rl;
-    
-}
-//______________________________________________________________________
-Int_t AliITSTrackerV1::Intersection(AliITSTrackV1 &track,Int_t layer,
-                                   Int_t &ladder,Int_t &detector) { 
-    // Origin  A. Badala' and G.S. Pappalardo
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // Found the intersection and the detector 
-
-    Double_t rk=fAvrad[layer-1];
-    if(track.DoNotCross(rk)){ /*cout<< " Do not cross \n";*/ return -1;} 
-    track.Propagation(rk);
-    Double_t zinters=track.GetZ();
-    Double_t phinters=track.Getphi();
-    //cout<<"zinters = "<<zinters<<"  phinters = "<<phinters<<"\n";
-
-    TVector det(9);
-    TVector listDet(2);
-    TVector distZCenter(2);
-
-    Int_t iz=0; 
-    Int_t iD;
-    for(iD = 1; iD<= fNdet[layer-1]; iD++) {
-       if(zinters > fzmin[layer-1][iD-1] && zinters <= fzmax[layer-1][iD-1]) {
-           if(iz>1) {
-               cout<< " Errore su iz in Intersection \n";
-               getchar();
-           }else {
-               listDet(iz)= iD; distZCenter(iz)=TMath::Abs(zinters-det(2));
-               iz++;
-           } // end if
-       } // end if
-    } // end for iD
-
-    if(iz==0) {/* cout<< " No detector along Z \n";*/ return -2;}
-    detector=Int_t (listDet(0));
-    if(iz>1 && (distZCenter(0)>distZCenter(1)))   detector=Int_t (listDet(1));
-
-    TVector listLad(2);
-    TVector distPhiCenter(2);
-    Int_t ip=0;
-    Double_t pigre=TMath::Pi();
-    Int_t iLd;   
-    for(iLd = 1; iLd<= fNlad[layer-1]; iLd++) {
-       Double_t phimin=fphimin[layer-1][iLd-1];
-       Double_t phimax=fphimax[layer-1][iLd-1];
-       Double_t phidet=fphidet[layer-1][iLd-1];
-       Double_t phiconfr=phinters;
-       if(phimin>phimax) {  
-           //if(phimin <5.5) {cout<<" Error in Intersection for phi \n";
-           // getchar();}
-           phimin-=(2.*pigre);
-           if(phinters>(1.5*pigre)) phiconfr=phinters-(2.*pigre); 
-           if(phidet>(1.5*pigre)) phidet-=(2.*pigre);
-       } // end if
-       if(phiconfr>phimin && phiconfr<= phimax) {
-           if(ip>1) {
-               cout<< " Errore su ip in Intersection \n"; getchar();
-           }else  {
-               listLad(ip)= iLd;
-               distPhiCenter(ip)=TMath::Abs(phiconfr-phidet); ip++;
-           } // end if
-       } // end if
-    } // end for iLd
-    if(ip==0) { cout<< " No detector along phi \n"; getchar();}
-    ladder=Int_t (listLad(0));
-    if(ip>1 && (distPhiCenter(0)>distPhiCenter(1)))  ladder=Int_t (listLad(1));
-    return 0;
-}
-//______________________________________________________________________
-void AliITSTrackerV1::KalmanFilter(AliITSTrackV1 *newTrack,TVector &cluster,
-                                  Double_t sigma[2]){ 
-    //Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
-    // Kalman filter without vertex constraint
-    ////// Evaluation of the measurement vector ////////////////////////
-    Double_t m[2];
-    Double_t rk,phik,zk;
-    rk=cluster(0);   phik=cluster(1);  zk=cluster(2);
-    m[0]=phik;    m[1]=zk;
-    //////////////////////// Evaluation of the error matrix V  /////////
-    Double_t v00=sigma[0];
-    Double_t v11=sigma[1];
-    ////////////////////////////////////////////////////////////////////  
-    Double_t cin00,cin10,cin20,cin30,cin40,cin11,cin21,cin31,cin41,cin22,
-            cin32,cin42,cin33,cin43,cin44;
-
-    newTrack->GetCElements(cin00,
-                          cin10,cin11,
-                          cin20,cin21,cin22,
-                          cin30,cin31,cin32,cin33,
-                          cin40,cin41,cin42,cin43,cin44); //get C matrix
-    Double_t rold00=cin00+v00;
-    Double_t rold10=cin10;
-    Double_t rold11=cin11+v11;
-    ////////////////////// R matrix inversion  /////////////////////////
-    Double_t det=rold00*rold11-rold10*rold10;
-    Double_t r00=rold11/det;
-    Double_t r10=-rold10/det;
-    Double_t r11=rold00/det;
-    ////////////////////////////////////////////////////////////////////
-    Double_t k00=cin00*r00+cin10*r10;
-    Double_t k01=cin00*r10+cin10*r11;
-    Double_t k10=cin10*r00+cin11*r10;  
-    Double_t k11=cin10*r10+cin11*r11;
-    Double_t k20=cin20*r00+cin21*r10;  
-    Double_t k21=cin20*r10+cin21*r11;  
-    Double_t k30=cin30*r00+cin31*r10;  
-    Double_t k31=cin30*r10+cin31*r11;  
-    Double_t k40=cin40*r00+cin41*r10;
-    Double_t k41=cin40*r10+cin41*r11;
-    Double_t x0,x1,x2,x3,x4;
-    newTrack->GetXElements(x0,x1,x2,x3,x4);     // get the state vector
-    Double_t savex0=x0, savex1=x1;
-    x0+=k00*(m[0]-savex0)+k01*(m[1]-savex1);
-    x1+=k10*(m[0]-savex0)+k11*(m[1]-savex1);
-    x2+=k20*(m[0]-savex0)+k21*(m[1]-savex1);
-    x3+=k30*(m[0]-savex0)+k31*(m[1]-savex1);
-    x4+=k40*(m[0]-savex0)+k41*(m[1]-savex1);
-    Double_t c00,c10,c20,c30,c40,c11,c21,c31,c41,c22,c32,c42,c33,c43,c44;
-    c00=cin00-k00*cin00-k01*cin10;
-    c10=cin10-k00*cin10-k01*cin11;
-    c20=cin20-k00*cin20-k01*cin21;
-    c30=cin30-k00*cin30-k01*cin31;
-    c40=cin40-k00*cin40-k01*cin41;
-    c11=cin11-k10*cin10-k11*cin11;
-    c21=cin21-k10*cin20-k11*cin21;
-    c31=cin31-k10*cin30-k11*cin31;
-    c41=cin41-k10*cin40-k11*cin41;
-    c22=cin22-k20*cin20-k21*cin21;
-    c32=cin32-k20*cin30-k21*cin31;
-    c42=cin42-k20*cin40-k21*cin41;
-    c33=cin33-k30*cin30-k31*cin31;
-    c43=cin43-k30*cin40-k31*cin41;
-    c44=cin44-k40*cin40-k41*cin41;
-    newTrack->PutXElements(x0,x1,x2,x3,x4);  // put the new state vector
-    newTrack->PutCElements(c00,
-                          c10,c11,
-                          c20,c21,c22,
-                          c30,c31,c32,c33,
-                          c40,c41,c42,c43,c44); // put in track the
-                                                 // new cov matrix 
-    Double_t vmcold00=v00-c00;
-    Double_t vmcold10=-c10;
-    Double_t vmcold11=v11-c11;
-    ////////////////////// Matrix vmc inversion  ///////////////////////
-    det=vmcold00*vmcold11-vmcold10*vmcold10;
-    Double_t vmc00=vmcold11/det;
-    Double_t vmc10=-vmcold10/det;
-    Double_t vmc11=vmcold00/det;
-    ////////////////////////////////////////////////////////////////////
-  Double_t chi2=(m[0]-x0)*( vmc00*(m[0]-x0) + 2.*vmc10*(m[1]-x1) ) +
-                (m[1]-x1)*vmc11*(m[1]-x1);
-  newTrack->SetChi2(newTrack->GetChi2()+chi2);
-}
-//----------------------------------------------------------------------
-//void AliITSTrackerV1::KalmanFilterVert(AliITSTrackV1 *newTrack,
-//                                       TVector &cluster,Double_t sigma[2]){
-void AliITSTrackerV1::KalmanFilterVert(AliITSTrackV1 *newTrack,
-                                      TVector &cluster,Double_t sigma[2]
-                                       /*, Double_t chi2pred*/){
-    //Origin  A. Badala' and G.S. Pappalardo:
-    // e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it 
-    // Kalman filter with vertex constraint
-    ///////////////////// Evaluation of the measurement vector m ////////
-    Double_t m[4];
-    Double_t rk,phik,zk;
-    rk=cluster(0);   phik=cluster(1);  zk=cluster(2);
-    m[0]=phik;    m[1]=zk;
-    Double_t cc=(*newTrack).GetC();
-    Double_t zv=(*newTrack).GetZv(); 
-    Double_t dv=(*newTrack).GetDv();
-    Double_t cy=cc/2.;
-    Double_t tgl= (zk-zv)*cy/TMath::ASin(cy*rk);
-    m[2]=dv;    m[3]=tgl;
-    /////////////////////// Evaluation of the error matrix V  //////////
-    Int_t layer=newTrack->GetLayer();
-    Double_t v00=sigma[0];
-    Double_t v11=sigma[1];
-    Double_t v31=sigma[1]/rk;
-    Double_t sigmaDv=newTrack->GetsigmaDv();
-    Double_t v22=sigmaDv*sigmaDv  + newTrack->Getd2(layer-1);
-    Double_t v32=newTrack->Getdtgl(layer-1);
-    Double_t sigmaZv=newTrack->GetsigmaZv();  
-    Double_t v33=(sigma[1]+sigmaZv*sigmaZv)/(rk*rk)+newTrack->Gettgl2(layer-1);
-    //////////////////////////////////////////////////////////////////
-    Double_t cin00,cin10,cin11,cin20,cin21,cin22,
-            cin30,cin31,cin32,cin33,cin40,cin41,cin42,cin43,cin44;
-    newTrack->GetCElements(cin00,
-                          cin10,cin11,
-                          cin20,cin21,cin22,
-                          cin30,cin31,cin32,cin33,
-                          cin40,cin41,cin42,cin43,cin44); //get C matrix
-    Double_t r[4][4];
-    r[0][0]=cin00+v00;
-    r[1][0]=cin10;
-    r[2][0]=cin20;
-    r[3][0]=cin30;
-    r[1][1]=cin11+v11;
-    r[2][1]=cin21;
-    r[3][1]=cin31+sigma[1]/rk;
-    r[2][2]=cin22+sigmaDv*sigmaDv+newTrack->Getd2(layer-1);
-    r[3][2]=cin32+newTrack->Getdtgl(layer-1);
-    r[3][3]=cin33+(sigma[1]+sigmaZv*sigmaZv)/(rk*rk)+
-                                   newTrack->Gettgl2(layer-1);
-    r[0][1]=r[1][0]; r[0][2]=r[2][0]; r[0][3]=r[3][0]; 
-    r[1][2]=r[2][1]; r[1][3]=r[3][1]; r[2][3]=r[3][2];
-    /////////////////////  Matrix R inversion //////////////////////////
-    const Int_t kn=4;
-    Double_t big, hold;
-    Double_t d=1.;
-    Int_t ll[kn],mm[kn];
-    Int_t i,j,k;
-
-    for(k=0; k<kn; k++) {
-       ll[k]=k;
-       mm[k]=k;
-       big=r[k][k];
-       for(j=k; j<kn ; j++) {
-           for (i=j; i<kn; i++) {
-               if(TMath::Abs(big) < TMath::Abs(r[i][j]) ) { 
-                   big=r[i][j]; 
-                   ll[k]=i; 
-                   mm[k]=j; 
-               } // end if
-           } // end for i
-       } // end for j
-       //
-       j= ll[k];
-       if(j > k) {
-           for(i=0; i<kn; i++) {
-               hold=-r[k][i]; 
-               r[k][i]=r[j][i]; 
-               r[j][i]=hold;
-           } // end for i
-       }// end if
-       //
-       i=mm[k];
-       if(i > k ) { 
-           for(j=0; j<kn; j++) {
-               hold=-r[j][k];
-               r[j][k]=r[j][i]; 
-               r[j][i]=hold; 
-           } // end for j
-       } // end if
-       //
-       if(!big) {
-           d=0.;
-           cout << "Singular matrix\n"; 
-       } // end if
-       for(i=0; i<kn; i++) {
-           if(i == k) { continue; }    
-           r[i][k]=r[i][k]/(-big);
-       } // end for i
-       //
-       for(i=0; i<kn; i++) {
-           hold=r[i][k];
-           for(j=0; j<kn; j++) {
-               if(i == k || j == k) continue;
-               r[i][j]=hold*r[k][j]+r[i][j];
-           } // end for j
-       } // end of ri
-       // 
-       for(j=0; j<kn; j++) {
-           if(j == k) continue;
-           r[k][j]=r[k][j]/big;
-       } // end for j
-       //
-       d=d*big;
-       //
-       r[k][k]=1./big;        
-    } // end for k
-    //
-    for(k=kn-1; k>=0; k--) {
-       i=ll[k];
-       if(i > k) {
-           for (j=0; j<kn; j++) {
-               hold=r[j][k];
-               r[j][k]=-r[j][i]; 
-               r[j][i]=hold;
-           } // end for j
-       } // end if i
-       j=mm[k];
-       if(j > k) {
-           for (i=0; i<kn; i++) {
-               hold=r[k][i]; 
-               r[k][i]=-r[j][i]; 
-               r[j][i]=hold;
-           } // end for i
-       } // end if
-    } // end for k
-    ////////////////////////////////////////////////////////////////////
-    Double_t k00=cin00*r[0][0]+cin10*r[1][0]+cin20*r[2][0]+cin30*r[3][0];
-    Double_t k01=cin00*r[1][0]+cin10*r[1][1]+cin20*r[2][1]+cin30*r[3][1];
-    Double_t k02=cin00*r[2][0]+cin10*r[2][1]+cin20*r[2][2]+cin30*r[3][2];
-    Double_t k03=cin00*r[3][0]+cin10*r[3][1]+cin20*r[3][2]+cin30*r[3][3];
-    Double_t k10=cin10*r[0][0]+cin11*r[1][0]+cin21*r[2][0]+cin31*r[3][0];  
-    Double_t k11=cin10*r[1][0]+cin11*r[1][1]+cin21*r[2][1]+cin31*r[3][1];
-    Double_t k12=cin10*r[2][0]+cin11*r[2][1]+cin21*r[2][2]+cin31*r[3][2];
-    Double_t k13=cin10*r[3][0]+cin11*r[3][1]+cin21*r[3][2]+cin31*r[3][3];
-    Double_t k20=cin20*r[0][0]+cin21*r[1][0]+cin22*r[2][0]+cin32*r[3][0];  
-    Double_t k21=cin20*r[1][0]+cin21*r[1][1]+cin22*r[2][1]+cin32*r[3][1];  
-    Double_t k22=cin20*r[2][0]+cin21*r[2][1]+cin22*r[2][2]+cin32*r[3][2];
-    Double_t k23=cin20*r[3][0]+cin21*r[3][1]+cin22*r[3][2]+cin32*r[3][3];
-    Double_t k30=cin30*r[0][0]+cin31*r[1][0]+cin32*r[2][0]+cin33*r[3][0];  
-    Double_t k31=cin30*r[1][0]+cin31*r[1][1]+cin32*r[2][1]+cin33*r[3][1];  
-    Double_t k32=cin30*r[2][0]+cin31*r[2][1]+cin32*r[2][2]+cin33*r[3][2];  
-    Double_t k33=cin30*r[3][0]+cin31*r[3][1]+cin32*r[3][2]+cin33*r[3][3];
-    Double_t k40=cin40*r[0][0]+cin41*r[1][0]+cin42*r[2][0]+cin43*r[3][0];
-    Double_t k41=cin40*r[1][0]+cin41*r[1][1]+cin42*r[2][1]+cin43*r[3][1];
-    Double_t k42=cin40*r[2][0]+cin41*r[2][1]+cin42*r[2][2]+cin43*r[3][2];  
-    Double_t k43=cin40*r[3][0]+cin41*r[3][1]+cin42*r[3][2]+cin43*r[3][3];
-
-    Double_t x0,x1,x2,x3,x4;
-    newTrack->GetXElements(x0,x1,x2,x3,x4);     // get the state vector
-    Double_t savex0=x0, savex1=x1, savex2=x2, savex3=x3;
-    x0+=k00*(m[0]-savex0)+k01*(m[1]-savex1)+k02*(m[2]-savex2)+
-       k03*(m[3]-savex3);
-    x1+=k10*(m[0]-savex0)+k11*(m[1]-savex1)+k12*(m[2]-savex2)+
-       k13*(m[3]-savex3);
-    x2+=k20*(m[0]-savex0)+k21*(m[1]-savex1)+k22*(m[2]-savex2)+
-       k23*(m[3]-savex3);
-    x3+=k30*(m[0]-savex0)+k31*(m[1]-savex1)+k32*(m[2]-savex2)+
-       k33*(m[3]-savex3);
-    x4+=k40*(m[0]-savex0)+k41*(m[1]-savex1)+k42*(m[2]-savex2)+
-       k43*(m[3]-savex3);
-    Double_t c00,c10,c20,c30,c40,c11,c21,c31,c41,c22,c32,c42,c33,c43,c44;
-    c00=cin00-k00*cin00-k01*cin10-k02*cin20-k03*cin30;
-    c10=cin10-k00*cin10-k01*cin11-k02*cin21-k03*cin31;
-    c20=cin20-k00*cin20-k01*cin21-k02*cin22-k03*cin32;
-    c30=cin30-k00*cin30-k01*cin31-k02*cin32-k03*cin33;
-    c40=cin40-k00*cin40-k01*cin41-k02*cin42-k03*cin43;
-    c11=cin11-k10*cin10-k11*cin11-k12*cin21-k13*cin31;
-    c21=cin21-k10*cin20-k11*cin21-k12*cin22-k13*cin32;
-    c31=cin31-k10*cin30-k11*cin31-k12*cin32-k13*cin33;
-    c41=cin41-k10*cin40-k11*cin41-k12*cin42-k13*cin43;
-    c22=cin22-k20*cin20-k21*cin21-k22*cin22-k23*cin32;
-    c32=cin32-k20*cin30-k21*cin31-k22*cin32-k23*cin33;
-    c42=cin42-k20*cin40-k21*cin41-k22*cin42-k23*cin43;
-    c33=cin33-k30*cin30-k31*cin31-k32*cin32-k33*cin33;
-    c43=cin43-k30*cin40-k31*cin41-k32*cin42-k33*cin43;
-    c44=cin44-k40*cin40-k41*cin41-k42*cin42-k43*cin43;
-
-    newTrack->PutXElements(x0,x1,x2,x3,x4); // put the new state vector
-    newTrack->PutCElements(c00,
-                          c10,c11,
-                          c20,c21,c22,
-                          c30,c31,c32,c33,
-                          c40,c41,c42,c43,c44); // put in track the
-                                                 // new cov matrix
-    Double_t vmc[4][4];
-    vmc[0][0]=v00-c00; vmc[1][0]=-c10; vmc[2][0]=-c20; vmc[3][0]=-c30;
-    vmc[1][1]=v11-c11; vmc[2][1]=-c21; vmc[3][1]=v31-c31;
-    vmc[2][2]=v22-c22; vmc[3][2]=v32-c32;
-    vmc[3][3]=v33-c33;
-    vmc[0][1]=vmc[1][0]; vmc[0][2]=vmc[2][0]; vmc[0][3]=vmc[3][0];
-    vmc[1][2]=vmc[2][1]; vmc[1][3]=vmc[3][1];
-    vmc[2][3]=vmc[3][2];
-    /////////////////////// vmc matrix inversion /////////////////////// 
-    d=1.;
-    for(k=0; k<kn; k++) {
-       ll[k]=k;
-       mm[k]=k;
-       big=vmc[k][k];
-       for(j=k; j<kn ; j++) {
-           for (i=j; i<kn; i++) {
-               if(TMath::Abs(big) < TMath::Abs(vmc[i][j]) ) {
-                   big=vmc[i][j]; 
-                   ll[k]=i;
-                   mm[k]=j;
-               } // end if
-           } // end for i
-       } // end for j
-       //
-       j= ll[k];
-       if(j > k) {
-           for(i=0; i<kn; i++) {
-               hold=-vmc[k][i]; 
-               vmc[k][i]=vmc[j][i];
-               vmc[j][i]=hold;
-           } // end for i
-       } // end if
-       //
-       i=mm[k];
-       if(i > k ) { 
-           for(j=0; j<kn; j++) { 
-               hold=-vmc[j][k]; 
-               vmc[j][k]=vmc[j][i]; 
-               vmc[j][i]=hold; 
-           } // end for j
-       } // end if
-       //
-       if(!big) {
-           d=0.;
-           cout << "Singular matrix\n"; 
-       } // end if
-       for(i=0; i<kn; i++) {
-           if(i == k) continue;    
-           vmc[i][k]=vmc[i][k]/(-big);
-       }    // end for i
-       //
-       for(i=0; i<kn; i++) {
-           hold=vmc[i][k];
-           for(j=0; j<kn; j++) {
-               if(i == k || j == k) continue;
-               vmc[i][j]=hold*vmc[k][j]+vmc[i][j];
-           } // end for j
-       } // end for i
-       //  
-       for(j=0; j<kn; j++) {
-           if(j == k) continue;
-           vmc[k][j]=vmc[k][j]/big;
-       } // end for j
-       //
-       d=d*big;
-       //
-       vmc[k][k]=1./big;        
-    }  // end for k
-    //  
-    for(k=kn-1; k>=0; k--) {
-       i=ll[k];
-       if(i > k) {
-           for (j=0; j<kn; j++) {
-               hold=vmc[j][k]; 
-               vmc[j][k]=-vmc[j][i];
-               vmc[j][i]=hold;
-           } // end for j
-       } // end if i>k
-       j=mm[k];
-       if(j > k) {
-           for (i=0; i<kn; i++) {
-               hold=vmc[k][i]; 
-               vmc[k][i]=-vmc[j][i]; 
-               vmc[j][i]=hold;
-           } // end for i
-       } // end if j>k
-    } // end for k
-    ////////////////////////////////////////////////////////////////////
-    Double_t chi2=(m[0]-x0)*( vmc[0][0]*(m[0]-x0) + 2.*vmc[1][0]*(m[1]-x1) + 
-                             2.*vmc[2][0]*(m[2]-x2)+ 2.*vmc[3][0]*(m[3]-x3) )+
-       (m[1]-x1)* ( vmc[1][1]*(m[1]-x1) + 2.*vmc[2][1]*(m[2]-x2)+ 
-                    2.*vmc[3][1]*(m[3]-x3) ) +
-       (m[2]-x2)* ( vmc[2][2]*(m[2]-x2)+ 2.*vmc[3][2]*(m[3]-x3) ) +
-       (m[3]-x3)*vmc[3][3]*(m[3]-x3);
-    //cout<<" chi2 kalman = "<<chi2<<"\n";  getchar(); 
-    newTrack->SetChi2(newTrack->GetChi2()+chi2);   
-    //   newTrack->SetChi2(newTrack->GetChi2()+chi2pred);
-}
-
diff --git a/ITS/AliITSTrackerV1.h b/ITS/AliITSTrackerV1.h
deleted file mode 100644 (file)
index 814199a..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-//Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
-//See cxx source for full Copyright notice
-//
-//The purpose of this class is to permorm the ITS tracking.
-//
-//      The constructor has the task to inizialize some private members.
-// The method DoTracking is written to be called by a macro. It gets the event
-// number, the minimum and maximum order number of TPC tracks that are to be
-// tracked trough the ITS, and the file where the recpoints are registered.
-//
-// The method AliiTStracking is a recursive function that performs the
-// tracking trough the ITS
-//
-// The method Intersection found the layer, ladder and detector where the
-// intersection take place and caluclate the cohordinates of this
-// intersection.  It returns an integer that is 0 if the intersection has
-// been found successfully.
-//
-// The two mwthods Kalmanfilter and kalmanfiltervert operate the
-// kalmanfilter without and with the verteximposition respectively.
-
-#ifndef ALIITSTRACKERV1_H
-#define ALIITSTRACKERV1_H
-
-#include <TObject.h>
-#include <TVectorfwd.h>
-
-class TObjArray;
-class AliITSTrackV1;
-class AliITSRad;
-class TStopwatch;
-
-class AliITSTrackerV1 : public TObject {
- public:
-    AliITSTrackerV1();
-    AliITSTrackerV1(Int_t evnumber, Bool_t flag);
-    AliITSTrackerV1(const AliITSTrackerV1 &cobj);
-    ~AliITSTrackerV1();
-    AliITSTrackerV1 &operator=(const AliITSTrackerV1 &obj);
-//  void DelMatrix(Int_t NumOfModules);
-    void DoTracking(Int_t evNumber, Int_t minTr, Int_t maxTr, TFile *file, Bool_t realmass=0);
-    void RecursiveTracking(TList *trackITSlist);
-    Int_t Intersection(AliITSTrackV1 &track, Int_t layer,Int_t &ladder,
-                      Int_t &detector); 
-    void KalmanFilter(AliITSTrackV1 *newtrack, TVector &cluster,
-                     Double_t sigma[2]);
-    void KalmanFilterVert(AliITSTrackV1 *newtrack, TVector &cluster,
-                         Double_t sigma[2]);
-    //void KalmanFilterVert(AliITSTrackV1 *newtrack, TVector &cluster,
-    //                      Double_t sigma[2], Double_t chi2pred);
-
- private:
-    //AliITS* fITS;              //! pointer to AliITS
-    AliITSDetTypeRec *fDetTypeRec;//ITS obj. for reconstruction
-    AliITSTrackV1 *fresult;    // result is a pointer to the final best track
-    Double_t fPtref;           // transvers momentum obtained from TPC tracking
-    Double_t fChi2max;         //  chi2 cut  
-    //Double_t fepsphi;  //eps for definition window in phi 
-   // Double_t fepsz;  //eps for definition window in z 
-    TClonesArray  *frecPoints;    // pointer to RecPoints
-    Int_t **fvettid;           // flag vector of used clusters
-    Bool_t fflagvert;          // a flag to impose or not the vertex constraint
-    AliITSRad *frl;            // pointer to get the radiation lenght matrix
-///      To be put in a specific geometric class        
-    Int_t fNlad[6];            // Number of ladders for a given layer
-    Int_t fNdet[6];            // Number of detector for a given layer
-    Double_t fAvrad[6];        // Average radius for a given layer
-    Double_t fDetx[6];// Semidimension of detectors along x axis for a given layer
-    Double_t fDetz[6];// Semidimension of detectors along z axis for a given layer
-    Double_t **fzmin;// Matrix of zmin for a given layer and a given detector
-    Double_t **fzmax;// Matrix of zmax for a given layer and a given detector
-    Double_t **fphimin;// Matrix of phimin for a given layer and a given ladder
-    Double_t **fphimax;// Matrix of phimax for a given layer and a given ladder
-    Double_t **fphidet; // azimuthal angle for a given layer and a given ladder
-        Int_t *fNRecPoints;        // pointer to the vector giving the number of recpoints for a given module
-        /*
-        Float_t **fRecCylR;        // pointer to the matrix giving the R cylindric cohordinate of a recpoint
-        Float_t **fRecCylPhi;      // pointer to the matrix giving the Phi cylindric cohordinate of a recpoint
-        Float_t **fRecCylZ;        // pointer to the matrix giving the Z cylindric cohordinate of a recpoint   
-        */
-        Double_t **fRecCylR;        // pointer to the matrix giving the R cylindric cohordinate of a recpoint
-        Double_t **fRecCylPhi;      // pointer to the matrix giving the Phi cylindric cohordinate of a recpoint
-        Double_t **fRecCylZ;        // pointer to the matrix giving the Z cylindric cohordinate of a recpoint            
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    Double_t fFieldFactor;     // Magnetic field factor 
-    ClassDef(AliITSTrackerV1,2)  
-};
-
-#endif
diff --git a/ITS/AliITSclusterSSD.cxx b/ITS/AliITSclusterSSD.cxx
deleted file mode 100644 (file)
index b1a90e2..0000000
+++ /dev/null
@@ -1,396 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id$ */
-////////////////////////////////////////////////////////////////////////////
-//Piotr Krzysztof Skowronski                                              //
-//Warsaw University of Technology                                         // 
-//skowron@if.pw.edu.pl                                                    //
-//                                                                        // 
-// Describes set of neighbouring digits on one side of detector,          //
-// that are supposed to be generated by one particle.                     //
-// includes information about clusters on other side that it crosses with //
-////////////////////////////////////////////////////////////////////////////
-
-#include <TArrayI.h>
-#include <TMath.h>
-#include <TClonesArray.h>
-
-
-#include "AliITSdigitSSD.h"
-#include "AliITSclusterSSD.h"
-
-ClassImp(AliITSclusterSSD)
-
-//______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD():
-fSide(kTRUE),
-fDigits(0),
-fNDigits(0),
-fDigitsIndex(0),
-fNCrosses(0),
-fCrossedClusterIndexes(0),
-fLeftNeighbour(kFALSE),
-fRightNeighbour(kFALSE),
-fConsumed(kFALSE),
-fTotalSignal(-1),
-fNTracks(-1){
-    // default constructor
-    for (Int_t i = 0; i < 10; i++) 
-      fTrack[i] = -1;
-}
-//______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes, 
-                                  TObjArray *Digits, Bool_t side):
-fSide(side),
-fDigits(Digits),
-fNDigits(ndigits),
-fDigitsIndex(0),
-fNCrosses(0),
-fCrossedClusterIndexes(0),
-fLeftNeighbour(kFALSE),
-fRightNeighbour(kFALSE),
-fConsumed(kFALSE),
-fTotalSignal(-1),
-fNTracks(-1){
-    // non-default constructor
-
-    fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );        
-    fCrossedClusterIndexes = new TArrayI(300);
-    for (Int_t i = 0; i < 10; i++) 
-      fTrack[i] = -1;
-}
-//______________________________________________________________________
-AliITSclusterSSD::~AliITSclusterSSD(){
-    // destructor
-
-    delete fDigitsIndex;
-    delete fCrossedClusterIndexes;
-}
-//______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) : 
-TObject(OneSCluster),
-fSide(OneSCluster.fSide),
-fDigits(OneSCluster.fDigits),
-fNDigits(OneSCluster.fNDigits),
-fDigitsIndex(0),
-fNCrosses(OneSCluster.fNCrosses),
-fCrossedClusterIndexes(0),
-fLeftNeighbour(OneSCluster.fLeftNeighbour),
-fRightNeighbour(OneSCluster.fRightNeighbour),
-fConsumed(OneSCluster.fConsumed),
-fTotalSignal(-1),
-fNTracks(-1){
-    // copy constructor
-
-    fDigitsIndex = new TArrayI(fNDigits);
-    fTotalSignal =-1;
-    fNTracks     = -1;
-    Int_t i;
-    for (i = 0; i < 10; i++) 
-      fTrack[i] = -1;
-    for (i = 0; i< fNCrosses ; i++){
-       fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
-    }
-    for (i = 0; i< fNDigits ; i++){
-       fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
-    }
-    return;
-}
-//______________________________________________________________________
-AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD 
-                                             &OneSCluster){
-    // assignment operator
-
-    if (this == &OneSCluster) return *this;
-    fNDigits = OneSCluster.fNDigits;
-    fSide=OneSCluster.fSide;
-    fDigits=OneSCluster.fDigits;
-    fDigitsIndex = new TArrayI(fNDigits);
-    fLeftNeighbour  = OneSCluster.fLeftNeighbour;
-    fRightNeighbour = OneSCluster.fRightNeighbour;
-    fTotalSignal =-1;
-    fNTracks     = -1;
-    fNCrosses = OneSCluster.fNCrosses;
-    fConsumed = OneSCluster.fConsumed;
-    Int_t i;
-    for (i = 0; i< fNCrosses ; i++){
-       fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
-    }
-    for (i = 0; i< fNDigits ; i++){
-       fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
-    }
-    return *this;
-}
-//______________________________________________________________________
-Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits){
-    //This methods generate data necessery to make new object of this class
-    //I choosen this way, because methods TClonesArray::Add* dont work
-    //so I have to use constraction: new (a[i]) Creator(params...);
-    //where 'a' is a TClonesArray 
-    //This method generate params - see AliITSmoduleSSD::SplitCluster;
-    Int_t tmp = fNDigits;
-    Int_t ind = 0;
-
-    outdigits[ind++]=(*fDigitsIndex)[where];
-    //coping border strip (it is shared by this two clusters)
-    for (Int_t i = (where+1); i < tmp; i++) {
-       outdigits[ind++]=(*fDigitsIndex)[i];  
-       //"moving" strips from this to the new one 
-       (*fDigitsIndex)[i]=-1;   
-       fNDigits--;   //deleting strips from this cluster
-    } 
-    return ind;                
-}
-//______________________________________________________________________
-Int_t AliITSclusterSSD::GetDigitStripNo(Int_t digit){
-    // return strip no of a digit
-    if (digit<0) return -1;
-    return (digit>(fNDigits-1)) ? -1 :
-       ((AliITSdigitSSD*)(fDigits->At((*fDigitsIndex)[digit])))->GetStripNumber();
-}
-//______________________________________________________________________
-Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit){
-    // returns digit signal
-    Int_t index,signal;
-    if (digit<0||digit>=fNDigits) return -1;
-    index  = (*fDigitsIndex)[digit];
-    signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
-    /*
-      if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
-      digit,index, signal);
-    */
-    return  signal;
-}
-//______________________________________________________________________
-void  AliITSclusterSSD::AddCross(Int_t clIndex){
-    // add cluster cross to list of cluster crosses
-  
-    (*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
-}
-//______________________________________________________________________
-Int_t AliITSclusterSSD::GetCross(Int_t crIndex) const {
-    // return crossing cluster
-
-    return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
-}
-//______________________________________________________________________
-Double_t AliITSclusterSSD::CentrOfGravity(){
-    // return center of gravity of the cluster
-    Float_t ret=0;
-  
-    if (fLeftNeighbour) ret+=(GetDigitStripNo(0)*0.5*GetDigitSignal(0));
-    else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
-    if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
-    else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
-    for (Int_t i=1;i<fNDigits-1;i++){
-       ret +=GetDigitStripNo(i)*GetDigitSignal(i);
-    }// end for i
-  
-    if (fTotalSignal<0) GetTotalSignal();
-       
-    return (ret/fTotalSignal);
-}
-//______________________________________________________________________
-Float_t AliITSclusterSSD::GetTotalSignal(){
-    // return total signal
-  
-    if(fTotalSignal <0){
-       fTotalSignal=0;
-       if (fNDigits ==1)  {
-           fTotalSignal = (Float_t)GetDigitSignal(0);
-           //printf("1 digit: signal %d \n",GetDigitSignal(0)); 
-           return fTotalSignal;
-       }
-       if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
-       else fTotalSignal += (Float_t) GetDigitSignal(0);
-       //printf("GetTotalSignal :i DigitSignal %d %d \n",0,GetDigitSignal(0));
-       if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(
-                                                                 fNDigits -1));
-      else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
-       //printf("GetTotalSignal :i  DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1));
-       for (Int_t i = 1;i<fNDigits -1;i++){
-           fTotalSignal += (Float_t)GetDigitSignal(i);
-           //printf("GetTotalSignal :i  DigitSignal %d %d \n",i,GetDigitSignal(i)); 
-       }
-       //printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal); 
-    }
-    return fTotalSignal;
-}
-//______________________________________________________________________
-Float_t  AliITSclusterSSD::GetTotalSignalError(){
-    // return the error on the signal
-    Float_t err =0;
-    for (Int_t i =1; i<fNDigits -1; i++){
-       err+=0.1*GetDigitSignal(i);   
-    } 
-    if (GetLeftNeighbour()){
-       err+=GetDigitSignal(0);
-    }else{
-       err+=0.1*GetDigitSignal(0);
-    } 
-    if (GetRightNeighbour()){
-       err+=GetDigitSignal(fNDigits -1);
-    }else{
-       err+=0.1*GetDigitSignal(fNDigits -1);
-    }
-    return err;
-}
-//______________________________________________________________________
-void AliITSclusterSSD::DelCross(Int_t index){
-    // remove cross clusters from the list of cross clusters
-    Int_t i,j; //iterators
-
-    for (i =0;i<fNCrosses;i++){
-       if ((*fCrossedClusterIndexes)[i] == index){
-           for (j=i;j<fNCrosses-1;j++){
-               (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
-           }
-           fNCrosses--;
-           return; 
-       }
-    }
-}
-//______________________________________________________________________
-Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt){
-    // return the track number of the cluster
-    Int_t ntrk = GetDigit(0)->GetNTracks();
-    Int_t ndig = GetNumOfDigits();
-    Int_t *idig = new Int_t[ndig];
-    Int_t *sdig = new Int_t[ndig];
-    Int_t *itrk = new Int_t[ndig*ntrk];
-    Int_t i,j,k,l,trk;
-    Bool_t b;
-
-    for(i=0;i<ndig;i++){idig[i] = i;sdig[i] = GetDigit(i)->GetSignal();}
-    TMath::Sort(ndig,sdig,idig,kTRUE);
-    for(i=0;i<ndig*ntrk;i++) itrk[i] = -3;
-    j = k = l = 0;
-    for(i=0;i<ndig;i++){ // fill itrk with track numbers in order of digit size
-       j = idig[i];
-       for(k=0;k<ntrk;k++) if((trk = GetDigit(j)->GetTrack(k))>=0) {
-           itrk[l] = trk;
-           l++;
-       } // end for k/if
-    } // end for i
-    for(i=0;i<10;i++) fTrack[i] = -3;
-    fTrack[0] = itrk[0]; // first element
-    k = 1;
-    b = kTRUE;
-    for(i=1;i<l;i++){
-       for(j=0;j<k;j++) if(fTrack[j]==itrk[i]) b = kFALSE;
-       if(b){fTrack[k] = itrk[i]; k++;}
-       if(k>9) break;
-    } // end for i
-    nt = k;
-
-    delete[] idig;
-    delete[] sdig;
-    delete[] itrk;
-
-    return fTrack;
-/*
-    Int_t *tidx=0;
-    Int_t i, j,n;
-    Int_t bit =0;
-    Int_t ntracks=0;
-    nt=0;
-
-    for (i=0;i<10;i++) fTrack[i] = -3;
-   
-    //cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;
-
-    for (i = 0; i<fNDigits; i++) {
-       tidx = GetDigit(i)->GetTracks();
-       n    = GetDigit(i)->GetNTracks();
-       for (j = 0; j<n && j<10;j++) {
-           if (tidx[j] >= 0) {
-               if(ntracks == 0){
-                   fTrack[ntracks] = tidx[j];
-                   ntracks++; 
-               }else if(tidx[j] != fTrack[ntracks-1]){
-                   ntracks++; 
-                   if(ntracks > 9) {
-                       bit = 1;
-                       break;
-                   } // end if ntracks > 9
-                   fTrack[ntracks-1] = tidx[j];
-               } // end if ntracke == 0
-           } // end if tidx[j] >=0
-       } // 3-tracks loop for the digit 
-       if(bit == 1) break;
-    } // digit loop
-
-    SetNTracks(ntracks); 
-    nt = ntracks;
-    return &(fTrack[0]);
-*/
-}
-//______________________________________________________________________
-Double_t AliITSclusterSSD::GetPosition(){
-    // return position of the cluster
-    Float_t ret;
-
-    switch(fNDigits){
-    case  1:
-       ret = GetDigitStripNo(0);
-       break;
-    case  2:
-       ret = EtaAlgorithm();
-       break;       
-    default:
-       ret = CentrOfGravity();   
-    }
-    return ret;
-}
-//______________________________________________________________________
-Double_t AliITSclusterSSD::EtaAlgorithm(){
-    // algorithm for determing cluster position
-    if (fNDigits != 2) return -1;
-
-    Int_t strip1  = GetDigit(0)->GetStripNumber(); 
-    Int_t strip2  = GetDigit(1)->GetStripNumber();
-    Int_t signal1 = GetDigit(0)->GetSignal();
-    Int_t signal2 = GetDigit(1)->GetSignal();
-
-    Double_t eta;
-  
-    if (strip1<strip2){
-       eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
-       if (eta<0.04) return strip1;
-       if (eta>0.96) return strip2;
-       return (strip1 + 0.43478261*eta + 0.2826087);   
-    } else{
-       eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
-       if (eta<0.04) return strip2;
-       if (eta>0.96) return strip1;
-       return (strip2 + 0.43478261*eta + 0.2826087);   
-    }
-}
-//______________________________________________________________________
-Double_t  AliITSclusterSSD::GetPositionError() const {
-    // return the position error
-    return (GetNumOfDigits()+1)/2;
-}
-//______________________________________________________________________
-Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx) const{
-    // return the cluster to which he crosses
-
-    for (Int_t i =0; i< fNCrosses;i++){
-       if (GetCross(i) == idx) return kTRUE;
-    }
-    return kFALSE;
-}
diff --git a/ITS/AliITSclusterSSD.h b/ITS/AliITSclusterSSD.h
deleted file mode 100644 (file)
index 5d4f5cb..0000000
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef ALIITSCLUSTERSSD_H
-#define ALIITSCLUSTERSSD_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/*
-  $Id$
- */
-
-    //Piotr Krzysztof Skowronski
-    //Warsaw University of Technology
-    //skowron@if.pw.edu.pl
-    //
-    // Describes set of neighbouring digits on one side of detector,
-    // that are supposed to be generated by one particle.
-    // includes information about clusters on other side that it crosses with
-#include "TObject.h"
-#include "TArrayI.h"
-class TConesArray;
-class AliITSdigitSSD;
-
-class AliITSclusterSSD : public TObject{
- public:
-    AliITSclusterSSD();    //Default Constructor
-    virtual ~AliITSclusterSSD();
-    AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes,
-                    TObjArray *Digits, Bool_t side);           
-    AliITSclusterSSD(const AliITSclusterSSD &source); 
-    AliITSclusterSSD& operator=( const AliITSclusterSSD & source);
-    void AddDigit(Int_t index){//adds on digit
-       (*fDigitsIndex)[fNDigits++]=index;} 
-    TObjArray* GetPointer2Digits() const {return fDigits;}// pointer to digits array 
-    void SetPointer2Digits(TObjArray *digits){// array of digits
-       fDigits = digits;}
-    Int_t GetNumOfDigits() const {//Returns number of digits that creates this cluster
-       return fNDigits;}
-    Int_t GetDigitSignal(Int_t digit);
-    AliITSdigitSSD *GetDigit(Int_t idx) { // comment to be written
-       return (AliITSdigitSSD *)((*fDigits)[GetDigitIndex(idx)]);}
-    Int_t GetDigitIndex (Int_t digit) const {// comment to be written
-       return (*fDigitsIndex)[digit];}
-    Int_t GetDigitStripNo(Int_t digit);
-    // comment to be written
-    Int_t GetFirstDigitStripNo(){return GetDigitStripNo(0);}
-    Int_t GetLastDigitStripNo(){// comment to be written
-       return GetDigitStripNo(fNDigits-1);}
-     //splits this one side cluster for two
-    Int_t SplitCluster(Int_t where,Int_t *outdigits);
-    void AddCross(Int_t clIndex);  //Add index of cluster that it crosses with
-     //return index of cluster that it crosses with
-    Int_t GetCross(Int_t crIndex) const ;
-    Int_t GetCrossNo()  const {// Returns number of crosses
-       return fNCrosses;}
-    void DelCross(Int_t index);
-    Double_t GetPosition();
-    Double_t GetPositionError() const;
-    Float_t GetTotalSignal();  
-    Float_t GetTotalSignalError();
-    void CutTotalSignal(Float_t sx) {// comment to be written
-       if (fTotalSignal>sx) fTotalSignal-=sx;}
-    Bool_t GetRightNeighbour() const {// comment to be written
-       return fRightNeighbour;}
-    Bool_t GetLeftNeighbour() const {// comment to be written
-       return fLeftNeighbour;}
-    void SetRightNeighbour(Bool_t nei) {// comment to be written
-       fRightNeighbour=nei;}
-    //comment to be written
-    void SetLeftNeighbour(Bool_t nei){fLeftNeighbour=nei;}
-    void SetNTracks(Int_t ntracks) {fNTracks=ntracks;}// set ntracks
-    Int_t GetNTracks() const {return fNTracks;}// comment to be written
-    Bool_t GetSide() const {return fSide;}// comment to be written
-    Int_t CheckSatus(Int_t *) const {return 0;}//check if dig's comes from same track
-    Int_t *GetTracks(Int_t &nt);
-    void Consume(){// comment
-       fConsumed = kTRUE;}
-    Bool_t IsConsumed() const{// comment
-       return fConsumed;}
-    Bool_t IsCrossingWith(Int_t idx) const;
- protected:
-    Bool_t    fSide;        //True if P
-    TObjArray *fDigits;     //Pointer to List of Digitsbelonging to AliITS
-    Int_t     fNDigits;     //Number of digits that make up that cluster 
-    TArrayI  *fDigitsIndex; // Digit indexes in fDigits array
-    Int_t    fNCrosses;     //Number of crossed one side clusters on the
-                            // other side (max 8 : it is not aribtrary)
-    TArrayI *fCrossedClusterIndexes; //Array of inedexes of crossed clusters
-                                     // (in TClonesArray)
-                                     // not in TArrayI in package
-    Bool_t   fLeftNeighbour;   // comment to be written
-    Bool_t   fRightNeighbour;  // comment to be written 
-    Bool_t   fConsumed;        // comment to be written
-    Float_t  fTotalSignal;     // comment to be written
-    Int_t    fTrack[10];       // comment to be written
-    Int_t    fNTracks;         // comment to be written
-    
-    Double_t CentrOfGravity();
-    Double_t EtaAlgorithm();
-  ClassDef(AliITSclusterSSD,1) // Cluster class for reconstructing SSD
-};
-
-#endif
diff --git a/ITS/AliITSpackageSSD.cxx b/ITS/AliITSpackageSSD.cxx
deleted file mode 100644 (file)
index 284bd20..0000000
+++ /dev/null
@@ -1,665 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-/* $Id$ */
-
-#include <Riostream.h>
-#include <TClonesArray.h>
-#include "AliITSpackageSSD.h"
-#include "AliITSclusterSSD.h"
-
-const Bool_t AliITSpackageSSD::fgkSIDEP=kTRUE;
-const Bool_t AliITSpackageSSD::fgkSIDEN=kFALSE;
-
-ClassImp(AliITSpackageSSD)
-////////////////////////////////////////////////////////////////////////////
-//Class describing set of AliITSoneSideClusterSSDs, which contact each other.
-//Piotr Krzysztof Skowronski
-//Warsaw University of Technology
-//skowron@if.pw.edu.pl
-//
-//--------------------------------------------------------------------------
-AliITSpackageSSD::AliITSpackageSSD():
-fClustersN(0),
-fClustersP(0),
-fNclustersN(0),
-fNclustersP(0),
-fClusterNIndexes(0),
-fClusterPIndexes(0){
-  // constructor
-}
-
-
-/*******************************************************/
-
-AliITSpackageSSD::AliITSpackageSSD
-(TClonesArray *clustersP, TClonesArray *clustersN):
-fClustersN(clustersN),
-fClustersP(clustersP),
-fNclustersN(0),
-fNclustersP(0),
-fClusterNIndexes(0),
-fClusterPIndexes(0){
-  // constructor
-  fClustersP=clustersP;
-  fClustersN=clustersN;
-       
-  fNclustersN=0;
-  fClusterNIndexes = new TArrayI(300); 
-       
-  fNclustersP=0;
-  fClusterPIndexes = new TArrayI(300);         
-}
-
-/*******************************************************/
-
-
-AliITSpackageSSD::AliITSpackageSSD(Int_t len, TClonesArray *clustersP, TClonesArray *clustersN):
-fClustersN(clustersN),
-fClustersP(clustersP),
-fNclustersN(0),
-fNclustersP(0),
-fClusterNIndexes(0),
-fClusterPIndexes(0){   
-  // constructor
-  fClustersP=clustersP;
-  fClustersN=clustersN;
-
-  fNclustersN=0;
-  fClusterNIndexes = new TArrayI(len); 
-       
-  fNclustersP=0;
-  fClusterPIndexes = new TArrayI(len);         
-}
-
-
-/*******************************************************/
-
-AliITSpackageSSD::~AliITSpackageSSD()
-{
-  // destructor
-  delete fClusterNIndexes;
-  delete fClusterPIndexes;             
-}
-
-/*******************************************************/
-
-AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) : 
-    TObject(package),
-fClustersN(package.fClustersN),
-fClustersP(package.fClustersP),
-fNclustersN(package.fNclustersN),
-fNclustersP(package.fNclustersP),
-fClusterNIndexes(0),
-fClusterPIndexes(0){
-  // copy constractor
-  Int_t i;  //iterator
-  for ( i =0; i<fNclustersN;i++)
-    {
-      fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
-    }
-  
-  for ( i =0; i<fNclustersP;i++)
-    {
-      fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
-    }
-  
-  
-}
-/*******************************************************/
-
-AliITSpackageSSD&  
-AliITSpackageSSD::operator=( const AliITSpackageSSD & package)
-{
-  //  assignment operator
-  //
-  Int_t i;  //iterator
-  
-  if (this == &package) return *this;
-  fClustersN = package.fClustersN;
-  fClustersP = package.fClustersP;
-  
-  fNclustersN= package.fNclustersN;
-  fNclustersP= package.fNclustersP;
-  
-  for ( i =0; i<fNclustersN;i++)
-    {
-      fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
-    }
-  
-  for ( i =0; i<fNclustersP;i++)
-    {
-      fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
-    }
-  
-  if (fgkDebug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
-  
-  return *this; 
-  
-}
-
-/*******************************************************/
-
-Int_t AliITSpackageSSD::GetNSideClusterIdx(Int_t index) const
-{
-  // get N-side cluster
-  // 
-  if ((index>-1)&&(index<fNclustersN))
-    return (*fClusterNIndexes)[index];
-  else 
-    {
-      cout << "AliITSpackageSSD::GetNSideClusterIdx  : Out of Range\n";
-      return -1;
-    }
-}
-/*******************************************************/
-
-
-Int_t AliITSpackageSSD::GetPSideClusterIdx(Int_t index) const
-{
-  // get P-side cluster
-  //
-  if ((index>-1)&&(index<fNclustersP))
-    return (*fClusterPIndexes)[index];
-  else 
-    {
-      cout << "AliITSpackageSSD::GetPSideClusterIdx  : Out of Range\n";
-      return -1;
-    } 
-}
-/*******************************************************/
-AliITSclusterSSD*  
-AliITSpackageSSD::GetPSideCluster(Int_t index)
-{
-  // get Pside cluster from the TClonesArray of SSD clusters
-  //
-  return (AliITSclusterSSD*)((*fClustersP)[GetPSideClusterIdx(index)]);
-}
-
-/*******************************************************/
-
-AliITSclusterSSD*  
-AliITSpackageSSD::GetNSideCluster(Int_t index)
-{
-  // get Nside cluster from the TClonesArray of SSD clusters
-  //
-  return (AliITSclusterSSD*)((*fClustersN)[GetNSideClusterIdx(index)]);
-}
-
-
-/*******************************************************/
-
-Bool_t AliITSpackageSSD::GetClusterWithOneCross
-(Int_t & index, Bool_t& side)
-{
-  // select clusters with on cross 
-  //
-  if((fNclustersP==0)||(fNclustersN==0) )
-    {
-      printf("Empty package ((fNclustersP==0)||(fNclustersN==0))\n");
-      index = -2;
-      return kFALSE;
-    } 
-  Int_t ind;
-  
-  ind =(*fClusterPIndexes)[fNclustersP-1]; 
-  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo()  ) ==1 )
-    {
-      //index=ind;
-      index =fNclustersP-1; 
-      side=fgkSIDEP;
-      return kTRUE;
-    }
-  
-  ind =(*fClusterNIndexes)[fNclustersN-1]; 
-  if (  (  ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo() ) ==1  )
-    {
-      //index=ind;
-      index = fNclustersN-1;
-      side=fgkSIDEN;
-      return kTRUE;
-    }
-  
-  
-  ind =(*fClusterPIndexes)[0];
-  if (  ( ((AliITSclusterSSD*)(*fClustersP)[ind]  )->GetCrossNo() ) ==1 )
-    {
-      //index=ind;
-      index = 0;
-      side=fgkSIDEP;
-      return kTRUE;
-    }
-  
-  
-  ind =(*fClusterNIndexes)[0];
-  if (  ( ((AliITSclusterSSD*)(*fClustersN)[ind]  )->GetCrossNo()  ) ==1  )
-    {
-      //    index=ind;
-      index = 0;  
-      side=fgkSIDEN;
-      return kTRUE;
-    }
-  
-  
-  //Add for to be shure 
-  index = -1;
-  return kFALSE;
-  
-}
-/*******************************************************/
-
-void AliITSpackageSSD::DelCluster(Int_t index, Bool_t side)
-{
-  // call DelPCluster or DelNCluster depending on side
-  //
-  if(side==fgkSIDEP) DelPCluster(index); else DelNCluster(index);
-}
-/*******************************************************/
-void AliITSpackageSSD::DelPCluster(Int_t index)
-{
-  //it not deletes delete given cluster physically, 
-  //but only complytely erase it from package
-  //all clusters are deleted automatically when TClonesArray is deleted
-  
-  Int_t i;
-  Int_t idx;
-  Int_t clToDelIdx = GetPSideClusterIdx(index); //Index of cluster in TClonesArray 
-  AliITSclusterSSD *clToDel = GetPSideCluster(index); //cluster to be deleted
-  Int_t ncr = clToDel->GetCrossNo();
-  
-  for (i =0;i<ncr;i++)
-    {
-      idx = clToDel->GetCross(i);
-      ((AliITSclusterSSD *)((*fClustersN)[idx])   )->DelCross(clToDelIdx);
-    }
-  
-  
-  for (i=index;i<fNclustersP-1;i++)
-    {
-      (*fClusterPIndexes)[i]=(*fClusterPIndexes)[i+1];
-    }
-  fNclustersP--; 
-  if (fgkDebug) cout<<"Cluster P ("<<index<<") deleted\n";
-  
-  
-  for (i=0;i<fNclustersN;i++)
-    {
-      if ( (GetNSideCluster(i)->GetCrossNo())==0) DelNCluster(i);
-    }
-}
-
-
-
-/*******************************************************/
-void AliITSpackageSSD::DelNCluster(Int_t index)
-{
-  //it not deletes delete given cluster physically, 
-  //but only complytely erase it from package
-  //all clusters are deleted automatically when TClonesArray is deleted
-  
-  Int_t i;
-  Int_t idx;
-  Int_t clToDelIdx = GetNSideClusterIdx(index); //Index of cluster in TClonesArray 
-  AliITSclusterSSD *clToDel = GetNSideCluster(index); //cluster to be deleted
-  Int_t ncr = clToDel->GetCrossNo();
-  
-  for (i =0;i<ncr;i++)
-    {
-      idx = clToDel->GetCross(i);
-      ((AliITSclusterSSD *)((*fClustersP)[idx])   )->DelCross(clToDelIdx);
-    }
-  
-  
-  for (i=index;i<fNclustersN-1;i++)
-    {
-      (*fClusterNIndexes)[i]=(*fClusterNIndexes)[i+1];
-    }
-  fNclustersN--; 
-  if (fgkDebug) cout<<"Cluster N ("<<index<<") deleted\n";
-  
-  for (i=0;i<fNclustersP;i++)
-    {
-      if ( (GetPSideCluster(i)->GetCrossNo())==0) DelPCluster(i);
-    }
-  
-}
-
-
-/*******************************************************/
-
-void AliITSpackageSSD::DelPClusterOI(Int_t index)
-{
-  //This function looks like this, 
-//because probably cut cluster is 
-//on the beginning or on the end of package 
- Int_t i;
- if( ((*fClusterPIndexes)[0]) == index) 
-  {
-    DelPCluster(0);
-    return;
-  }
- else
-  { 
-   if( ((*fClusterPIndexes)[fNclustersP-1]) ==index)
-    {
-      DelPCluster(fNclustersP-1);
-      return;
-    }
-   else
-    {
-     for (i=1;i<fNclustersP-1;i++)
-       {
-         if( ((*fClusterPIndexes)[i])==index)
-         {
-            DelPCluster(i);
-            return;
-         }
-       }
-    }
-  }
- cout<<"AliITSpackageSSD - DelPClusterOI: index "<<index<<" not found\n";
-
-}
-
-
-/*******************************************************/
-
-void AliITSpackageSSD::DelNClusterOI(Int_t index)
-{
-//This function looks like this, 
-//because probably cluster to cut is 
-//on the beginning or on the end of package 
-
- Int_t i;
- if( ((*fClusterNIndexes)[0])==index) 
-  {
-    DelNCluster(0);
-    return;
-  }
- else
-  { 
-   if( ((*fClusterNIndexes)[fNclustersN-1])==index)
-    {
-      DelNCluster(fNclustersN-1);
-      return;
-    }
-   else
-    {
-     for (i=1;i<fNclustersN-1;i++)
-       {
-         if( ((*fClusterNIndexes)[i])==index)
-         {
-          DelNCluster(i);
-          return;
-         }
-       }
-    }
-  }
- cout<<"AliITSpackageSSD - DelNClusterOI: index "<<index<<" not found\n";
-}
-
-
-/*******************************************************/
-
-
-void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
-{
-  // delete cluster
- if (side == fgkSIDEP)
-  {    
-    DelPClusterOI(index);
-  } 
-  else
-  {
-    DelNClusterOI(index);
-  }
-
-}
-
-
-/**********************************************/
-
-
-void  AliITSpackageSSD::GetAllCombinations(Int_t**array,Int_t &num,Int_t sizet)
-{
-  // get all combinations
-  Int_t *takenNcl = new Int_t[fNclustersN];
-  
-  num=0;
-  
-  if (fgkDebug) PrintClusters();
-
-  for (Int_t i=0;i<fNclustersP;i++)
-   {
-     takenNcl[i]=-1;
-   }
-  //see comment on the beginning of MakeCombin
-  if (fgkDebug) cout<<"GetAllCombinations entered";
-  MakeCombin (array,num,0,takenNcl,sizet);
-
-  delete []takenNcl; 
-}
-/**********************************************/
-
-
-void  AliITSpackageSSD::MakeCombin
-   (Int_t**arr,Int_t& nu, Int_t np, Int_t *occup, Int_t sizet)
-
-{
-//ATTENTION: anybody watching this function
-//AliITSclusterSSD::GetCrossNo() returns index of cluster in main array belonging to AliITSmodulesSSD
-//however, we have pointer to that array (TClonesArray)
-//we can not use 
-//Get?SideCluster because it takes index from local look_up_table
- Int_t i,j;
- //this cluster
- AliITSclusterSSD *cl=GetPSideCluster(np);
-
- Int_t nc = cl->GetCrossNo();  //number of crosses for this cluster
- Int_t indcro;                 //index of given cluster on side N that 
-                               // this cluster crosses with
-   
- if (np == fNclustersP-1) {
-   for (i=0;i<nc;i++) {
-     indcro=cl->GetCross(i);
-     if(IsFree(indcro,np,occup)) {
-        occup[np]=indcro;
-        for(j=0;j<fNclustersP;j++)  
-        {
-          if (nu<sizet) arr[nu][j]=occup[j];
-          else {
-              continue;}
-        }
-      
-        occup[np]=-1;
-        if (nu<sizet-1) nu++;
-     }
-   }
-  } else {
-    for (i=0;i<nc;i++) {
-       indcro=cl->GetCross(i);
-       if(IsFree(indcro,np,occup)) {
-         occup[np]=indcro;
-         if (nu<sizet) MakeCombin(arr,nu,(np+1),occup,sizet);
-         //else printf("MakeComb - exceeding array size!\n");
-       }
-    }
-    occup[np]=-1;
-  } 
-
-}
-
-/**********************************************/
-Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, const Int_t *lis) const
-{
-  // 
-  for (Int_t i=0;i<nn;i++)
-    {
-      if (lis[i]==idx) return kFALSE;
-    }
-  return kTRUE;
-}
-
-/**********************************************/
-void AliITSpackageSSD::PrintClusters()
-{
-  // print cluster info
-Int_t i,j;
-cout<<"SIDE P\n";
-for (i=0;i<fNclustersP;i++)
- {
-   cout<<i<<".  IO="<<GetPSideClusterIdx(i)<<" NC="<<GetPSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
-   for (j=0;j<GetPSideCluster(i)->GetCrossNo();j++)
-    {
-      cout<<GetPSideCluster(i)->GetCross(j)<<" ";
-    }
- //  if (GetPSideCluster(i)->GetSide()) cout<<" P\n";
- //  else cout<<"BAD SIDE ==N\n";
-    cout<<"\n";
-   
- }
-
-cout <<"SIDE N\n";
-for (i=0;i<fNclustersN;i++)
- {
-   cout<<i<<".  IO="<<GetNSideClusterIdx(i)<<" NC="<<GetNSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
-   for (j=0;j<GetNSideCluster(i)->GetCrossNo();j++)
-    {
-      cout<<GetNSideCluster(i)->GetCross(j)<<" ";
-    }
- //  if (GetNSideCluster(i)->GetSide()) cout<<" N\n";
- //  else cout<<"BAD SIDE ==P\n";
-    cout<<"\n";   
- }
-}
-
-/**********************************************/
-void AliITSpackageSSD::ConsumeClusters()
-{
-  // consume cluster
-  register Int_t i;
-  
-  for(i=0;i<fNclustersP;i++)
-    {
-      GetPSideCluster(i)->Consume();
-    }
-  
-  for(i=0;i<fNclustersN;i++)
-    {
-      GetNSideCluster(i)->Consume();
-    }
-  
-}
-
-/**********************************************/
-
-Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI) const
-{
- //Returns index of next P cluster OI in package; OI == Original Inedx (in TClonesArray)
- //if not egsist return -1;
- for (Int_t i =0; i<fNclustersP-1;i++)
-  {
-    if(GetPSideClusterIdx(i) == OI)
-       return GetPSideClusterIdx(i+1);
-  }
- return -1;
-}
-
-/**********************************************/
-Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI) const
-{
- //Returns index of previous P cluster  OI in package; OI == Original Inedx (in TClonesArray)
- //if not egsist return -1;
- for (Int_t i =1; i<fNclustersP;i++)
-  {
-    if(GetPSideClusterIdx(i) == OI)
-       return GetPSideClusterIdx(i-1);
-  }
-  return -1;
-}
-/**********************************************/
-Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI) const
-{
-//Returns index of next N cluster OI in package; OI == Original Inedx (in TClonesArray)
- //if not egsist return -1;
- for (Int_t i =0; i<fNclustersN-1;i++)
-  {
-    if(GetNSideClusterIdx(i) == OI)
-       return GetNSideClusterIdx(i+1);
-  }
- return -1;
-
-}
-/**********************************************/
-Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI) const
-{
- //Returns index of previous N cluster OI in package; OI == Original Inedx (in TClonesArray)
- //if not egsist return -1;
- for (Int_t i =1; i<fNclustersN;i++)
-  {
-    if(GetNSideClusterIdx(i) == OI)
-       return GetNSideClusterIdx(i-1);
-  }
-  return -1;
-}
-
-void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
-{
-  // split package of clusters
-  Int_t p=-1, n=-1;
-  Int_t i;
-  for (i=0;i<fNclustersN;i++)
-   {
-     if((*fClusterNIndexes)[i]==ni) 
-      {
-        n = i;
-       break;
-      }
-    } 
-   
-  for (i=0;i<fNclustersP;i++)
-   {
-     if((*fClusterPIndexes)[i]==pi) 
-      {
-        p = i;
-       break;
-      }
-    }  
-  if (fgkDebug) {
-    cout<<" p = "<<p<<"  n = "<<n;
-  }
-  if ((p==-1)||(n==-1)) return;
-  
-  for (i=p;i<fNclustersP;i++)
-   {
-     pkg->AddPSideCluster(GetPSideClusterIdx(i));       
-   }
-  fNclustersP = p;
-  
-  for (i=n;i<fNclustersN;i++)
-   {
-     pkg->AddNSideCluster(GetNSideClusterIdx(i));       
-   }
-  fNclustersN = n;
-  cout<<"  After split: fNclustersP = "<< fNclustersP<< "fNclustersN = "<< fNclustersN<<"\n";
-}
diff --git a/ITS/AliITSpackageSSD.h b/ITS/AliITSpackageSSD.h
deleted file mode 100644 (file)
index 3228d6c..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-#ifndef ALIITSPACKAGESSD_H
-#define ALIITSPACKAGESSD_H
-//Class describing set of AliITSoneSideClusterSSDs, which contact each other.
-//Piotr Krzysztof Skowronski
-//Warsaw University of Technology
-//skowron@if.pw.edu.pl
-//
-#include "TObject.h"
-#include "TArrayI.h"
-
-//#include "AliITSclusterSSD.h"
-
-class AliITSclusterSSD;
-
-//-------------------------------------------------------------------
-
-class AliITSpackageSSD : public TObject
-{
- public:
-  AliITSpackageSSD(); 
-
-  AliITSpackageSSD(Int_t len, TClonesArray *clustersP, TClonesArray *clustersN);  
-  AliITSpackageSSD(TClonesArray *clustersP, TClonesArray *clustersN);  
-
-  ~AliITSpackageSSD();
-  
-  AliITSpackageSSD(const AliITSpackageSSD &package); 
-  AliITSpackageSSD&  operator=( const AliITSpackageSSD & package);
-  //Add cluster in side N, clindex is an index of this cluster in TClonesArray
-  
-  void     AddNSideCluster(Int_t clindex) {(*fClusterNIndexes)[fNclustersN++]=clindex;} 
-  void     AddPSideCluster(Int_t clindex) {(*fClusterPIndexes)[fNclustersP++]=clindex;} 
-
-  void     AddCluster(Int_t clindex, Bool_t side){
-             (side)?(*fClusterNIndexes)[fNclustersN++]= 
-                   clindex:(*fClusterPIndexes)[fNclustersP++]=clindex;}
-       
-//Returns index of one side cluster in TClonesArray, NOT AliITSclusterSSD
-  Int_t    GetNSideClusterIdx(Int_t index) const; //input index is number of cluster in this package 
-  Int_t    GetPSideClusterIdx(Int_t index) const; //returns index in TClonesArray
-  Int_t    GetClusterIdx(Int_t index,Bool_t side) const 
-               {return (side)?GetPSideClusterIdx(index):GetNSideClusterIdx(index);}
-  AliITSclusterSSD*    GetNSideCluster(Int_t index);
-  AliITSclusterSSD*    GetPSideCluster(Int_t index); //index is 
-  AliITSclusterSSD*    GetCluster(Int_t index, Bool_t side)
-               {return (side)?GetPSideCluster(index):GetNSideCluster(index);}
-                       
-  Int_t    GetNextPIdx(Int_t OI) const; //Returns index of next P cluster in package; OI == Original Inedx (in TClonesArray)
-  Int_t    GetPrvPIdx(Int_t OI) const;  //Returns index of previous P cluster in package; OI == Original Inedx (in TClonesArray)
-  Int_t    GetNextNIdx(Int_t OI) const; //Returns index of next N cluster in package; OI == Original Inedx (in TClonesArray)
-  Int_t    GetPrvNIdx(Int_t OI) const;  //Returns index of previous N cluster in package; OI == Original Inedx (in TClonesArray)
-  
-  Int_t    GetNumOfClustersN() const {return fNclustersN;}  
-  Int_t    GetNumOfClustersP() const {return fNclustersP;}   
-  Int_t    GetNumOfClusters() const {return fNclustersP+fNclustersN;}  
-  Int_t    GetNumOfClusters(Bool_t side) const {return (side)?fNclustersP:fNclustersN;}
-  
-  //returns number of clusters belonging to package,
-  //that crosses with only one cluster on the other side 
-  //There might be only 2 such a clusters:
-  //on the begining and on the end of the package
-  //
-  Bool_t    GetClusterWithOneCross(Int_t & index, Bool_t& side );  
-  void      DelCluster(Int_t index, Bool_t side);
-  void      DelPCluster(Int_t index);
-  void      DelNCluster(Int_t index);
-  void      DelClusterOI(Int_t index, Bool_t side); //OI indicates that it is Original Index
-  void      DelPClusterOI(Int_t index); //it means value in look up table
-  void      DelNClusterOI(Int_t index);  
-  
-  void      SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg);
-  void      GetAllCombinations(Int_t**array,Int_t &num,Int_t size);
-  
-  void      ConsumeClusters();
-  void      PrintClusters();
-  
-protected:
-  
-  TClonesArray *fClustersN;   //Pointer to array of clusters - only to have direct acces to 
-  TClonesArray *fClustersP;   //clusters
-  Int_t    fNclustersN;       // number of N clusters
-  Int_t    fNclustersP;       // number of P cluster
-  TArrayI *fClusterNIndexes;  // array of pointers to the N clusters
-  TArrayI *fClusterPIndexes;  // array of pointers to the P clusters
-
-  static const Bool_t fgkSIDEP;  // boolean for P side 
-  static const Bool_t fgkSIDEN;  // boolean for N side
-  static const Int_t fgkDebug=0;    // debugging flag
-
-
-/***************/
-/*   Methods   */
-/***************/
-
-  
-  void    MakeCombin(Int_t**arr, Int_t& nu, Int_t np, Int_t *occup,Int_t size);
-  Bool_t  IsFree(Int_t idx, Int_t nn, const Int_t *lis) const;
-  
-
-                
-private:
-                
-//-------------------------------------------------------               
-  ClassDef(AliITSpackageSSD,1) 
-};
-
-#endif
diff --git a/ITS/AliITSvBeamTestITS04.cxx b/ITS/AliITSvBeamTestITS04.cxx
deleted file mode 100644 (file)
index 076d08f..0000000
+++ /dev/null
@@ -1,645 +0,0 @@
-////////////////////////////////////////////////////////
-// ITS geometry class and step manager for the        //
-//   integrated ITS test beam of Nov. 04              //
-//  Author: mercedes.lopez.noriega@cern.ch            //
-////////////////////////////////////////////////////////
-
-
-#include "AliITS.h"
-#include "AliITSgeom.h"
-#include "AliITShit.h"
-#include "AliITSvBeamTestITS04.h"
-#include "AliMC.h"
-#include "AliMagF.h"
-#include "AliRun.h"
-#include "AliTrackReference.h"
-
-#include <TVirtualMC.h>
-#include <TClonesArray.h>
-#include <TGeoGlobalMagField.h>
-#include <TGeoManager.h>
-#include <TGeoMatrix.h>
-#include <TGeoPcon.h>
-#include <TGeoVolume.h>
-#include <TLorentzVector.h>
-#include <TString.h>
-
-const Int_t AliITSvBeamTestITS04::fgkNumberOfSPD = 4;
-const Int_t AliITSvBeamTestITS04::fgkNumberOfSDD = 2;
-const Int_t AliITSvBeamTestITS04::fgkNumberOfSSD = 4;
-// Dimension (thickness:Y (beam direction), width:X, length:Z)
-
-const char*    AliITSvBeamTestITS04::fgSPDsensitiveVolName = "ITSspdSensitiv";
-//dimensions (preliminary values from Petra (in cms))
-const Double_t AliITSvBeamTestITS04::fgkSPDthickness    = 0.02;
-const Double_t AliITSvBeamTestITS04::fgkSPDwidth        = 1.4; 
-const Double_t AliITSvBeamTestITS04::fgkSPDlength       = 7.2;
-const Double_t AliITSvBeamTestITS04::fgkSPDthickSens    = 0.02;
-const Double_t AliITSvBeamTestITS04::fgkSPDwidthSens    = 1.2; 
-const Double_t AliITSvBeamTestITS04::fgkSPDlengthSens   = 7.0;
-//position
-const Double_t AliITSvBeamTestITS04::fgkSPD0y = 23.7;
-const Double_t AliITSvBeamTestITS04::fgkSPD1y = 33.7;
-
-//===
-const char*    AliITSvBeamTestITS04::fgSDDsensitiveVolName = "ITSsddSensitiv";
-//dimensions (preliminary values from Ludovic (in cms))
-const Double_t AliITSvBeamTestITS04::fgkSDDthickness     = 0.03;
-const Double_t AliITSvBeamTestITS04::fgkSDDwidth         = 7.22;
-const Double_t AliITSvBeamTestITS04::fgkSDDlength        = 8.76;
-const Double_t AliITSvBeamTestITS04::fgkSDDthickSens     = 0.02998;
-const Double_t AliITSvBeamTestITS04::fgkSDDwidthSens     = 7.017;
-const Double_t AliITSvBeamTestITS04::fgkSDDlengthSens    = 7.497;
-//position
-const Double_t AliITSvBeamTestITS04::fgkSDD0y = 51.7;
-const Double_t AliITSvBeamTestITS04::fgkSDD1y = 57.2;
-
-//===
-const char*    AliITSvBeamTestITS04::fgSSDsensitiveVolName = "ITSssdSensitiv";
-//dimensions (final values from Javier (in cms))
-const Double_t AliITSvBeamTestITS04::fgkSSDthickness    = 0.03;
-const Double_t AliITSvBeamTestITS04::fgkSSDwidth        = 7.7;
-const Double_t AliITSvBeamTestITS04::fgkSSDlength       = 4.4;
-const Double_t AliITSvBeamTestITS04::fgkSSDthickSens    = 0.03;
-const Double_t AliITSvBeamTestITS04::fgkSSDwidthSens    = 7.5;
-const Double_t AliITSvBeamTestITS04::fgkSSDlengthSens   = 4.2;
-//position
-const Double_t AliITSvBeamTestITS04::fgkSSD0y = 73.6;
-const Double_t AliITSvBeamTestITS04::fgkSSD1y = 80.6;
-
-//===============================================================
-
-
-
-ClassImp(AliITSvBeamTestITS04)
-    
-//_____________________________________________________________
-  AliITSvBeamTestITS04::AliITSvBeamTestITS04() : 
-AliITS(),              // Base class
-fITSmotherVolume(0),   // Pointer to ITS mother volume.
-fNspd(fgkNumberOfSPD), //Number of SPD modules
-fNsdd(fgkNumberOfSDD), //Number of SDD modules
-fNssd(fgkNumberOfSSD), //Number of SSD modules
-fGeomDetOut(kFALSE),   // Flag to write .det file out
-fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
-fWrite(),              //! file name to write .det file 
-fRead(),               // file name to read .det file (JC)
-fMajorVersion(kvITS04),// Major Version
-fMinorVersion(1),      // Minor Version
-fIgm(kvITS04)          //! Init geometry object
-{
-    //
-    // Constructor
-    //
-
-    fIdN = 3;         
-    fIdName    = new TString[fIdN];
-    fIdName[0] = fgSPDsensitiveVolName;
-    fIdName[1] = fgSDDsensitiveVolName;
-    fIdName[2] = fgSSDsensitiveVolName;
-    fIdSens    = new Int_t[fIdN];
-    for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
-    
-    for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
-}
-//_____________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title):
-AliITS(name,title),   // Base class
-fITSmotherVolume(0),   // Pointer to ITS mother volume.
-fNspd(fgkNumberOfSPD), //Number of SPD modules
-fNsdd(fgkNumberOfSDD), //Number of SDD modules
-fNssd(fgkNumberOfSSD), //Number of SSD modules
-fGeomDetOut(kFALSE),   // Flag to write .det file out
-fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
-fWrite(),              //! file name to write .det file 
-fRead(),               // file name to read .det file (JC)
-fMajorVersion(kvITS04),// Major Version
-fMinorVersion(1),       // Minor Version
-fIgm(kvITS04)          //! Init geometry object
-{
-    //
-    // Constructor
-    //
-
-    fIdN = 3;         
-    fIdName    = new TString[fIdN];
-    fIdName[0] = fgSPDsensitiveVolName;
-    fIdName[1] = fgSDDsensitiveVolName;
-    fIdName[2] = fgSSDsensitiveVolName;
-    fIdSens    = new Int_t[fIdN];
-    for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
-    for(Int_t a=0;a<60;a++) fWrite[a] = '\0';    
-}
-//__________________________________________________________________
-AliITSvBeamTestITS04::~AliITSvBeamTestITS04(){
-    //
-    // Destructor
-    //
-}
-//______________________________________________________________________
-void AliITSvBeamTestITS04::CreateMaterials(){
-    // Media defined here should correspond to the one defined in galice.cuts
-    // This file is read in (AliMC*) fMCApp::Init() { ReadTransPar(); }
-    // Create ITS materials
-    Int_t   ifield = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
-    Float_t fieldm = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
-    
-    Float_t tmaxfdSi = 0.1;
-    Float_t stemaxSi = 0.0075;
-    Float_t deemaxSi = 0.1;
-    Float_t epsilSi  = 1.0E-4;
-    Float_t stminSi  = 0.0;
-    
-    Float_t tmaxfdAir = 0.1;
-    Float_t stemaxAir = .10000E+01;
-    Float_t deemaxAir = 0.1;
-    Float_t epsilAir  = 1.0E-4;
-    Float_t stminAir  = 0.0;
-    // AIR
-    Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
-    Float_t zAir[4]={6.,7.,8.,18.};
-    Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
-    Float_t dAir = 1.20479E-3;
-    
-    AliMaterial(51,"ITSspdSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
-    AliMedium(51,"ITSspdSi",51,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    
-    AliMaterial(1,"ITSsddSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
-    AliMedium(1,"ITSsddSi",1,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    
-    //AliMaterial(?,"ITSssdSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
-    //AliMedium(?,"ITSssdSi",51,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    
-    AliMixture(5,"ITSair",aAir,zAir,dAir,4,wAir);
-    AliMedium(5,"ITSair",5,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,epsilAir,stminAir);
-    
-//NEED TO ADD PLASTIC OF SCINTILLATORS!!
-
-}
-
-//______________________________________________________________________
-void AliITSvBeamTestITS04::CreateGeometry(){    
-    //Creates geometry
-    // These constant character strings are set by cvs during commit
-    // do not change them unless you know what you are doing!
-    const Char_t *cvsDate="$Date$";
-    const Char_t *cvsRevision="$Revision$";
-    TGeoManager *geoManager = gGeoManager;
-    TGeoVolume *vALIC = geoManager->GetTopVolume();
-    
-    //================================
-    //       ITS mother volume
-    //================================
-    TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
-    // DefineSection(section number, Z, Rmin, Rmax).
-    sITS->DefineSection(0,-100.0,0.01,100.0); // Units in cms
-    sITS->DefineSection(1,+100.0,0.01,100.0);
-    
-    TGeoMedium *air = geoManager->GetMedium("ITSair");
-    fITSmotherVolume = new TGeoVolume("ITSV",sITS,air);
-    const Int_t kLength=100;
-    Char_t vstrng[kLength];
-    if(fIgm.WriteVersionString(vstrng,kLength,(AliITSVersion_t)IsVersion(),
-                               fMinorVersion,cvsDate,cvsRevision))
-        fITSmotherVolume->SetTitle(vstrng);
-    else Error("CreateGeometry","Error writing/setting version string");
-    //printf("Title set to %s\n",vstrng);
-    if(vALIC==0) {
-        Error("CreateGeometry","alic=0");
-        return;
-    } // end if
-    fITSmotherVolume->SetVisibility(kFALSE);
-    vALIC->AddNode(fITSmotherVolume,1,0);
-    
-//     //Scintillators
-//     TGeoMedium *plasticScint = new TGeoMedium("plasticScint",1,Plastic);
-//     //First Scintillator
-//     TGeoBBox *Scint1Shape = new TGeoBBox("Scint1Shape",0.5,0.1,0.5,0); //1x1cm
-//     TGeoVolume *Scint1 = new TGeoVolume("Scint1",Scint1Shape,plasticScint);
-//     TGeoTranslation *firstScint = new TGeoTranslation(0,0.7,0);
-//     vALIC->AddNode(Scint1,2,firstScint);
-//     //Second Scintillator
-//     TGeoBBox *Scint2Shape = new TGeoBBox("Scint2Shape",1.,0.1,1.,0); //2x2cm
-//     TGeoVolume *Scint2 = new TGeoVolume("Scint2",Scint2Shape,plasticScint);
-//     TGeoTranslation *secondScint = new TGeoTranslation(0,90.,0);
-//     vALIC->AddNode(Scint2,3,secondScint);
-    
-    AddSPDGeometry(fITSmotherVolume);
-    AddSDDGeometry(fITSmotherVolume);
-    AddSSDGeometry(fITSmotherVolume);
-}
-
-//______________________________________________________________________
-void AliITSvBeamTestITS04::Init()
-{
-    // Initialize the ITS after it has been created.
-    // Inputs:
-    //   none.
-    // Outputs:
-    //   none.
-    // Return:
-    //   none.
-
-    AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion,
-                 fMinorVersion));
-    //
-    UpdateInternalGeometry();
-    AliITS::Init();
-    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
-
-    //
-}
-/*
-//______________________________________________________________________
-void AliITSvBeamTestITS04::InitAliITSgeom()
-{    
-  //initialisation of ITSgeom
-    const Int_t knlayers = 6;
-    Int_t nlad[knlayers], ndet[knlayers];
-    
-    nlad[0] = 1; ndet[0] = 2;
-    nlad[1] = 1; ndet[1] = 2;
-    nlad[2] = 1; ndet[2] = 1;
-    nlad[3] = 1; ndet[3] = 1;
-    nlad[4] = 1; ndet[4] = 2;
-    nlad[5] = 1; ndet[5] = 2;
-
-    Int_t nModTot = fNspd + fNsdd + fNssd;
-    if (GetITSgeom()) SetITSgeom(0x0);
-    AliITSgeom* geom = new AliITSgeom(0,knlayers,nlad,ndet,nModTot);
-    SetITSgeom(geom);
-    // *** Set default shapes 
-    const Float_t kDxyzSPD[] = {fgkSPDwidthSens/2, fgkSPDthickSens/2,fgkSPDlengthSens/2};  
-    if(!(GetITSgeom()->IsShapeDefined(kSPD)))
-       GetITSgeom()->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
-    
-    const Float_t kDxyzSDD[] = {fgkSDDwidthSens/2., fgkSDDthickSens/2.,fgkSDDlengthSens/2.};
-    if(!(GetITSgeom()->IsShapeDefined(kSDD)))
-       GetITSgeom()->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
-    
-    const Float_t kDxyzSSD[] = {fgkSSDlengthSens/2, fgkSSDthickSens/2,fgkSSDwidthSens/2};
-    if(!(GetITSgeom()->IsShapeDefined(kSSD)))
-       GetITSgeom()->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
-    
-    // Creating the matrices in AliITSgeom for each sensitive volume
-    // (like in AliITSv11GeometrySDD) mln
-    // Here, each layer is one detector
-    
-    char layerName[30];
-    Int_t startMod = 0;
-    
-    // SPD
-    for (Int_t i=0; i<fNspd;i++) {
-       sprintf(layerName, "ITSspdWafer_%i",i+1);
-       TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           if ((i+1==2)||(i+1==4)) iDet = 2;
-           Int_t iLad = 1;
-           Int_t iLay = 1;
-           if (i+1>2) iLay = 2;
-           GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
-           startMod++;
-       };
-    };
-    
-    // SDD
-    for (Int_t i=0; i<fNsdd;i++) {
-       sprintf(layerName, "ITSsddWafer_%i",i+fNspd+1);
-       TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           Int_t iLad = 1;
-           Int_t iLay = fNspd-1+i;
-           GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
-           startMod++;
-       };
-    };
-    
-    // SSD
-    for (Int_t i=0; i<fNssd;i++) {
-       sprintf(layerName, "ITSssdWafer_%i",i+fNspd+fNsdd+1);
-       TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
-       if (layNode) {
-           TGeoHMatrix layMatrix(*layNode->GetMatrix());           
-           Double_t *trans  = layMatrix.GetTranslation();
-           Double_t *r      = layMatrix.GetRotationMatrix();
-           Double_t rot[10] = {r[0],r[1],r[2],
-                               r[3],r[4],r[5],
-                               r[6],r[7],r[8], 1.0};
-           Int_t iDet = 1;
-           if ((i+1==2)||(i+1==4)) iDet = 2;
-           Int_t iLad = 1;
-           Int_t iLay = 5;
-           if (i+1>2) iLay = 6;
-           GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
-           startMod++;
-       };
-    };
-    
-    return;
-}
-//______________________________________________________________________
-void AliITSvBeamTestITS04::SetDefaults()
-{
-    // (from AliITSv11) mln
-    
-    const Float_t kconv = 1.0e+04; // convert cm to microns
-    
-    if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
-    fDetTypeSim->SetITSgeom(GetITSgeom());
-    fDetTypeSim->ResetCalibrationArray();
-    fDetTypeSim->ResetSegmentation();
-    AliITSgeomSPD *s0;
-    AliITSgeomSDD *s1;
-    AliITSgeomSSD *s2;
-    Int_t i;
-    Float_t bx[256],bz[280];
-
-    // If fGeomDetIn is set true the geometry will
-    // be initialised from file (JC)
-    if(GetITSgeom()!=0) SetITSgeom(0x0);
-    AliITSgeom* geom = new AliITSgeom();
-    SetITSgeom(geom);
-    if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead);
-    if(!fGeomDetIn) this->InitAliITSgeom();
-    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
-
-   
-    // SPD
-
-    s0 = (AliITSgeomSPD*) GetITSgeom()->GetShape(kSPD);// Get shape info.
-    if (s0) {
-       AliITSCalibration *resp0=new AliITSCalibrationSPD();
-       SetCalibrationModel(kSPD,resp0);
-
-       AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD();
-       seg0->SetDetSize(s0->GetDx()*2.*kconv, // base this on AliITSgeomSPD
-                        s0->GetDz()*2.*kconv, // for now.
-                        s0->GetDy()*2.*kconv);// x,z,y full width in microns.
-       seg0->SetNPads(256,160);               // Number of Bins in x and z
-       for(i=000;i<256;i++) bx[i] =  50.0;    // in x all are 50 microns.
-       for(i=000;i<160;i++) bz[i] = 425.0;    // most are 425 microns except below
-       for(i=160;i<280;i++) bz[i] =   0.0;    // Outside of detector.
-       bz[ 31] = bz[ 32] = 625.0;             // first chip boundry
-       bz[ 63] = bz[ 64] = 625.0;             // first chip boundry
-       bz[ 95] = bz[ 96] = 625.0;             // first chip boundry
-       bz[127] = bz[128] = 625.0;             // first chip boundry
-       bz[160] = 425.0;                       // Set so that there is no zero pixel size for fNz.
-       seg0->SetBinSize(bx,bz);               // Based on AliITSgeomSPD for now.
-       SetSegmentationModel(kSPD,seg0);
-    }
-  
-    // SDD
-   
-    s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);// Get shape info.
-    if (s1) {
-      AliITSCalibrationSDD *resp1=new AliITSCalibrationSDD("simulated");
-      SetCalibrationModel(kSDD,resp1);
-      AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD();
-      seg1->SetDetSize(s1->GetDx()*kconv, // base this on AliITSgeomSDD
-                      s1->GetDz()*4.*kconv, // for now.
-                      s1->GetDy()*4.*kconv); // x,z,y full width in microns.
-      seg1->SetDriftSpeed(AliITSDriftSpeedSDD::DefaultDriftSpeed());
-      seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
-      SetSegmentationModel(kSDD,seg1);
-    }
-    
-    // SSD
-    
-    s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);// Get shape info. Do it this way for now.
-    if (s2) {
-      AliITSCalibration *resp2=new AliITSCalibrationSSD("simulated");
-      SetCalibrationModel(kSSD,resp2);
-
-      AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD();
-      seg2->SetDetSize(s2->GetDx()*2.*kconv, // base this on AliITSgeomSSD
-                      s2->GetDz()*2.*kconv, // for now.
-                      s2->GetDy()*2.*kconv); // x,z,y full width in microns.
-      seg2->SetPadSize(95.,0.); // strip x pitch in microns
-      seg2->SetNPads(768,0); // number of strips on each side.
-      seg2->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
-      SetSegmentationModel(kSSD,seg2); 
-    }
-    
-  if(fgkNTYPES>3){Warning("SetDefaults","Only the four basic detector types are initialised!");}
-  return;
-}
-*/
-//______________________________________________________________________
-void AliITSvBeamTestITS04::AddSPDGeometry(TGeoVolume *moth) const
-{
-  //Adds SPD geometry
-    TGeoMedium *siliconSPD = gGeoManager->GetMedium("ITSspdSi");
-    
-    //outer volume
-    TGeoBBox *waferSPDshape = new TGeoBBox("ITSspdWaferShape",fgkSPDwidth/2,fgkSPDthickness/2,fgkSPDlength/2,0);
-    TGeoVolume *waferSPD = new TGeoVolume("ITSspdWafer",waferSPDshape,siliconSPD);
-    //sensitive volume
-    TGeoBBox *sensSPDbox = new TGeoBBox("ITSsddSensorSensBox",fgkSPDwidthSens/2,fgkSPDthickSens/2,fgkSPDlengthSens/2,0);
-    TGeoVolume *sensVolSPD = new TGeoVolume(fgSPDsensitiveVolName,sensSPDbox,siliconSPD);
-    waferSPD->AddNode(sensVolSPD, 1, 0); //added to outer volume
-    
-    //locate them in space (with respect top volume)
-    TGeoTranslation *spd1tr = new TGeoTranslation(0,fgkSPD0y,fgkSPDlength/2);
-    TGeoTranslation *spd2tr = new TGeoTranslation(0,fgkSPD0y,-fgkSPDlength/2);
-
-    TGeoTranslation *spd3tr = new TGeoTranslation(0,fgkSPD1y,fgkSPDlength/2);
-    TGeoTranslation *spd4tr = new TGeoTranslation(0,fgkSPD1y,-fgkSPDlength/2);
-    
-    //add to top volume
-    moth->AddNode(waferSPD, 1, spd1tr);
-    moth->AddNode(waferSPD, 2, spd2tr);
-    moth->AddNode(waferSPD, 3, spd3tr);
-    moth->AddNode(waferSPD, 4, spd4tr);
-    
-    //draw options
-    waferSPD->SetLineColor(4);
-    sensVolSPD->SetLineColor(4);
-}
-
-
-//______________________________________________________________________
-void AliITSvBeamTestITS04::AddSDDGeometry(TGeoVolume *moth) const
-{
-  //Adds SDD geometry
-    TGeoMedium *siliconSDD = gGeoManager->GetMedium("ITSsddSi");
-    
-    //outer volume
-    TGeoBBox *waferSDDshape = new TGeoBBox("ITSsddWaferShape",fgkSDDwidth/2,fgkSDDthickness/2,fgkSDDlength/2,0);
-    TGeoVolume *waferSDD = new TGeoVolume("ITSsddWafer",waferSDDshape,siliconSDD);
-    //sensitive volume
-    TGeoBBox *sensSDDbox = new TGeoBBox("ITSsddSensorSensBox",fgkSDDwidthSens/2,fgkSDDthickSens/2,fgkSDDlengthSens/2,0);
-    TGeoVolume *sensVolSDD = new TGeoVolume(fgSDDsensitiveVolName,sensSDDbox,siliconSDD);
-    waferSDD->AddNode(sensVolSDD, 1, 0); //added to outer volume
-    
-    //locate them in space
-    TGeoTranslation *sdd1tr = new TGeoTranslation(0,fgkSDD0y,0);
-    TGeoTranslation *sdd2tr = new TGeoTranslation(0,fgkSDD1y,0);
-        
-    //add to top volume
-    moth->AddNode(waferSDD, fNspd+1, sdd1tr);
-    moth->AddNode(waferSDD, fNspd+2, sdd2tr);
-    
-    //draw options
-    waferSDD->SetLineColor(3);
-    sensVolSDD->SetLineColor(3);
-}
-
-
-//______________________________________________________________________
-void AliITSvBeamTestITS04::AddSSDGeometry(TGeoVolume *moth) const
-{
-  //Adds SSD geometry
-    TGeoMedium *siliconSSD = gGeoManager->GetMedium("ITSspdSi"); // SSD medium still needed!!!
-    
-    //outer volume 
-    TGeoBBox *waferSSDshape = new TGeoBBox("ITSssdWaferShape",fgkSSDwidth/2,fgkSSDthickness/2,fgkSSDlength/2,0);
-    TGeoVolume *waferSSD = new TGeoVolume("ITSssdWafer",waferSSDshape,siliconSSD);
-    //sensitive volume
-    TGeoBBox *sensSSDbox = new TGeoBBox("ITSssdSensorSensBox",fgkSSDwidthSens/2,fgkSSDthickSens/2,fgkSSDlengthSens/2,0);
-    TGeoVolume *sensVolSSD = new TGeoVolume(fgSSDsensitiveVolName,sensSSDbox,siliconSSD);
-    waferSSD->AddNode(sensVolSSD, 1, 0);
-    
-    //locate them in space
-    /* In the SSD, there was an overlap of sensitive volumes of 2.9mm = 0.29cm (0.29/2=0.145) 
-       in the modules in the same plane, therefore the modules where not in the same plane in 
-       the Y direction, there was a "thickness" (0.03cm) difference */
-    TGeoTranslation *ssd1tr = new TGeoTranslation(0,fgkSSD0y,fgkSSDlength/2-0.145);
-    TGeoTranslation *ssd2tr = new TGeoTranslation(0,fgkSSD0y+0.03,-fgkSSDlength/2+0.145);
-
-    TGeoTranslation *ssd3tr = new TGeoTranslation(0,fgkSSD1y,fgkSSDlength/2-0.145);
-    TGeoTranslation *ssd4tr = new TGeoTranslation(0,fgkSSD1y+0.03,-fgkSSDlength/2+0.145);
-
-    //add to top volume
-    moth->AddNode(waferSSD, fNspd+fNsdd+1, ssd1tr);
-    moth->AddNode(waferSSD, fNspd+fNsdd+2, ssd2tr);
-    moth->AddNode(waferSSD, fNspd+fNsdd+3, ssd3tr);
-    moth->AddNode(waferSSD, fNspd+fNsdd+4, ssd4tr);
-    
-    //draw options
-    waferSSD->SetLineColor(2);
-    sensVolSSD->SetLineColor(2);
-}
-
-//______________________________________________________________________
-void AliITSvBeamTestITS04::StepManager()
-{
-    // Called for every step in the ITS, then calles the AliITShit class
-    // creator with the information to be recoreded about that hit.
-
-    // "Standard" StepManager. (Similar to AliITSv11) mln
-    Int_t cpy0,mod,status,id,kk;
-    TLorentzVector position, momentum;
-    static AliITShit hit;// Saves on calls to construtors
-    
-    if(!(this->IsActive())) return;
-    if(!(gMC->TrackCharge())) return;
-    //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
-    TClonesArray &lhits = *(Hits());
-    //
-    // Track status
-    // Track status
-    status = 0;
-    if(gMC->IsTrackInside())      status +=  1;
-    if(gMC->IsTrackEntering())    status +=  2;
-    if(gMC->IsTrackExiting())     status +=  4;
-    if(gMC->IsTrackOut())         status +=  8;
-    if(gMC->IsTrackDisappeared()) status += 16;
-    if(gMC->IsTrackStop())        status += 32;
-    if(gMC->IsTrackAlive())       status += 64;
-    
-    id=gMC->CurrentVolID(cpy0);
-    
-    Bool_t sensvol = kFALSE;
-    for(kk=0;kk<fIdN;kk++) if(id == fIdSens[kk]) sensvol = kTRUE;
-    if(!sensvol) return;
-
-    fIgm.DecodeDetector(mod,gGeoManager->GetMother(1)->GetNumber(),1,1,1);
-    //
-    // Fill hit structure.
-    //
-    hit.SetModule(mod);
-    hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
-    gMC->TrackPosition(position);
-    gMC->TrackMomentum(momentum);
-    hit.SetPosition(position);
-    hit.SetTime(gMC->TrackTime());
-    hit.SetMomentum(momentum);
-    hit.SetStatus(status);
-    hit.SetEdep(gMC->Edep());
-    hit.SetShunt(GetIshunt());
-    if(gMC->IsTrackEntering()){
-        hit.SetStartPosition(position);
-        hit.SetStartTime(gMC->TrackTime());
-        hit.SetStartStatus(status);
-        return; // don't save entering hit.
-    } // end if IsEntering
-    // Fill hit structure with this new hit.
-    //Info("StepManager","Calling Copy Constructor");
-    new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
-    // Save old position... for next hit.
-    hit.SetStartPosition(position);
-    hit.SetStartTime(gMC->TrackTime());
-    hit.SetStartStatus(status);
-    return;
-}
-/*
-//______________________________________________________________________
-Int_t AliITSvBeamTestITS04::GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const
-{ 
-  // Function which gives the layer, ladder and det.
-  // index of the current volume. To be used in
-  // AliITS::StepManager()
-
-    det  = 1;   ladd = 1;
-    
-    TGeoNode *node = gGeoManager->GetMother(1);
-    if (!node) return kFALSE;
-    Int_t nodeNum = node->GetNumber();
-    
-    // GetNumber() return the index recorded in the node
-    
-    if (nodeNum==5||nodeNum==6) {         // SDD: one layer, one detector
-       lay = nodeNum-2;
-    } else if (nodeNum==3||nodeNum==4) {  // SPD layer 2
-       lay = 2;
-       if (nodeNum==4) det = 2;
-    } else if (nodeNum==1||nodeNum==2){   // SPD layer 1
-       lay = 1;
-       if (nodeNum==2) det = 2; 
-    } else if (nodeNum==9||nodeNum==10) { // SSD layer 2
-       lay = 6;
-       if (nodeNum==10) det = 2;
-    } else if (nodeNum==7||nodeNum==8){   // SSD layer 1
-       lay = 5;
-       if (nodeNum==8) det = 2; 
-    };  
-    
-    return kTRUE;
-}
-*/
-//_____________________________________________________________
-
- Int_t AliITSvBeamTestITS04::GetNumberOfSubDet(const TString& det) const{
-    
-   //Get number of individual detectors
-    if(det.Contains("SPD")) return fNspd;
-    if(det.Contains("SDD")) return fNsdd;
-    if(det.Contains("SSD")) return fNssd;
-    return 0;
-  }
diff --git a/ITS/AliITSvBeamTestITS04.h b/ITS/AliITSvBeamTestITS04.h
deleted file mode 100644 (file)
index 11e4e5c..0000000
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef ALIITSVBEAMTESTITS04_H
-#define ALIITSVBEAMTESTITS04_H
-
-////////////////////////////////////////////////
-// ITS geometry class and step manager for the//
-//   integrated ITS test beam of Nov. 04      //
-////////////////////////////////////////////////
-#include "AliITSInitGeometry.h"
-#include "AliITS.h"
-
-class TGeoVolume;
-
-class AliITSvBeamTestITS04 : public AliITS {
- public:
-    AliITSvBeamTestITS04();
-    AliITSvBeamTestITS04(const char* name,const char *title);
-    virtual ~AliITSvBeamTestITS04();
-    virtual void SetNumberOfSPD(Int_t nSPD) {fNspd=nSPD;}
-    virtual void SetNumberOfSDD(Int_t nSDD) {fNsdd=nSDD;}
-    virtual void SetNumberOfSSD(Int_t nSSD) {fNssd=nSSD;}
-    Int_t GetNSPD() const {return fNspd;}
-    Int_t GetNSDD() const {return fNsdd;}
-    Int_t GetNSSD() const {return fNssd;}
-    Int_t GetNumberOfSubDet(const TString& det) const;
-    virtual void CreateGeometry();
-    virtual void CreateMaterials();
-    virtual Int_t IsVersion()const{return (Int_t)kvITS04;}//Return Major Version
-    virtual Int_t MinorVersion()const{return fMinorVersion;}//Return Minor Version
-    //virtual void InitAliITSgeom();
-    virtual void Init();
-    //virtual void SetDefaults();
-    virtual void StepManager();
-    //for writing out geometry set .det write 
-    virtual void   SetWriteDet(Bool_t det=kTRUE){fGeomDetOut = det;}
-    virtual void   SetWriteDet(const char *f){fWrite[59]=0;strncpy(fWrite,f,59);
-                             fGeomDetOut = kTRUE;}// set write file 
-    //for reading geometry (JC) set .det read
-    virtual void   SetReadDet(Bool_t det=kTRUE){fGeomDetIn = det;}
-    virtual void   SetReadDet(const char *f){fRead[59]=0;strncpy(fRead,f,59);
-                         fGeomDetIn = kTRUE;} // set read file
- public:
-    void AddSPDGeometry(TGeoVolume *moth) const;
-    void AddSDDGeometry(TGeoVolume *moth) const;
-    void AddSSDGeometry(TGeoVolume *moth) const;
- protected:
-           //! ITS mother volume
-    static const Int_t fgkNumberOfSPD;       //number of SPD
-    static const Int_t fgkNumberOfSDD;       //number of SDD
-    static const Int_t fgkNumberOfSSD;       //number of SSD
-    // SPD specific
-    static const char*    fgSPDsensitiveVolName;  //SPD volume name
-    static const Double_t fgkSPDthickness;        //SPD thickness
-    static const Double_t fgkSPDwidth;            //SPD width
-    static const Double_t fgkSPDlength;           //SPD length
-    static const Double_t fgkSPDthickSens;        //SPD sensitive thickness
-    static const Double_t fgkSPDwidthSens;        //SPD sensitive width
-    static const Double_t fgkSPDlengthSens;       //SPD sensitive length
-    static const Double_t fgkSPD0y;               //SPD position
-    static const Double_t fgkSPD1y;               //SPD position
-    // SDD specific
-    static const char*    fgSDDsensitiveVolName;  //SDD volume name
-    static const Double_t fgkSDDthickness;        //SDD thickness
-    static const Double_t fgkSDDwidth;            //SDD width
-    static const Double_t fgkSDDlength;           //SDD length
-    static const Double_t fgkSDDthickSens;        //SDD sensitive thickness
-    static const Double_t fgkSDDwidthSens;        //SDD sensitive width
-    static const Double_t fgkSDDlengthSens;       //SDD sensitive length
-    static const Double_t fgkSDD0y;               //SDD position
-    static const Double_t fgkSDD1y;               //SDD position
-    // SDD specific
-    static const char*    fgSSDsensitiveVolName;   //SSD volume name
-    static const Double_t fgkSSDthickness;         //SSD thickness
-    static const Double_t fgkSSDwidth;             //SSD width
-    static const Double_t fgkSSDlength;            //SSD length
-    static const Double_t fgkSSDthickSens;         //SSD sensitive thickness
-    static const Double_t fgkSSDwidthSens;         //SSD sensitive width
-    static const Double_t fgkSSDlengthSens;        //SSD sensitive length
-    static const Double_t fgkSSD0y;                //SSD position
-    static const Double_t fgkSSD1y;                //SSD position
-    //
- private:
-    //Int_t GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const;:
-    AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source);//Copy constructor
-    //=operator
-    AliITSvBeamTestITS04& operator=(const AliITSvBeamTestITS04 &source);
-    //
-    TGeoVolume *fITSmotherVolume;       //Pointer to mother volume 
-    Int_t     fNspd;                    //Number of SPD modules
-    Int_t     fNsdd;                    //Number of SDD modules
-    Int_t     fNssd;                    //Number of SSD modules
-    //for writing out geometry
-    Bool_t fGeomDetOut;       // Flag to write .det file out 
-    Bool_t fGeomDetIn;        // Flag to read geometry file (JC)
-    char   fWrite[60];        //! file name to write .det file 
-    char   fRead[60];         // file name to read .det file (JC)
-    AliITSVersion_t fMajorVersion; // Major Version
-    Int_t           fMinorVersion; // Minor Version
-    AliITSInitGeometry fIgm; //! Init geometry object
-
-    ClassDef(AliITSvBeamTestITS04,3) // Full ITS test beam geometry 2004
-};
-
-#endif
-
-    
diff --git a/ITS/AliITSvSDD03.cxx b/ITS/AliITSvSDD03.cxx
deleted file mode 100644 (file)
index 41ecc69..0000000
+++ /dev/null
@@ -1,866 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/*
- $Id$ 
-*/
-/////////////////////////////////////////////////////////////////
-//  Class for the SDD beam test August2004                     //
-//                                                             //
-//                                                             //
-/////////////////////////////////////////////////////////////////
-
-#include <TGeoGlobalMagField.h>
-#include <TGeoManager.h>
-#include <TGeoMatrix.h>
-#include <TLorentzVector.h>
-#include <TVirtualMC.h>
-
-#include "AliMC.h"
-#include "AliRun.h"
-#include "AliMagF.h"
-#include "AliTrackReference.h"
-#include "AliITShit.h"
-#include "AliITSgeom.h"
-#include "AliITSgeomSDD.h"
-#include "AliITSgeomSSD.h"
-#include "AliITSDetTypeSim.h"
-#include "AliITSCalibrationSPD.h"
-#include "AliITSCalibrationSDD.h"
-#include "AliITSCalibrationSSD.h"
-#include "AliITSsegmentationSPD.h"
-#include "AliITSsegmentationSDD.h"
-#include "AliITSsegmentationSSD.h"
-#include "AliITSsimulationSPD.h"
-#include "AliITSsimulationSDD.h"
-#include "AliITSsimulationSSD.h"
-
-#include "AliITSvSDD03.h"
-
-ClassImp(AliITSvSDD03)
-
-//______________________________________________________________________
-AliITSvSDD03::AliITSvSDD03() :
-AliITS(),
-fMajorVersion(IsVersion()),
-fMinorVersion(2),
-fIDMother(0),
-fYear(2003),
-fTarg(kNoTarg),
-fTargThick(0.0),
-fIgm(kvSDD03){
-    ////////////////////////////////////////////////////////////////////////
-    // Standard default constructor for the ITS SDD test beam 2002 version 1.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    A default created class.
-    ////////////////////////////////////////////////////////////////////////
-
-    fIdN          = 0;
-    fIdName       = 0;
-    fIdSens       = 0;
-}
-//______________________________________________________________________
-AliITSvSDD03::AliITSvSDD03(const char *title,Int_t year):
-AliITS("ITS", title),
-fMajorVersion(IsVersion()),
-fMinorVersion(2),
-fIDMother(0),
-fYear(year),
-fTarg(kNoTarg),
-fTargThick(0.0),
-fIgm(kvSDD03){
-    ////////////////////////////////////////////////////////////////////////
-    //    Standard constructor for the ITS SDD testbeam 2002 version 1.
-    // Inputs:
-    //    const char *title    title for this ITS geometry.
-    // Outputs:
-    //    none.
-    // Return:
-    //    A standard created class.
-    ////////////////////////////////////////////////////////////////////////
-    Int_t i;
-
-    fIdN = 3;
-    fIdName = new TString[fIdN];
-    fIdName[0] = "IMBS";
-    fIdName[1] = "ITST";
-    fIdName[2] = "ISNT";
-    fIdSens    = new Int_t[fIdN];
-    for(i=0;i<fIdN;i++) fIdSens[i] = 0;
-
-}
-//______________________________________________________________________
-AliITSvSDD03::~AliITSvSDD03() {
-    ////////////////////////////////////////////////////////////////////////
-    //    Standard destructor for the ITS SDD test beam 2002 version 1.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    ////////////////////////////////////////////////////////////////////////
-}
-/*
-//______________________________________________________________________
-Int_t AliITSvSDD03::DecodeDetector(Int_t id,Int_t cpy,Int_t &lay,
-                                   Int_t &det,Int_t &lad) const{
-    // Given the Geant id and copy volume number, returns the layer, ladder,
-    // and detector number, allong with the module number of the detector
-    // involved. Returns -1 and lay=0, lad=0, and det=0 if not a sensitive 
-    // volume.
-    // Inputs:
-    //    Int_t id    Geometry volume id number
-    //    Int_t cpy   Geometry copy number
-    // Outputs:
-    //    Int_t lay   ITS layer number
-    //    Int_t lad   ITS ladder number
-    //    Int_t det   ITS detector number
-    // Return:
-    //    Int_t module number.
-    Int_t mod;
-
-    lay = 0; lad = 0; det = 0; mod = -1;
-    if(id==fIdSens[0]){ // Volume name is IMBS (ITEL)
-        lad = 1; det = 1;
-        lay = cpy;
-        if(cpy>4) lay+=2;
-        mod = lay-1;
-        return mod;
-    }// end if
-    if(id==fIdSens[1]){ // Volume name is ITST (IDet)
-        lad = 1; det = 1;lay = cpy+4; 
-       mod = lay-1;
-        return mod;
-    }// end if
-    return mod;
-}
-*/
-//______________________________________________________________________
-void AliITSvSDD03::CreateGeometry(){
-    ////////////////////////////////////////////////////////////////////////
-    //  This routine defines and Creates the geometry for version 1 of the ITS.
-    //    ALIC    ALICE Mother Volume
-    //     |- ITSV     ITS Mother Volume
-    //         |- IDET *2    Detector under Test (boxcontaining SDD)
-    //         |   |-IDAI        Air inside box
-    //         |       |- ITS0       SDD Si Chip
-    //         |          |- ITST      SDD Sensitivve Volume
-    //         |- ITEL *10   SSD Telescope (plastic box containting SSD's)
-    //         |   |- ITAI       Air inside box
-    //         |       |- IMB0       SDD Si Chip
-    //         |           |- IMBS     SDD Sensitive volume
-    //         |-ISNT*4    Sintilator triggers
-    //
-    //      ITEL ITEL ITEL ITEL IDET IDET ITEL ITEL ITEL ITEL ITEL ITEL
-    // Z->  -584 -574 -504 -494  000 +052 +601 +610 +684 +694 +877 +887
-    //        |    |    |    |    |    |    |    |    |    |    |    |
-    // cpn1   1    2    3    4    1    2    5    6    7    8    9   10
-    //
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    ////////////////////////////////////////////////////////////////////////
-    Float_t data[49];
-    // Define media off-set
-    Int_t *idtmed = fIdtmed->GetArray()+1; // array of media indexes
-    Int_t idrotm[4]; // Array of rotation matrix indexes
-    //Float_t ddettest=200.0E-4,ddettelescope=300.0E-4;
-    //Float_t dchipMiniBus=750.0E-4,dchiptest=300.0E-4;
-    //Float_t yposition= 0.0;
-    const Float_t kmm=0.1,kcm=1.0,kmicm=kmm/1000.;
-    // These constant character strings are set by cvs during commit
-    // do not change them unless you know what you are doing!
-    const Char_t *cvsDate="$Date$";
-    const Char_t *cvsRevision="$Revision$";
-    // Define Rotation-reflextion Matrixes needed
-    // 0 is the unit matrix
-    AliMatrix(idrotm[0], 90.0,0.0, 0.0,0.0, 90.0,270.0); // SDD and SSD X
-    AliMatrix(idrotm[1], 90.0,90.0, 0.0,180.0, 90.0,270.0); // SSD Y
-    AliMatrix(idrotm[2],90.0,90.0,90.0,180.0,0.0,0.0);  //Rotate about Z 90 degree
-    /*
-    data[0] = 150.0*kmm;
-    data[1] = 150.0*kmm;
-    data[2] = 1100.0*kmm;
-    gMC->Gsvolu("ITSV","BOX ",idtmed[0],data,3);
-    gMC->Gspos("ITSV",1,"ALIC",0.0,0.0,0.0,0,"ONLY");
-    */
-    TGeoVolumeAssembly *itsV = gGeoManager->MakeVolumeAssembly("ITSV");
-    const Int_t kLength=100;
-    Char_t vstrng[kLength];
-    if(fIgm.WriteVersionString(vstrng,kLength,(AliITSVersion_t)IsVersion(),
-                               fMinorVersion,cvsDate,cvsRevision))
-        itsV->SetTitle(vstrng);
-    else Error("CreateGeometry","Error writing/setting version string");
-    //printf("Title set to %s\n",vstrng);
-    TGeoVolume *alic = gGeoManager->GetVolume("ALIC");
-    if(alic==0) {
-        Error("CreateGeometry","alic=0");
-        return;
-    } // end if
-    alic->AddNode(itsV,1,0);
-
-    // Crossed sintilator triggers (2 in front 2 in back)
-    data[0] = 10.0*kcm;
-    data[1] = 2.0*kcm;
-    data[2] = 2.0*kmm;
-    gMC->Gsvolu("ISNT","BOX ",idtmed[2],data,3);
-    gMC->Gspos("ISNT",1,"ITSV",0.0,0.0,-950.0*kmm,0,"ONLY");
-    gMC->Gspos("ISNT",2,"ITSV",0.0,0.0,-950.0*kmm-data[2],idrotm[2],"ONLY");
-    gMC->Gspos("ISNT",3,"ITSV",0.0,0.0,950.0*kmm+data[2],0,"ONLY");
-    gMC->Gspos("ISNT",4,"ITSV",0.0,0.0,950.0*kmm,idrotm[2],"ONLY");
-
-
-////Create Volumes
-
-    // SSD part of telescope (MiniBuS)
-    Float_t detMiniBusX,detMiniBusY,detMiniBusZ;
-    data[0] = detMiniBusX = 10600.0*kmicm;
-    data[1] = detMiniBusY = 0.150*kmm;
-    data[2] = detMiniBusZ = 1.1*kcm;
-    gMC->Gsvolu("IMB0", "BOX ", idtmed[1], data, 3);   // contains detector
-    data[0] = 0.5*384*50*kmicm;
-    data[1] = 0.1499*kmm;
-    data[2] = 1.0*kcm;
-    gMC->Gsvolu("IMBS","BOX ",idtmed[1],data,3); // sensitive detector volume
-    gMC->Gspos("IMBS",1,"IMB0",0.0,0.0,0.0,0,"ONLY"); // place IMBS inside
-    // Box containing SSD's
-    data[0] = 11600.0*kmicm;
-    data[1] = 0.450*kcm;
-    data[2] = 1.16*kcm;
-    gMC->Gsvolu("ITAI","BOX ",idtmed[0],data,3);
-    // Plastic box size = insize + thickness.
-    data[0] = data[0] + 2.0*kmm;
-    data[1] = data[1] + 200.0*kmicm;
-    data[2] = data[2] + 2.0*kmm;
-    gMC->Gsvolu("ITEL","BOX ",idtmed[3],data,3);
-    gMC->Gspos("ITAI",1,"ITEL",0.0,0.0,0.0,0,"ONLY");
-    gMC->Gspos("IMB0",1,"ITAI",0.0,0.0,0.0,0,"ONLY");
-
-    // SDD under test
-    Float_t sddX,sddY,sddZ;
-    data[0] = sddX = 3.62500*kcm;
-    data[1] = sddY = 0.1500*kmm;
-    data[2] = sddZ = 4.37940*kcm;
-    gMC->Gsvolu("ITS0", "BOX ", idtmed[1], data, 3);   // contains detector
-    data[0] = 3.50860*kcm;
-    data[1] = 0.1499*kmm;
-    data[2] = 3.76320*kcm;
-    gMC->Gsvolu("ITST","BOX ",idtmed[1],data,3);// sensitive detecor volume
-    gMC->Gspos("ITST",1,"ITS0",0.0,0.0,0.0,0,"ONLY"); // place ITST inside
-    // Box containing SDD under test
-    data[0] = 4.0*kcm;
-    data[1] = 0.5*kcm;
-    data[2] = 5.0*kcm;
-    gMC->Gsvolu("IDAI","BOX ",idtmed[0],data,3);
-    data[0] = data[0] + 2.0*kmm;
-    data[1] = data[1] + 200.0*kmicm;
-    data[2] = data[2] + 2.0*kmm;
-    gMC->Gsvolu("IDET","BOX ",idtmed[3],data,3);
-    gMC->Gspos("IDAI",1,"IDET",0.0,0.0,0.0,0,"ONLY");
-    gMC->Gspos("ITS0",1,"IDAI",0.0,0.0,0.0,0,"ONLY");
-
-
-//// Position detectors, Beam Axis Z, X to the right, Y up to the sky.
-    // Upsteram planes of the telescope    
-    Float_t p00X,p00Y,p00Z,p01X,p01Y,p01Z,p10X,p10Y,p10Z,p11X,p11Y,p11Z;
-    p00X = 0.0*kcm;
-    p00Y = 0.0*kcm;
-    p00Z = -584*kmm;
-    gMC->Gspos("ITEL",1,"ITSV",p00X,p00Y,p00Z,idrotm[0],"ONLY");//SSD X
-    p01X = 0.0*kcm;
-    p01Y = 0.0*kcm;
-    p01Z = -574*kmm;
-    gMC->Gspos("ITEL",2,"ITSV",p01X,p01Y,p01Z,idrotm[1],"ONLY");//SSD Y
-    p01X = 0.0*kcm;
-    p01Y = 0.0*kcm;
-    p01Z = -504*kmm;
-    gMC->Gspos("ITEL",3,"ITSV",p01X,p01Y,p01Z,idrotm[0],"ONLY");//SSD X
-    p01X = 0.0*kcm;
-    p01Y = 0.0*kcm;
-    p01Z = -494*kmm;
-    gMC->Gspos("ITEL",4,"ITSV",p01X,p01Y,p01Z,idrotm[1],"ONLY");//SSD Y
-
-    // Downstream planes of the telescope
-    p10X = 0.0*kcm;
-    p10Y = 0.0*kcm;
-    p10Z = +601.0*kmm; 
-    gMC->Gspos("ITEL",5,"ITSV",p10X,p10Y,p10Z,idrotm[0],"ONLY");//SSD X
-    p11X = 0.0*kcm;
-    p11Y = 0.0*kcm;
-    p11Z = +610.0*kmm; //611.0
-    gMC->Gspos("ITEL",6,"ITSV",p11X,p11Y,p11Z,idrotm[1],"ONLY");//SSD Y
-    p11X = 0.0*kcm;
-    p11Y = 0.0*kcm;
-    p11Z = +684.0*kmm;
-    gMC->Gspos("ITEL",7,"ITSV",p11X,p11Y,p11Z,idrotm[0],"ONLY");//SSD X
-    p11X = 0.0*kcm;
-    p11Y = 0.0*kcm;
-    p11Z = +694.0*kmm;
-    gMC->Gspos("ITEL",8,"ITSV",p11X,p11Y,p11Z,idrotm[1],"ONLY");//SSD Y
-    p11X = 0.0*kcm;
-    p11Y = 0.0*kcm;
-    p11Z = +877.0*kmm;
-    gMC->Gspos("ITEL",9,"ITSV",p11X,p11Y,p11Z,idrotm[0],"ONLY");//SSD X
-    p11X = 0.0*kcm;
-    p11Y = 0.0*kcm;
-    p11Z = +887.0*kmm;
-    gMC->Gspos("ITEL",10,"ITSV",p11X,p11Y,p11Z,idrotm[1],"ONLY");//SSD Y
-
-    // SDDs 
-    Float_t pdet1X,pdet1Y,pdet1Z;
-    Float_t pdet2X,pdet2Y,pdet2Z;
-    pdet1X = 0.0*kcm;
-    pdet1Y = 0.0*kcm;
-    pdet1Z = 0.0*kcm;
-    gMC->Gspos("IDET",1,"ITSV",pdet1X,pdet1Y,pdet1Z,idrotm[0],"ONLY");// Detector1
-    pdet2X = 0.0*kcm;
-    pdet2Y = 0.0*kcm;
-    pdet2Z = 52*kmm; //52
-    gMC->Gspos("IDET",2,"ITSV",pdet2X,pdet2Y,pdet2Z,idrotm[0],"ONLY");// Detector2
-
-// Target definition and placement
-    if(fTarg != kNoTarg){
-      data[0] = 30*kmm;
-      data[1] = fTargThick*kmm;  // Target thickness
-      data[2] = 30*kmm;
-      gMC->Gsvolu("ITGT","BOX ",idtmed[fTarg],data,3);
-
-      Float_t a,z,dens,radl,absl;
-      Float_t* ubuf=0; Int_t nbuf;
-      char* ssss=0;
-      gMC->Gfmate(idtmed[fTarg],ssss,a,z,dens,radl,absl,ubuf,nbuf);
-
-      Info("CreateGeometry","Target A=%f,  Z=%f,  dens=%f",a,z,dens);
-      Info("Creategeometry","Target thickness=%f mm",fTargThick);
-
-      Float_t ptgtX,ptgtY,ptgtZ;
-      ptgtX = 0.0*kcm;
-      ptgtY = 0.0*kcm;
-      ptgtZ = -50*kmm;
-      gMC->Gspos("ITGT",1,"ITSV",ptgtX,ptgtY,ptgtZ,idrotm[0],"ONLY");// Target
-    }else{
-      Info("CreateGeometry","No target defined");
-    }
-}
-//______________________________________________________________________
-void AliITSvSDD03::CreateMaterials(){
-    ////////////////////////////////////////////////////////////////////////
-    //
-    // Create ITS SDD test beam materials
-    //     This function defines the default materials used in the Geant
-    // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
-    // AliITSvSDD03.
-    // In general it is automatically replaced by
-    // the CreateMaterials routine defined in AliITSv?. Should the function
-    // CreateMaterials not exist for the geometry version you are using this
-    // one is used. See the definition found in AliITSv5 or the other routine
-    // for a complete definition.
-    //
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    /////////////////////////////////////////////////////////////////////////
-    Float_t tmaxfdSi = 0.1; // Degree
-    Float_t stemaxSi = 0.0075; // cm //0.0075
-    Float_t deemaxSi = 0.1; // Fraction of particle's energy 0<deemax<=1
-    Float_t epsilSi  = 1.0E-4;//
-    Float_t stminSi  = 0.0; // cm "Default value used"
-
-    Float_t tmaxfdAir = 0.1; // Degree
-    Float_t stemaxAir = .10000E+01; // 1 cm  //cm
-    Float_t deemaxAir = 0.1; // Fraction of particle's energy 0<deemax<=1
-    Float_t epsilAir  = 1.0E-4;//
-    Float_t stminAir  = 0.0; // cm "Default value used"
-    Int_t   ifield = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
-    Float_t fieldm = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
-    //
-
-    // AIR
-    Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
-    Float_t zAir[4]={6.,7.,8.,18.};
-    Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
-    Float_t dAir = 1.20479E-3;
-    // Lucite/Plexiglass
-    Float_t aLuc[3] = {1.,12.,16.};
-    Float_t zLuc[3] = {1.,6.,8.};
-    Float_t wLuc[3] = {8.,5.,2.};
-    Float_t dLuc = 1.19;
-    // stainless steel
-    Float_t asteel[4] = { 55.847,51.9961,58.6934,28.0855 };
-    Float_t zsteel[4] = { 26.,24.,28.,14. };
-    Float_t wsteel[4] = { .715,.18,.1,.005 };
-    Float_t dsteel = 7.88;
-
-    AliMixture(1, "AIR$",aAir,zAir,dAir,4,wAir);
-    AliMaterial(2,"SI$",28.086,14.0,2.3300,9.3600,999.00);
-    AliMixture(3,"Sintilator$",aLuc,zLuc,dLuc,-3,wLuc);
-    AliMixture(4,"PlasticBox$",aLuc,zLuc,dLuc,-3,wLuc);
-    AliMaterial(5, "IRON$", 55.85, 26., 7.87, 1.76, 999.00);
-    AliMaterial(6, "LEAD$", 207.19, 82., 11.35, .56, 999.00);
-    AliMixture(7, "STAINLESS STEEL$", asteel, zsteel,dsteel, 4, wsteel);
-    AliMaterial(9, "C$", 12.011, 6., 2.265, 18.8, 999.00);
-    AliMaterial(10, "Al$", 26.98, 13., 2.70, 8.9, 999.00);
-    AliMaterial(11, "Be$", 9.012, 4., 1.848, 35.3, 999.00);
-    AliMaterial(12, "Ti$", 47.88, 22., 4.54, 3.56, 999.00);
-    AliMaterial(13, "Sn$", 118.69, 50., 7.31, 1.21, 999.00); 
-    AliMaterial(14, "Cu$", 63.55, 29., 8.96, 1.43, 999.00);
-    AliMaterial(15, "Ge$", 72.59, 32., 5.323, 2.30, 999.00);
-    AliMaterial(20, "W$", 183.85, 74., 19.3, 0.35, 999.00);
-    AliMedium(1,"AIR$",1,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,
-             epsilAir,stminAir);
-    AliMedium(2,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-    AliMedium(3,"Scintillator$",3,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-    AliMedium(4,"PlasticBox$",4,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-    AliMedium(5,"IRON$",5,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-    AliMedium(6,"LEAD$",6,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-    AliMedium(7,"StainlessSteel$",7,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-
-    AliMedium(9,"C$",9,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(10,"Al$",10,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(11,"Be$",11,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(12,"Ti$",12,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(13,"Sn$",13,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(14,"Cu$",14,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(15,"Ge$",15,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    AliMedium(20,"W$",20,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
-    //dummy materials to avoid warning during simulation (galice.cuts)
-
-   AliMedium(21,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(25,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(26,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(27,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(51,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(52,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(53,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(54,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(55,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(56,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(61,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(62,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(63,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(64,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(65,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(68,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(69,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(70,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(71,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(72,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(73,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(74,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(75,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(76,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(77,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(78,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(79,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(80,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(81,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(82,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(83,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(84,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(85,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(90,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(91,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(92,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(93,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(94,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(95,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-   AliMedium(96,"SI$",2,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,
-             epsilSi,stminSi);
-
-}/*
-//______________________________________________________________________
-void AliITSvSDD03::InitAliITSgeom(){
-    //     Based on the geometry tree defined in Geant 3.21, this
-    // routine initilizes the Class AliITSgeom from the Geant 3.21 ITS geometry
-    // sturture.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    const Int_t knlayers=12;
-    //   const Int_t kndeep=6;
-    const Int_t kltypess=2;
-    const AliITSDetector kidet[knlayers]={kSSD,kSDD};
-    const TString knames[kltypess]={
-        "/ALIC_1/ITSV_1/ITEL_%d/ITAI_1/IMB0_1/IMBS_1",
-        "/ALIC_1/ITSV_1/IDET_%d/IDAI_1/ITS0_1/ITST_1"};
-    const Int_t kitsGeomTreeCopys[kltypess]={10,2};
-    const Int_t knp=384;
-    const Float_t kpitch=50.E-4;//cm
-    Float_t box[3]={0.5*kpitch*(Float_t)knp,150.E-4,1.0},p[knp+1],n[knp+1];
-    Int_t nlad[knlayers]={knlayers*1};
-    Int_t ndet[knlayers]={knlayers*1};
-    Int_t mod=knlayers,lay=0,lad=0,det=0,i,j,cp0;
-    TString path,shapeName;
-    TGeoHMatrix matrix;
-    Double_t trans[3]={3*0.0},rot[10]={10*0.0};
-    TArrayD shapePar;
-    TArrayF shapeParF;
-    Bool_t isShapeDefined[kltypess]={kltypess*kFALSE};
-    AliITSgeom *geom = new AliITSgeom(0,knlayers,nlad,ndet,mod);
-    if(GetITSgeom()!=0) SetITSgeom(0x0);// delet existing if there.
-    SetITSgeom(geom);
-
-    p[0]=-box[0];
-    n[0]=box[0];
-    // Fill in anode and cathode strip locations (lower edge)
-    for(i=1;i<knp;i++){
-        p[i] =p[i-1]+kpitch;
-        n[i] =n[i-1]-kpitch;
-    } // end for i
-    p[knp]=box[0];
-    n[knp]=-box[0];
-    for(i=0;i<kltypess;i++)for(cp0=1;cp0<=kitsGeomTreeCopys[i];cp0++){
-        mod = DecodeDetector(fIdSens[i],cp0,lay,lad,det);
-        path.Form(knames[i].Data(),cp0);
-        gMC->GetTransformation(path.Data(),matrix);
-        gMC->GetShape(path.Data(),shapeName,shapePar);
-        shapeParF.Set(shapePar.GetSize());
-        for(j=0;j<shapePar.GetSize();j++)shapeParF[j]=shapePar[j];
-        geom->CreateMatrix(mod,lay,lad,det,kidet[i],trans,rot);
-        geom->SetTrans(mod,matrix.GetTranslation());
-        geom->SetRotMatrix(mod,matrix.GetRotationMatrix());
-        geom->GetGeomMatrix(mod)->SetPath(path.Data());
-        switch (kidet[i]){
-        case kSDD: if(!(GetITSgeom()->IsShapeDefined((Int_t)kSDD))){
-            geom->ReSetShape(kSDD,new AliITSgeomSDD256(shapeParF.GetSize(),
-                                                       shapeParF.GetArray()));
-            isShapeDefined[i]=kTRUE;
-        } break;
-        case kSSD:if(!(GetITSgeom()->IsShapeDefined((Int_t)kSSD))){
-            geom->ReSetShape(kSSD,new AliITSgeomSSD(box,0.0,0.0,
-                                                    knp+1,p,knp+1,n));
-            isShapeDefined[i]=kTRUE;
-        } break;
-        default:{} break;
-        } // end switch
-    } // end for i,cp0
-    return;
-}*/
-//______________________________________________________________________
-void AliITSvSDD03::Init(){
-    ////////////////////////////////////////////////////////////////////////
-    //     Initialise the ITS after it has been created.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    ////////////////////////////////////////////////////////////////////////
-
-
-    Info("Init","**********AliITSvSDD03 %d _Init *************",fMinorVersion);
-
-    AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion,
-                 fMinorVersion));
-    //
-    UpdateInternalGeometry();
-    AliITS::Init();
-    //
-    fIDMother = gMC->VolId("ITSV"); // ITS Mother Volume ID.
-
-}/*
-//______________________________________________________________________
-void AliITSvSDD03::SetDefaults(){
-    // sets the default segmentation, response, digit and raw cluster classes
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-
-  //    const Float_t kconv = 1.0e+04; // convert cm to microns
-
-    if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
-    fDetTypeSim->SetITSgeom(GetITSgeom());
-    fDetTypeSim->ResetCalibrationArray();
-    fDetTypeSim->ResetSegmentation();
-    AliITSgeomSDD *s1;
-    AliITSgeomSSD *s2;
-    SetCalibrationModel(GetITSgeom()->GetStartSPD(),new AliITSCalibrationSPD());
-    SetSegmentationModel(kSPD,(AliITSsegmentationSPD*)
-                        (GetITSgeom()->GetShape(kSPD)));
-    fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
-
-    // SDD
-    s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);// Get shape info. Do it this way for now.
-    AliITSCalibrationSDD *resp1=new AliITSCalibrationSDD("simulated");
-    SetCalibrationModel(GetITSgeom()->GetStartSDD(),resp1);
-
-    AliITSsegmentationSDD *seg1 = (AliITSsegmentationSDD*)
-                        (GetITSgeom()->GetShape(kSDD));
-    seg1->SetDriftSpeed(AliITSDriftSpeedSDD::DefaultDriftSpeed());
-    seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
-    SetSegmentationModel(kSDD,seg1);
-    const char *kData1=(fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSDD()))->DataType();
-
-    // SSD  Layer 5
-
-    s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);// Get shape info. Do it this way for now.
-   
-    AliITSCalibration *resp2= new AliITSCalibrationSSD("simulated");
-    SetCalibrationModel(GetITSgeom()->GetStartSSD(),resp2);
-
-    AliITSsegmentationSSD *seg2 = (AliITSsegmentationSSD*)
-                        (GetITSgeom()->GetShape(kSSD));
-    seg2->SetPadSize(50.,0.); // strip x pitch in microns
-    seg2->SetNPads(384,0); // number of strips on each side.
-    seg2->SetLayer(5);
-    seg2->SetAngles(0.,0.); // strip angles rad P and N side.
-    seg2->SetAnglesLay5(0.,0.); // strip angles rad P and N side.
-    seg2->SetAnglesLay6(0.,0.); // strip angles rad P and N side.
-
-    SetSegmentationModel(kSSD,seg2); 
-    const char *kData2=(fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()))->DataType();
-    if(strstr(kData2,"real") ) fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigit");
-    else fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigitSSD");
-
-    if(fgkNTYPES>3){
-       Warning("SetDefaults",
-               "Only the four basic detector types are initialised!");
-    }// end if
-    return;
-}
-//______________________________________________________________________
-void AliITSvSDD03::SetDefaultSimulation(){
-    // sets the default simulation.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-  if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
-  AliITSsimulation *sim;
-  //AliITSsegmentation *seg;
-  //AliITSCalibration *res;
-  //SPD
-  if(fDetTypeSim){
-    sim = fDetTypeSim->GetSimulationModel(kSPD);
-    if (!sim) {
-      //seg =(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD);
-      //if(seg==0) seg = new AliITSsegmentationSPD();
-      //res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSPD());
-      //if(res==0) res = new AliITSCalibrationSPD();
-      sim = new AliITSsimulationSPD(fDetTypeSim);
-      SetSimulationModel(kSPD,sim);
-    }else{ // simulation exists, make sure it is set up properly.
-      sim->SetSegmentationModel(kSPD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSPD));
-      sim->SetCalibrationModel(GetITSgeom()->GetStartSPD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSPD()));
-      sim->Init();
-    } // end if
-  } // end if iDetType
-  //SDD
-  if(fDetTypeSim){
-    sim = fDetTypeSim->GetSimulationModel(kSDD);
-    if (!sim) {
-      //      seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD);
-      //res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSDD());
-      sim = new AliITSsimulationSDD(fDetTypeSim);
-      SetSimulationModel(kSDD,sim);
-    }else{ // simulation exists, make sure it is set up properly.
-      sim->SetSegmentationModel(kSDD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSDD));
-      sim->SetCalibrationModel(GetITSgeom()->GetStartSDD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSDD()));
-      
-      sim->Init();
-    } //end if
-  } // end if iDetType
-  //SSD
-  if(fDetTypeSim){
-    sim = fDetTypeSim->GetSimulationModel(kSSD);
-    if (!sim) {
-      //      seg = (AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD);
-      // res = (AliITSCalibration*)fDetTypeSim->GetResponseModel(GetITSgeom()->GetStartSSD());
-      sim = new AliITSsimulationSSD(fDetTypeSim);
-      SetSimulationModel(kSSD,sim);
-    }else{ // simulation exists, make sure it is set up properly.
-      sim->SetSegmentationModel(kSSD,(AliITSsegmentation*)fDetTypeSim->GetSegmentationModel(kSSD));
-      sim->SetCalibrationModel(GetITSgeom()->GetStartSSD(),(AliITSCalibration*)fDetTypeSim->GetCalibrationModel(GetITSgeom()->GetStartSSD()));
-      sim->Init();
-    } // end if
-  } // end if iDetType
-  }*/
-//______________________________________________________________________
-void AliITSvSDD03::DrawModule() const{
-    ////////////////////////////////////////////////////////////////////////
-    //     Draw a shaded view of the ITS SDD test beam version 1.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    ////////////////////////////////////////////////////////////////////////
-    // Set everything unseen
-    gMC->Gsatt("*", "seen", -1);
-    // Set ALIC mother visible
-    gMC->Gsatt("ALIC","SEEN",0);
-    // Set ALIC ITS visible
-    gMC->Gsatt("ITSV","SEEN",1);
-    // Set ALIC Telescopes visible
-    gMC->Gsatt("ITEL","SEEN",1);
-    gMC->Gsatt("ITEL","colo",2);
-    // Set ALIC detetcor visible
-    gMC->Gsatt("IDET","SEEN",1);
-    gMC->Gsatt("IDET","colo",4);
-    // Set ALIC Scintillator visible
-    gMC->Gsatt("ISNT","SEEN",1);
-    gMC->Gsatt("ISNT","colo",3);
-    // Set Detector mother visible and drawn
-//    gMC->Gsatt("ITS0","SEEN",1);
-    // Set minibus mother visible and drawn
-//    gMC->Gsatt("IMB0","SEEN",1);
-
-    // Draw
-    gMC->Gdraw("alic", 60, 30, 180, 10,10, .12, .12);
-}
-//______________________________________________________________________
-void AliITSvSDD03::StepManager(){
-    ////////////////////////////////////////////////////////////////////////
-    //    Called for every step in the ITS SDD test beam, then calles the 
-    // AliITShit class  creator with the information to be recoreded about
-    //  that hit.
-    //     The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
-    // printing of information to a file which can be used to create a .det
-    // file read in by the routine CreateGeometry(). If set to 0 or any other
-    // value except 1, the default behavior, then no such file is created nor
-    // it the extra variables and the like used in the printing allocated.
-    // Inputs:
-    //    none.
-    // Outputs:
-    //    none.
-    // Return:
-    //    none.
-    ////////////////////////////////////////////////////////////////////////
-    if(!(this->IsActive())) return;
-    if(!(gMC->TrackCharge())) return;
-
-    Int_t  cpy0,cpy1,ncpys=0,status,id,mod;
-    TLorentzVector position, momentum;
-    static AliITShit hit;// Saves on calls to construtors
-    //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
-    TClonesArray &lhits = *(Hits());
-    //
-    // Track status
-    // Track status
-    status = 0;
-    if(gMC->IsTrackInside())      status +=  1;
-    if(gMC->IsTrackEntering())    status +=  2;
-    if(gMC->IsTrackExiting())     status +=  4;
-    if(gMC->IsTrackOut())         status +=  8;
-    if(gMC->IsTrackDisappeared()) status += 16;
-    if(gMC->IsTrackStop())        status += 32;
-    if(gMC->IsTrackAlive())       status += 64;
-    //
-    // Fill hit structure.
-    gMC->TrackPosition(position);
-    gMC->TrackMomentum(momentum);
-    id   = gMC->CurrentVolID(cpy0);
-    gMC->CurrentVolOffID(3,cpy1);
-    if(id==fIdSens[0])ncpys=10;
-    if(id==fIdSens[1])ncpys=2;
-    fIgm.DecodeDetector(mod,ncpys,cpy0,cpy1,1);
-    //
-    // Fill hit structure.
-    //
-    hit.SetModule(mod);
-    hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
-    gMC->TrackPosition(position);
-    gMC->TrackMomentum(momentum);
-    hit.SetPosition(position);
-    hit.SetTime(gMC->TrackTime());
-    hit.SetMomentum(momentum);
-    hit.SetStatus(status);
-    hit.SetEdep(gMC->Edep());
-    hit.SetShunt(GetIshunt());
-    if(gMC->IsTrackEntering()){
-        hit.SetStartPosition(position);
-        hit.SetStartTime(gMC->TrackTime());
-        hit.SetStartStatus(status);
-        return; // don't save entering hit.
-    } // end if IsEntering
-    // Fill hit structure with this new hit.
-    //Info("StepManager","Calling Copy Constructor");
-    new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
-    // Save old position... for next hit.
-    hit.SetStartPosition(position);
-    hit.SetStartTime(gMC->TrackTime());
-    hit.SetStartStatus(status);
-    return;
-}
-
diff --git a/ITS/AliITSvSDD03.h b/ITS/AliITSvSDD03.h
deleted file mode 100644 (file)
index ddbe0fe..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef ALIITSVSDD03_H
-#define ALIITSVSDD03_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-/*
-  $Id$
-*/
-// ITS step manager and geometry class for the ITS SDD test beam geometry
-// of Summer 2003 and later.
-// At present, the geometry and materials need to be checked against the
-// proper geometry of the 2003 test beam. In addition, because the SSD
-// used in the test beam are single sided, the second side needs be ignored.
-// This can cause some problems with the SSD reconstruction code.
-#include "AliITSInitGeometry.h"
-#include "AliITS.h"
-
-typedef enum {
-  kNoTarg=0,kIron=4,kLead,kSteel,
-  kCarbon=8,kAl,kBe,kTi,kSn,kCopper,kGe,kTungsten=19
-} TargTyp_t;
-
-class AliITSvSDD03 : public AliITS{
- public:
-    AliITSvSDD03(); // default constructor
-    AliITSvSDD03(const char *title,Int_t year); // standard constructor
-    virtual ~AliITSvSDD03(); // destructor
-    virtual void   CreateGeometry();
-    virtual void   CreateMaterials();
<