1) Added classes for digitization
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Aug 2012 00:48:30 +0000 (00:48 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Aug 2012 00:48:30 +0000 (00:48 +0000)
2) Brought to uniform naming scheme AliITSU...
3) Removed AliITSgeom and AliITSInitGeometry dependencies: all geom manipulations
are done via AliITSUGeomTGeo class, which is not anymore static.

49 files changed:
ITS/UPGRADE/AliITSDetTypeSimUpg.cxx [deleted file]
ITS/UPGRADE/AliITSDetTypeSimUpg.h [deleted file]
ITS/UPGRADE/AliITSInitGeometryUpg.h [deleted file]
ITS/UPGRADE/AliITSU.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSU.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUCalibrationPix.cxx [moved from ITS/UPGRADE/AliITSCalibrationPixUpg.cxx with 77% similarity]
ITS/UPGRADE/AliITSUCalibrationPix.h [moved from ITS/UPGRADE/AliITSCalibrationPixUpg.h with 75% similarity]
ITS/UPGRADE/AliITSUDigitPix.cxx [moved from ITS/UPGRADE/AliITSdigitPixUpg.cxx with 89% similarity]
ITS/UPGRADE/AliITSUDigitPix.h [moved from ITS/UPGRADE/AliITSdigitPixUpg.h with 70% similarity]
ITS/UPGRADE/AliITSUDigitizer.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUDigitizer.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUGeomTGeo.cxx [moved from ITS/UPGRADE/AliITSgeomTGeoUpg.cxx with 53% similarity]
ITS/UPGRADE/AliITSUGeomTGeo.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUHit.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUHit.cxx~ [new file with mode: 0644]
ITS/UPGRADE/AliITSUHit.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUInitGeometry.cxx [moved from ITS/UPGRADE/AliITSInitGeometryUpg.cxx with 86% similarity]
ITS/UPGRADE/AliITSUInitGeometry.h [new file with mode: 0644]
ITS/UPGRADE/AliITSULoader.cxx [moved from ITS/UPGRADE/AliITSLoaderUpg.cxx with 78% similarity]
ITS/UPGRADE/AliITSULoader.h [moved from ITS/UPGRADE/AliITSLoaderUpg.h with 89% similarity]
ITS/UPGRADE/AliITSUModule.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUModule.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUSDigit.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSDigit.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUSegmentationPix.cxx [moved from ITS/UPGRADE/AliITSsegmentationPixUpg.cxx with 80% similarity]
ITS/UPGRADE/AliITSUSegmentationPix.h [moved from ITS/UPGRADE/AliITSsegmentationPixUpg.h with 78% similarity]
ITS/UPGRADE/AliITSUSensMap.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSensMap.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimuParam.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimuParam.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimulation.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimulation.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimulationPix.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUSimulationPix.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUpg.cxx [deleted file]
ITS/UPGRADE/AliITSUpg.h [deleted file]
ITS/UPGRADE/AliITSUv11.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUv11.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUv11Layer.cxx [moved from ITS/UPGRADE/AliITSv11GeometryUpgrade.cxx with 87% similarity]
ITS/UPGRADE/AliITSUv11Layer.h [moved from ITS/UPGRADE/AliITSv11GeometryUpgrade.h with 84% similarity]
ITS/UPGRADE/AliITSgeomTGeoUpg.h [deleted file]
ITS/UPGRADE/AliITSresponsePixUpg.cxx [deleted file]
ITS/UPGRADE/AliITSresponsePixUpg.h [deleted file]
ITS/UPGRADE/AliITSsimulationPixUpg.cxx [deleted file]
ITS/UPGRADE/AliITSsimulationPixUpg.h [deleted file]
ITS/UPGRADE/CMakelibITSUpgradeBase.pkg
ITS/UPGRADE/CMakelibITSUpgradeSim.pkg
ITS/UPGRADE/ITSUpgradeBaseLinkDef.h
ITS/UPGRADE/ITSUpgradeSimLinkDef.h

diff --git a/ITS/UPGRADE/AliITSDetTypeSimUpg.cxx b/ITS/UPGRADE/AliITSDetTypeSimUpg.cxx
deleted file mode 100644 (file)
index 914eb51..0000000
+++ /dev/null
@@ -1,242 +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: AliITSDetTypeSimUpg.cxx 56993 2012-06-08 08:24:17Z fca $
-*/
-
-
-/////////////////////////////////////////////////////////////////////
-// Base simulation functions for ITS upgrade                       //
-//                                                                 //
-//                                                                 //
-/////////////////////////////////////////////////////////////////////          
-#include "TBranch.h"
-#include "TClonesArray.h"
-#include "TObjArray.h"
-#include "TTree.h"
-
-#include "AliRun.h"
-
-#include "AliCDBManager.h"
-#include "AliCDBId.h"
-#include "AliCDBStorage.h"
-#include "AliCDBEntry.h"
-#include "AliCDBMetaData.h"
-#include "AliITSdigit.h"
-#include "AliITSdigitPixUpg.h"
-#include "AliITSgeom.h"
-#include "AliITSDetTypeSimUpg.h"
-#include "AliITSpListItem.h"
-#include "AliITSCalibration.h"
-#include "AliITSsimulation.h"
-#include "AliITSTriggerConditions.h"
-#include "AliITSsegmentation.h"
-#include "AliITSsegmentationPixUpg.h"
-#include "AliITSsimulationPixUpg.h"
-#include "AliBaseLoader.h"
-
-using std::endl;
-using std::cout;
-ClassImp(AliITSDetTypeSimUpg)
-
-const char* AliITSDetTypeSimUpg::fgkDetTypeName[AliITSDetTypeSimUpg::kNDetTypes] = {"PixUpg"};
-
-
-//----------------------------------------------------------------------
-AliITSDetTypeSimUpg::AliITSDetTypeSimUpg() 
-{ 
-  // Default Constructor
-  // Note: the base class AliITSDetTypeSim is badly designed, since its 
-  // default c-tor dynamically creates lot of stuff. 
-  // To be derived directly from TObject later...
-  // Inputs:
-  //    none.
-  // Outputs:
-  //    none.
-  // Return:
-  //    A properly zero-ed AliITSDetTypeSimUpg class.
-  if (kNDetTypes>3) AliFatal("The hack failed: kNDetTypes>fgkNdettypes");
-  //
-  for (int i=kNDetTypes;i--;) fDetNModules[i] = 0;
-}
-
-//----------------------------------------------------------------------
-AliITSDetTypeSimUpg::~AliITSDetTypeSimUpg()
-{
-  // Destructor
-  // RS: delegate everything to base class
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::SetDefaultSegmentation(Int_t idet)
-{
-  // Set default segmentation model objects
-  AliITSsegmentation *seg = 0;
-  //  
-  if (GetSegmentationModel(idet)) delete GetSegmentation()->RemoveAt(idet);
-  //
-  switch (idet) 
-    {
-    case kDetPixUpg: seg = new AliITSsegmentationPixUpg(); break;
-    default        : AliFatal(Form("Uknown detector type %d",idet));
-  };
-  SetSegmentationModel(idet,seg);
-  //
-}
-
-//_______________________________________________________________________
-AliITSCalibration* AliITSDetTypeSimUpg::GetCalibrationModel(Int_t iMod) const 
-{
-  //Get response model for module number iMod 
-  //
-  TObjArray* calarr = GetCalibrationArray();
-  if (!calarr) {
-    AliError("Calibration array is not initialized");
-    return 0;
-  }
-  return (AliITSCalibration*)calarr->At(iMod);
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::SetDefaults()
-{
-  //Set defaults for segmentation and response
-  
-  if(GetITSgeom()==0){
-    Warning("SetDefaults","GetITSgeom() is 0!");
-    return;
-  } // end if
-  if (GetCalibrationArray()==0) {
-    CreateCalibrationArray();
-  } // end if
-  //
-  ResetSegmentation();
-  if(!GetCalibration()){AliFatal("Exit"); exit(0);}
-  
-  SetDigitClassName(0,"AliITSdigitPixUpg");
-  //  
-  for(Int_t idet=0;idet<kNDetTypes;idet++){
-    if(!GetSegmentationModel(idet)) SetDefaultSegmentation(idet);
-  }
-  //
-}
-
-//______________________________________________________________________
-Bool_t AliITSDetTypeSimUpg::GetCalibration() 
-{
-  // Get Default calibration if a storage is not defined.
-  /*
-  //
-  if(!fFirstcall){
-    AliITSCalibration* cal = GetCalibrationModel(0);
-    if(cal)return kTRUE;
-  }
-  else {
-    fFirstcall = kFALSE;
-  }
-  
-  SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
-  Int_t run=GetRunNumber();
-  
-  Bool_t isCacheActive = kTRUE;
-  if (run) {
-    isCacheActive=kFALSE;
-    fCalibration->SetOwner(kTRUE);
-  }
-  else{
-    fCalibration->SetOwner(kFALSE);
-  }
-  
-  AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
-  //
-  // TO DO, RS
-  */
-  return kTRUE;
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::SetDefaultSimulation()
-{
-  //Set default simulation for detector type
-  //
-  if (GetITSgeom()==0) {
-    Warning("SetDefaultSimulation","GetITSgeom() is 0!");
-    return;
-  }
-  if (GetCalibrationArray()==0) {
-    Warning("SetDefaultSimulation","fCalibration is 0!");
-    return;
-  }
-  if (GetSegmentation()==0) {
-    Warning("SetDefaultSimulation","fSegmentation is 0!");
-    for (Int_t i=0;i<kNDetTypes;i++) SetDefaultSegmentation(i);
-  } else for(Int_t i=0;i<kNDetTypes;i++) if(!GetSegmentationModel(i)){
-       Warning("SetDefaultSimulation",
-               "Segmentation not defined for det %d - Default taken\n!",i);
-       SetDefaultSegmentation(i);
-      }
-  //
-  AliITSsimulation* sim;
-  //
-  for (Int_t idet=0;idet<kNDetTypes;idet++) {
-    //PixUpg
-    if (idet==kDetPixUpg) {
-      sim = GetSimulationModel(idet); 
-      if (!sim) {
-       sim = new AliITSsimulationPixUpg(this);
-       SetSimulationModel(idet,sim);
-      }
-    }
-  }
-}
-
-
-//__________________________________________________________
-void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch, const AliITSdigit* d)
-{  
-  // Add a simulated digit.
-  TClonesArray* ldigits = DigitsAddress(branch);
-  if (!ldigits) AliFatal(Form("Digits array for detector %d is not initialized",branch));
-  int* ndig = GetNDigitArray();
-  //
-  switch(branch){
-  case kDetPixUpg:
-    new( (*ldigits)[ndig[branch]++]) AliITSdigitPixUpg(*((AliITSdigitPixUpg*)d));
-    break;
-  default:
-    AliFatal(Form("Digit for unknown detector type %d",branch));
-  }  
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
-                                     Int_t *tracks,Int_t *hits,Float_t *charges, 
-                                     Int_t sigexpanded)
-{
-  //   Add a simulated digit to the list.
-
-  TClonesArray *ldigits = DigitsAddress(branch);
-  if (!ldigits) AliFatal(Form("Digits array for detector %d is not initialized",branch));
-  int* ndig = GetNDigitArray();
-  //
-  switch(branch){
-  case kDetPixUpg:
-    new((*ldigits)[ndig[branch]++]) AliITSdigitPixUpg(digits,tracks,hits);
-    break;
-  default:
-    AliFatal(Form("Digit for unknown detector type %d",branch));
-  } 
-}
diff --git a/ITS/UPGRADE/AliITSDetTypeSimUpg.h b/ITS/UPGRADE/AliITSDetTypeSimUpg.h
deleted file mode 100644 (file)
index 6aa99d3..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-#ifndef ALIITSDETTYPESIMUPG_H
-#define ALIITSDETTYPESIMUPG_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/*
-  $Id: AliITSDetTypeSimUpg.h 53025 2011-11-19 22:50:51Z masera $ 
-*/
-
-/////////////////////////////////////////////////////////////////////////
-// * This class contains all of the "external" information needed to do//
-// * detector specific simulations for the ITS.                        //
-/////////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include "AliITSLoader.h"
-#include "AliITSSimuParam.h"
-#include "AliITSDetTypeSim.h"
-
-class TObjArray;
-class TClonesArray;
-class TTree;
-class AliCDBMetaData;
-class AliITSdigit;
-class AliITSdigitPixUpg;
-class AliITSmodule;
-class AliITSpListItem;
-class AliITSsimulation;
-class AliITSsegmentation;
-class AliITSresponse;
-class AliITSCalibration;
-class AliITSgeom;
-class AliITSTriggerConditions;
-
-
-class AliITSDetTypeSimUpg : public AliITSDetTypeSim {
- public:
-  //
-  enum {kDetPixUpg, kNDetTypes};
-  //  
-  AliITSDetTypeSimUpg();
-  virtual ~AliITSDetTypeSimUpg(); 
-  
-  virtual AliITSCalibration* GetCalibrationModel(Int_t iMod) const;
-  virtual AliITSTriggerConditions* GetTriggerConditions() {return 0;} // tmp
-  
-  virtual void SetDefaults();
-  virtual void SetDefaultSimulation();
-  //
-  virtual void AddSimDigit(Int_t branch, const AliITSdigit *d);
-  virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
-                          Int_t* tracks,Int_t *hits,Float_t* trkcharges,
-                          Int_t sigexpanded=-1000);
-
- protected:
-  virtual Bool_t GetCalibration();
-    
- private:
-  AliITSDetTypeSimUpg(const AliITSDetTypeSimUpg &source);
-  AliITSDetTypeSimUpg& operator=(const AliITSDetTypeSimUpg &source);
-  void SetDefaultSegmentation(Int_t idet);  // creates def segm.
-  //
-  Int_t              fDetNModules[kNDetTypes]; // Total numbers of modules of each type, RS
-  //       
-  static const char* fgkDetTypeName[kNDetTypes]; // detector names
-  //
-  ClassDef(AliITSDetTypeSimUpg,1) // ITS Upg Simulation structure
-};
-
-#endif
diff --git a/ITS/UPGRADE/AliITSInitGeometryUpg.h b/ITS/UPGRADE/AliITSInitGeometryUpg.h
deleted file mode 100644 (file)
index 3e7cbdd..0000000
+++ /dev/null
@@ -1,119 +0,0 @@
-#ifndef ALIITSINITGEOMETRYUPG_H
-#define ALIITSINITGEOMETRYUPG_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/*
-$Id: AliITSInitGeometryUpg.h $
-*/
-
-/////////////////////////////////////////////////////////////////////
-// Class to inilize AliITSgeom and the like for both simulation
-//  and reconstruction.
-/////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include <TString.h>
-#include "AliITSgeom.h"
-
-typedef enum {
-  kvDefault=0,kv11=11,kvUpgrade=20
-} AliITSVersion_t;
-
-class TArrayD;
-class TGeoHMatrix;
-class TDatime;
-
-class AliITSInitGeometryUpg : public TObject{
- public:
-
-    AliITSInitGeometryUpg();//Default Constructor
-    AliITSInitGeometryUpg(AliITSVersion_t version,
-                      Int_t minorversion=2);//Standard Constructor
-    //virtual ~AliITSInitGeometryUpg(); // Destructor
-    //
-    // Create and initialize geometry from TGeo
-    AliITSgeom* CreateAliITSgeom();
-    AliITSgeom* CreateAliITSgeom(Int_t major,Int_t minor); 
-    Bool_t InitAliITSgeom(AliITSgeom *geom);//Initilize geometry from gGeoManager
-    // Getters and Setters
-    // Getters and Setters
-    void    SetVersion(AliITSVersion_t maj,Int_t min) {// Set Major and Minor versions
-        fMajorVersion=maj;fMinorVersion=min;}
-    TString GetGeometryName()const {return fName;}// Return geometry name
-    void    SetGeometryName(const Char_t *name){fName = name;}// Set Geometry name
-    Int_t   GetMajorVersion()const {return (Int_t)fMajorVersion;} // Return geometry major version
-    Int_t   GetMinorVersion()const{return fMinorVersion;}// Return geometry minor version
-    Bool_t  GetTiming()const{return fTiming;} // return routine timing flag
-    void    SetTiming(Bool_t time=kTRUE){fTiming=time;}// Set routine timing (on)
-    Bool_t  GetSegGeom()const{return fSegGeom;} // return flag indecating the use of AliITSsegmentation or AliITSgeomS?D class in fShape.
-    void    SetSegGeom(Bool_t seg=kTRUE){fSegGeom = seg;}// Set the use of AliITSsegmentation class' instead of AliITSgeomS?D class in fShape
-    Bool_t  GetDecoding()const{return fDecode;}// Return flag indecating wether to use new/old decoding
-    void    SetDecoding(Bool_t newdec=kFALSE){fDecode = newdec;}// Set flag to use new/old decoding
-     // Set debug level. debug=0 no debug info outputted.
-    void    SetDebug(Int_t debug=0){fDebug=debug;};
-    // Retrun debug value
-    Int_t   GetDebug()const{return fDebug;};
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayers(Int_t mod,Int_t &lay,Int_t &lad,Int_t &det);
-    // find module number by layer, and copy numbers
-    void DecodeDetector(Int_t &mod,Int_t lay,Int_t cpn0,
-                        Int_t cpn1,Int_t cpn2) const;
-    // Given module number, find copy numbers.
-    void RecodeDetector(Int_t mod,Int_t &cpn0,Int_t &cpn1,Int_t &cpn2);
-   // fills the string str with the major and minor version number
-    Bool_t WriteVersionString(Char_t *str,Int_t length,
-                              AliITSVersion_t maj,Int_t min,
-                              const Char_t *cvsDate,const Char_t *cvsRev)const;
-    // decodes the string str with the major and minor version number
-    Bool_t ReadVersionString(const Char_t *str,Int_t length,
-                             AliITSVersion_t &maj,Int_t &min,TDatime &dt)const;
-
-    Int_t GetNumberOfLayers();
-    Int_t GetNumberOfLadders(const Int_t lay) const;
-    Int_t GetNumberOfModules(const Int_t lay) const;
-    Int_t GetLayerDetTypeID(const Int_t lay) const;
-    //
- private:
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
-                                Int_t &lad,Int_t &det);
-    // find module number by layer, and copy numbers
-    void DecodeDetectorv11(Int_t &mod,Int_t lay,Int_t cpn0,Int_t cpn1,
-                          Int_t cpn2)const;
-    // Given module number, find copy numbers.
-    void RecodeDetectorv11(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                          Int_t &cpn2);
-    // Decode module number into old layer, ladder, and detector numbers
-    void DecodeDetectorvUpgrade(Int_t &mod,Int_t lay,Int_t cpn0,Int_t cpn1,
-                                    Int_t cpn2)const;
-    // find module number by layer, and copy numbers
-    void RecodeDetectorvUpgrade(Int_t mod,Int_t &cpn0,Int_t &cpn1,
-                                    Int_t &cpn2);
-    // Given module number, find copy numbers.
-    void DecodeDetectorLayersvUpgrade(Int_t mod,Int_t &lay,Int_t &lad,
-                                    Int_t &det);
-                  
-    // Virtual MC code 
-    Bool_t InitAliITSgeomV11(AliITSgeom *geom);
-    Bool_t InitAliITSgeomVUpgrade(AliITSgeom *geom);
-    Bool_t GetTransformation(const TString &volumePath,TGeoHMatrix &mat);
-    Bool_t GetShape(const TString &volumePath,TString &shapeType,TArrayD &par);
-    void TransposeTGeoHMatrix(TGeoHMatrix *m) const;
-
-    TString         fName;         // Geometry name
-    Int_t           fMinorVersion; // Geometry minor version
-    AliITSVersion_t fMajorVersion; // Geometry swich value
-    Bool_t          fTiming;       // Flag to start inilization timing
-    Bool_t          fSegGeom;      // Flag to switch between the old use of
-                                   // AliITSgeomS?D class, or AliITSsegmentation
-                                   // class in fShape of AliITSgeom class.
-    Bool_t          fDecode;       // Flag for new/old decoding
-    Int_t           fDebug;        // Debug flag
-
-    ClassDef(AliITSInitGeometryUpg,0) // create/Init AliITSgeom
-    // 0 in ClassDef indicates that this class will not be "saved" in a file.
-};
-
-#endif
-
diff --git a/ITS/UPGRADE/AliITSU.cxx b/ITS/UPGRADE/AliITSU.cxx
new file mode 100644 (file)
index 0000000..3b137bd
--- /dev/null
@@ -0,0 +1,820 @@
+/*
+*/
+
+/**************************************************************************
+ * 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: AliITSU.cxx $ */
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//      An overview of the basic philosophy of the ITS code development      //
+// and analysis is show in the figure below.                                 //
+//Begin_Html                                                                 //
+/*                                               
+<img src="picts/ITS/ITS_Analysis_schema.gif">
+</pre>
+<br clear=left>
+<font size=+2 color=red>
+<p>Roberto Barbera is in charge of the ITS Offline code (1999).
+<a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
+</font>
+<pre>
+*/
+//End_Html
+//
+//  AliITSU. Inner Traking System base class.
+//  This class contains the base procedures for the Inner Tracking System
+//
+//Begin_Html
+/*
+<img src="picts/ITS/AliITS_Class_Diagram.gif">
+</pre>
+<br clear=left>
+<font size=+2 color=red>
+<p>This show the class diagram of the different elements that are part of
+the AliITS class.
+</font>
+<pre>
+*/
+//End_Html
+//
+// Version: 0
+// Written by Rene Brun, Federico Carminati, and Roberto Barbera
+//
+// Version: 1
+// Modified and documented by Bjorn S. Nilsen
+// July 11 1999
+//
+// Version: 2
+// Modified and documented by A. Bologna
+// October 18 1999
+//
+// AliITSU is the general base class for the ITS. Also see AliDetector for
+// futher information.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdlib.h>
+#include <TClonesArray.h>
+#include <TFile.h>
+#include <TParticle.h>
+#include <TString.h>
+#include <TTree.h>
+#include <TVirtualMC.h>
+#include "AliDetector.h"
+#include "AliITSU.h"
+#include "AliITSLoader.h"
+#include "AliITSULoader.h"
+#include "AliITSUHit.h"
+#include "AliITSUSDigit.h"
+#include "AliITSUSimulation.h"
+#include "AliITSUSimulationPix.h"
+#include "AliITSsimulationFastPoints.h"
+#include "AliMC.h"
+#include "AliITSUDigitizer.h"
+#include "AliITSRecPoint.h"
+#include "AliRawReader.h"
+#include "AliRun.h"
+#include "AliLog.h"
+#include "AliITSdigit.h"
+#include "AliITSUModule.h"
+#include "AliITSUDigitPix.h"
+#include "AliITSsegmentation.h"
+#include "AliITSUSegmentationPix.h"
+#include "AliITSUSimuParam.h"
+#include "AliITSFOSignalsSPD.h"
+
+ClassImp(AliITSU)
+
+//______________________________________________________________________
+AliITSU::AliITSU() : 
+AliDetector()
+  ,fEuclidOut(0)
+  ,fNLayers(0)
+  ,fIdSens(0)
+  ,fLayerName(0)
+  ,fTiming(kFALSE)
+  ,fSimuParam(0)
+  ,fGeomTGeo(0)
+  ,fModA(0)
+  ,fpSDigits(0)
+  ,fSDigits(0)
+  ,fDetHits(0)
+  ,fModuleHits(0)
+  ,fDetDigits(0)
+  ,fSensMap(0)
+  ,fSimulation(0)
+  ,fSegmentation(0)
+  ,fCalibration(0)
+  ,fRunNumber(0)
+  ,fSimInitDone(kFALSE)
+{
+  // Default initializer for ITS  
+}
+
+//______________________________________________________________________
+AliITSU::AliITSU(const Char_t *title, Int_t nlay) :
+  AliDetector("ITS",title)
+  ,fEuclidOut(0)
+  ,fNLayers(nlay)
+  ,fIdSens(0)
+  ,fLayerName(0)
+  ,fTiming(kFALSE)
+  ,fSimuParam(0)
+  ,fGeomTGeo(0)
+  ,fModA(0)
+  ,fpSDigits(0)
+  ,fSDigits(0)
+  ,fDetHits(0)
+  ,fModuleHits(0)
+  ,fDetDigits(0)
+  ,fSensMap(0)
+  ,fSimulation(0)
+  ,fSegmentation(0)
+  ,fCalibration(0)
+  ,fRunNumber(0)
+  ,fSimInitDone(kFALSE)
+{
+  //     The standard Constructor for the ITS class. 
+}
+
+
+//______________________________________________________________________
+AliITSU::~AliITSU()
+{
+  // Default destructor for ITS.
+  //  
+  delete fHits;
+  delete fModuleHits;
+  delete fSimuParam;
+  delete fSensMap;
+  if (fSimulation) fSimulation->Delete();
+  delete fSimulation;
+  delete fSegmentation;
+  delete[] fLayerName;  // Array of TStrings
+  delete[] fIdSens;
+  //
+  int nmod = fGeomTGeo ? fGeomTGeo->GetNModules() : 0;
+  if (fModuleHits) fModuleHits->Delete();
+  delete fModuleHits;
+  if(fModA){
+    for(Int_t j=0; j<nmod; j++){
+      fModA[j]->Delete();
+      delete fModA[j];
+    }
+    delete[] fModA;
+  }
+  if (fpSDigits) { fpSDigits->Delete(); delete fpSDigits; }
+  if (fSDigits)  { fSDigits->Delete(); delete fSDigits; }
+  delete fGeomTGeo;
+  //
+}
+
+//______________________________________________________________________
+AliDigitizer* AliITSU::CreateDigitizer(AliDigitizationInput* manager) const
+{
+  // Creates the AliITSDigitizer in a standard way for use via AliModule.
+  // This function can not be included in the .h file because of problems
+  // with the order of inclusion (recursive).
+  // Inputs:
+  //    AliDigitizationInput *manager  The Manger class for Digitization
+  // Output:
+  //    none.
+  // Return:
+  //    A new AliITSRunDigitizer (cast as a AliDigitizer).
+  //
+  if (!IsSimInitDone()) AliFatal("Simulation is not initialized");
+  return new AliITSUDigitizer(manager);
+}
+
+//______________________________________________________________________
+void AliITSU::Init() 
+{
+  // Initializer ITS after it has been built
+  //     This routine initializes the AliITS class. It is intended to be
+  // called from the Init function in AliITSv?. Besides displaying a banner
+  // indicating that it has been called it initializes the array fIdSens
+  // and sets the default segmentation, response, digit and raw cluster
+  // classes therefore it should be called after a call to CreateGeometry.
+  //
+  if (!fIdSens) fIdSens = new Int_t[fNLayers];
+  for(int i=0;i<fNLayers;i++) fIdSens[i] = gMC ? gMC->VolId(fLayerName[i]) : 0;
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::MakeBranch(Option_t* option)
+{
+  // Creates Tree branches for the ITS.
+  // Inputs:
+  //      Option_t *option    String of Tree types S,D, and/or R.
+  //      const char *file    String of the file name where these branches
+  //                          are to be stored. If blank then these branches
+  //                          are written to the same tree as the Hits were
+  //                          read from.
+  // Outputs:
+  //      none.
+  // Return:
+  //      none.
+  
+  Bool_t cH = (strstr(option,"H")!=0);
+  Bool_t cS = (strstr(option,"S")!=0);
+  Bool_t cD = (strstr(option,"D")!=0);
+  
+  if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
+  AliDetector::MakeBranch(option);
+  
+  if(cS) MakeBranchS(0);
+  if(cD) MakeBranchD(0);
+  // 
+}
+
+//___________________________________________________________________
+void AliITSU::MakeBranchS(const char* fl) 
+{
+  // Creates Tree Branch for the ITS summable digits.
+  // Inputs:
+  //      cont char *fl  File name where SDigits branch is to be written
+  //                     to. If blank it write the SDigits to the same
+  //                     file in which the Hits were found.
+  //  
+  Int_t buffersize = 4000;
+  char branchname[31];
+  //
+  // only one branch for SDigits.
+  snprintf(branchname,30,"%s",GetName());
+  if(fLoader->TreeS()) MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::MakeBranchD(const char* file)
+{
+  //Make branch for digits
+  MakeBranchInTreeD(fLoader->TreeD(),file);
+}
+
+//___________________________________________________________________
+void AliITSU:: MakeBranchInTreeD(TTree* treeD, const char* file)
+{
+  // Creates Tree branches for the ITS.
+  //
+  if (!treeD) {AliFatal("No tree provided");}
+  Int_t buffersize = 4000;
+  if (!fDetDigits) InitArrays();
+  //
+  for (Int_t i=0;i<kNDetTypes;i++) {
+    ResetDigits(i);
+    TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
+    AliDetector::MakeBranchInTree(treeD,Form("%sDigits%s",GetName(),fGeomTGeo->GetDetTypeName(i)),
+                                 &darr,buffersize,file);
+  }
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::InitArrays()
+{
+  // initialize arrays
+  //
+  fHits = new TClonesArray("AliITSUHit",1560); // from AliDetector
+  if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
+  if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
+  //  
+  fDetDigits = new TObjArray(kNDetTypes);
+  for (Int_t i=0;i<kNDetTypes;i++) fDetDigits->AddAt(new TClonesArray(GetDigitClassName(i),100),i);
+  //
+  fSDigits = new TClonesArray("AliITSUSDigit",100);
+  //
+  fDetHits = new TClonesArray("AliITSUHit",100);
+  //
+  fModuleHits = new TObjArray(fGeomTGeo->GetNModules());
+  for (int i=0;i<fGeomTGeo->GetNModules();i++) fModuleHits->AddLast( new AliITSUModule(i,fGeomTGeo) );
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::SetTreeAddress()
+{
+  // Set branch address for the Trees.
+  TTree *treeS = fLoader->TreeS();
+  if (treeS) treeS->GetBranch(GetName())->SetAddress(&fSDigits);
+  //
+  TTree *treeD = fLoader->TreeD();
+  if (treeD) {
+    if (!fDetDigits) InitArrays();
+    for (int i=0;i<kNDetTypes;i++) {
+      TString brname = Form("%sDigits%s",GetName(),GetDetTypeName(i));
+      TBranch* br = treeD->GetBranch(brname.Data());
+      if (!br) AliFatal(Form("Did not find branch for %s",brname.Data()));
+      TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
+      br->SetAddress(&darr);
+    }
+  }
+  if (fLoader->TreeH() && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
+  AliDetector::SetTreeAddress();
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::AddHit(Int_t track, Int_t *vol, Float_t *hits)
+{
+  // Add an ITS hit
+  //     The function to add information to the AliITSUHit class. See the
+  // AliITSUHit class for a full description. This function allocates the
+  // necessary new space for the hit information and passes the variable
+  // track, and the pointers *vol and *hits to the AliITSUHit constructor
+  // function.
+  // Inputs:
+  //      Int_t   track   Track number which produced this hit.
+  //      Int_t   *vol    Array of Integer Hit information. See AliITSUHit.h
+  //      Float_t *hits   Array of Floating Hit information.  see AliITSUHit.h
+  TClonesArray &lhits = *fHits;
+  new(lhits[fNhits++]) AliITSUHit(fIshunt,track,vol,hits);
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::FillModules(Int_t bgrev, Option_t *option, const char *filename) 
+{
+  // fill the modules with the sorted by module hits; add hits from
+  // background if option=Add.
+  //
+  static TTree *trH1=0;                 //Tree with background hits
+  static Bool_t first=kTRUE;
+  static TFile *file = 0;
+  const char *addBgr = strstr(option,"Add");
+  //
+  if (addBgr ) {
+    if(first) {
+      file = new TFile(filename);    
+      first=kFALSE;
+    }
+    file->cd();
+    file->ls();
+    // Get Hits Tree header from file
+    if (trH1) {delete trH1; trH1=0;}
+    //
+    char treeName[21];
+    snprintf(treeName,20,"TreeH%d",bgrev);
+    trH1 = (TTree*)gDirectory->Get(treeName);
+    if (!trH1) Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
+    // Set branch addresses
+  } // end if addBgr
+  
+  FillModules(fLoader->TreeH(),0); // fill from this file's tree.
+  //
+  if (addBgr ) {
+    FillModules(trH1,10000000); // Default mask 10M.
+    TTree *fAli=fLoader->GetRunLoader()->TreeK();
+    TFile *fileAli=0;
+    if (fAli) {
+      fileAli = fAli->GetCurrentFile();
+      fileAli->cd();
+    }
+  } // end if add
+  //  
+}
+
+//______________________________________________________________________
+void AliITSU::FillModules(TTree *treeH, Int_t /*mask*/)
+{
+  // fill the modules with the sorted by module hits; 
+  // can be called many times to do a merging
+  // Inputs:
+  //      TTree *treeH  The tree containing the hits to be copied into
+  //                    the modules.
+  //      Int_t mask    The track number mask to indecate which file
+  //                    this hits came from.
+  //  
+  if (treeH == 0x0) { AliError("Tree H  is NULL"); return; }
+  //
+  Int_t lay,lad,det,index;
+  AliITSUHit *itsHit=0;
+  char branchname[21];
+  snprintf(branchname,20,"%s",GetName());
+  TBranch *branch = treeH->GetBranch(branchname);
+  if (!branch) {Error("FillModules","%s branch in TreeH not found",branchname); return;} // end if !branch
+  //
+  branch->SetAddress(&fHits);
+  Int_t nTracks =(Int_t) treeH->GetEntries();
+  Int_t iPrimTrack,h;
+  for (iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++) {
+    ResetHits();
+    Int_t nBytes = treeH->GetEvent(iPrimTrack);
+    if (nBytes <= 0) continue;
+    Int_t nHits = fHits->GetEntriesFast();
+    for (h=0; h<nHits; h++){
+      itsHit = (AliITSUHit *)fHits->UncheckedAt(h);
+      itsHit->GetDetectorID(lay,lad,det);
+      index = fGeomTGeo->GetModuleIndex(--lay,--lad,--det); // !!! AliITSHit counts indices from 1!
+      itsHit = new( (*fDetHits)[fDetHits->GetEntriesFast()] ) AliITSUHit(*itsHit);
+      itsHit->SetUniqueID(h);
+      GetModule(index)->AddHit(itsHit);
+      // do we need to add a mask?
+      // itsHit->SetTrack(itsHit->GetTrack()+mask);
+    } // end loop over hits 
+  } // end loop over tracks
+}
+
+//______________________________________________________________________
+void AliITSU::ClearModules()
+{
+  // clear accumulated hits
+  if (!fModuleHits || !fDetHits) AliFatal("Hits accumulation arrays are not defined");
+  for (int i=fGeomTGeo->GetNModules();i--;) GetModule(i)->Clear();
+  fDetHits->Clear();
+}
+
+//______________________________________________________________________
+void AliITSU::Hits2SDigits()
+{
+  // Standard Hits to summable Digits function.
+  // Inputs:
+  //      none.
+  // Outputs:
+  //      none.
+  if (!IsSimInitDone()) InitSimulation();
+  fLoader->LoadHits("read");
+  fLoader->LoadSDigits("recreate");
+  AliRunLoader* rl = fLoader->GetRunLoader(); 
+  //
+  for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
+    rl->GetEvent(iEvent);
+    if (!fLoader->TreeS()) fLoader->MakeTree("S");
+    MakeBranch("S");
+    SetTreeAddress();
+    Hits2SDigits(iEvent,0," "," ");
+  } // end for iEvent
+    //
+  fLoader->UnloadHits();
+  fLoader->UnloadSDigits();
+  // 
+}
+
+//______________________________________________________________________
+void AliITSU::Hits2SDigits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
+{
+  // Keep galice.root for signal and name differently the file for 
+  // background when add! otherwise the track info for signal will be lost !
+  // Inputs:
+  //      Int_t evnt       Event to be processed.
+  //      Int_t bgrev      Background Hit tree number.
+  //      Int_t nmodules   Not used.
+  //      Option_t *option String indicating if merging hits or not. To
+  //                       merge hits set equal to "Add". Otherwise no
+  //                       background hits are considered.
+  //      Test_t *filename File name containing the background hits..
+  //
+  if (!IsSimInitDone()) InitSimulation();
+  FillModules(bgrev,option,filename);
+  //
+  Int_t nmodules = fGeomTGeo->GetNModules();
+  for(int module=0;module<nmodules;module++) {
+    int id = fGeomTGeo->GetModuleDetTypeID(module);
+    AliITSUSimulation* sim = GetSimulationModel(id);
+    if (!sim) AliFatal(Form("The sim.class for module %d of DetTypeID %d is missing",module,id));
+    sim->SDigitiseModule( GetModule(module), module, evNumber, GetSegmentation(id));
+    fLoader->TreeS()->Fill();      // fills all branches - wasted disk space
+    ResetSDigits();
+  } 
+  //
+  ClearModules();
+  //
+  fLoader->TreeS()->GetEntries();
+  fLoader->TreeS()->AutoSave();
+  fLoader->WriteSDigits("OVERWRITE");
+  fLoader->TreeS()->Reset();
+}
+
+//______________________________________________________________________
+void AliITSU::Hits2Digits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
+{
+  //   Keep galice.root for signal and name differently the file for 
+  // background when add! otherwise the track info for signal will be lost !
+  // Inputs:
+  //      Int_t evnt       Event to be processed.
+  //      Int_t bgrev      Background Hit tree number.
+  //      Option_t *option String indicating if merging hits or not. To
+  //                       merge hits set equal to "Add". Otherwise no
+  //                       background hits are considered.
+  //      Test_t *filename File name containing the background hits..
+  // Outputs:
+  //  
+  if (!IsSimInitDone()) InitSimulation();
+  FillModules(bgrev,option,filename);
+  // 
+  Int_t nmodules = fGeomTGeo->GetNModules();
+  for (Int_t module=0;module<nmodules;module++) {
+    int id = fGeomTGeo->GetModuleDetTypeID(module);
+    AliITSUSimulation* sim = GetSimulationModel(id);
+    if (!sim) AliFatal(Form("The sim.class for module %d of DetTypeID %d is missing",module,id));
+    sim->DigitiseModule( GetModule(module) ,module, evNumber, GetSegmentation(id));
+    // fills all branches - wasted disk space
+    fLoader->TreeD()->Fill(); 
+    ResetDigits();
+  } // end for module
+  //
+  ClearModules();
+  //
+  //    WriteFOSignals(); // Add Fast-OR signals to event (only one object per event)
+  fLoader->TreeD()->GetEntries();
+  fLoader->TreeD()->AutoSave();
+  fLoader->TreeD()->Reset(); 
+  //
+}
+
+//_____________________________________________________________________
+void AliITSU::Hits2FastRecPoints(Int_t bgrev,Option_t *opt,const char *flnm)
+{
+  // keep galice.root for signal and name differently the file for 
+  // background when add! otherwise the track info for signal will be lost !
+  // Inputs:
+  //      Int_t evnt       Event to be processed.
+  //      Int_t bgrev      Background Hit tree number.
+  //      Option_t *opt    Option passed to FillModules. See FillModules.
+  //      Test_t *flnm     File name containing the background hits..
+  // Outputs:
+  //      none.
+  // Return:
+  //      none.
+  if (!IsSimInitDone()) InitSimulation();
+  AliITSULoader *pITSloader = (AliITSULoader*)fLoader;
+  Int_t nmodules = fGeomTGeo->GetNModules();
+  FillModules(bgrev,opt,flnm);
+  //
+  TTree *lTR = pITSloader->TreeR();
+  if(!lTR) {
+    pITSloader->MakeTree("R");
+    lTR = pITSloader->TreeR();
+  }
+  //
+  TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
+  TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
+  branch->SetAddress(&ptarray);
+  for (int module=0;module<nmodules;module++){
+    int id = fGeomTGeo->GetModuleDetTypeID(module);
+    AliITSUSimulation* sim = GetSimulationModel(id);
+    if (!sim) AliFatal(Form("The sim.class for module %d of DetTypeID %d is missing",module,id));
+    sim->CreateFastRecPoints( GetModule(module) ,module,gRandom,ptarray);
+    lTR->Fill();
+    ptarray->Clear();
+  } // end for module
+  //
+  ClearModules();
+  fLoader->WriteRecPoints("OVERWRITE");
+  delete ptarray;
+}
+
+//_____________________________________________________________________
+Int_t AliITSU::Hits2Clusters(TTree *hTree, TTree *cTree)
+{
+  /* RS: TODO
+  // This function creates ITS clusters
+  if (!IsSimInitDone()) InitSimulation();
+  Int_t mmax = 0;
+  FillModules(hTree,0);
+  //
+  TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
+  TBranch *branch=cTree->GetBranch("ITSRecPoints");
+  if (!branch) cTree->Branch("ITSRecPoints",&points);
+  else branch->SetAddress(&points);
+  //
+  AliITSsimulationFastPoints sim;
+  Int_t ncl=0;
+  for (Int_t m=0; m<mmax; m++) {
+    sim.CreateFastRecPoints(GetModule(m),m,gRandom,points);      
+    ncl+=points->GetEntriesFast();
+    cTree->Fill();
+    points->Clear();
+  }
+  //
+  ClearModules();
+  //
+  AliDebug(1,Form("Number of found fast clusters : %d",ncl));
+  //cTree->Write();
+  delete points;
+  */
+  return 0;
+}
+
+//_____________________________________________________________________
+void AliITSU::CheckLabels(Int_t lab[3]) const //RSDONE
+{
+  // Tries to find mother's labels
+  //
+  if(lab[0]<0 && lab[1]<0 && lab[2]<0) return; // In case of no labels just exit
+  //
+  Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
+  for (Int_t i=0;i<3;i++){
+    Int_t label = lab[i];
+    if (label>=0 && label<ntracks) {
+      TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
+      if (part->P() < 0.005) {
+       Int_t m=part->GetFirstMother();
+       if (m<0) continue;
+       if (part->GetStatusCode()>0) continue;
+       lab[i]=m;       
+      }
+    }    
+  }
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::ResetDigits() //RSDONE?
+{
+  // Reset number of digits and the digits array for the ITS detector.
+  if (fDetDigits) for (int i=kNDetTypes;i--;) ResetDigits(i);
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::ResetDigits(Int_t branch)
+{
+  // Reset number of digits and the digits array for this branch.
+  if (fDetDigits) ((TClonesArray*)fDetDigits->At(branch))->Clear();
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::AddSumDigit(AliITSUSDigit &sdig)
+{
+  // Adds the module summable digits to the summable digits tree.
+  new( (*fSDigits)[fSDigits->GetEntriesFast()]) AliITSUSDigit(sdig);
+  //  
+}
+
+//______________________________________________________________________
+void AliITSU::AddSimDigit(Int_t branch, AliITSdigit *d)
+{
+  //    Add a simulated digit.
+  // Inputs:
+  //      Int_t id        Detector type number.
+  //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
+  //                      AliITSdigit.h
+  TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
+  int nd = ldigits.GetEntriesFast();
+  switch(branch){
+  case AliITSUGeomTGeo::kDetTypePixUpg:
+    new(ldigits[nd]) AliITSUDigitPix(*((AliITSUDigitPix*)d));
+    break;
+  default:
+    AliFatal(Form("Unknown digits branch %d",branch));
+  }
+}
+
+//______________________________________________________________________
+void AliITSU::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
+                           Int_t *hits,Float_t *charges, Int_t sigexpanded)
+{
+  // Add a simulated digit to the list.
+  // Inputs:
+  //      Int_t id        Detector type number.
+  //      Float_t phys    Physics indicator. See AliITSdigits.h
+  //      Int_t *digits   Integer array containing the digits info. See 
+  //                      AliITSdigit.h
+  //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
+  //                      containing the track numbers that contributed to
+  //                      this digit.
+  //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
+  //                      containing the hit numbers, from AliITSmodule, that
+  //                      contributed to this digit.
+  //      Float_t *charge Floating point array of the signals contributed
+  //                      to this digit by each track.
+  TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
+  int nd = ldigits.GetEntriesFast();
+  switch(branch){
+  case AliITSUGeomTGeo::kDetTypePixUpg:
+    new(ldigits[nd]) AliITSUDigitPix(digits,tracks,hits);
+    break;
+  default:
+    AliFatal(Form("Unknown digits branch %d",branch));
+  }  
+  //
+}
+
+//______________________________________________________________________
+void AliITSU::Digits2Raw()
+{
+  AliError("Not ready");
+}
+
+//______________________________________________________________________
+AliLoader* AliITSU::MakeLoader(const char* topfoldername)
+{ 
+  //builds ITSgetter (AliLoader type)
+  //if detector wants to use castomized getter, it must overload this method
+  
+  AliDebug(1,Form("Creating AliITSULoader. Top folder is %s.",topfoldername));
+  fLoader = new AliITSULoader(GetName(),topfoldername);
+  return fLoader;
+}
+
+//______________________________________________________________________
+Bool_t AliITSU::Raw2SDigits(AliRawReader* rawReader)
+{
+  AliError("Not ready");
+  return kFALSE;
+}
+
+//______________________________________________________________________
+/*
+AliTriggerDetector* AliITSU::CreateTriggerDetector() const 
+{
+  // create an AliITSTrigger object (and set trigger conditions as input)
+  return new AliITSTrigger(fDetTypeSim->GetTriggerConditions());
+}
+*/
+
+//______________________________________________________________________
+void AliITSU::WriteFOSignals()
+{
+  // This method write FO signals in Digits tree both in Hits2Digits
+  // or SDigits2Digits
+  AliError("Not ready");
+  //  fDetTypeSim->ProcessNoiseForFastOr();
+}
+
+//_______________________________________________________________________
+void AliITSU::SDigits2Digits()
+{
+  // Standard Summable digits to Digits function.
+  //
+  if (!IsSimInitDone()) InitSimulation();
+  TTree* trees = fLoader->TreeS();
+  if( !(trees && fSDigits) ) AliFatal("Error: No trees or SDigits.");
+  TBranch* brchSDigits = trees->GetBranch(GetName());
+  //
+  int nmodules = fGeomTGeo->GetNModules();
+  for (int module=0;module<nmodules;module++) {
+    int id = fGeomTGeo->GetModuleDetTypeID(module);
+    AliITSUSimulation *sim = GetSimulationModel(id);
+    if(!sim){
+      AliFatal(Form("The sim.class for module %d of DetTypeID %d is missing",module,id));
+      exit(1);
+    }
+    sim->InitSimulationModule(module,gAlice->GetEvNumber(),GetSegmentation(id));
+    fSDigits->Clear();
+    brchSDigits->GetEvent(module);
+    sim->AddSDigitsToModule(fSDigits,0);
+    sim->FinishSDigitiseModule();
+    fLoader->TreeD()->Fill();
+    ResetDigits();
+  }
+  //  WriteFOSignals(); 
+  fLoader->TreeD()->GetEntries();
+  fLoader->TreeD()->AutoSave();
+  fLoader->TreeD()->Reset();
+}
+
+//_______________________________________________________________________
+void AliITSU::InitSimulation()
+{
+  // Initialize arrays, segmentations ets, needed for simulation
+  // Equivalent of old AliITSDetTypeSim construction
+  //
+  if (fSimInitDone) {AliInfo("Already done"); return;}
+  //
+  fGeomTGeo     = new AliITSUGeomTGeo(kTRUE);
+  fSimuParam    = new AliITSUSimuParam();
+  fSensMap      = new AliITSUSensMap("AliITSUSDigit",0,0);
+  fSimulation   = new TObjArray(kNDetTypes);
+  fSegmentation = new TObjArray();
+  AliITSUSegmentationPix::LoadSegmentations(fSegmentation, AliITSUGeomTGeo::GetITSsegmentationFileName());
+  fSegmentation->SetOwner(kTRUE);
+  //
+  // add known simulation types used in the setup
+  for (int i=fNLayers;i--;) {
+    int sType = fGeomTGeo->GetLayerDetTypeID(i)/AliITSUGeomTGeo::kMaxSegmPerDetType;
+    if (fSimulation->At(sType)) continue;
+    //
+    AliITSUSimulation* simUpg = 0;
+    switch (sType) {
+    case AliITSUGeomTGeo::kDetTypePixUpg : 
+      simUpg = new AliITSUSimulationPix(fSimuParam,fSensMap); 
+      break;
+    default: AliFatal(Form("No %d detector type is defined",sType));
+    };
+    fSimulation->AddAtAndExpand(simUpg,sType);
+  }
+  //
+  InitArrays();
+  //
+  fSimInitDone = kTRUE;
+  //
+}
diff --git a/ITS/UPGRADE/AliITSU.h b/ITS/UPGRADE/AliITSU.h
new file mode 100644 (file)
index 0000000..d14ed02
--- /dev/null
@@ -0,0 +1,155 @@
+#ifndef ALIITSU_H
+#define ALIITSU_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliITSU.h */
+
+////////////////////////////////////////////////////////////////////////
+//           Manager class for set: ITS Upgrade                       //
+////////////////////////////////////////////////////////////////////////
+
+
+#include <TObjArray.h> // used in inline function GetModule.
+#include "AliDetector.h"
+#include "AliITSTrigger.h"
+#include "AliITSDetTypeSim.h"
+#include "AliITSUGeomTGeo.h"
+
+class TString;
+class TTree;
+class AliITSUSDigit;
+class AliITSUSimulation;
+class AliITSsegmentation;
+class AliITSUModule;
+class AliITSCalibration;
+class AliITSUHit;
+class AliITSgeom;
+class AliITSdigit;
+class AliDigitizationInput;
+class AliITSUSensMap;
+class AliITSUSimuParam;
+
+
+class AliITSU : public AliDetector {
+
+ public:
+  //
+  // number detector types
+  enum {kNDetTypes = AliITSUGeomTGeo::kNDetTypes};
+  //
+  //================= Standard Classes ===============================
+  AliITSU();  // Default creator.
+  AliITSU(const char *title, Int_t nlayers); // extended standard Creator
+  virtual ~AliITSU(); // destructor
+  virtual Int_t IsVersion() const {return 11;}
+  
+  //===================== Simulation Geometry ========================
+  // get geometry version - detailed (major) or coarse (minor)
+  virtual Int_t GetMajorVersion() const {return -1;}
+  virtual Int_t GetMinorVersion() const {return -1;}
+  virtual void  GetGeometryVersion(Int_t &a,Int_t &b) const {a = GetMajorVersion();b=GetMinorVersion();return;}
+  virtual void  SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
+  virtual Bool_t GetEUCLID()const {return fEuclidOut;}
+  //-------------------- Geometry Transformations --------------------
+  
+  // ITS geometry functions From Simulation
+  AliITSUGeomTGeo* GetITSGeomTGeo() const {return fGeomTGeo;}
+  //RS  AliITSgeom* GetITSgeom() const {return fDetTypeSim->GetITSgeom();}
+  //RS  void   SetITSgeom(AliITSgeom *geom) {fDetTypeSim->SetITSgeom(geom);}
+  // return pointer to the array of modules
+  
+  AliITSUModule   * GetModule(Int_t index) {return (AliITSUModule*)fModuleHits->UncheckedAt(index);}
+  AliITSUSimuParam* GetSimuParam() const {return fSimuParam;}
+    
+  //================ Necessary general Classes =======================
+  virtual void Init();
+  virtual AliLoader* MakeLoader(const char* topfoldername);
+  virtual void MakeBranch(Option_t *opt=" ");
+  virtual void MakeBranchS(const char* fl);
+  virtual void MakeBranchD(const char* file);
+  virtual void MakeBranchInTreeD(TTree* treeD, const char* file=0);
+  virtual void SetTreeAddress();
+  virtual AliITSUSimulation* GetSimulationModel(Int_t id) {return (AliITSUSimulation*)fSimulation->At(id/AliITSUGeomTGeo::kMaxSegmPerDetType);}
+  virtual AliITSsegmentation*  GetSegmentation(Int_t id)    {return (AliITSsegmentation*) fSegmentation->At(id);}
+  //=================== Hits =========================================
+  virtual void StepManager() {} // See Step Manager for specific geometry.
+  //------------ sort hits by module for Digitisation ----------------
+  virtual void FillModules(Int_t bgrev, Option_t *opt, const char *filename); 
+  virtual void FillModules(TTree *treeH, Int_t mask = 0);
+  virtual void ClearModules();
+  virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
+  void         InitSimulation();
+  //
+  // Trigger
+  //  virtual AliTriggerDetector* CreateTriggerDetector() const;
+
+  AliDigitizer* CreateDigitizer(AliDigitizationInput* manager) const;
+  virtual void SDigits2Digits();
+  virtual void Hits2Digits(); 
+  virtual void Hits2SDigits();
+  virtual void Hits2Digits(Int_t evNumber,Int_t bgrev,Option_t *option, const char *filename);
+  virtual void Hits2SDigits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename);
+    
+  virtual void ResetSDigits()       {if (fSDigits) fSDigits->Clear();}
+  virtual void ResetDigits();
+  virtual void ResetDigits(Int_t branch);
+  virtual void AddSumDigit(AliITSUSDigit &sdig);
+  virtual void AddSimDigit(Int_t branch, AliITSdigit *d);
+  virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,Int_t* tracks,Int_t *hits,Float_t* trkcharges,Int_t sigexpanded=-1000);
+  TObjArray*   GetDigits()                const {return fDetDigits;}
+  TClonesArray *DigitsAddress(Int_t id)  {return fDetDigits ? (TClonesArray*)fDetDigits->At(id) : 0;}
+  //Fast simulation
+  virtual void  Hits2FastRecPoints(Int_t bgrev,Option_t *opr, const char *filename);
+  virtual Int_t Hits2Clusters(TTree *in, TTree *out);
+  virtual void  CheckLabels(Int_t lab[3]) const;
+
+  //===================== Raw Data IO ================================
+  // Write digits into raw data format
+  virtual void   Digits2Raw();
+  virtual Bool_t Raw2SDigits(AliRawReader*);
+    
+  //===================== FO signals ================================
+  // Write FO signals in UserInfo of SDigits/Digits tree
+  void    WriteFOSignals();
+
+  void    SetRunNumber(Int_t rn=0)        {fRunNumber = rn;}
+  Int_t   GetNLayers()              const {return fNLayers;}
+  Int_t   GetRunNumber()            const {return fRunNumber;}
+  Bool_t  IsSimInitDone()           const {return fSimInitDone;}
+
+ protected:
+  void        InitArrays();
+  const char* GetDigitClassName(Int_t i) {return Form("AliITSdigit%s",AliITSUGeomTGeo::GetDetTypeName(i));}
+  const char* GetDetTypeName(Int_t i) {return AliITSUGeomTGeo::GetDetTypeName(i);}
+  
+ protected:
+  //================== Data Members ==================================
+  Bool_t                fEuclidOut;      // Flag to write geometry in euclid format
+  Int_t                 fNLayers;        // the number of layers
+  Int_t                *fIdSens;         //[fNLayers] layer identifier
+  TString              *fLayerName;      //[fNLayers] layer identifier
+  Bool_t                fTiming;         // flag to turn on/off timers.
+  AliITSUSimuParam*   fSimuParam;      //simulation parameters
+  AliITSUGeomTGeo*    fGeomTGeo;       //  access to geometry details
+  TClonesArray**        fModA;           //! Used by Raw2SDigits (one TC per module)
+  TClonesArray*         fpSDigits;       //! Branch address to build SD from raw data 
+  TClonesArray*         fSDigits;        //! Branch address to build SD
+  TClonesArray*         fDetHits;        //! array of full detector hits
+  TObjArray*            fModuleHits;     //! module's hits container in (pointers on the fDetHits)
+  TObjArray*            fDetDigits;      //! AliDetector has TClonesArray fDigits, avoid same name
+  AliITSUSensMap*     fSensMap;        //! sensor map for digitization
+  //
+  TObjArray            *fSimulation;     //! simulation objects per det.type
+  TObjArray            *fSegmentation;   //! segmentation objects per det.type (and segmentation)
+  TObjArray            *fCalibration;    //! calibration objects
+  Int_t                 fRunNumber;      //! run number
+  Bool_t                fSimInitDone;    //! flag initialized simulation
+
+ private:
+  AliITSU(const AliITSU &source); // copy constructor. Not to be used!
+  AliITSU& operator=(const AliITSU &source); // = operator. Not to be used!
+  ClassDef(AliITSU,1) // Base class for ITS
+};
+
+#endif
similarity index 77%
rename from ITS/UPGRADE/AliITSCalibrationPixUpg.cxx
rename to ITS/UPGRADE/AliITSUCalibrationPix.cxx
index 7ce9319..cc8016f 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 #include "TArrayI.h"
-#include "AliITSCalibrationPixUpg.h"
+#include "AliITSUCalibrationPix.h"
 
 ///////////////////////////////////////////////////////////////////////////
 //
 //
 ///////////////////////////////////////////////////////////////////////////
 
-ClassImp(AliITSCalibrationPixUpg)
+ClassImp(AliITSUCalibrationPix)
 
 //______________________________________________________________________
-AliITSCalibrationPixUpg::AliITSCalibrationPixUpg() 
+AliITSUCalibrationPix::AliITSUCalibrationPix() 
 : fNChips(0)
   ,fNColPerChip(0)
   ,fNCol(0)
   ,fNRow(0)
-  ,fNrBad(0)
+  ,fNrBadSingle(0)
   ,fBadChips(0)
   ,fBadChannels(0)
 {
@@ -44,12 +44,12 @@ AliITSCalibrationPixUpg::AliITSCalibrationPixUpg()
 }
 
 //______________________________________________________________________
-AliITSCalibrationPixUpg::AliITSCalibrationPixUpg(Short_t nChips,Short_t nColPerChip,Short_t nRow) 
+AliITSUCalibrationPix::AliITSUCalibrationPix(Short_t nChips,Short_t nColPerChip,Short_t nRow) 
 : fNChips(0)
   ,fNColPerChip(0)
   ,fNCol(0)
   ,fNRow(0)
-  ,fNrBad(0)
+  ,fNrBadSingle(0)
   ,fBadChips(0)
   ,fBadChannels(0)
 {
@@ -60,40 +60,40 @@ AliITSCalibrationPixUpg::AliITSCalibrationPixUpg(Short_t nChips,Short_t nColPerC
 }
 
 //______________________________________________________________________
-AliITSCalibrationPixUpg::AliITSCalibrationPixUpg(const AliITSCalibrationPixUpg &src) : 
+AliITSUCalibrationPix::AliITSUCalibrationPix(const AliITSUCalibrationPix &src) : 
   AliITSCalibration(src)
   ,fNChips(src.fNChips)
   ,fNColPerChip(src.fNColPerChip)
   ,fNCol(src.fNCol)
   ,fNRow(src.fNRow)
-  ,fNrBad(src.fNrBad)
+  ,fNrBadSingle(src.fNrBadSingle)
   ,fBadChips(src.fBadChips)
   ,fBadChannels(src.fBadChannels)
 {
 }
 
 //____________________________________________________________________________
-void AliITSCalibrationPixUpg::ClearBad() 
+void AliITSUCalibrationPix::ClearBad() 
 {
   // clear all bad pixels (single+chips)
   fBadChannels.Reset();
-  fNrBad=0;
+  fNrBadSingle=0;
   fBadChips = 0;
   //
 }
 
 //____________________________________________________________________________
-void AliITSCalibrationPixUpg::AddBad(Int_t col, Int_t row) 
+void AliITSUCalibrationPix::AddBad(Int_t col, Int_t row) 
 {
   // add single bad pixel 
-  fBadChannels.Set(fNrBad*2+2);
-  fBadChannels.AddAt(col,fNrBad*2);
-  fBadChannels.AddAt(row,fNrBad*2+1);
-  fNrBad++;
+  fBadChannels.Set(fNrBadSingle*2+2);
+  fBadChannels.AddAt(col,fNrBadSingle*2);
+  fBadChannels.AddAt(row,fNrBadSingle*2+1);
+  fNrBadSingle++;
 }
 
 //____________________________________________________________________________
-void AliITSCalibrationPixUpg::SetChipBad(Int_t chip) 
+void AliITSUCalibrationPix::SetChipBad(Int_t chip) 
 {
   // set full chip bad
   if ((int)chip>=fNChips) {AliError(Form("chip number %d exceeds allowed limit %d",chip,fNChips)); return;}
@@ -102,7 +102,7 @@ void AliITSCalibrationPixUpg::SetChipBad(Int_t chip)
 }
 
 //____________________________________________________________________________
-void AliITSCalibrationPixUpg::UnSetChipBad(Int_t chip) 
+void AliITSUCalibrationPix::UnSetChipBad(Int_t chip) 
 {
   // unset full chip bad
   if (chip>=fNChips) {AliError(Form("chip number %d exceeds allowed limit %d",chip,fNChips)); return;}
@@ -111,7 +111,7 @@ void AliITSCalibrationPixUpg::UnSetChipBad(Int_t chip)
 }
 
 //____________________________________________________________________________
-Int_t AliITSCalibrationPixUpg::GetBadColAt(Int_t index) const 
+Int_t AliITSUCalibrationPix::GetBadColAt(Int_t index) const 
 {
   // Get column of index-th bad pixel
   int nrc = fNColPerChip*fNRow;
@@ -134,7 +134,7 @@ Int_t AliITSCalibrationPixUpg::GetBadColAt(Int_t index) const
 }
 
 //____________________________________________________________________________
-Int_t AliITSCalibrationPixUpg::GetBadRowAt(Int_t index) const 
+Int_t AliITSUCalibrationPix::GetBadRowAt(Int_t index) const 
 {
   // Get row of index-th bad pixel
   int nrc = fNColPerChip*fNRow;
@@ -157,7 +157,7 @@ Int_t AliITSCalibrationPixUpg::GetBadRowAt(Int_t index) const
 }
 
 //____________________________________________________________________________
-void AliITSCalibrationPixUpg::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const 
+void AliITSUCalibrationPix::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const 
 {
   // i: is the i-th bad pixel in single bad pixel list
   // row: is the corresponding row (-1 if i is out of range)
@@ -189,27 +189,38 @@ void AliITSCalibrationPixUpg::GetBadPixel(Int_t index, Int_t &row, Int_t &col) c
   AliError(Form("Index %d is out of bounds - nothing done",index));
 }
 
+//____________________________________________________________________________
+void AliITSUCalibrationPix::GetBadPixelSingle(Int_t index, UInt_t &row, UInt_t &col) const 
+{
+  // i: is the i-th bad pixel in single bad pixel list
+  // row: is the corresponding row (-1 if i is out of range)
+  // col: is the corresponding column (-1 if i is out of range)
+  if(index<0 && index>=GetNrBadSingle())  AliFatal(Form("Index %d >= NrBadSingle=%d",index,fNrBadSingle));
+  col = fBadChannels.At(index*2);
+  row = fBadChannels.At(index*2+1);
+}
+
 //___________________________________________________________________________
-Int_t  AliITSCalibrationPixUpg::GetNrBad() const 
+Int_t  AliITSUCalibrationPix::GetNrBad() const 
 {
   // Total number of bad pixels (including bad chips) in a given module
   Int_t bad=0;
   // single pixels:
-  bad += fNrBad;
+  bad += fNrBadSingle;
   // whole chips:
   for (int chip=fNChips; chip--;) if (IsChipMarkedBad(chip)) bad += fNColPerChip*fNRow;
   return bad;
 }
 
 //___________________________________________________________________________
-Int_t  AliITSCalibrationPixUpg::GetNrBadInChip(Int_t chip) const 
+Int_t  AliITSUCalibrationPix::GetNrBadInChip(Int_t chip) const 
 {
   // Total number of bad pixels (including bad chips) in a given chip
   if(chip<0 || chip>=fNChips) {AliError("Wrong chip number"); return -1;}
   if (IsChipMarkedBad(chip)) return fNColPerChip*fNRow;
   else {
     Int_t bad=0;
-    for (int i=fNrBad; i--;) {
+    for (int i=fNrBadSingle; i--;) {
       Int_t col = GetBadColAt(i);
       if (col!=-1) if (GetChipIndexFromCol(col)==chip) bad++;
     }
@@ -218,20 +229,20 @@ Int_t  AliITSCalibrationPixUpg::GetNrBadInChip(Int_t chip) const
 }
 
 //___________________________________________________________________________
-Int_t  AliITSCalibrationPixUpg::GetNrBadInColumn(Int_t col) const 
+Int_t  AliITSUCalibrationPix::GetNrBadInColumn(Int_t col) const 
 {
   // Total number of bad pixels (including bad chips) in a given column: col. range
   if(col<0 || col>=fNCol) {AliError("Wrong column number"); return -1;}
   if (IsChipMarkedBad(GetChipIndexFromCol(col))) return fNRow;
   else {
     Int_t bad=0;
-    for (int i=fNrBad; i--;) if (GetBadColAt(i)==col) bad++;
+    for (int i=fNrBadSingle; i--;) if (GetBadColAt(i)==col) bad++;
     return bad;
   }
 }
 
 //______________________________________________________________________
-Bool_t AliITSCalibrationPixUpg::IsBad() const 
+Bool_t AliITSUCalibrationPix::IsBad() const 
 {
   // Are all chips of this module bad?
   for (Int_t chip=fNChips; chip--;) if (!IsChipMarkedBad(chip)) return kFALSE;
@@ -239,32 +250,32 @@ Bool_t AliITSCalibrationPixUpg::IsBad() const
 }
 
 //______________________________________________________________________
-Bool_t AliITSCalibrationPixUpg::IsChipBad(Int_t chip) const 
+Bool_t AliITSUCalibrationPix::IsChipBad(Int_t chip) const 
 {
   // Is the full chip bad?
   return (GetNrBadInChip(chip)==fNColPerChip*fNRow);
 }
 
 //______________________________________________________________________
-Bool_t AliITSCalibrationPixUpg::IsColumnBad(Int_t col) const 
+Bool_t AliITSUCalibrationPix::IsColumnBad(Int_t col) const 
 {
   // Is the full column bad?
   return (GetNrBadInColumn(col)==fNRow);
 }
 
 //____________________________________________________________________________
-Bool_t AliITSCalibrationPixUpg::IsPixelBad(Int_t col, Int_t row) const 
+Bool_t AliITSUCalibrationPix::IsPixelBad(Int_t col, Int_t row) const 
 {
   // Is this pixel bad?
   if(col<0 || col>=fNCol) {AliError("Wrong column number"); return kFALSE;}
   Int_t chip = GetChipIndexFromCol(col);
   if (IsChipMarkedBad(chip)) return kTRUE;
-  for (Int_t i=fNrBad; i--;) if (GetBadColAt(i)==col && GetBadRowAt(i)==row) return kTRUE;
+  for (Int_t i=fNrBadSingle; i--;) if (GetBadColAt(i)==col && GetBadRowAt(i)==row) return kTRUE;
   return kFALSE;
 }
 
 //______________________________________________________________________
-Int_t AliITSCalibrationPixUpg::GetChipIndexFromCol(Int_t col) const 
+Int_t AliITSUCalibrationPix::GetChipIndexFromCol(Int_t col) const 
 {
   // returns chip index for specific column
   if(col>=fNCol) {AliWarning("Wrong column number"); return -1;}
@@ -272,14 +283,14 @@ Int_t AliITSCalibrationPixUpg::GetChipIndexFromCol(Int_t col) const
 }
 
 //______________________________________________________________________
-void AliITSCalibrationPixUpg::SetNrBad(Int_t /*nr*/) 
+void AliITSUCalibrationPix::SetNrBad(Int_t /*nr*/) 
 {
   // should not be used anymore !!!
   AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
 }
 
 //____________________________________________________________________________
-void  AliITSCalibrationPixUpg::SetColRowData(Short_t nchip, Short_t ncolperchip, Short_t nrow) 
+void  AliITSUCalibrationPix::SetColRowData(Short_t nchip, Short_t ncolperchip, Short_t nrow) 
 {
   // set segmentation data
   fNChips = nchip; 
similarity index 75%
rename from ITS/UPGRADE/AliITSCalibrationPixUpg.h
rename to ITS/UPGRADE/AliITSUCalibrationPix.h
index 8da3efe..1f7cf61 100644 (file)
@@ -1,9 +1,9 @@
-#ifndef ALIITSCALIBRATIONPIXUPG_H
-#define ALIITSCALIBRATIONPIXUPG_H
+#ifndef ALIITSUCALIBRATIONPIX_H
+#define ALIITSUCALIBRATIONPIX_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliITSCalibrationPixUpg.h 53595 2011-12-14 16:13:16Z masera $ */
+/* $Id: AliITSUCalibrationPix.h 53595 2011-12-14 16:13:16Z masera $ */
 //#include "TRandom.h"
 #include "AliITSCalibration.h"
 #include "TArrayS.h"
 // ITS response class for pixels                  //
 ////////////////////////////////////////////////////
 
-class AliITSCalibrationPixUpg :  public AliITSCalibration {
+class AliITSUCalibrationPix :  public AliITSCalibration {
  public:
-    AliITSCalibrationPixUpg(); // default constructor
-    AliITSCalibrationPixUpg(Short_t nChips,Short_t nColPerChip,Short_t nRow); // default constructor
-    AliITSCalibrationPixUpg(const AliITSCalibrationPixUpg &src);
+    AliITSUCalibrationPix(); // default constructor
+    AliITSUCalibrationPix(Short_t nChips,Short_t nColPerChip,Short_t nRow); // default constructor
+    AliITSUCalibrationPix(const AliITSUCalibrationPix &src);
     //    
-    virtual ~AliITSCalibrationPixUpg() {;} // destructror
+    virtual ~AliITSUCalibrationPix() {;} // destructror
 
     virtual void   ClearBad();
 
@@ -30,9 +30,10 @@ class AliITSCalibrationPixUpg :  public AliITSCalibration {
     virtual Int_t  GetBadColAt(Int_t index) const;
     virtual Int_t  GetBadRowAt(Int_t index) const;
     virtual void   GetBadPixel(Int_t index, Int_t &row, Int_t &col) const;
+    virtual void   GetBadPixelSingle(Int_t i,UInt_t &row, UInt_t &col) const;
 
-    virtual Int_t  GetNrBadSingle() const {return fNrBad;}
-    virtual void   SetNrBadSingle(Int_t nr) {fNrBad=nr;} // used to be called SetNrBad, but misleading
+    virtual Int_t  GetNrBadSingle() const {return fNrBadSingle;}
+    virtual void   SetNrBadSingle(Int_t nr) {fNrBadSingle=nr;} // used to be called SetNrBad, but misleading
     virtual void   SetBadList(TArrayS badlist) {fBadChannels=badlist;}
     virtual void   SetNrBad(Int_t /*nr*/); // Use SetNrBadSingle!!!
 
@@ -69,13 +70,13 @@ class AliITSCalibrationPixUpg :  public AliITSCalibration {
     Short_t  fNColPerChip;     // n of columns per chip
     Short_t  fNCol;            // number of columns
     Short_t  fNRow;            // number of rows
-    Int_t    fNrBad;           // Nr of SINGLE bad pixels
+    Int_t    fNrBadSingle;     // Nr of SINGLE bad pixels
     UInt_t   fBadChips;        // bit pattern of completely dead chips?
-    TArrayS  fBadChannels;     // Array with bad channels info (col0,row0,col1...rowN) N = fNrBad
+    TArrayS  fBadChannels;     // Array with bad channels info (col0,row0,col1...rowN) N = fNrBadSingle
     //
-    AliITSCalibrationPixUpg& operator=(const AliITSCalibrationPixUpg& source);
+    AliITSUCalibrationPix& operator=(const AliITSUCalibrationPix& source);
     //
-    ClassDef(AliITSCalibrationPixUpg,1) // pixels response
+    ClassDef(AliITSUCalibrationPix,1) // pixels response
 };
 
 #endif
similarity index 89%
rename from ITS/UPGRADE/AliITSdigitPixUpg.cxx
rename to ITS/UPGRADE/AliITSUDigitPix.cxx
index a99141d..21e5437 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-#include <AliITSdigitPixUpg.h>
+#include <AliITSUDigitPix.h>
 #include <TArrayI.h>
 
 ///////////////////////////////////////////////////////////////////
 //                                                               //
 ///////////////////////////////////////////////////////////////////
 
-ClassImp(AliITSdigitPixUpg)
+ClassImp(AliITSUDigitPix)
 
 //______________________________________________________________________
-AliITSdigitPixUpg::AliITSdigitPixUpg():AliITSdigit(),
+AliITSUDigitPix::AliITSUDigitPix():AliITSdigit(),
 fSignalPix(0){
     // default constructor, zero coordinates and set array
     // elements to clearly unphysical values. A value of 0 may
@@ -39,7 +39,7 @@ fSignalPix(0){
 }
 
 //______________________________________________________________________
-AliITSdigitPixUpg::AliITSdigitPixUpg(const Int_t *digits):
+AliITSUDigitPix::AliITSUDigitPix(const Int_t *digits):
   fSignalPix(digits[2])
 {
     // Creates a pixel digit object
@@ -53,7 +53,7 @@ AliITSdigitPixUpg::AliITSdigitPixUpg(const Int_t *digits):
 }
 
 //______________________________________________________________________
-AliITSdigitPixUpg::AliITSdigitPixUpg(const Int_t *digits,const Int_t *tracks,
+AliITSUDigitPix::AliITSUDigitPix(const Int_t *digits,const Int_t *tracks,
                               const Int_t *hits):
 fSignalPix(digits[2])
 {
@@ -69,7 +69,7 @@ fSignalPix(digits[2])
 }
 
 //______________________________________________________________________
-Int_t AliITSdigitPixUpg::GetListOfTracks(TArrayI &t)
+Int_t AliITSUDigitPix::GetListOfTracks(TArrayI &t)
 {
     // Fills the TArrayI t with the tracks found in fTracks removing
     // duplicated tracks, but otherwise in the same order. It will return
@@ -102,7 +102,7 @@ Int_t AliITSdigitPixUpg::GetListOfTracks(TArrayI &t)
 }
 
 //______________________________________________________________________
-void AliITSdigitPixUpg::Print(ostream *os)
+void AliITSUDigitPix::Print(ostream *os)
 {
     //Standard output format for this class
     Int_t i;
@@ -114,7 +114,7 @@ void AliITSdigitPixUpg::Print(ostream *os)
 }
 
 //______________________________________________________________________
-void AliITSdigitPixUpg::Read(istream *os)
+void AliITSUDigitPix::Read(istream *os)
 {
     //Standard input for this class
     Int_t i;
@@ -126,7 +126,7 @@ void AliITSdigitPixUpg::Read(istream *os)
 }
 
 //______________________________________________________________________
-ostream &operator<<(ostream &os,AliITSdigitPixUpg &source)
+ostream &operator<<(ostream &os,AliITSUDigitPix &source)
 {
     // Standard output streaming function.
 
@@ -135,7 +135,7 @@ ostream &operator<<(ostream &os,AliITSdigitPixUpg &source)
 }
 
 //______________________________________________________________________
-istream &operator>>(istream &os,AliITSdigitPixUpg &source)
+istream &operator>>(istream &os,AliITSUDigitPix &source)
 {
     // Standard output streaming function.
 
similarity index 70%
rename from ITS/UPGRADE/AliITSdigitPixUpg.h
rename to ITS/UPGRADE/AliITSUDigitPix.h
index 9c38c11..59d1c97 100644 (file)
@@ -8,14 +8,14 @@
 #include <AliITSdigit.h>
 
 //______________________________________________________________________
-class AliITSdigitPixUpg: public AliITSdigit {
+class AliITSUDigitPix: public AliITSdigit {
 
  public:
-    AliITSdigitPixUpg(); //default creator
-    AliITSdigitPixUpg(const Int_t *digits);//standard creator digits only
+    AliITSUDigitPix(); //default creator
+    AliITSUDigitPix(const Int_t *digits);//standard creator digits only
     //standard creator with digits, tracks, and hits
-    AliITSdigitPixUpg(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
-    virtual ~AliITSdigitPixUpg(){/*destructor*/}
+    AliITSUDigitPix(const Int_t *digits,const Int_t *tracks,const Int_t *hits);
+    virtual ~AliITSUDigitPix(){/*destructor*/}
     // returns the signal in electrons
     Int_t GetSignalPix() const {return fSignalPix;}
     virtual Int_t GetListOfTracks(TArrayI &t);
@@ -30,11 +30,11 @@ class AliITSdigitPixUpg: public AliITSdigit {
     
     Int_t fSignalPix;   // Signal in electrons
 
-    ClassDef(AliITSdigitPixUpg,1)   // Simulated digit object for Pixels
+    ClassDef(AliITSUDigitPix,1)   // Simulated digit object for Pixels
 
 };
 // Input and output functions for standard C++ input/output.
-ostream &operator<<(ostream &os,AliITSdigitPixUpg &source);
-istream &operator>>(istream &os,AliITSdigitPixUpg &source);
+ostream &operator<<(ostream &os,AliITSUDigitPix &source);
+istream &operator>>(istream &os,AliITSUDigitPix &source);
 
 #endif
diff --git a/ITS/UPGRADE/AliITSUDigitizer.cxx b/ITS/UPGRADE/AliITSUDigitizer.cxx
new file mode 100644 (file)
index 0000000..2ec5d7f
--- /dev/null
@@ -0,0 +1,252 @@
+/**************************************************************************
+ * 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: AliITSUDigitizer.cxx 52261 2011-10-23 15:46:57Z hristov $ */
+///////////////////////////////////////////////////////////////////////////
+//Piotr.Skowronski@cern.ch :                                             //
+//Corrections applied in order to compile (only)                         // 
+//   with new I/O and folder structure                                   //
+//To be implemented correctly by responsible                             //
+//                                                                       //
+//  Class used to steer                                                  //
+//  the digitization for ITS                                             //
+//                                                                       //
+///////////////////////////////////////////////////////////////////////////
+
+#include <stdlib.h>
+#include <TClonesArray.h>
+#include <TTree.h>
+#include <TBranch.h>
+
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+#include "AliLog.h"
+#include "AliDigitizationInput.h"
+#include "AliITSUDigitizer.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUSimulation.h"
+#include "AliITSUSDigit.h"
+
+ClassImp(AliITSUDigitizer)
+
+//______________________________________________________________________
+AliITSUDigitizer::AliITSUDigitizer() 
+:  fITS(0)
+  ,fModActive(0)
+  ,fInit(kFALSE)
+  ,fRoif(-1)
+  ,fRoiifile(0)
+  ,fFlagFirstEv(kTRUE)
+{
+  // Default constructor.
+}
+
+//______________________________________________________________________
+AliITSUDigitizer::AliITSUDigitizer(AliDigitizationInput* digInp) 
+  :AliDigitizer(digInp)
+  ,fITS(0)
+  ,fModActive(0)
+  ,fInit(kFALSE)
+  ,fRoif(-1)
+  ,fRoiifile(0)
+  ,fFlagFirstEv(kTRUE)
+{
+  // Standard constructor.
+}
+
+//______________________________________________________________________
+AliITSUDigitizer::~AliITSUDigitizer()
+{
+  // destructor. 
+  fITS = 0; // don't delete fITS. Done else where.
+  delete[] fModActive;
+}
+
+//______________________________________________________________________
+Bool_t AliITSUDigitizer::Init()
+{
+  // Initialization. Set up region of interest, if switched on, and loads ITS and ITSgeom.
+  //
+  if (fInit) return kTRUE;
+  //
+  fInit = kTRUE; // Assume for now init will work.
+  //
+  if(!gAlice) {
+    fITS      = 0;
+    fRoiifile = 0;
+    fInit     = kFALSE;
+    AliFatal("gAlice not found");
+  } // end if
+  //
+  fITS = (AliITSU *)(gAlice->GetDetector("ITS"));
+  if(!fITS){
+    fRoiifile = 0;
+    fInit     = kFALSE;
+    AliFatal("ITS not found");
+  } 
+  int nm = fITS->GetITSGeomTGeo()->GetNModules();
+  fModActive = new Bool_t[nm];
+  for (Int_t i=nm;i--;) fModActive[i] = kTRUE;
+
+  return fInit;
+}
+
+//______________________________________________________________________
+void AliITSUDigitizer::Digitize(Option_t* opt)
+{
+  // Main digitization function. 
+  //
+  if (!fInit) AliFatal("Init not successful, aborting.");
+  //
+  Int_t nfiles = GetDigInput()->GetNinputs();
+  Int_t event  = GetDigInput()->GetOutputEventNr();
+  //
+  TString loadname = Form("%sLoader",fITS->GetName());
+  //
+  AliITSUGeomTGeo* geom = fITS->GetITSGeomTGeo();
+  Int_t nModules  = geom->GetNModules();
+  Bool_t lmod;
+  Int_t *fl = new Int_t[nfiles];
+  fl[0] = fRoiifile;
+  int mask = 1;
+  for (int id=0;id<nfiles;id++) if(id!=fRoiifile) fl[mask++] = id;
+  //
+  TClonesArray * sdig = new TClonesArray( "AliITSUSDigit",1000 );
+  //
+  AliRunLoader *inRL = 0x0, *outRL = 0x0;
+  AliLoader *ingime = 0x0, *outgime = 0x0;    
+  //
+  outRL = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());    
+  if (!outRL) AliFatal("Can not get Output Run Loader");
+  //
+  outRL->GetEvent(event);
+  outgime = outRL->GetLoader(loadname);
+  if ( outgime == 0x0) AliFatal("Can not get Output ITS Loader");
+  //
+  outgime->LoadDigits("update");
+  if (outgime->TreeD() == 0x0) outgime->MakeTree("D");
+  //
+  // Digitize
+  fITS->MakeBranchInTreeD(outgime->TreeD());
+  if(fRoif!=0) AliDebug(1,"Region of Interest digitization selected");
+  else         AliDebug(1,"No Region of Interest selected. Digitizing everything");
+  //
+  for (int ifiles=0; ifiles<nfiles; ifiles++ ) {
+    inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
+    ingime = inRL->GetLoader(loadname);
+    if (ingime->TreeS() == 0x0) ingime->LoadSDigits();
+  }
+  //
+  for (int module=0; module<nModules; module++ ) {
+    //
+    if (!fRoif && !fModActive[module]) continue;
+    int id = geom->GetModuleDetTypeID(module);
+    AliITSUSimulation *sim = fITS->GetSimulationModel(id);
+    if (!sim) AliFatal(Form("The simulation model %d is not available",id));
+    //
+    // Fill the module with the sum of SDigits
+    sim->InitSimulationModule(module, event, fITS->GetSegmentation(id));
+    //
+    for (int ifiles=0; ifiles<nfiles; ifiles++ ) {
+      //
+      if (!fRoif && !fModActive[module]) continue;
+      inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
+      ingime = inRL->GetLoader(loadname);
+      //
+      TTree *treeS = ingime->TreeS();
+      fITS->SetTreeAddress();
+      //
+      if( !treeS  ) continue; 
+      TBranch *brchSDigits = treeS->GetBranch( fITS->GetName() );
+      if( brchSDigits )        brchSDigits->SetAddress( &sdig ); 
+      else {
+       AliError(Form("branch ITS not found in TreeS, input file %d ", ifiles));
+       delete [] fl;
+       return;
+      } 
+      //
+      sdig->Clear();
+      mask = GetDigInput()->GetMask(ifiles);
+      brchSDigits->GetEvent( module );
+      lmod = sim->AddSDigitsToModule(sdig,mask);
+      if(GetRegionOfInterest() && !ifiles) fModActive[module] = lmod;
+      //
+    } 
+    // Digitize current module sum(SDigits)->Digits
+    sim->FinishSDigitiseModule();
+    //
+    outgime->TreeD()->Fill();       // fills all branches - wasted disk space
+    fITS->ResetDigits();
+  } // end for module
+  //
+  //  fITS->WriteFOSignals(); 
+  outgime->TreeD()->AutoSave();
+  outgime->WriteDigits("OVERWRITE");
+  outgime->UnloadDigits();
+  for(int ifiles=0; ifiles<nfiles; ifiles++ ) {
+    inRL =  AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(fl[ifiles]));
+    ingime = inRL->GetLoader(loadname);
+    ingime->UnloadSDigits();
+  }
+  //
+  delete[] fl;
+  sdig->Clear();
+  delete sdig;
+  for (Int_t i=nModules;i--;) fModActive[i] = kTRUE;
+  //
+  return;
+}
+
+//______________________________________________________________________
+void AliITSUDigitizer::SetByRegionOfInterest(TTree *ts)
+{
+  // Scans through the ITS branch of the SDigits tree, ts, for modules
+  // which have SDigits in them. For these modules, a flag is set to
+  // digitize only these modules. The value of fRoif determines how many
+  // neighboring modules will also be turned on. fRoif=0 will turn on only
+  // those modules with SDigits in them. fRoif=1 will turn on, in addition,
+  // those modules that are +-1 module from the one with the SDigits. And
+  // So on. This last feature is not supported yet.
+  // Inputs:
+  //      TTree *ts  The tree in which the existing SDigits will define the
+  //                 region of interest.
+  if (fRoif==0) return;
+  if (ts==0)    return;
+  TBranch *brchSDigits = ts->GetBranch(fITS->GetName());
+  TClonesArray * sdig = new TClonesArray( "AliITSUSDigit",1000 );
+  //
+  if( brchSDigits ) brchSDigits->SetAddress( &sdig );
+  else  {AliError("Branch ITS not found in TreeS"); return;}
+  //
+  int nm = fITS->GetITSGeomTGeo()->GetNModules();
+  for (int m=0;m<nm;m++) {
+    fModActive[m] = kFALSE; // Not active by default
+    sdig->Clear();
+    brchSDigits->GetEvent(m);
+    int ndig = sdig->GetEntries();
+    for(int i=0;i<ndig;i++) {
+      // activate the necessary modules
+      if ( ((AliITSUSDigit*)sdig->At(m))->GetSumSignal()>0.0 ) { // Must have non zero signal.
+       fModActive[m] = kTRUE;
+       break;
+      } // end if
+    } // end if. end for i.
+  } // end for m
+  AliDebug(1,"Digitization by Region of Interest selected");
+  sdig->Clear();
+  delete sdig;
+  return;
+}
diff --git a/ITS/UPGRADE/AliITSUDigitizer.h b/ITS/UPGRADE/AliITSUDigitizer.h
new file mode 100644 (file)
index 0000000..48f1c4d
--- /dev/null
@@ -0,0 +1,48 @@
+#ifndef ALIITSUDIGITIZER_H
+#define ALIITSUDIGITIZER_H
+/* Copyright (c) 1998-2001, ALICE Experiment at CERN, All rights reserved *
+ * See cxx source for full Copyright notice                               */
+
+/*
+  $Id: AliITSUDigitizer.h 52261 2011-10-23 15:46:57Z hristov $
+ */
+//////////////////////////////////////////////////////////////////
+// Digitizer class for ITS                                      //
+//////////////////////////////////////////////////////////////////
+class TObjArray;
+class TTree;
+
+class AliDigitizationInput;
+
+#include "AliDigitizer.h" // Base class from which this one is derived
+#include "AliITSU.h"   // ITS class functions used in inline functions.
+
+class AliITSUDigitizer : public AliDigitizer {
+ public:
+  AliITSUDigitizer();
+  AliITSUDigitizer(AliDigitizationInput* digInput);
+  
+  virtual ~AliITSUDigitizer();
+  virtual Bool_t Init();
+  virtual void Digitize(Option_t* opt=0);
+  virtual void SetModuleActive(Int_t i){if(fModActive) fModActive[i] = kTRUE;}
+  virtual void SetModuleInActive(Int_t i){if(fModActive) fModActive[i] = kFALSE;}
+  virtual void SetByRegionOfInterestFlag(Int_t i=0){fRoif = i;};
+  virtual void SetByRegionOfFileNumber(Int_t i=-1){fRoiifile = i;};
+  virtual void ClearByRegionOfInterestFlag(){fRoif = 0;};
+ private:
+  AliITSUDigitizer(const AliITSUDigitizer& dig);
+  AliITSUDigitizer& operator=(const AliITSUDigitizer &source);
+  AliDigitizationInput* GetDigInput(){return fDigInput;}
+  virtual void SetByRegionOfInterest(TTree *ts);
+ private:
+  AliITSU *fITS;      //! local pointer to ITS
+  Bool_t    *fModActive;//! flag to indicate which module to digitize.
+  Bool_t     fInit;     //! flag to indecate Initilization when well.
+  Int_t      fRoif;     //! Region of interest flag.
+  Int_t      fRoiifile; //! The file number with which to determing the region of interest from.
+  Bool_t     fFlagFirstEv; //! Flag to control calibration access
+  
+  ClassDef(AliITSUDigitizer,1) // Task to Digitize ITS from summable hits.
+};
+#endif
similarity index 53%
rename from ITS/UPGRADE/AliITSgeomTGeoUpg.cxx
rename to ITS/UPGRADE/AliITSUGeomTGeo.cxx
index 9059de0..31140f3 100644 (file)
@@ -14,7 +14,7 @@
  **************************************************************************/
 
 ///////////////////////////////////////////////////////////////////////////
-//    AliITSgeomTGeoUpg is a simple interface class to TGeoManager       //
+//    AliITSUGeomTGeo is a simple interface class to TGeoManager       //
 //    It is used in the simulation and reconstruction in order to        //
 //    query the TGeo ITS geometry                                        //
 //                                                                       //
@@ -22,6 +22,9 @@
 //    15/02/2007                                                         //
 //    adapted to ITSupg 18/07/2012 - ruben.shahoyan@cern.ch              //
 //                                                                       //
+//    ATTENTION: In opposite to ols AliITSgeomTGeo, all indices start    //
+//    from 0, not from 1!!!                                              //
+//                                                                       //
 ///////////////////////////////////////////////////////////////////////////
 
 #include <TClass.h>
 #include <TGeoPhysicalNode.h>
 #include <TDatime.h>
 
-#include "AliITSgeomTGeoUpg.h"
+#include "AliITSUGeomTGeo.h"
 #include "AliLog.h"
 #include "AliAlignObj.h"
 
-ClassImp(AliITSgeomTGeoUpg)
+ClassImp(AliITSUGeomTGeo)
+
 
+const char* AliITSUGeomTGeo::fgkITSVolName = "ITSV";
+const char* AliITSUGeomTGeo::fgkITSLrName  = "ITSupgLayer";
+const char* AliITSUGeomTGeo::fgkITSLadName = "ITSupgLadder";
+const char* AliITSUGeomTGeo::fgkITSModName = "ITSupgModule";
+const char* AliITSUGeomTGeo::fgkITSSensName ="ITSupgSensor";
+const char* AliITSUGeomTGeo::fgkITSDetTypeName[AliITSUGeomTGeo::kNDetTypes] = {"PixUpg"};
+//
+TString     AliITSUGeomTGeo::fgITSsegmFileName = "itsSegmentations.root";
 
-const char* AliITSgeomTGeoUpg::fgkITSVolName = "ITSV";
-const char* AliITSgeomTGeoUpg::fgkITSLrName  = "ITSupgLayer";
-const char* AliITSgeomTGeoUpg::fgkITSLadName = "ITSupgLadder";
-const char* AliITSgeomTGeoUpg::fgkITSModName = "ITSupgModule";
-const char* AliITSgeomTGeoUpg::fgkITSSensName ="ITSupgSensor";
+//______________________________________________________________________
+AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build)
+:  fVersion(kITSVNA)
+  ,fNLayers(0)
+  ,fNModules(0)
+  ,fNLadders(0)
+  ,fLrDetType(0)
+  ,fNDetectors(0)
+  ,fLastModIndex(0)
+{
+  // default c-tor
+  if (build) BuildITS();
+}
 
-const Int_t AliITSgeomTGeoUpg::fgkNModulesOld = 2198;
-const Int_t AliITSgeomTGeoUpg::fgkNLaddersOld[AliITSgeomTGeoUpg::kNLayersOld] = {20,40,14,22,34,38};
-const Int_t AliITSgeomTGeoUpg::fgkNDetectorsOld[AliITSgeomTGeoUpg::kNLayersOld] = {4,4,6,8,22,25};
+//______________________________________________________________________
+AliITSUGeomTGeo::AliITSUGeomTGeo(const AliITSUGeomTGeo &src)
+  :TObject(src)
+  ,fVersion(src.fVersion)
+  ,fNLayers(src.fNLayers)
+  ,fNModules(src.fNModules)
+  ,fNLadders(0)
+  ,fLrDetType(0)
+  ,fNDetectors(0)
+  ,fLastModIndex(0)
+{
+  // copy c-tor
+  if (fNLayers) {
+    fNLadders   = new Int_t[fNLayers];
+    fNDetectors = new Int_t[fNLayers];
+    fLrDetType  = new Int_t[fNLayers];
+    fLastModIndex   = new Int_t[fNLayers];
+    for (int i=fNLayers;i--;) {
+      fNLadders[i] = src.fNLadders[i];
+      fNDetectors[i] = src.fNDetectors[i];
+      fLrDetType[i]  = src.fLrDetType[i];
+      fLastModIndex[i] = src.fLastModIndex[i];
+    }
+  }
+}
 
-Int_t  AliITSgeomTGeoUpg::fgVersion = 0;
-Int_t  AliITSgeomTGeoUpg::fgNLayers = 0;
-Int_t  AliITSgeomTGeoUpg::fgNModules = 0;
-Int_t* AliITSgeomTGeoUpg::fgNLadders = 0;
-Int_t* AliITSgeomTGeoUpg::fgNDetectors = 0;
-Int_t* AliITSgeomTGeoUpg::fgLrDetType = 0;
+//______________________________________________________________________
+AliITSUGeomTGeo::~AliITSUGeomTGeo()
+{
+  //d-tor
+  delete[] fNLadders;
+  delete[] fLrDetType;
+  delete[] fNDetectors;
+  delete[] fLastModIndex;
+}
 
 
 //______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::GetModuleIndex(Int_t lay,Int_t lad,Int_t det)
+AliITSUGeomTGeo& AliITSUGeomTGeo::operator=(const AliITSUGeomTGeo &src)
+{
+  // cp op.
+  if (this!=&src) {
+    delete[] fNLadders;
+    delete[] fLrDetType;
+    delete[] fNDetectors;
+    delete[] fLastModIndex;
+    fNLadders = fLrDetType = fNDetectors = fLastModIndex = 0;
+    fVersion = src.fVersion;
+    fNLayers = src.fNLayers;
+    fNModules = src.fNModules;
+    if (fNLayers) {
+      fNLadders   = new Int_t[fNLayers];
+      fNDetectors = new Int_t[fNLayers];
+      fLrDetType  = new Int_t[fNLayers];
+      fLastModIndex   = new Int_t[fNLayers];
+      for (int i=fNLayers;i--;) {
+       fNLadders[i] = src.fNLadders[i];
+       fNDetectors[i] = src.fNDetectors[i];
+       fLrDetType[i]  = src.fLrDetType[i];
+       fLastModIndex[i] = src.fLastModIndex[i];
+      }
+    }    
+  }
+  return *this;
+}
+
+//______________________________________________________________________
+Int_t AliITSUGeomTGeo::GetModuleIndex(Int_t lay,Int_t lad,Int_t det) const
 {
-  // The method is taken from the old AliITSgeom class by Bjorn Nilsen
-  //
   // This routine computes the module index number from the layer,
   // ladder, and detector numbers. The number of ladders and detectors
   // per layer is set statically
   // see above for details.
   // Inputs:
-  //    Int_t lay  The layer number. Starting from 1.
-  //    Int_t lad  The ladder number. Starting from 1.
-  //    Int_t det  The detector number. Starting from 1.
-  // Return:
-  //    the module index number, starting from zero.
-  //    -1 in case of error
-  CheckInit();
+  //    Int_t lay  The layer number. Starting from 0.
+  //    Int_t lad  The ladder number. Starting from 0
+  //    Int_t det  The detector number in the ladder. Starting from 0
   //
-  if (lay < 1 || lay > fgNLayers) {
-    AliErrorClass(Form("Invalid layer: %d (1 -> %d",lay,fgNLayers));
-    return -1;
-  }
-
-  if (lad < 1 || lad > fgNLadders[lay-1] ||
-      det < 1 || det > fgNDetectors[lay-1]) {
-    AliErrorClass(Form("Invalid layer,ladder,detector combination: %d, %d, %d",lay,lad,det));
-    return -1;
-  }
-
-  Int_t index = fgNDetectors[lay-1] * (lad-1) + (det-1);
-  for(Int_t iLayer=0;iLayer < (lay-1); iLayer++)
-    index += fgNDetectors[iLayer]*fgNLadders[iLayer];
-
-  return index;
+  return GetFirstModIndex(lay) + fNDetectors[lay]*lad + det;
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetLayer(Int_t index,Int_t &lay,Int_t &index2) 
+Bool_t AliITSUGeomTGeo::GetLayer(Int_t index,Int_t &lay,Int_t &index2)  const
 {
-  // The method is taken from the old AliITSgeom class by Bjorn Nilsen
-  //
   // This routine computes the layer number for a
-  // given the module index. The number of ladders and detectors
-  // per layer is defined statically,
-  // see above for details.
+  // given the module index. The 
   // Inputs:
   //     Int_t index  The module index number, starting from zero.
   // Outputs:
   //     Int_t index2 The module index inside a layer, starting from zero.
-  //     Int_t lay    The layer number. Starting from 1.
-  // Return:
-  //     kTRUE in case of valid index
-  //     kFALSE in case of error
-  CheckInit();
-  //
-  if (index < 0 || index >= fgNModules) {
-    index2 = -1;
-    AliErrorClass(Form("Invalid module index: %d (0 -> %d)",index,fgNModules));
-    return -1;
-  }
+  //     Int_t lay    The layer number. Starting from 0.
+  //
+  lay = GetLayer(index);
+  index2 = index - GetFirstModIndex(lay);
+  return kTRUE;
+  //
+}
 
-  lay = 0;
-  index2 = 0;
-  do {
-    index2 += fgNLadders[lay]*fgNDetectors[lay];
-    lay++;
-  } while(index2 <= index);
-  index2 -= fgNLadders[lay-1]*fgNDetectors[lay-1];
-  index2 = index - index2;
+//______________________________________________________________________
+Int_t AliITSUGeomTGeo::GetLayer(Int_t index) const
+{
+  // Get module layer, from 0
+  //
+  int lay = 0;
+  while(index<=fLastModIndex[lay]) lay++;
+  return --lay;
+}
 
-  return lay;
+//______________________________________________________________________
+Int_t AliITSUGeomTGeo::GetLadder(Int_t index) const
+{
+  // Get module ladder, from 0
+  //
+  int lay = 0;
+  while(index<=fLastModIndex[lay]) lay++;
+  index -= GetFirstModIndex(--lay);
+  return index/fNDetectors[lay];
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det) 
+Int_t AliITSUGeomTGeo::GetModIdInLayer(Int_t index) const
+{
+  // Get module number within layer, from 0
+  //
+  int lay = 0;
+  while(index<=fLastModIndex[lay]) lay++;
+  index -= GetFirstModIndex(--lay);
+  return index;
+}
+
+//______________________________________________________________________
+Int_t AliITSUGeomTGeo::GetModIdInLadder(Int_t index) const
+{
+  // Get module number within ladder, from 0
+  //
+  int lay = 0;
+  while(index<=fLastModIndex[lay]) lay++;
+  index -= GetFirstModIndex(--lay);
+  return index%fNDetectors[lay];
+}
+
+//______________________________________________________________________
+Bool_t AliITSUGeomTGeo::GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det)  const
 {
   // The method is taken from the old AliITSgeom class by Bjorn Nilsen
   //
   // This routine computes the layer, ladder and detector number 
-  // given the module index number. The number of ladders and detectors
-  // per layer is defined statically,
-  // see above for details.
+  // given the module index number. 
   // Inputs:
   //     Int_t index  The module index number, starting from zero.
   // Outputs:
-  //     Int_t lay    The layer number. Starting from 1.
-  //     Int_t lad    The ladder number. Starting from 1.
-  //     Int_t det    The detector number. Starting from 1.
-  // Return:
-  //     kTRUE in case of valid index
-  //     kFALSE in case of error
-  CheckInit();
-  //
-  if (index < 0 || index >= fgNModules) {
-    lay = lad = det = -1;
-    AliErrorClass(Form("Invalid module index: %d (0 -> %d)",index,fgNModules));
-    return kFALSE;
-  }
-
-  lay  = lad = det = 0;
-  Int_t index2 = 0;
-  do {
-    index2 += fgNLadders[lay]*fgNDetectors[lay];
-    lay++;
-  } while(index2 <= index);
-  index2 -= fgNLadders[lay-1]*fgNDetectors[lay-1];
-
-  do {
-    index2 += fgNDetectors[lay-1];
-    lad++;
-  } while(index2 <= index);
-  index2 -= fgNDetectors[lay-1];
-
-  det = index-index2+1;
-
+  //     Int_t lay    The layer number. Starting from 0
+  //     Int_t lad    The ladder number. Starting from 0
+  //     Int_t det    The detector number. Starting from 0
+  //
+  lay  = GetLayer(index);
+  index -= GetFirstModIndex(lay);
+  lad  = index/fNDetectors[lay];
+  det  = index%fNDetectors[lay];
   return kTRUE;
 }
 
 //______________________________________________________________________
-const char* AliITSgeomTGeoUpg::GetSymName(Int_t index) 
+const char* AliITSUGeomTGeo::GetSymName(Int_t index)  const
 {
   // Get the TGeoPNEntry symbolic name
   // for a given module identified by 'index'
-  CheckInit();
   //
-  if (index < 0 || index >= fgNModules) {
-    AliErrorClass(Form("Invalid ITS module index: %d (0 -> %d) !",index,fgNModules));
-    return NULL;
-  }
-
   Int_t lay, index2;
   if (!GetLayer(index,lay,index2)) return NULL;
-  if (fgVersion == kITSVOld) return AliGeomManager::SymName((AliGeomManager::ELayerID)((lay-1)+AliGeomManager::kSPD1),index2);
-  else {
-    // RS: this is not optimal, but we cannod access directly AliGeomManager, since the latter has hardwired layers 
-    TGeoPNEntry* pne = gGeoManager->GetAlignableEntryByUID( AliGeomManager::LayerToVolUID(lay,index2) );
-    if (!pne) {
-      AliErrorClass(Form("Failed to find alignable entry with index %d: (Lr%d Mod:%d) !",index,lay,index2));
-      return NULL;
-    }
-    return pne->GetName();
+  // return AliGeomManager::SymName((AliGeomManager::ELayerID)((lay-1)+AliGeomManager::kSPD1),index2);
+  // RS: this is not optimal, but we cannod access directly AliGeomManager, since the latter has hardwired layers 
+  TGeoPNEntry* pne = gGeoManager->GetAlignableEntryByUID( AliGeomManager::LayerToVolUID(lay+1,index2) );
+  if (!pne) {
+    AliError(Form("Failed to find alignable entry with index %d: (Lr%d Mod:%d) !",index,lay,index2));
+    return NULL;
   }
+  return pne->GetName();
 }
 
 //______________________________________________________________________
-TGeoHMatrix* AliITSgeomTGeoUpg::GetMatrix(Int_t index) 
+TGeoHMatrix* AliITSUGeomTGeo::GetMatrix(Int_t index)  const
 {
   // Get the transformation matrix for a given module 'index'
   // by quering the TGeoManager
-  CheckInit();
-  //
   TGeoPNEntry *pne = GetPNEntry(index);
   if (!pne) return NULL;
 
@@ -213,20 +255,22 @@ TGeoHMatrix* AliITSgeomTGeoUpg::GetMatrix(Int_t index)
   if (pnode) return pnode->GetMatrix();
 
   const char* path = pne->GetTitle();
+  gGeoManager->PushPath(); // Preserve the modeler state.
   if (!gGeoManager->cd(path)) {
-    AliErrorClass(Form("Volume path %s not valid!",path));
+    gGeoManager->PopPath();
+    AliError(Form("Volume path %s not valid!",path));
     return NULL;
   }
-  return gGeoManager->GetCurrentMatrix();
+  TGeoHMatrix *mat = gGeoManager->GetCurrentMatrix();
+  gGeoManager->PopPath();
+  return mat;
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetTranslation(Int_t index, Double_t t[3]) 
+Bool_t AliITSUGeomTGeo::GetTranslation(Int_t index, Double_t t[3])  const
 {
   // Get the translation vector for a given module 'index'
   // by quering the TGeoManager
-  CheckInit();
-  //
   TGeoHMatrix *m = GetMatrix(index);
   if (!m) return kFALSE;
 
@@ -237,12 +281,10 @@ Bool_t AliITSgeomTGeoUpg::GetTranslation(Int_t index, Double_t t[3])
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetRotation(Int_t index, Double_t r[9]) 
+Bool_t AliITSUGeomTGeo::GetRotation(Int_t index, Double_t r[9])  const
 {
   // Get the rotation matrix for a given module 'index'
   // by quering the TGeoManager
-  CheckInit();
-  //
   TGeoHMatrix *m = GetMatrix(index);
   if (!m) return kFALSE;
 
@@ -253,14 +295,12 @@ Bool_t AliITSgeomTGeoUpg::GetRotation(Int_t index, Double_t r[9])
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetOrigMatrix(Int_t index, TGeoHMatrix &m)
+Bool_t AliITSUGeomTGeo::GetOrigMatrix(Int_t index, TGeoHMatrix &m) const
 {
   // Get the original (ideal geometry) TGeo matrix for
   // a given module identified by 'index'.
   // The method is slow, so it should be used
   // with great care.
-  CheckInit();
-  //
   m.Clear();
 
   const char *symname = GetSymName(index);
@@ -270,12 +310,10 @@ Bool_t AliITSgeomTGeoUpg::GetOrigMatrix(Int_t index, TGeoHMatrix &m)
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetOrigTranslation(Int_t index, Double_t t[3]) 
+Bool_t AliITSUGeomTGeo::GetOrigTranslation(Int_t index, Double_t t[3])  const
 {
   // Get the original translation vector (ideal geometry)
   // for a given module 'index' by quering the TGeoManager
-  CheckInit();
-  //
   TGeoHMatrix m;
   if (!GetOrigMatrix(index,m)) return kFALSE;
 
@@ -286,12 +324,10 @@ Bool_t AliITSgeomTGeoUpg::GetOrigTranslation(Int_t index, Double_t t[3])
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetOrigRotation(Int_t index, Double_t r[9]) 
+Bool_t AliITSUGeomTGeo::GetOrigRotation(Int_t index, Double_t r[9])  const
 {
   // Get the original rotation matrix (ideal geometry)
   // for a given module 'index' by quering the TGeoManager
-  CheckInit();
-  //
   TGeoHMatrix m;
   if (!GetOrigMatrix(index,m)) return kFALSE;
 
@@ -302,30 +338,26 @@ Bool_t AliITSgeomTGeoUpg::GetOrigRotation(Int_t index, Double_t r[9])
 }
 
 //______________________________________________________________________
-const TGeoHMatrix* AliITSgeomTGeoUpg::GetTracking2LocalMatrix(Int_t index)
+const TGeoHMatrix* AliITSUGeomTGeo::GetTracking2LocalMatrix(Int_t index) const
 {
   // Get the matrix which transforms from the tracking to local r.s.
   // The method queries directly the TGeoPNEntry
-  CheckInit();
-  //
   TGeoPNEntry *pne = GetPNEntry(index);
   if (!pne) return NULL;
 
   const TGeoHMatrix *m = pne->GetMatrix();
   if (!m)
-    AliErrorClass(Form("TGeoPNEntry (%s) contains no matrix !",pne->GetName()));
+    AliError(Form("TGeoPNEntry (%s) contains no matrix !",pne->GetName()));
 
   return m;
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
+Bool_t AliITSUGeomTGeo::GetTrackingMatrix(Int_t index, TGeoHMatrix &m) const
 {
   // Get the matrix which transforms from the tracking r.s. to
   // the global one.
   // Returns kFALSE in case of error.
-  CheckInit();
-  //
   m.Clear();
 
   TGeoHMatrix *m1 = GetMatrix(index);
@@ -341,35 +373,58 @@ Bool_t AliITSgeomTGeoUpg::GetTrackingMatrix(Int_t index, TGeoHMatrix &m)
 }
 
 //______________________________________________________________________
-TGeoPNEntry* AliITSgeomTGeoUpg::GetPNEntry(Int_t index)
+TGeoHMatrix* AliITSUGeomTGeo::GetMatrixSens(Int_t lay, Int_t ladd, Int_t detInLad)  const
+{
+  // Get the transformation matrix of the SENSOR (not ncessary the same as the module) for a given module 'index'
+  // by quering the TGeoManager
+  const TString kPathBase = Form("/ALIC_1/%s_1/",AliITSUGeomTGeo::GetITSVolPattern());
+  const TString kNames = Form("%%s%s%%d_1/%s%%d_%%d/%s%%d_%%d/%s%%d_%%d"
+                             ,AliITSUGeomTGeo::GetITSLayerPattern()
+                             ,AliITSUGeomTGeo::GetITSLadderPattern()
+                             ,AliITSUGeomTGeo::GetITSModulePattern()
+                             ,AliITSUGeomTGeo::GetITSSensorPattern());
+  TString path;
+  //
+  path.Form(kNames.Data(),kPathBase.Data(),lay,lay,ladd,lay,detInLad,lay,1);
+  gGeoManager->PushPath();
+  if (!gGeoManager->cd(path.Data())) {
+    gGeoManager->PopPath();
+    AliError(Form("Error in cd-ing to %s",path.Data()));
+    return 0;
+  } // end if !gGeoManager
+  TGeoHMatrix* mat = gGeoManager->GetCurrentMatrix();
+  // Retstore the modeler state.
+  gGeoManager->PopPath();
+  return mat;
+}
+
+
+//______________________________________________________________________
+TGeoPNEntry* AliITSUGeomTGeo::GetPNEntry(Int_t index) const
 {
   // Get a pointer to the TGeoPNEntry of a module
   // identified by 'index'
   // Returns NULL in case of invalid index,
   // missing TGeoManager or invalid symbolic name
-  CheckInit();
   //
-  if (index < 0 || index >= fgNModules) {
-    AliErrorClass(Form("Invalid ITS module index: %d (0 -> %d) !",index,fgNModules));
+  if (index >= fNModules) {
+    AliError(Form("Invalid ITS module index: %d (0 -> %d) !",index,fNModules));
     return NULL;
   }
   
   if (!gGeoManager || !gGeoManager->IsClosed()) {
-    AliErrorClass("Can't get the matrix! gGeoManager doesn't exist or it is still opened!");
+    AliError("Can't get the matrix! gGeoManager doesn't exist or it is still opened!");
     return NULL;
   }
 
   TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(GetSymName(index));
-  if (!pne)
-    AliErrorClass(Form("The symbolic volume name %s does not correspond to a physical entry!",
-                      GetSymName(index)));
-
+  if (!pne) AliError(Form("The symbolic volume name %s does not correspond to a physical entry!",GetSymName(index)));
+  //
   return pne;
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::LocalToGlobal(Int_t index,
-                                    const Double_t *loc, Double_t *glob)
+Bool_t AliITSUGeomTGeo::LocalToGlobal(Int_t index,const Double_t *loc, Double_t *glob) const
 {
   // Make the conversion from the local sensitive reference system to the global
   // reference system, for an arbitrary local position. The input is the pointer
@@ -377,7 +432,6 @@ Bool_t AliITSgeomTGeoUpg::LocalToGlobal(Int_t index,
   //
   // Please don't use this method to get the global coordinates of clusters, use
   // the direct method of AliCluster instead.
-  CheckInit();
   //
   const TGeoHMatrix *m2 = GetTracking2LocalMatrix(index);
   if (!m2) return kFALSE;
@@ -393,13 +447,11 @@ Bool_t AliITSgeomTGeoUpg::LocalToGlobal(Int_t index,
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GlobalToLocal(Int_t index,
-                                    const Double_t *glob, Double_t *loc)
+Bool_t AliITSUGeomTGeo::GlobalToLocal(Int_t index, const Double_t *glob, Double_t *loc) const
 {
   // Make the conversion from the global reference system to the sensitive local
   // reference system, for an arbitrary global position. The input is the pointer
   // to the array of global coordinates, the result is sent to the loc pointer.
-  CheckInit();
   //
   TGeoHMatrix *ml = GetMatrix(index);
   if (!ml) return kFALSE;
@@ -415,13 +467,11 @@ Bool_t AliITSgeomTGeoUpg::GlobalToLocal(Int_t index,
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::LocalToGlobalVect(Int_t index,
-                                        const Double_t *loc, Double_t *glob)
+Bool_t AliITSUGeomTGeo::LocalToGlobalVect(Int_t index, const Double_t *loc, Double_t *glob) const
 {
   // Make the conversion from the local sensitive reference system to the global
   // reference system, for an arbitrary vector. The input is the pointer to the
   // array of local coordinates, the result is sent to the glob pointer.
-  CheckInit();
   //
   TGeoHMatrix *ml = GetMatrix(index);
   if (!ml) return kFALSE;
@@ -430,146 +480,53 @@ Bool_t AliITSgeomTGeoUpg::LocalToGlobalVect(Int_t index,
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::GlobalToLocalVect(Int_t index,
-                                        const Double_t *glob, Double_t *loc)
+Bool_t AliITSUGeomTGeo::GlobalToLocalVect(Int_t index, const Double_t *glob, Double_t *loc) const
 {
   // Make the conversion from the global reference system to the sensitive local
   // reference system, for an arbitrary vector. The input is the pointer to the
   // array of global coordinates, the result is sent to the loc pointer.
-  CheckInit();
-  //
   TGeoHMatrix *ml = GetMatrix(index);
   if (!ml) return kFALSE;
   ml->MasterToLocalVect(glob,loc);
-
   return kTRUE;
 }
 
 //______________________________________________________________________
-void AliITSgeomTGeoUpg::BuildITS()
-{
-  // build ITS info from TGeo 
-  if (fgVersion!=kITSVNA) return; // already initialized
-  // 
-  if (!gGeoManager) AliFatalClass("Geometry is not loaded");
-  //
-  // get ITS version
-  TGeoVolume *itsV = gGeoManager->GetVolume(fgkITSVolName);
-  if (!gGeoManager) AliFatalClass(Form("ITS volume %s is not in the geometry",fgkITSVolName));
-  //
-  Int_t minor = 0;
-  TDatime datetime;
-  const Char_t *title = itsV->GetTitle();
-  if(!ReadVersionString(title,fgVersion,minor,datetime))
-    AliFatalClass(Form("Can't read title %s to extract version",title));
-  //
-  if (fgVersion==kITSVNA) AliFatalClass(Form("Failed to detrmine ITS version from title %s",title));
-  //
-  (fgVersion==kITSVOld) ? BuildITSOld() : BuildITSUpg();
-  //
-}
-
-//______________________________________________________________________
-void AliITSgeomTGeoUpg::BuildITSOld()
-{
-  // assign old ITS
-  fgNLayers  = kNLayersOld;
-  fgNModules = fgkNModulesOld;
-  fgNLadders = (Int_t*)fgkNLaddersOld;
-  fgNDetectors = (Int_t*)fgkNDetectorsOld;
-  fgLrDetType = 0;
-}
-
-//______________________________________________________________________
-void AliITSgeomTGeoUpg::BuildITSUpg()
+void AliITSUGeomTGeo::BuildITS()
 {
   // exract upg ITS parameters from TGeo
-  fgNLayers    = ExtractNumberOfLayers();
-  if (!fgNLayers) return;
-  //
-  fgNLadders   = new Int_t[fgNLayers];
-  fgNDetectors = new Int_t[fgNLayers];
-  fgLrDetType  = new Int_t[fgNLayers];
-  fgNModules = 0;
-  for (int i=0;i<fgNLayers;i++) {
-    fgNLadders[i]   = ExtractNumberOfLadders(i+1);
-    fgNDetectors[i] = ExtractNumberOfDetectors(i+1);
-    fgLrDetType[i]  = ExtractLayerDetType(i+1);
-    fgNModules     += fgNLadders[i]*fgNDetectors[i];
+  if (fVersion!=kITSVNA) {AliWarning("Already built"); return; // already initialized}
+    if (!gGeoManager) AliFatal("Geometry is not loaded");
   }
+  fNLayers    = ExtractNumberOfLayers();
+  if (!fNLayers) return;
+  //
+  fNLadders   = new Int_t[fNLayers];
+  fNDetectors = new Int_t[fNLayers];
+  fLrDetType  = new Int_t[fNLayers];
+  fLastModIndex   = new Int_t[fNLayers];
+  fNModules = 0;
+  for (int i=0;i<fNLayers;i++) {
+    fNLadders[i]   = ExtractNumberOfLadders(i);
+    fNDetectors[i] = ExtractNumberOfDetectors(i);
+    fLrDetType[i]  = ExtractLayerDetType(i);
+    fNModules     += fNLadders[i]*fNDetectors[i];
+    fLastModIndex[i]   = fNModules-1;
+  }
+  //
+  fVersion = kITSVUpg;
   //
 }
 
 //______________________________________________________________________
-Bool_t AliITSgeomTGeoUpg::ReadVersionString(const Char_t *str,
-                                           Int_t &maj,Int_t &min,
-                                           TDatime &dt)
-{
-  // fills the string str with the major and minor version number
-  // Inputs:
-  //   Char_t *str   The character string to holding the major and minor
-  //                 version numbers in
-  // Outputs:
-  //   Int_t           maj  The major number
-  //   Int_t           min  The minor number
-  //   TDatime         dt   The date and time of the cvs commit
-  // Return:
-  //   kTRUE if no errors
-  enum {kv11=11,kv110=110,kvUpgrade=20}; // RS: to make consistent global numbering scheme
-  
-  Bool_t ok;
-  Char_t cvsRevision[10],cvsDate[11],cvsTime[9];
-  Int_t i,m,n=strlen(str),year,month,day,hours,minuts,seconds;
-  memset(cvsRevision,0,10*sizeof(Char_t));
-  memset(cvsDate,0,11*sizeof(Char_t));    
-  memset(cvsTime,0,9*sizeof(Char_t));
-  
-  if(n<35) return kFALSE; // not enough space for numbers
-  m = sscanf(str,"Major Version= %d  Minor Version= %d Revision: %9s "
-            "Date: %10s %8s",&i,&min,cvsRevision,cvsDate,cvsTime);
-  ok = m==5;
-  if(!ok) return !ok;
-  m = sscanf(cvsDate,"%d/%d/%d",&year,&month,&day);
-  ok = m==3;
-  if(!ok) return !ok;
-  m = sscanf(cvsTime,"%d:%d:%d",&hours,&minuts,&seconds);
-  ok = m==3;
-  if(!ok) return !ok;
-  dt.Set(year,month,day,hours,minuts,seconds);
-  //
-  switch (i){
-  case kv110:
-  case kv11:{
-    maj = kITSVOld;
-  } break;
-  case kvUpgrade:{
-    maj = kITSVUpg;
-  } break;
-  default:{
-    maj = kITSVNA;
-  } break;
-  } // end switch
-  return ok;
-}
-
-//______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::ExtractNumberOfLayers()
+Int_t AliITSUGeomTGeo::ExtractNumberOfLayers() const
 {
   // Determines the number of layers in the Upgrade Geometry
   //
-  // Inputs:
-  //   none
-  // Outputs:
-  //   none
-  // Return:
-  //   the number of layers in the current geometry
-  //   -1 if not Upgrade Geometry
-  // MS
-  //
   Int_t numberOfLayers = 0;
   //
   TGeoVolume *itsV = gGeoManager->GetVolume(fgkITSVolName);
-  if (!itsV) AliFatalClass(Form("ITS volume %s is not in the geometry",fgkITSVolName));
+  if (!itsV) AliFatal(Form("ITS volume %s is not in the geometry",fgkITSVolName));
   //
   // Loop on all ITSV nodes, count Layer volumes by checking names
   Int_t nNodes = itsV->GetNodes()->GetEntries();
@@ -579,23 +536,19 @@ Int_t AliITSgeomTGeoUpg::ExtractNumberOfLayers()
 }
 
 //______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::ExtractNumberOfLadders(const Int_t lay)
+Int_t AliITSUGeomTGeo::ExtractNumberOfLadders(Int_t lay) const
 {
   // Determines the number of layers in the Upgrade Geometry
   //
   // Inputs:
-  //   lay: layer number, starting from 1
-  // Outputs:
-  //   none
-  // Return:
-  //   the number of ladders in layer lay
-  //   -1 if not Upgrade Geometry
+  //   lay: layer number, starting from 0
+  //
   // MS
   Int_t numberOfLadders = 0;
   char laynam[30];
   snprintf(laynam, 30, "%s%d",fgkITSLrName,lay);
   TGeoVolume* volLr = gGeoManager->GetVolume(laynam);
-  if (!volLr) AliFatalClass(Form("can't find %s volume",laynam));
+  if (!volLr) AliFatal(Form("can't find %s volume",laynam));
   //
   // Loop on all layer nodes, count Ladder volumes by checking names
   Int_t nNodes = volLr->GetNodes()->GetEntries();
@@ -606,23 +559,18 @@ Int_t AliITSgeomTGeoUpg::ExtractNumberOfLadders(const Int_t lay)
 }
 
 //______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::ExtractNumberOfDetectors(const Int_t lay) 
+Int_t AliITSUGeomTGeo::ExtractNumberOfDetectors(Int_t lay)  const
 {
   // Determines the number of detectors per ladder in the Upgrade Geometry
   //
   // Inputs:
-  //   lay: layer number from 1
-  // Outputs:
-  //   none
-  // Return:
-  //   the number of modules per ladder in layer lay
-  //   -1 if not Upgrade Geometry
+  //   lay: layer number from 0
   // MS
   Int_t numberOfModules = 0;
   char laddnam[30];
   snprintf(laddnam, 30, "%s%d", fgkITSLadName,lay);
   TGeoVolume* volLd = gGeoManager->GetVolume(laddnam);
-  if (!volLd) AliFatalClass(Form("can't find %s volume",laddnam));
+  if (!volLd) AliFatal(Form("can't find %s volume",laddnam));
   //
   // Loop on all ladder nodes, count Module volumes by checking names
   Int_t nNodes = volLd->GetNodes()->GetEntries();
@@ -633,7 +581,7 @@ Int_t AliITSgeomTGeoUpg::ExtractNumberOfDetectors(const Int_t lay)
 }
 
 //______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::ExtractLayerDetType(const Int_t lay) 
+Int_t AliITSUGeomTGeo::ExtractLayerDetType(Int_t lay)  const
 {
   // Determines the layer detector type the Upgrade Geometry
   //
@@ -647,8 +595,15 @@ Int_t AliITSgeomTGeoUpg::ExtractLayerDetType(const Int_t lay)
   char laddnam[30];
   snprintf(laddnam, 30, "%s%d", fgkITSLrName,lay);
   TGeoVolume* volLd = gGeoManager->GetVolume(laddnam);
-  if (!volLd) {AliFatalClass(Form("can't find %s volume",laddnam)); return -1;}
+  if (!volLd) {AliFatal(Form("can't find %s volume",laddnam)); return -1;}
   //
   return volLd->GetUniqueID();
   //
 }
+
+//______________________________________________________________________
+UInt_t AliITSUGeomTGeo::ComposeDetTypeID(UInt_t segmId)
+{
+  if (segmId>=kMaxSegmPerDetType) AliFatalClass(Form("Id=%d is >= max.allowed %d",segmId,kMaxSegmPerDetType));
+  return segmId + kDetTypePixUpg*kMaxSegmPerDetType;
+}
diff --git a/ITS/UPGRADE/AliITSUGeomTGeo.h b/ITS/UPGRADE/AliITSUGeomTGeo.h
new file mode 100644 (file)
index 0000000..6f0c3f4
--- /dev/null
@@ -0,0 +1,245 @@
+#ifndef ALIITSUGEOMTGEO_H
+#define ALIITSUGEOMTGEO_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/////////////////////////////////////////////////////////////////////////
+//  AliITSUGeomTGeo is a simple interface class to TGeoManager       //
+//  It is used in the simulation and reconstruction in order to        //
+//  query the TGeo ITS geometry                                        //
+//                                                                     //
+//  author - cvetan.cheshkov@cern.ch                                   //
+//  15/02/2007                                                         //
+//  adapted to ITSupg 18/07/2012 - ruben.shahoyan@cern.ch              //
+//  RS: in order to preserve the static character of the class but     //
+//  make it dynamically access geometry, we need to check in every     //
+//  method if the structures are initialized. To be converted to       //
+//  singleton at later stage.                                          //
+//                                                                     //
+//  Note on the upgrade detector types:                                //
+//  The coarse type defines detectors served by different classes,     //
+//  like PixUpg. Each such a detector type can have kMaxSegmPerDetType //
+//  segmentations (pitch etc.) whose parameteres are stored in the     //
+//  AliITSsegmentation derived class (like AliITSUSegmentationPix)   //
+//  This allows to have in the setup modules served by the same        //
+//  classes but with different segmentations.                          //
+//  The full detector type is composed as:                             //
+//  CoarseType*kMaxSegmPerDetType + segmentationType                   //
+//  The only requirement on the segmentationType that should be        //
+//  < kMaxSegmPerDetType.                                              //
+//  The methods like GetLayerDetTypeID return the full detector type   //
+//                                                                     //
+//                                                                     //
+/////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <TGeoMatrix.h>
+#include <TString.h>
+
+class TGeoPNEntry;
+class TDatime;
+
+class AliITSUGeomTGeo : public TObject {
+
+ public:
+  enum {kITSVNA, kITSVUpg}; // ITS version
+  enum {kDetTypePixUpg=0, kNDetTypes, kMaxSegmPerDetType=10}; // defined detector types (each one can have different segmentations)
+  //
+  AliITSUGeomTGeo(Bool_t build = kFALSE);
+  virtual ~AliITSUGeomTGeo(); 
+  AliITSUGeomTGeo(const AliITSUGeomTGeo &src);
+  AliITSUGeomTGeo& operator=(const AliITSUGeomTGeo &geom);
+  //
+  Int_t   GetNModules()                                                   const {return fNModules;}
+  Int_t   GetNDetectors(Int_t lay)                                        const {return fNDetectors[lay];}
+  Int_t   GetNLadders(Int_t lay)                                          const {return fNLadders[lay];}
+  Int_t   GetNLayers()                                                    const {return fNLayers;}
+  
+  Int_t  GetModuleIndex(Int_t lay,Int_t lad,Int_t det)                    const;
+  Bool_t GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det)        const;
+  Int_t  GetLayer(Int_t index)                                            const;
+  Int_t  GetLadder(Int_t index)                                           const;
+  Int_t  GetModIdInLayer(Int_t index)                                     const;
+  Int_t  GetModIdInLadder(Int_t index)                                    const;
+  //
+  Int_t  GetLastModIndex(Int_t lay)                                       const {return fLastModIndex[lay];}
+  Int_t  GetFirstModIndex(Int_t lay)                                      const {return (lay==0) ? 0:fLastModIndex[lay-1]+1;}
+  //  
+  const char *GetSymName(Int_t index)                                     const;
+  const char *GetSymName(Int_t lay,Int_t lad,Int_t det)                   const;
+  //
+  // Attention: these are the matrices for the alignable volumes of the modules, i.e. not necessarily the sensors
+  TGeoHMatrix* GetMatrix(Int_t index)                                     const;
+  TGeoHMatrix* GetMatrix(Int_t lay,Int_t lad,Int_t det)                   const;
+  Bool_t GetTranslation(Int_t index, Double_t t[3])                       const;
+  Bool_t GetTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3])     const;
+  Bool_t GetRotation(Int_t index, Double_t r[9])                          const;
+  Bool_t GetRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9])        const;
+  Bool_t GetOrigMatrix(Int_t index, TGeoHMatrix &m)                       const;
+  Bool_t GetOrigMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m)     const;
+  Bool_t GetOrigTranslation(Int_t index, Double_t t[3])                   const;
+  Bool_t GetOrigTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3]) const;
+  Bool_t GetOrigRotation(Int_t index, Double_t r[9])                      const;
+  Bool_t GetOrigRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9])    const;
+  //
+  const TGeoHMatrix* GetTracking2LocalMatrix(Int_t index)                   const;
+  const TGeoHMatrix* GetTracking2LocalMatrix(Int_t lay,Int_t lad,Int_t det) const;
+  //
+  Bool_t GetTrackingMatrix(Int_t index, TGeoHMatrix &m)                   const;
+  Bool_t GetTrackingMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m) const;
+  //
+  // Attention: these are transformations wrt sensitive volume!
+  TGeoHMatrix* GetMatrixSens(Int_t index)                                 const;
+  TGeoHMatrix* GetMatrixSens(Int_t lay,Int_t lad,Int_t det)               const;
+  Bool_t LocalToGlobal(Int_t index, const Double_t *loc, Double_t *glob)  const;
+  Bool_t LocalToGlobal(Int_t lay, Int_t lad, Int_t det,const Double_t *loc, Double_t *glob) const;
+  //
+  Bool_t GlobalToLocal(Int_t index, const Double_t *glob, Double_t *loc)  const;
+  Bool_t GlobalToLocal(Int_t lay, Int_t lad, Int_t det,const Double_t *glob, Double_t *loc) const;
+  //
+  Bool_t LocalToGlobalVect(Int_t index, const Double_t *loc, Double_t *glob) const;
+  Bool_t GlobalToLocalVect(Int_t index, const Double_t *glob, Double_t *loc) const;
+  Int_t  GetLayerDetTypeID(Int_t lr)                                         const;
+  Int_t  GetModuleDetTypeID(Int_t id)                                        const;
+  //
+  static const char* GetITSVolPattern()                                             {return fgkITSVolName;}
+  static const char* GetITSLayerPattern()                                           {return fgkITSLrName;}
+  static const char* GetITSLadderPattern()                                          {return fgkITSLadName;}
+  static const char* GetITSModulePattern()                                          {return fgkITSModName;}
+  static const char* GetITSSensorPattern()                                          {return fgkITSSensName;}
+  static const char* GetDetTypeName(Int_t i)                                        {return (i<0||i>=kNDetTypes) ? 0 : fgkITSDetTypeName[i];}
+  static const char* GetITSsegmentationFileName()                                   {return fgITSsegmFileName.Data();}
+  static void        SetITSsegmentationFileName(const char* nm)                     {fgITSsegmFileName = nm;}
+  static UInt_t      ComposeDetTypeID(UInt_t segmId);
+  //
+ private:
+//
+  Bool_t       GetLayer(Int_t index,Int_t &lay,Int_t &index2) const;
+  TGeoPNEntry* GetPNEntry(Int_t index)                        const;
+  Int_t        ExtractNumberOfDetectors(Int_t lay)            const;
+  Int_t        ExtractNumberOfLadders(Int_t lay)              const;
+  Int_t        ExtractLayerDetType(Int_t lay)                 const;
+  Int_t        ExtractNumberOfLayers()                        const;
+  void         BuildITS();
+  //
+  Int_t  fVersion;             // ITS Version 
+  Int_t  fNLayers;             // number of layers
+  Int_t  fNModules;            //[fNLayers] The total number of modules
+  Int_t *fNLadders;            //[fNLayers] Array of the number of ladders/layer(layer)
+  Int_t *fLrDetType;           //[fNLayers] Array of layer detector types
+  Int_t *fNDetectors;          //[fNLayers] Array of the number of detector/ladder(layer)
+  Int_t *fLastModIndex;        //[fNLayers] max ID of the detctor in the layer
+  //
+  static const char*  fgkITSVolName;             // ITS mother volume name
+  static const char*  fgkITSLrName;              // ITS Layer name
+  static const char*  fgkITSLadName;             // ITS Ladder name 
+  static const char*  fgkITSModName;             // ITS Module name 
+  static const char*  fgkITSSensName;            // ITS Sensor name 
+  static const char*  fgkITSDetTypeName[kNDetTypes]; // ITS upg detType Names
+  //
+  static TString      fgITSsegmFileName;         // file name for segmentations
+  //
+  ClassDef(AliITSUGeomTGeo, 1) // ITS geometry based on TGeo
+};
+
+//_____________________________________________________________________________________________
+inline const char *AliITSUGeomTGeo::GetSymName(Int_t lay,Int_t lad,Int_t det) const    
+{
+  // sym name
+  return GetSymName(GetModuleIndex(lay,lad,det));
+}
+
+//_____________________________________________________________________________________________
+inline TGeoHMatrix* AliITSUGeomTGeo::GetMatrix(Int_t lay,Int_t lad,Int_t det) const    
+{
+  // module current matrix
+  return GetMatrix(GetModuleIndex(lay,lad,det));
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3]) const    
+{
+  // translation
+  return GetTranslation(GetModuleIndex(lay,lad,det),t); 
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9]) const    
+{
+  // rot
+  return GetRotation(GetModuleIndex(lay,lad,det),r); 
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetOrigMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m) const    
+{
+  // orig matrix
+  return GetOrigMatrix(GetModuleIndex(lay,lad,det),m); 
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetOrigTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3]) const    
+{
+  // orig trans
+  return GetOrigTranslation(GetModuleIndex(lay,lad,det),t); 
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetOrigRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9]) const    
+{
+  // orig rot
+  return GetOrigRotation(GetModuleIndex(lay,lad,det),r); 
+}
+
+//_____________________________________________________________________________________________
+inline const TGeoHMatrix* AliITSUGeomTGeo::GetTracking2LocalMatrix(Int_t lay,Int_t lad,Int_t det) const  
+{
+  // t2l matrix
+  return GetTracking2LocalMatrix(GetModuleIndex(lay,lad,det)); 
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GetTrackingMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m) const    
+{
+  // tracking mat
+  return GetTrackingMatrix(GetModuleIndex(lay,lad,det),m); 
+}
+
+//_____________________________________________________________________________________________
+inline TGeoHMatrix* AliITSUGeomTGeo::GetMatrixSens(Int_t index) const    
+{
+  // semsor matrix
+  int lr,ld,dt; 
+  return GetModuleId(index,lr,ld,dt) ? GetMatrixSens(GetModuleIndex(lr,ld,dt)) : 0;
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::LocalToGlobal(Int_t lay, Int_t lad, Int_t det,const Double_t *loc, Double_t *glob) const 
+{
+  // Local2Master (sensor)
+  return LocalToGlobal(GetModuleIndex(lay,lad,det), loc, glob);
+}
+
+//_____________________________________________________________________________________________
+inline Bool_t AliITSUGeomTGeo::GlobalToLocal(Int_t lay, Int_t lad, Int_t det,const Double_t *glob, Double_t *loc) const 
+{
+  // master2local (sensor)
+  return GlobalToLocal(GetModuleIndex(lay,lad,det), glob, loc);
+}
+
+//_____________________________________________________________________________________________
+inline Int_t  AliITSUGeomTGeo::GetLayerDetTypeID(Int_t lr) const  
+{
+  // detector type ID of layer
+  return fLrDetType[lr];
+}
+
+//_____________________________________________________________________________________________
+inline Int_t  AliITSUGeomTGeo::GetModuleDetTypeID(Int_t id) const  
+{
+  // detector type ID of module
+  return GetLayerDetTypeID(GetLayer(id));
+} 
+
+
+#endif
diff --git a/ITS/UPGRADE/AliITSUHit.cxx b/ITS/UPGRADE/AliITSUHit.cxx
new file mode 100644 (file)
index 0000000..013b741
--- /dev/null
@@ -0,0 +1,100 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+#include "AliITSU.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUHit.h"
+
+ClassImp(AliITSUHit)
+
+////////////////////////////////////////////////////////////////////////
+//
+// At the moment the same functionality/data-members as parent AliITShit 
+// except the geometry transformation uses AliITSgeomTGeoUp 
+//
+////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------
+AliITSUHit::AliITSUHit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,Float_t tof,
+                          TLorentzVector &x,TLorentzVector &x0,TLorentzVector &p) 
+: AliITShit(shunt,track,vol,edep,tof,x,x0,p)
+{
+  // ct-r
+}
+
+//______________________________________________________________________
+AliITSUHit::AliITSUHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits) 
+  : AliITShit(shunt, track, vol, hits) 
+{
+  // c-tor
+}
+
+//______________________________________________________________________
+AliITSUHit::AliITSUHit(const AliITSUHit &h)
+: AliITShit(h)
+{
+  // cp c-tor
+}
+
+//______________________________________________________________________
+AliITSUHit& AliITSUHit::operator=(const AliITSUHit &h)
+{
+  // The standard = operator
+  if(this == &h) return *this;
+  AliITShit::operator=(h);
+  return *this;
+}
+
+//______________________________________________________________________
+void AliITSUHit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof)
+{
+  // Returns the position and time of flight of this hit in the local
+  // coordinates of this module, and in the units of the Monte Carlo.
+  //
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  double g[3]={fX,fY,fZ},l[3];
+  gm->GetMatrixSens(fModule)->MasterToLocal(g,l);
+  x = l[0];
+  y = l[1];
+  z = l[2];
+  tof = fTof;
+  //
+}
+
+//______________________________________________________________________
+void AliITSUHit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
+{
+  // Returns the initial position and time of flight of this hit 
+  // in the local coordinates of this module, and in the units of the 
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  double g[3]={fx0,fy0,fz0},l[3];  
+  gm->GetMatrixSens(fModule)->MasterToLocal(g,l);
+  x = l[0];
+  y = l[1];
+  z = l[2];
+  tof = ft0;
+}
+
+//----------------------------------------------------------------------
+void AliITSUHit::GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det) const
+{
+  // Returns the layer ladder and detector number lables for this
+  // ITS module. Note: indices start from 0!
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  gm->GetModuleId(fModule,layer,ladder,det);
+}  
diff --git a/ITS/UPGRADE/AliITSUHit.cxx~ b/ITS/UPGRADE/AliITSUHit.cxx~
new file mode 100644 (file)
index 0000000..52c1080
--- /dev/null
@@ -0,0 +1,100 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+#include "AliITSU.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUHit.h"
+
+ClassImp(AliITSHit)
+
+////////////////////////////////////////////////////////////////////////
+//
+// At the moment the same functionality/data-members as parent AliITShit 
+// except the geometry transformation uses AliITSgeomTGeoUp 
+//
+////////////////////////////////////////////////////////////////////////
+
+//----------------------------------------------------------------------
+AliITSUHit::AliITSUHit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,Float_t tof,
+                          TLorentzVector &x,TLorentzVector &x0,TLorentzVector &p) 
+: AliITShit(shunt,track,vol,edep,tof,x,x0,p)
+{
+  // ct-r
+}
+
+//______________________________________________________________________
+AliITSUHit::AliITSUHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits) 
+  : AliITShit(shunt, track, vol, hits) 
+{
+  // c-tor
+}
+
+//______________________________________________________________________
+AliITSUHit::AliITSUHit(const AliITSUHit &h)
+: AliITShit(h)
+{
+  // cp c-tor
+}
+
+//______________________________________________________________________
+AliITSUHit& AliITSUHit::operator=(const AliITSUHit &h)
+{
+  // The standard = operator
+  if(this == &h) return *this;
+  AliITShit::operator=(h);
+  return *this;
+}
+
+//______________________________________________________________________
+void AliITSUHit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof)
+{
+  // Returns the position and time of flight of this hit in the local
+  // coordinates of this module, and in the units of the Monte Carlo.
+  //
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  double g[3]={fX,fY,fZ},l[3];
+  gm->GetMatrixSens(fModule)->MasterToLocal(g,l);
+  x = l[0];
+  y = l[1];
+  z = l[2];
+  tof = fTof;
+  //
+}
+
+//______________________________________________________________________
+void AliITSUHit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
+{
+  // Returns the initial position and time of flight of this hit 
+  // in the local coordinates of this module, and in the units of the 
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  double g[3]={fx0,fy0,fz0},l[3];  
+  gm->GetMatrixSens(fModule)->MasterToLocal(g,l);
+  x = l[0];
+  y = l[1];
+  z = l[2];
+  tof = ft0;
+}
+
+//----------------------------------------------------------------------
+void AliITSUHit::GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det) const
+{
+  // Returns the layer ladder and detector number lables for this
+  // ITS module. Note: indices start from 0!
+  AliITSUGeomTGeo *gm = ((AliITSU*)gAlice->GetDetector("ITS"))->GetITSGeomTGeo();
+  if (!gm) AliFatal("NULL pointer to the geometry!");
+  gm->GetModuleId(fModule,layer,ladder,det);
+}  
diff --git a/ITS/UPGRADE/AliITSUHit.h b/ITS/UPGRADE/AliITSUHit.h
new file mode 100644 (file)
index 0000000..c05f226
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef ALIITSUHIT_H
+#define ALIITSUHIT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////////////////////////////
+//
+// At the moment the same functionality/data-members as parent AliITShit 
+// except the geometry transformation uses AliITSgeomTGeoUp 
+//
+////////////////////////////////////////////////////////////////////////
+
+#include "AliITShit.h" 
+#include "AliRun.h"
+
+class AliITSUHit : public AliITShit {
+
+ public:
+  //
+  AliITSUHit() {}
+  AliITSUHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
+  AliITSUHit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,Float_t tof,TLorentzVector &x,TLorentzVector &x0,TLorentzVector &p);
+  AliITSUHit(const AliITSUHit &h);
+  AliITSUHit& operator=(const AliITSUHit &h);
+  virtual ~AliITSUHit() {};
+  virtual Int_t GetLayer() const;
+  virtual Int_t GetLadder() const;
+  virtual Int_t GetDetector() const;
+  virtual void  GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det) const;
+  virtual void  GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof);
+  virtual void  GetPositionL(Float_t &x,Float_t &y,Float_t &z) {Float_t tf;GetPositionL(x,y,z,tf);}
+  virtual void  GetPositionL(Double_t &x,Double_t &y,Double_t &z,Double_t &t) {Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;t=tf;}
+  virtual void  GetPositionL(Double_t &x,Double_t &y,Double_t &z) {Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;}
+  virtual void  GetPositionL0(Double_t &x,Double_t &y,Double_t &z,Double_t &t);
+  
+  //
+ protected:
+
+  ClassDef(AliITSUHit,1)  //Hits object
+        
+}; 
+
+#endif
similarity index 86%
rename from ITS/UPGRADE/AliITSInitGeometryUpg.cxx
rename to ITS/UPGRADE/AliITSUInitGeometry.cxx
index 8006f1b..001b565 100644 (file)
@@ -14,7 +14,7 @@
  **************************************************************************/
 
 /*
-$Id: AliITSInitGeometryUpg.cxx $
+$Id: AliITSUInitGeometry.cxx $
 */
 ////////////////////////////////////////////////////////////////
 //  This class initializes the class AliITSgeom
@@ -45,97 +45,39 @@ $Id: AliITSInitGeometryUpg.cxx $
 #include <TMath.h>
 
 #include "AliLog.h"
-#include "AliITSgeomTGeoUpg.h"
-#include "AliITSInitGeometryUpg.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUInitGeometry.h"
 #include <TDatime.h>
 
-ClassImp(AliITSInitGeometryUpg)
+ClassImp(AliITSUInitGeometry)
 
 //______________________________________________________________________
-AliITSInitGeometryUpg::AliITSInitGeometryUpg():
-TObject(),                   // Base Class
-fName(0),                    // Geometry name
-fMinorVersion(-1),           // Minor version number/type
-fMajorVersion(kvDefault),    // Major versin number
-fTiming(kFALSE),             // Flag to start inilization timing
-fSegGeom(kFALSE),            // Flag to switch between the old use of
-                             // AliITSgeomS?D class, or AliITSsegmentation
-                             // class in fShape of AliITSgeom class.
-fDecode(kFALSE),             // Flag for new/old decoding
-fDebug(0){                   // Debug flag
-    // Default Creator
-    // Inputs:
-    //   none.
-    // Outputs:
-    //   none.
-    // Return:
-    //   A default inilized AliITSInitGeometryUpg object
-
-    fName = "Undefined";
+AliITSUInitGeometry::AliITSUInitGeometry()
+: TObject()
+  ,fName(0)
+  ,fTiming(kFALSE)
+  ,fDebug(0)
+{  
 }
-//______________________________________________________________________
-AliITSInitGeometryUpg::AliITSInitGeometryUpg(AliITSVersion_t version,
-                                            Int_t minorversion):
-TObject(),                   // Base Class
-fName(0),                    // Geometry name
-fMinorVersion(minorversion), // Minor version number/type
-fMajorVersion(version),      // Major versin number
-fTiming(kFALSE),             // Flag to start inilization timing
-fSegGeom(kFALSE),            // Flag to switch between the old use of
-                             // AliITSgeomS?D class, or AliITSsegmentation
-                             // class in fShape of AliITSgeom class.
-fDecode(kFALSE),             // Flag for new/old decoding
-fDebug(0){                   // Debug flag
-    // Default Creator
-    // Inputs:
-    //   none.
-    // Outputs:
-    //   none.
-    // Return:
-    //   A default inilized AliITSInitGeometryUpg object
 
-  switch (version) {
-    case kv11:
-        fName="AliITSv11";
-       break;
-    case kvUpgrade:
-        fName="AliITSvUpgrade";
-       break;
-    case kvDefault:
-    default:
-        AliFatal(Form("Undefined geometry: fMajorVersion=%d, "
-                      "fMinorVersion= %d",(Int_t)fMajorVersion,fMinorVersion));
-        fName = "Undefined";
-       break;
-    } // switch
-}
 //______________________________________________________________________
-AliITSgeom* AliITSInitGeometryUpg::CreateAliITSgeom(){
-    // Creates and 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:
-    //   none.
-    // Outputs:
-    //   none.
-    // Return:
-    //   A pointer to a new properly inilized AliITSgeom class. If
-    //   pointer = 0 then failed to init.
-
+AliITSgeom* AliITSUInitGeometry::CreateAliITSgeom()
+{
+  // Creates and 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.
+  //
 
   AliITSVersion_t version = kvDefault;
   Int_t minor = 0;
   TDatime datetime;
-  TGeoVolume *itsV = gGeoManager->GetVolume(AliITSgeomTGeoUpg::GetITSVolPattern());
+  TGeoVolume *itsV = gGeoManager->GetVolume(AliITSUGeomTGeo::GetITSVolPattern());
   if(!itsV){
     Error("CreateAliITSgeom","Can't find ITS volume ITSV, aborting");
     return 0;
   }// end if
-  const Char_t *title = itsV->GetTitle();
-  if(!ReadVersionString(title,(Int_t)strlen(title),version,minor,
-                       datetime))
-    Warning("UpdateInternalGeometry","Can't read title=%s\n",title);
+
   SetTiming(kFALSE);
   SetSegGeom(kFALSE);
   SetDecoding(kFALSE);
@@ -143,8 +85,9 @@ AliITSgeom* AliITSInitGeometryUpg::CreateAliITSgeom(){
   AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
   return geom;
 }
+
 //______________________________________________________________________
-AliITSgeom* AliITSInitGeometryUpg::CreateAliITSgeom(Int_t major,Int_t minor){
+AliITSgeom* AliITSUInitGeometry::CreateAliITSgeom(Int_t major,Int_t minor){
     // Creates and Initilizes the geometry transformation class AliITSgeom
     // to values appropreate to this specific geometry. Now that
     // the segmentation is part of AliITSgeom, the detector
@@ -164,7 +107,7 @@ AliITSgeom* AliITSInitGeometryUpg::CreateAliITSgeom(Int_t major,Int_t minor){
         SetVersion(kv11,minor);
         break;
     case kvUpgrade:
-        SetGeometryName("AliITSvUpgrade");
+        SetGeometryName("AliITSUv11");
         SetVersion(kvUpgrade,minor);
         break;
     case kvDefault:
@@ -181,7 +124,7 @@ AliITSgeom* AliITSInitGeometryUpg::CreateAliITSgeom(Int_t major,Int_t minor){
     return geom;
 }
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::InitAliITSgeom(AliITSgeom *geom){
+Bool_t AliITSUInitGeometry::InitAliITSgeom(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
@@ -214,7 +157,7 @@ Bool_t AliITSInitGeometryUpg::InitAliITSgeom(AliITSgeom *geom){
     return kFALSE;
 }
 //______________________________________________________________________
-void AliITSInitGeometryUpg::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
+void AliITSUInitGeometry::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
     // Transpose the rotation matrix part of a TGeoHMatrix. This
     // is needed because TGeo stores the transpose of the rotation
     // matrix as compared to what AliITSgeomMatrix uses (and Geant3).
@@ -241,7 +184,7 @@ void AliITSInitGeometryUpg::TransposeTGeoHMatrix(TGeoHMatrix *m)const{
 
 
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::InitAliITSgeomV11(AliITSgeom *geom){
+Bool_t AliITSUInitGeometry::InitAliITSgeomV11(AliITSgeom *geom){
   // Initilizes the geometry transformation class AliITSgeom
   // Now that the segmentation is part of AliITSgeom, the detector
   // segmentations are also defined here.
@@ -327,7 +270,7 @@ Bool_t AliITSInitGeometryUpg::InitAliITSgeomV11(AliITSgeom *geom){
   return kTRUE;
 }
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::InitAliITSgeomVUpgrade(AliITSgeom *geom){
+Bool_t AliITSUInitGeometry::InitAliITSgeomVUpgrade(AliITSgeom *geom){
   // Initilizes the geometry transformation class AliITSgeom
   // Now that the segmentation is part of AliITSgeom, the detector
   // segmentations are also defined here.
@@ -341,8 +284,6 @@ Bool_t AliITSInitGeometryUpg::InitAliITSgeomVUpgrade(AliITSgeom *geom){
   const Int_t kItype  = 0; // Type of transformation defined 0=> Geant
   const Int_t klayers = GetNumberOfLayers(); // Number of layers in the ITS
   const AliITSDetector kIdet = AliITSDetector(0); //kUPG; RS temporary
-  TString pathbase = Form("/ALIC_1/%s_2/",AliITSgeomTGeoUpg::GetITSVolPattern()); // We have 2 to cheat AliGeoManager::CheckSymNamesLUT
-
   if (klayers <= 0) {
     AliError("No layers found in ITSV");
     return kFALSE;
@@ -355,12 +296,12 @@ Bool_t AliITSInitGeometryUpg::InitAliITSgeomVUpgrade(AliITSgeom *geom){
     kladders[j] = GetNumberOfLadders(j);
     kdetectors[j] = GetNumberOfModules(j);
   }
-  const TString kPathBase = Form("/ALIC_1/%s_1/",AliITSgeomTGeoUpg::GetITSVolPattern());
+  const TString kPathBase = Form("/ALIC_1/%s_1/",AliITSUGeomTGeo::GetITSVolPattern());
   const TString kNames = Form("%%s%s%%d_1/%s%%d_%%d/%s%%d_%%d/%s%%d_%%d"
-                             ,AliITSgeomTGeoUpg::GetITSLayerPattern()
-                             ,AliITSgeomTGeoUpg::GetITSLadderPattern()
-                             ,AliITSgeomTGeoUpg::GetITSModulePattern()
-                             ,AliITSgeomTGeoUpg::GetITSSensorPattern()
+                             ,AliITSUGeomTGeo::GetITSLayerPattern()
+                             ,AliITSUGeomTGeo::GetITSLadderPattern()
+                             ,AliITSUGeomTGeo::GetITSModulePattern()
+                             ,AliITSUGeomTGeo::GetITSSensorPattern()
                              );
   Int_t mod,nmods=0, lay, lad, det, cpn0, cpn1, cpn2;
   Double_t tran[3]={0.,0.,0.}, rot[10]={9*0.0,1.0};
@@ -406,7 +347,7 @@ Bool_t AliITSInitGeometryUpg::InitAliITSgeomVUpgrade(AliITSgeom *geom){
 }
 
 //_______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::GetTransformation(const TString &volumePath,
+Bool_t AliITSUInitGeometry::GetTransformation(const TString &volumePath,
                                             TGeoHMatrix &mat){
     // Returns the Transformation matrix between the volume specified
     // by the path volumePath and the Top or mater volume. The format
@@ -442,7 +383,7 @@ Bool_t AliITSInitGeometryUpg::GetTransformation(const TString &volumePath,
     return kTRUE;
 }
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::GetShape(const TString &volumePath,
+Bool_t AliITSUInitGeometry::GetShape(const TString &volumePath,
                                    TString &shapeType,TArrayD &par){
     // Returns the shape and its parameters for the volume specified
     // by volumeName.
@@ -701,7 +642,7 @@ Bool_t AliITSInitGeometryUpg::GetShape(const TString &volumePath,
     return kFALSE;
 }
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetector(
+void AliITSUInitGeometry::DecodeDetector(
     Int_t &mod,Int_t layer,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
@@ -738,7 +679,7 @@ void AliITSInitGeometryUpg::DecodeDetector(
     return;
 }
 //______________________________________________________________________
-void AliITSInitGeometryUpg::RecodeDetector(Int_t mod,Int_t &cpn0,
+void AliITSUInitGeometry::RecodeDetector(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
@@ -775,7 +716,7 @@ void AliITSInitGeometryUpg::RecodeDetector(Int_t mod,Int_t &cpn0,
     return;
 }
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetectorLayers(Int_t mod,Int_t &layer,
+void AliITSUInitGeometry::DecodeDetectorLayers(Int_t mod,Int_t &layer,
                                               Int_t &lad,Int_t &det){
     // decode geometry into detector module number. There are two decoding
     // Scheams. Old which does not follow the ALICE coordinate system
@@ -817,7 +758,7 @@ void AliITSInitGeometryUpg::DecodeDetectorLayers(Int_t mod,Int_t &layer,
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetectorv11(Int_t &mod,Int_t layer,
+void AliITSUInitGeometry::DecodeDetectorv11(Int_t &mod,Int_t layer,
                                  Int_t cpn0,Int_t cpn1,Int_t cpn2) const {
     // decode geometry into detector module number
     // Inputs:
@@ -858,7 +799,7 @@ void AliITSInitGeometryUpg::DecodeDetectorv11(Int_t &mod,Int_t layer,
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetectorvUpgrade(Int_t &mod,Int_t layer,
+void AliITSUInitGeometry::DecodeDetectorvUpgrade(Int_t &mod,Int_t layer,
                                  Int_t cpn0,Int_t cpn1,Int_t /*cpn2*/) const {
     // decode geometry into detector module number
     // Inputs:
@@ -883,7 +824,7 @@ void AliITSInitGeometryUpg::DecodeDetectorvUpgrade(Int_t &mod,Int_t layer,
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::RecodeDetectorv11(Int_t mod,Int_t &cpn0,
+void AliITSUInitGeometry::RecodeDetectorv11(Int_t mod,Int_t &cpn0,
                                           Int_t &cpn1,Int_t &cpn2) {
     // decode geometry into detector module number using the new decoding
     // Scheme.
@@ -916,13 +857,13 @@ void AliITSInitGeometryUpg::RecodeDetectorv11(Int_t mod,Int_t &cpn0,
          cpn0--;
         } // end if Lay<5/else
     } // end if lay<3/else
-    /*printf("AliITSInitGeometryUpg::RecodeDetectorv11:"
+    /*printf("AliITSUInitGeometry::RecodeDetectorv11:"
            "mod=%d lay=%d lad=%d det=%d cpn0=%d cpn1=%d cpn2=%d\n",
            mod,lay,lad,det,cpn0,cpn1,cpn2);*/
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::RecodeDetectorvUpgrade(Int_t mod,Int_t &cpn0,
+void AliITSUInitGeometry::RecodeDetectorvUpgrade(Int_t mod,Int_t &cpn0,
                                                Int_t &cpn1,Int_t &cpn2) {
     // decode geometry into detector module number using the new decoding
     // Scheme.
@@ -944,13 +885,13 @@ void AliITSInitGeometryUpg::RecodeDetectorvUpgrade(Int_t mod,Int_t &cpn0,
     cpn0 = lad;
 //    cpn1--;
 //    cpn0--;
-    /*printf("AliITSInitGeometryUpg::RecodeDetectorv11:"
+    /*printf("AliITSUInitGeometry::RecodeDetectorv11:"
            "mod=%d lay=%d lad=%d det=%d cpn0=%d cpn1=%d cpn2=%d\n",
            mod,lay,lad,det,cpn0,cpn1,cpn2);*/
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
+void AliITSUInitGeometry::DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
                                                 Int_t &lad,Int_t &det) {
 
   // decode module number into detector indices for v11
@@ -989,7 +930,7 @@ void AliITSInitGeometryUpg::DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
 }
 
 //______________________________________________________________________
-void AliITSInitGeometryUpg::DecodeDetectorLayersvUpgrade(Int_t  mod,Int_t &lay,
+void AliITSUInitGeometry::DecodeDetectorLayersvUpgrade(Int_t  mod,Int_t &lay,
                                                      Int_t &lad,Int_t &det){
 
   // decode module number into detector indices for vUpgrade
@@ -1030,7 +971,7 @@ void AliITSInitGeometryUpg::DecodeDetectorLayersvUpgrade(Int_t  mod,Int_t &lay,
 }
 
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::WriteVersionString(Char_t *str,Int_t length,
+Bool_t AliITSUInitGeometry::WriteVersionString(Char_t *str,Int_t length,
                         AliITSVersion_t maj,Int_t min,
                         const Char_t *cvsDate,const Char_t *cvsRevision)const{
     // fills the string str with the major and minor version number
@@ -1074,7 +1015,7 @@ Bool_t AliITSInitGeometryUpg::WriteVersionString(Char_t *str,Int_t length,
     n = 50+(Int_t)(TMath::Log10(TMath::Abs((Double_t)i)))+1+
         (Int_t)(TMath::Log10(TMath::Abs((Double_t)min)))+1
         +cvsDateLength-6+cvsRevisionLength-10;
-    if(GetDebug()>1) printf("AliITSInitGeometryUpg::WriteVersionString:"
+    if(GetDebug()>1) printf("AliITSUInitGeometry::WriteVersionString:"
                         "length=%d major=%d minor=%d cvsDate=%s[%d] "
                         "cvsRevision=%s[%d] n=%d\n",length,i,min,cvslikedate,
                         cvsDateLength,cvsRevision,cvsRevisionLength,n);
@@ -1096,7 +1037,7 @@ Bool_t AliITSInitGeometryUpg::WriteVersionString(Char_t *str,Int_t length,
     i = (Int_t)maj;
     snprintf(str,length-1,"Major Version= %d Minor Version= %d Revision: %s Date: %s",i,min,cvsrevision,cvsdate);
     /* this gives compilation warnings on some compilers: descriptor zu
-    if(GetDebug()>1)printf("AliITSInitGeometryUpg::WriteVersionString: "
+    if(GetDebug()>1)printf("AliITSUInitGeometry::WriteVersionString: "
                        "n=%d str=%s revision[%zu] date[%zu]\n",
                        n,str,strlen(cvsrevision),strlen(cvsdate));
     */
@@ -1105,7 +1046,7 @@ Bool_t AliITSInitGeometryUpg::WriteVersionString(Char_t *str,Int_t length,
     return kTRUE;
 }
 //______________________________________________________________________
-Bool_t AliITSInitGeometryUpg::ReadVersionString(const Char_t *str,Int_t length,
+Bool_t AliITSUInitGeometry::ReadVersionString(const Char_t *str,Int_t length,
                                              AliITSVersion_t &maj,Int_t &min,
                                              TDatime &dt)const{
     // fills the string str with the major and minor version number
@@ -1129,7 +1070,7 @@ Bool_t AliITSInitGeometryUpg::ReadVersionString(const Char_t *str,Int_t length,
     memset(cvsDate,0,11*sizeof(Char_t));    
     memset(cvsTime,0,9*sizeof(Char_t));
 
-    if(GetDebug()>1)printf("AliITSInitGeometryUpg::ReadVersionString:"
+    if(GetDebug()>1)printf("AliITSUInitGeometry::ReadVersionString:"
                        "str=%s length=%d\n",
                        str,length);
     if(n<35) return kFALSE; // not enough space for numbers
@@ -1144,10 +1085,10 @@ Bool_t AliITSInitGeometryUpg::ReadVersionString(const Char_t *str,Int_t length,
     ok = m==3;
     if(!ok) return !ok;
     dt.Set(year,month,day,hours,minuits,seconds);
-    if(GetDebug()>1)printf("AliITSInitGeometryUpg::ReadVersionString: i=%d "
+    if(GetDebug()>1)printf("AliITSUInitGeometry::ReadVersionString: i=%d "
                      "min=%d cvsRevision=%s cvsDate=%s cvsTime=%s m=%d\n",
                        i,min,cvsRevision,cvsDate,cvsTime,m);
-    if(GetDebug()>1)printf("AliITSInitGeometryUpg::ReadVersionString: year=%d"
+    if(GetDebug()>1)printf("AliITSUInitGeometry::ReadVersionString: year=%d"
                        " month=%d day=%d hours=%d minuits=%d seconds=%d\n",
                        year,month,day,hours,minuits,seconds);
     switch (i){
@@ -1164,7 +1105,7 @@ Bool_t AliITSInitGeometryUpg::ReadVersionString(const Char_t *str,Int_t length,
     return ok;
 }
 //______________________________________________________________________
-Int_t AliITSInitGeometryUpg::GetNumberOfLayers(){
+Int_t AliITSUInitGeometry::GetNumberOfLayers(){
   // Determines the number of layers in the Upgrade Geometry
   //
   // Inputs:
@@ -1189,20 +1130,20 @@ Int_t AliITSInitGeometryUpg::GetNumberOfLayers(){
       return 0;
     }
 
-    if (!gGeoManager->GetVolume(AliITSgeomTGeoUpg::GetITSVolPattern())) {
-      AliError(Form("can't find %s volume",AliITSgeomTGeoUpg::GetITSVolPattern()));
+    if (!gGeoManager->GetVolume(AliITSUGeomTGeo::GetITSVolPattern())) {
+      AliError(Form("can't find %s volume",AliITSUGeomTGeo::GetITSVolPattern()));
       return 0;
     }
 
     // Loop on all ITSV nodes, count Layer volumes by checking names
-    Int_t nNodes = gGeoManager->GetVolume(AliITSgeomTGeoUpg::GetITSVolPattern())->GetNodes()->GetEntries();
+    Int_t nNodes = gGeoManager->GetVolume(AliITSUGeomTGeo::GetITSVolPattern())->GetNodes()->GetEntries();
 
     if (nNodes == 0)
       return 0;
 
     for (Int_t j=0; j<nNodes; j++)
-      if (strstr(gGeoManager->GetVolume(AliITSgeomTGeoUpg::GetITSVolPattern())->GetNodes()->At(j)->GetName(),
-                AliITSgeomTGeoUpg::GetITSLayerPattern()))
+      if (strstr(gGeoManager->GetVolume(AliITSUGeomTGeo::GetITSVolPattern())->GetNodes()->At(j)->GetName(),
+                AliITSUGeomTGeo::GetITSLayerPattern()))
        numberOfLayers++;
 
 
@@ -1210,7 +1151,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfLayers(){
 }
 
 //______________________________________________________________________
-Int_t AliITSInitGeometryUpg::GetNumberOfLadders(const Int_t lay) const {
+Int_t AliITSUInitGeometry::GetNumberOfLadders(const Int_t lay) const {
   // Determines the number of layers in the Upgrade Geometry
   //
   // Inputs:
@@ -1236,7 +1177,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfLadders(const Int_t lay) const {
     }
 
     char laynam[15];
-    snprintf(laynam, 15, "%s%d", AliITSgeomTGeoUpg::GetITSLayerPattern(),lay+1);
+    snprintf(laynam, 15, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(),lay+1);
     if (!gGeoManager->GetVolume(laynam)) {
       AliError(Form("can't find %s volume",laynam));
       return 0;
@@ -1250,7 +1191,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfLadders(const Int_t lay) const {
 
     for (Int_t j=0; j<nNodes; j++)
       if (strstr(gGeoManager->GetVolume(laynam)->GetNodes()->At(j)->GetName(),
-                AliITSgeomTGeoUpg::GetITSLadderPattern()))
+                AliITSUGeomTGeo::GetITSLadderPattern()))
        numberOfLadders++;
 
 
@@ -1258,7 +1199,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfLadders(const Int_t lay) const {
 }
 
 //______________________________________________________________________
-Int_t AliITSInitGeometryUpg::GetLayerDetTypeID(const Int_t lay) const 
+Int_t AliITSUInitGeometry::GetLayerDetTypeID(const Int_t lay) const 
 {
   // Determines the layers det. type in the Upgrade Geometry
   //
@@ -1283,7 +1224,7 @@ Int_t AliITSInitGeometryUpg::GetLayerDetTypeID(const Int_t lay) const
   }
   
   char laynam[15];
-  snprintf(laynam, 15, "%s%d", AliITSgeomTGeoUpg::GetITSLayerPattern(),lay+1);
+  snprintf(laynam, 15, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(),lay+1);
   TGeoVolume* volLr = gGeoManager->GetVolume(laynam);
   if (!volLr) {
     AliError(Form("can't find %s volume",laynam));
@@ -1295,7 +1236,7 @@ Int_t AliITSInitGeometryUpg::GetLayerDetTypeID(const Int_t lay) const
 }
 
 //______________________________________________________________________
-Int_t AliITSInitGeometryUpg::GetNumberOfModules(const Int_t lay) const {
+Int_t AliITSUInitGeometry::GetNumberOfModules(const Int_t lay) const {
   // Determines the number of layers in the Upgrade Geometry
   //
   // Inputs:
@@ -1321,7 +1262,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfModules(const Int_t lay) const {
     }
 
     char laddnam[15];
-    snprintf(laddnam, 15, "%s%d", AliITSgeomTGeoUpg::GetITSLadderPattern(),lay+1);
+    snprintf(laddnam, 15, "%s%d", AliITSUGeomTGeo::GetITSLadderPattern(),lay+1);
     if (!gGeoManager->GetVolume(laddnam)) {
       AliError(Form("can't find %s volume",laddnam));
       return 0;
@@ -1335,7 +1276,7 @@ Int_t AliITSInitGeometryUpg::GetNumberOfModules(const Int_t lay) const {
 
     for (Int_t j=0; j<nNodes; j++)
       if (strstr(gGeoManager->GetVolume(laddnam)->GetNodes()->At(j)->GetName(),
-                AliITSgeomTGeoUpg::GetITSModulePattern()))
+                AliITSUGeomTGeo::GetITSModulePattern()))
        numberOfModules++;
 
 
diff --git a/ITS/UPGRADE/AliITSUInitGeometry.h b/ITS/UPGRADE/AliITSUInitGeometry.h
new file mode 100644 (file)
index 0000000..7bf8244
--- /dev/null
@@ -0,0 +1,89 @@
+#ifndef ALIITSUINITGEOMETRY_H
+#define ALIITSUINITGEOMETRY_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+$Id: AliITSUInitGeometry.h $
+*/
+
+/////////////////////////////////////////////////////////////////////
+// Class to inilize AliITSgeom and the like for both simulation
+//  and reconstruction.
+/////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <TString.h>
+#include "AliITSgeom.h"
+
+class TArrayD;
+class TGeoHMatrix;
+class TDatime;
+
+class AliITSUInitGeometry : public TObject{
+ public:
+
+    AliITSUInitGeometry();//Default Constructor
+    AliITSUInitGeometry(AliITSVersion_t version,Int_t minorversion=2);//Standard Constructor
+    //virtual ~AliITSUInitGeometry(); // Destructor
+    //
+    // Create and initialize geometry from TGeo
+    AliITSgeom* CreateAliITSgeom();
+    AliITSgeom* CreateAliITSgeom(Int_t major,Int_t minor); 
+    Bool_t InitAliITSgeom(AliITSgeom *geom);//Initilize geometry from gGeoManager
+    TString GetGeometryName()const {return fName;}// Return geometry name
+    void    SetGeometryName(const Char_t *name){fName = name;}// Set Geometry name
+    Bool_t  GetTiming()const{return fTiming;} // return routine timing flag
+    void    SetTiming(Bool_t time=kTRUE){fTiming=time;}// Set routine timing (on)
+    void    SetDebug(Int_t debug=0){fDebug=debug;};
+    // Retrun debug value
+    Int_t   GetDebug()const{return fDebug;};
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayers(Int_t mod,Int_t &lay,Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void  DecodeDetector(Int_t &mod,Int_t lay,Int_t cpn0,
+                        Int_t cpn1,Int_t cpn2) const;
+    // Given module number, find copy numbers.
+    void  RecodeDetector(Int_t mod,Int_t &cpn0,Int_t &cpn1,Int_t &cpn2);
+    Int_t GetNumberOfLayers();
+    Int_t GetNumberOfLadders(const Int_t lay) const;
+    Int_t GetNumberOfModules(const Int_t lay) const;
+    Int_t GetLayerDetTypeID(const Int_t lay) const;
+    //
+ private:
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorLayersv11(Int_t mod,Int_t &lay,
+                                Int_t &lad,Int_t &det);
+    // find module number by layer, and copy numbers
+    void DecodeDetectorv11(Int_t &mod,Int_t lay,Int_t cpn0,Int_t cpn1,
+                          Int_t cpn2)const;
+    // Given module number, find copy numbers.
+    void RecodeDetectorv11(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                          Int_t &cpn2);
+    // Decode module number into old layer, ladder, and detector numbers
+    void DecodeDetectorvUpgrade(Int_t &mod,Int_t lay,Int_t cpn0,Int_t cpn1,
+                                    Int_t cpn2)const;
+    // find module number by layer, and copy numbers
+    void RecodeDetectorvUpgrade(Int_t mod,Int_t &cpn0,Int_t &cpn1,
+                                    Int_t &cpn2);
+    // Given module number, find copy numbers.
+    void DecodeDetectorLayersvUpgrade(Int_t mod,Int_t &lay,Int_t &lad,
+                                    Int_t &det);
+                  
+    // Virtual MC code 
+    Bool_t InitAliITSgeomV11(AliITSgeom *geom);
+    Bool_t InitAliITSgeomVUpgrade(AliITSgeom *geom);
+    Bool_t GetTransformation(const TString &volumePath,TGeoHMatrix &mat);
+    Bool_t GetShape(const TString &volumePath,TString &shapeType,TArrayD &par);
+    void TransposeTGeoHMatrix(TGeoHMatrix *m) const;
+
+    TString         fName;         // Geometry name
+    Bool_t          fTiming;       // Flag to start inilization timing
+    Int_t           fDebug;        // Debug flag
+
+    ClassDef(AliITSUInitGeometry,0) // create/Init AliITSgeom
+    // 0 in ClassDef indicates that this class will not be "saved" in a file.
+};
+
+#endif
+
similarity index 78%
rename from ITS/UPGRADE/AliITSLoaderUpg.cxx
rename to ITS/UPGRADE/AliITSULoader.cxx
index 0099a09..730a1f6 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: AliITSLoaderUpg.cxx $ */
+/* $Id: AliITSULoader.cxx $ */
 
 #include <TClonesArray.h>
 #include <TClass.h>
 #include <TTree.h>
 
 #include "AliITSdigit.h"
-#include "AliITSLoaderUpg.h"
+#include "AliITSULoader.h"
 #include "AliRunLoader.h"
 #include "AliObjectLoader.h"
-#include "AliITSInitGeometryUpg.h"
 #include "AliLog.h"
 
 ///////////////////////////////////////////////////////////////////////////
 // V0 and cascade
 // and tracks propagated to the origin
 //////////////////////////////////////////////////////////////////////////
-ClassImp(AliITSLoaderUpg)
+ClassImp(AliITSULoader)
 
 /**********************************************************************/
-  AliITSLoaderUpg::AliITSLoaderUpg():AliLoader(),
-fGeom(0){
+AliITSULoader::AliITSULoader()
+:AliLoader()
+{
   // Default constructor
 }
+
 /*********************************************************************/
-AliITSLoaderUpg::AliITSLoaderUpg(const Char_t *name,const Char_t *topfoldername):
-AliLoader(name,topfoldername),
-fGeom(0){
+AliITSULoader::AliITSULoader(const Char_t *name,const Char_t *topfoldername)
+: AliLoader(name,topfoldername)
+{
   //Constructor   
   TString rawContainerName = "TreeC";
     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
@@ -83,9 +84,9 @@ fGeom(0){
     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
 }
 /**********************************************************************/
-AliITSLoaderUpg::AliITSLoaderUpg(const Char_t *name,TFolder *topfolder): 
-  AliLoader(name,topfolder),
-fGeom(0){
+AliITSULoader::AliITSULoader(const Char_t *name,TFolder *topfolder)
+: AliLoader(name,topfolder)
+{
   //ctor  
    TString rawContainerName="TreeC";
     AliDataLoader*  rawClustersDataLoader = new AliDataLoader(
@@ -125,7 +126,7 @@ fGeom(0){
 
 
 /**********************************************************************/
-AliITSLoaderUpg::~AliITSLoaderUpg(){
+AliITSULoader::~AliITSULoader(){
     //destructor
     UnloadRawClusters();
     AliDataLoader *dl = GetRawClLoader();
@@ -147,12 +148,10 @@ AliITSLoaderUpg::~AliITSLoaderUpg(){
     dl = GetCascadeDataLoader();
     fDataLoaders->Remove(dl);
   
-    if(fGeom)delete fGeom;
-    fGeom = 0;
 }
 /*
 //----------------------------------------------------------------------
-AliITS* AliITSLoaderUpg::GetITS(){
+AliITS* AliITSULoader::GetITS(){
     // Returns the pointer to the ITS, kept on the file. A short cut metthod
     // Inputs:
     //    none.
@@ -177,7 +176,7 @@ AliITS* AliITSLoaderUpg::GetITS(){
     return its;
 }
 //----------------------------------------------------------------------
-void AliITSLoaderUpg::SetupDigits(AliITS *its){
+void AliITSULoader::SetupDigits(AliITS *its){
     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
     // Inputs:
     //    AliITS *its  Pointer to the ITS
@@ -190,7 +189,7 @@ void AliITSLoaderUpg::SetupDigits(AliITS *its){
 }
 */
 //----------------------------------------------------------------------
-void AliITSLoaderUpg::SetupDigits(TObjArray *digPerDet,Int_t n,
+void AliITSULoader::SetupDigits(TObjArray *digPerDet,Int_t n,
                                  const Char_t **digclass){
     // Sets up digPerDet to store ITS Digits.
     // Inputs:
@@ -251,7 +250,7 @@ void AliITSLoaderUpg::SetupDigits(TObjArray *digPerDet,Int_t n,
     } // end for i
 }
 //---------------------------------------------------------------------
-AliITSdigit * AliITSLoaderUpg::GetDigit(TObjArray *digPerDet,Int_t module,
+AliITSdigit * AliITSULoader::GetDigit(TObjArray *digPerDet,Int_t module,
                                        Int_t digit){
     // Gets the digit for for a specific detector type and module.
     // To be used in conjustion with Setupdigits(AliITS *its).
@@ -272,36 +271,8 @@ AliITSdigit * AliITSLoaderUpg::GetDigit(TObjArray *digPerDet,Int_t module,
     } // end if
     return 0;
 }
-/*
-//---------------------------------------------------------------------
-AliITSdigit * AliITSLoaderUpg::GetDigit(AliITS *its,Int_t module,Int_t digit){
-    // Gets the digit for for a specific detector type and module.
-    // To be used in conjustion with Setupdigits(AliITS *its).
-    // Inputs:
-    //   AliITS *its    Pointer to the ITS
-    //   Int_t  module  Module number
-    //   Int_t digit    Digit number
-    // Outputs:
-    //   none.
-    // Return:
-    //   returns the pointer to the digit. if zero then last digit for that
-    //   module.
-    //AliITSDetType *idtype;
-    AliITSgeom *geom = its->GetITSgeom();
-    Int_t idet = geom->GetModuleType(module);
-    TClonesArray *digits;
-    its->ResetDigits();
-    TreeD()->GetEvent(module);
-    digits = its->DigitsAddress(idet);
-    if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
-        return (AliITSdigit*) digits->At(digit);
-    } // end if
-    return 0;
-}
-*/
 //----------------------------------------------------------------------
-void AliITSLoaderUpg::MakeTree(Option_t *opt){
+void AliITSULoader::MakeTree(Option_t *opt){
     // invokes AliLoader::MakeTree + specific ITS tree(s)
     // Valid options: H,S,D,R,T and C (C=raw clusters)
     AliLoader::MakeTree(opt);
@@ -317,41 +288,3 @@ void AliITSLoaderUpg::MakeTree(Option_t *opt){
     const char *oX = strstr(opt,"X");
     if (oX) MakeCascadeContainer();
 }
-
-//----------------------------------------------------------------------
-AliITSgeom* AliITSLoaderUpg::GetITSgeom(Bool_t force) {
-  // retrieves the ITS geometry from file
-  if(fGeom && !force)return fGeom;
-  if(fGeom && force){
-    delete fGeom;
-    fGeom = 0;
-  }
-  if(!gGeoManager){
-    AliError("gGeoManager is a null pointer - ITS geometry not built");
-    return fGeom;
-  }
-  AliITSInitGeometryUpg initgeom;
-  fGeom = initgeom.CreateAliITSgeom();
-  AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
-  AliDebug(1,Form("Geometry name: %s",(initgeom.GetGeometryName()).Data()));
-  return fGeom;
-}
-//______________________________________________________________________
-void AliITSLoaderUpg::SetITSgeom(AliITSgeom *geom){
-    // Replaces the AliITSgeom object read from file with the one
-    // given.
-    // Inputs:
-    //   AliITSgeom *geom   The AliITSgeom object to replace the one
-    //                      read from the file
-    // Outputs:
-    //   none.
-    // Return:
-    //   none.
-
-    if(fGeom==geom) return; // Same do nothing
-    if(fGeom) {
-       delete fGeom;
-       fGeom=0;
-    }// end if
-    fGeom=geom;
-}
similarity index 89%
rename from ITS/UPGRADE/AliITSLoaderUpg.h
rename to ITS/UPGRADE/AliITSULoader.h
index 2ac1983..029307e 100644 (file)
@@ -1,22 +1,21 @@
-#ifndef ALIITSLOADERUPG_H
-#define ALIITSLOADERUPG_H
+#ifndef ALIITSULOADER_H
+#define ALIITSULOADER_H
 //////////////////////////////////////////////////////////
 // Loader class for ITS Upgrade                         //
 //////////////////////////////////////////////////////////
 #include <AliLoader.h>
 #include <AliESDVertex.h>
-#include <AliITSgeom.h>
 class AliITSpidESD;
 class AliITSdigit;
 class TObjArray;
 
-class AliITSLoaderUpg: public AliLoader{
+class AliITSULoader: public AliLoader{
   public:
-    AliITSLoaderUpg();
-    AliITSLoaderUpg(const Char_t *name,const Char_t *topfoldername);
-    AliITSLoaderUpg(const Char_t *name,TFolder *topfolder);
+    AliITSULoader();
+    AliITSULoader(const Char_t *name,const Char_t *topfoldername);
+    AliITSULoader(const Char_t *name,TFolder *topfolder);
 
-    virtual ~AliITSLoaderUpg();
+    virtual ~AliITSULoader();
 
     void           MakeTree(Option_t* opt);
     virtual void   SetupDigits(TObjArray *digPerDet,Int_t n,
@@ -108,12 +107,10 @@ class AliITSLoaderUpg: public AliLoader{
 
     // Geometry. Geom is read from file, unless already loaded
     // readout from file can be forced if force=kTRUE
-    AliITSgeom* GetITSgeom(Bool_t force=kFALSE); 
-    void SetITSgeom(AliITSgeom* g);
   protected:
 
-    AliITSLoaderUpg(const AliITSLoaderUpg &ob); // copy constructor
-    AliITSLoaderUpg& operator=(const AliITSLoaderUpg & /* source */); // ass.
+    AliITSULoader(const AliITSULoader &ob); // copy constructor
+    AliITSULoader& operator=(const AliITSULoader & /* source */); // ass.
 
     // METHODS
     virtual void   MakeRawClustersContainer() {GetRawClLoader()->MakeTree();}
@@ -132,11 +129,8 @@ class AliITSLoaderUpg: public AliLoader{
     Int_t          PostCascades(){
         return GetCascadeDataLoader()->GetBaseLoader(0)->Post();}
 
-    // DATA
-    AliITSgeom *fGeom;     //! pointer to the ITS geometry class
 
-
-    ClassDef(AliITSLoaderUpg,1) // Loader for additional ITS specific trees.
+    ClassDef(AliITSULoader,1) // Loader for additional ITS specific trees.
 };
  
 #endif
diff --git a/ITS/UPGRADE/AliITSUModule.cxx b/ITS/UPGRADE/AliITSUModule.cxx
new file mode 100644 (file)
index 0000000..a4f6316
--- /dev/null
@@ -0,0 +1,344 @@
+/**************************************************************************
+ * 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: AliITSUModule.cxx 53509 2011-12-10 18:55:52Z masera $ */
+
+#include <TArrayI.h>
+
+#include <stdlib.h>
+
+#include "AliRun.h"
+#include "AliITS.h"
+#include "AliITSUModule.h"
+#include "AliITSUGeomTGeo.h"
+
+ClassImp(AliITSUModule)
+
+//_______________________________________________________________________
+//
+// Impementation of class AliITSUModule
+//
+// created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski 
+//             R. Barbers, B. Batyunia, B. S. Nilsen
+// ver 1.0     CERN 16.09.1999
+//_______________________________________________________________________
+//________________________________________________________________________
+// 
+// Constructors and deconstructor
+//________________________________________________________________________
+//
+AliITSUModule::AliITSUModule()
+:  fHitsM(0)
+  ,fGeomTG(0)
+{
+  // constructor
+}
+
+//_________________________________________________________________________
+AliITSUModule::AliITSUModule(Int_t index, AliITSUGeomTGeo* tg)
+  :fHitsM(new TObjArray())
+  ,fGeomTG(tg)
+{
+  // constructor
+  SetIndex(index);
+}
+
+//__________________________________________________________________________
+AliITSUModule::~AliITSUModule() 
+{
+  // The destructor for AliITSUModule. Before destoring AliITSUModule
+  // we must first destroy all of it's members.
+  if (fHitsM) fHitsM->Clear();
+  delete fHitsM;
+}
+
+//____________________________________________________________________________
+AliITSUModule::AliITSUModule(const AliITSUModule &source)
+ :TObject(source)
+ ,fHitsM(source.fHitsM)
+ ,fGeomTG(source.fGeomTG)
+{
+//     Copy Constructor 
+}
+
+//_____________________________________________________________________________
+AliITSUModule& AliITSUModule::operator=(const AliITSUModule &source)
+{
+  //    Assignment operator 
+  if (this!=&source) {
+    this->~AliITSUModule();
+    new(this) AliITSUModule(source);
+  }
+  return *this;
+}
+
+//___________________________________________________________________________
+Double_t AliITSUModule::PathLength(const AliITSUHit *itsHit1,const AliITSUHit *itsHit2) 
+{
+  // path lenght
+  Float_t  x1g,y1g,z1g;   
+  Float_t  x2g,y2g,z2g;
+  Double_t s;
+  //
+  itsHit1->GetPositionG(x1g,y1g,z1g);
+  itsHit2->GetPositionG(x2g,y2g,z2g);
+  //
+  s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
+                  ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
+                  ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
+   return s;
+}
+
+//___________________________________________________________________________
+void AliITSUModule::PathLength(Float_t x,Float_t y,Float_t z,Int_t status,Int_t &nseg,Float_t &x1,Float_t &y1,Float_t &z1,
+                             Float_t &dx1,Float_t &dy1,Float_t &dz1,Int_t &flag) const
+{
+  // path length
+  static Float_t x0,y0,z0;
+  //
+  if ((status&0x0002)!=0){ // entering
+    x0 = x;
+    y0 = y;
+    z0 = z;
+    nseg = 0;
+    flag = 1;
+  }else{
+    x1 = x0;
+    y1 = y0;
+    z1 = z0;
+    dx1 = x-x1;
+    dy1 = y-y1;
+    dz1 = z-z1;
+    nseg++;
+    if ((status&0x0004)!=0) flag = 0; //exiting
+    if ((status&0x0001)!=0) flag = 2; // inside
+    else flag = 2; //inside ?
+    x0 = x;
+    y0 = y;
+    z0 = z;
+  } // end if
+}
+
+//___________________________________________________________________________
+Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
+                                 Double_t &e,Double_t &f,Double_t &de)
+{
+  // line segment
+  AliITSUHit *h1;
+  Double_t t;
+  //  
+  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
+  //
+  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
+  if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
+  de = h1->GetIonization();
+  h1->GetPositionL0(a,c,e,t);
+  h1->GetPositionL(b,d,f);
+  b = b - a;
+  d = d - c;
+  f = f - e;
+  return kTRUE;
+}
+
+//___________________________________________________________________________
+Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
+                                 Double_t &e,Double_t &f,Double_t &de)
+{
+  // line segment
+  AliITSUHit *h1;
+  Double_t t;
+  //
+  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
+  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
+  if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
+  de = h1->GetIonization();
+  h1->GetPositionG0(a,c,e,t);
+  h1->GetPositionG(b,d,f);
+  b = b - a;
+  d = d - c;
+  f = f - e;
+  return kTRUE;
+}
+
+//___________________________________________________________________________
+Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
+                                 Double_t &e,Double_t &f,Double_t &de,Int_t &track)
+{
+  // line segmente
+  AliITSUHit *h1;
+  Double_t t;
+  //
+  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
+  //
+  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
+  if(h1->StatusEntering()){ // if track entering volume, get index for next
+    // step
+    track = h1->GetTrack();
+    return kFALSE;
+  } // end if StatusEntering()
+    // else stepping
+  de = h1->GetIonization();
+  h1->GetPositionL0(a,c,e,t);
+  h1->GetPositionL(b,d,f);
+  b = b - a;
+  d = d - c;
+  f = f - e;
+  track = h1->GetTrack();
+  return kTRUE;
+}
+
+//___________________________________________________________________________
+Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
+                                 Double_t &e,Double_t &f,Double_t &de,Int_t &track)
+{
+  // line segment
+  AliITSUHit *h1;
+  Double_t t;
+  //
+  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
+  //
+  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
+  if(h1->StatusEntering()){ // if track entering volume, get index for next
+    // step
+    track = h1->GetTrack();
+    return kFALSE;
+  } // end if StatusEntering()
+  de = h1->GetIonization();
+  h1->GetPositionG0(a,c,e,t);
+  h1->GetPositionG(b,d,f);
+  b = b - a;
+  d = d - c;
+  f = f - e;
+  track = h1->GetTrack();
+  return kTRUE;
+}
+
+//______________________________________________________________________
+Bool_t AliITSUModule::MedianHitG(AliITSUHit *h1,AliITSUHit *h2,Float_t &x,Float_t &y,Float_t &z)
+{
+  // Computes the mean hit location for a set of hits that make up a track
+  // passing through a volume. Returns kFALSE untill the the track leaves
+  // the volume.
+  // median hit
+  Float_t x1l=0.,y1l=0.,z1l=0.;
+  Float_t x2l=0.,y2l=0.,z2l=0.;
+  Float_t xMl,yMl=0,zMl;
+  Double_t l[3], g[3];
+  
+  h1->GetPositionG(x1l,y1l,z1l);
+  h2->GetPositionG(x2l,y2l,z2l);
+  
+  if((y2l*y1l)<0.) {
+    xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
+    zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
+  } else {
+    xMl = 0.5*(x1l+x2l);
+    zMl = 0.5*(z1l+z2l);
+  }
+  
+  l[0] = xMl;
+  l[1] = yMl;
+  l[2] = zMl;
+  fGeomTG->LocalToGlobal(h1->GetModule(),l,g);
+  x = g[0];
+  y = g[1];
+  z = g[2];
+  return kTRUE;
+}
+
+//___________________________________________________________________________
+void AliITSUModule::MedianHitG(Int_t index,Float_t hitx1,Float_t hity1,Float_t hitz1,Float_t hitx2,Float_t hity2,Float_t hitz2,
+                                Float_t &xMg, Float_t &yMg, Float_t &zMg)
+{
+  // median hit
+  Float_t x1l,y1l,z1l;
+  Float_t x2l,y2l,z2l;
+  Float_t xMl,yMl=0,zMl;
+  Double_t l[3], g[3];
+  
+  g[0] = hitx1;
+  g[1] = hity1;
+  g[2] = hitz1;
+  fGeomTG->GlobalToLocal(index,g,l);
+  x1l = l[0];
+  y1l = l[1];
+  z1l = l[2];
+  
+  g[0] = hitx2;
+  g[1] = hity2;
+  g[2] = hitz2;
+  fGeomTG->GlobalToLocal(index,g,l);
+  x2l = l[0];
+  y2l = l[1];
+  z2l = l[2];
+  
+  if((y2l*y1l)<0.) {
+    xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
+    zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
+  } else {
+    xMl = 0.5*(x1l+x2l);
+    zMl = 0.5*(z1l+z2l);
+  }
+  
+  l[0] = xMl;
+  l[1] = yMl;
+  l[2] = zMl;
+  fGeomTG->LocalToGlobal(index,l,g);
+  xMg = g[0];
+  yMg = g[1];
+  zMg = g[2];
+}
+
+//___________________________________________________________________________
+Bool_t AliITSUModule::MedianHitL( AliITSUHit *itsHit1,AliITSUHit *itsHit2, Float_t &xMl, Float_t &yMl, Float_t &zMl) const
+{
+  // median hit
+  Float_t x1l,y1l,z1l;
+  Float_t x2l,y2l,z2l;
+  
+  itsHit1->GetPositionL(x1l,y1l,z1l);
+  itsHit2->GetPositionL(x2l,y2l,z2l);
+  
+  yMl = 0.0;
+  if((y2l*y1l)<0.) {
+    xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
+    zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;       
+  } else {
+    xMl = 0.5*(x1l+x2l);
+    zMl = 0.5*(z1l+z2l);
+  }
+  return kTRUE;
+}
+
+//___________________________________________________________________________
+void AliITSUModule::MedianHit(Int_t index,Float_t xg,Float_t yg,Float_t zg,Int_t status,
+                            Float_t &xMg,Float_t &yMg,Float_t &zMg,Int_t &flag)
+{
+  // median hit
+  static Float_t x1,y1,z1;
+  //
+  if ((status&0x0002)!=0){ // entering
+    x1 = xg;
+    y1 = yg;
+    z1 = zg;
+    flag = 1;
+  } else if ((status&0x0004)!=0){ // exiting
+    MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
+    flag = 0;
+  } // end if
+  else  flag = 1;
+}
+
+
diff --git a/ITS/UPGRADE/AliITSUModule.h b/ITS/UPGRADE/AliITSUModule.h
new file mode 100644 (file)
index 0000000..d5e6cad
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef ALIITSUMODULE_H
+#define ALIITSUMODULE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliITSUModule.h 53509 2011-12-10 18:55:52Z masera $ */
+///////////////////////////////////////////////////////////////////////
+//                                                                   //
+//  Class AliITSUModule                                            //
+//  is a superclass for AliITSUModuleSSD, SPD and SDD.             //
+//  The main function of modules is to simulate DIGITS from          //
+//  GEANT HITS and produce POINTS from DIGITS                        //
+//  It also make fast simulation without use of DIGITS               //
+//                                                                   //
+//  created by: A.Boucham, W.Peryt, S.Radomski, P.Skowronski         //
+//              R.Barbera, B. Batynia, B. Nilsen                     //
+//  ver. 1.0    CERN, 16.09.1999                                     //
+//  modified for upgrade: ruben.shahoyan@cern.ch                     //
+//                                                                   //
+///////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+#include <TObjArray.h>
+#include "AliITSUHit.h"
+class AliITSUGeomTGeo;
+
+class AliITSUModule: public TObject {
+
+ public:
+  AliITSUModule();             // default constructor
+  AliITSUModule(Int_t index, AliITSUGeomTGeo* tg);
+  virtual ~AliITSUModule();
+  UInt_t     GetIndex()                                 const {return GetUniqueID();}
+  void       SetIndex(UInt_t ind)                             {return SetUniqueID(ind);}
+  Int_t      GetNHits()                                 const {return fHitsM->GetEntriesFast();}
+  TObjArray *GetHits()                                  const {return fHitsM;}
+  AliITSUHit *GetHit(Int_t i)                         const {return (AliITSUHit*)fHitsM->UncheckedAt(i);}
+  void       AddHit(AliITSUHit *hit)                        {fHitsM->AddLast(hit);}
+  void       Clear(Option_t* opt=0);
+  //
+  Bool_t   MedianHitG(AliITSUHit *h1,AliITSUHit *h2,Float_t &x,Float_t &y,Float_t &z);
+  void     MedianHitG(Int_t index, Float_t hitx1,Float_t hity1,Float_t hitz1,Float_t hitx2,Float_t hity2,Float_t hitz2, Float_t &xMg,Float_t &yMg, Float_t &zMg);
+  Bool_t   MedianHitL(AliITSUHit *h1,AliITSUHit *h2,Float_t &x,Float_t &y,Float_t &z) const;
+  void     MedianHitL(Int_t,AliITSUHit *,AliITSUHit *,Float_t &,Float_t &, Float_t &){};
+  Double_t PathLength(const AliITSUHit *itsHit1,const AliITSUHit *itsHit2);
+  void     MedianHit(Int_t index, Float_t xg,Float_t yg,Float_t zg,Int_t status,Float_t &xMg, Float_t &yMg, Float_t &zMg,Int_t &flag);
+  void     PathLength(Float_t x,Float_t y,Float_t z,Int_t status,Int_t &nseg,Float_t &x1,Float_t &y1,Float_t &z1,Float_t &dx1,Float_t &dy1, Float_t &dz1,Int_t &flag) const;
+  Bool_t   LineSegmentL(Int_t hindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,Double_t &e,Double_t &f,Double_t &de);
+  Bool_t   LineSegmentL(Int_t hindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,Double_t &e,Double_t &f,Double_t &de,Int_t &track);
+  //
+  Bool_t   LineSegmentG(Int_t hindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,Double_t &e,Double_t &f,Double_t &de);
+  Bool_t   LineSegmentG(Int_t hindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,Double_t &e,Double_t &f,Double_t &de,Int_t &track);
+  //
+ protected:
+    AliITSUModule(const AliITSUModule &source); 
+    AliITSUModule& operator=(const AliITSUModule &source); 
+    TObjArray            *fHitsM;     // Pointer to list of hits on this module
+    AliITSUGeomTGeo    *fGeomTG;    // pointed to geometry
+    //
+    ClassDef(AliITSUModule,1) // Copy the hits into a more useful order
+};
+
+inline void AliITSUModule::Clear(Option_t *) {fHitsM->Clear();}
+
+#endif
+
+
+
diff --git a/ITS/UPGRADE/AliITSUSDigit.cxx b/ITS/UPGRADE/AliITSUSDigit.cxx
new file mode 100644 (file)
index 0000000..239d287
--- /dev/null
@@ -0,0 +1,274 @@
+/**************************************************************************
+ * Copyright(c) 1998-2004, 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.                  *
+ **************************************************************************/
+#include <Riostream.h>
+#include <TMath.h>
+#include "AliLog.h"
+#include "AliITSUSDigit.h"
+ClassImp(AliITSUSDigit)
+
+// Addapted from ITS/AliITSpListItem, ruben.shahoyan@cern.ch
+
+//______________________________________________________________________
+AliITSUSDigit::AliITSUSDigit() 
+: fModule(0)
+  ,fNTracks(0)
+  ,fTsignal(0.0)
+  ,fNoise(0.0)
+  ,fSignalAfterElect(0.0)
+{
+  // Default constructor
+}
+
+//______________________________________________________________________
+AliITSUSDigit::AliITSUSDigit(UInt_t module,UInt_t index,Double_t noise) 
+  :fModule(module)
+  ,fNTracks(0)
+  ,fTsignal(0.0)
+  ,fNoise(noise)
+  ,fSignalAfterElect(0.0)
+{
+  // Standard noise constructor
+  SetUniqueID(index);
+  for (int i=kBuffSize;i--;) {
+    fTrack[i] = -2;
+    fHits[i] = -1;
+    fSignal[i] = 0;
+  }
+}
+
+//______________________________________________________________________
+AliITSUSDigit::AliITSUSDigit(Int_t track,Int_t hit,UInt_t module,UInt_t index,Double_t signal)
+  :fModule(module)
+  ,fNTracks(1)
+  ,fTsignal(signal)
+  ,fNoise(0.0)
+  ,fSignalAfterElect(0.0)
+{
+  // Standard signal constructor
+  // Inputs:
+  //    Int_t track     The track number which produced this signal
+  //    Int_t hit       The hit number which produced this signal
+  //    Int_t module    The module where this signal occurred
+  //    Int_t index     The cell index where this signal occurred
+  //    Double_t signal The value of the signal (ionization)
+  SetUniqueID(index);
+  fTrack[0]  = track;
+  fHits[0]   = hit;
+  fSignal[0] = signal;
+  for (int i=1;i<kBuffSize;i++) {
+    fTrack[i] = -2;
+    fHits[i] = -1;
+    fSignal[i] = 0;
+  }
+}
+
+//______________________________________________________________________
+AliITSUSDigit& AliITSUSDigit::operator=(const AliITSUSDigit &source)
+{
+  // = operator
+  if (&source!=this) {
+    this->~AliITSUSDigit();
+    new(this) AliITSUSDigit(source);
+  }
+  return *this;
+  //
+}
+
+//______________________________________________________________________
+AliITSUSDigit::AliITSUSDigit(const AliITSUSDigit &source) 
+  :TObject(source)
+  ,fModule(source.fModule)
+  ,fNTracks(source.fNTracks)
+  ,fTsignal(source.fTsignal)
+  ,fNoise(source.fNoise)
+  ,fSignalAfterElect(source.fSignalAfterElect)
+{
+  // Copy operator
+  for(Int_t i=kBuffSize;i--;) {
+    fTrack[i]  = source.fTrack[i];
+    fSignal[i] = source.fSignal[i];
+    fHits[i]   = source.fHits[i];
+  } // end if i
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::AddSignal(Int_t track,Int_t hit,Double_t signal)
+{
+  // Adds this track number and signal to the pList and orders them
+  // Inputs:
+  //    Int_t track     The track number which produced this signal
+  //    Int_t hit       The hit number which produced this signal
+  //    Int_t module    The module where this signal occurred
+  //    Int_t index     The cell index where this signal occurred
+  //    Double_t signal The value of the signal (ionization)
+  Int_t    i,j;
+  Bool_t   flg=kFALSE;
+  //
+  if (TMath::Abs(signal)>2147483647.0) {
+    //PH 2147483647 is the max. integer
+    //PH This apparently is a problem which needs investigation
+    AliWarning(Form("Too big or too small signal value %f",signal));
+    signal = TMath::Sign((Double_t)2147483647,signal);
+  }
+  //
+  fTsignal += signal; // Keep track of sum signal.
+  for (i=fNTracks;i--;) {
+    if ( track==fTrack[i]  ) {
+      fSignal[i] += signal;
+      flg = kTRUE;
+      break;
+    } // end for i & if.
+  }
+  //
+  if (flg && fNTracks>1) { // resort arrays.  
+    for (i=1;i<fNTracks;i++) {
+      j = i;
+      while(j>0 && fSignal[j]>fSignal[j-1]) {
+       swap(fTrack[j-1],fTrack[j]);
+       swap(fHits[j-1] ,fHits[j]);
+       swap(fSignal[j-1],fSignal[j]);
+       j--;
+      } // end while
+    } // end if i
+    return;
+  } // end if added to existing and resorted array
+  //
+  // new entry add it in order.
+  // if this signal is <= smallest then don't add it.
+  if (fNTracks==(kBuffSize-1) && signal <= fSignal[kBuffSize-1]) return;
+  //
+  for (i=fNTracks;i--;) {
+    if (signal > fSignal[i]) {
+      fSignal[i+1] = fSignal[i];
+      fTrack[i+1]  = fTrack[i];
+      fHits[i+1]   = fHits[i];
+    } else {
+      fSignal[i+1] = signal;
+      fTrack[i+1]  = track;
+      fHits[i+1]   = hit;
+      fNTracks++;
+      return; // put it in the right place, now exit.
+    } //  end if
+  } // end if; end for i
+  //
+  // Still haven't found the right place. Must be at top of list.
+  fSignal[0] = signal;
+  fTrack[0]  = track;
+  fHits[0]   = hit;
+  fNTracks++;
+  return;
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::Add(const AliITSUSDigit *pl)
+{
+  // Adds the contents of pl to this
+  // pl could come from different module and index 
+  Double_t sigT = 0.0;
+  for(int i=pl->GetNTracks();i--;) {
+    double sig = pl->GetSignal(i); 
+    AddSignal(pl->GetTrack(i),pl->GetHit(i),sig);
+    sigT += sig;
+  } // end for i
+  fTsignal += (pl->fTsignal - sigT);
+  fNoise   += pl->fNoise;
+  return;
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::AddTo(Int_t fileIndex,const AliITSUSDigit *pl) 
+{
+  // Adds the contents of pl to this with track number off set given by
+  // fileIndex.
+  // Inputs:
+  //    Int_t fileIndex      track number offset value
+  //    AliITSUSDigit *pl  an AliITSUSDigit to be added to this class.
+  //
+  for (int i=pl->GetNTracks();i--;) AddSignal(pl->GetTrack(i)+fileIndex,pl->GetHit(i),pl->GetSignal(i));
+  fSignalAfterElect += (pl->fSignalAfterElect + pl->fNoise - fNoise);
+  fNoise = pl->fNoise;
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::ShiftIndices(Int_t fileIndex)
+{
+  // Shift track numbers
+  //
+  for (int i=GetNTracks();i--;) fTrack[i] += fileIndex;
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::Print(ostream *os) const 
+{
+  //Standard output format for this class
+  Int_t i;
+  //
+  *os << fModule <<","<<GetUniqueID()<<","<<fNTracks<<",";
+  for (i=0;i<fNTracks;i++) *os << fTrack[i] <<",";
+  for (i=0;i<fNTracks;i++) *os << fHits[i] <<",";
+  for (i=0;i<fNTracks;i++) *os << fSignal[i] <<",";
+  *os << fTsignal <<","<< fNoise << "," << fSignalAfterElect;
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::Read(istream *is) 
+{
+  // Standard output streaming function.
+  Int_t i,iss;
+  UInt_t ind;
+  //
+  *is >> fModule >> ind >> fNTracks;
+  SetUniqueID(ind);
+  *is >> iss; // read in fNTracks
+  for(i=0;i<fNTracks&&i<iss;i++) *is >> fTrack[i];
+  for(i=0;i<fNTracks&&i<iss;i++) *is >> fHits[i];
+  for(i=0;i<fNTracks&&i<iss;i++) *is >> fSignal[i];
+  *is >> fTsignal >> fNoise >> fSignalAfterElect;
+}
+
+//______________________________________________________________________
+ostream &operator<<(ostream &os,AliITSUSDigit &source)
+{
+  // Standard output streaming function.
+  source.Print(&os);
+  return os;
+}
+
+//______________________________________________________________________
+istream &operator>>(istream &os,AliITSUSDigit &source)
+{
+  // Standard output streaming function.
+  source.Read(&os);
+  return os;
+}
+
+//______________________________________________________________________
+Int_t AliITSUSDigit::Compare(const TObject* obj) const
+{
+  // compare objects
+  if (GetUniqueID()<obj->GetUniqueID()) return -1;
+  if (GetUniqueID()>obj->GetUniqueID()) return  1;
+  return 0;
+}
+
+//______________________________________________________________________
+void AliITSUSDigit::Print(Option_t*) const 
+{
+  // print itself
+  printf("Mod: %4d Index:%7d Ntr:%2d |",fModule,GetUniqueID(),fNTracks);
+  for (int i=0;i<fNTracks;i++) printf("%d |",fTrack[i]); printf("\n");
+}
diff --git a/ITS/UPGRADE/AliITSUSDigit.h b/ITS/UPGRADE/AliITSUSDigit.h
new file mode 100644 (file)
index 0000000..a274003
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef ALIITSUSDIGIT_H
+#define ALIITSUSDIGIT_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+
+#include <TObject.h>
+
+
+class AliITSUSDigit: public TObject 
+{
+ public:
+  enum {kBuffSize=10};
+  //
+  AliITSUSDigit();
+  AliITSUSDigit(Int_t track,Int_t hit,UInt_t module,UInt_t index,Double_t signal);
+  AliITSUSDigit(UInt_t module,UInt_t index,Double_t noise);
+  AliITSUSDigit(const AliITSUSDigit &source);
+  AliITSUSDigit& operator=(const AliITSUSDigit &source);
+  virtual ~AliITSUSDigit() {}
+  Double_t GetSignal(Int_t i)    const {return ( (i>=0&&i<kBuffSize) ? fSignal[i] : 0.0);}
+  Double_t GetSignal()           const {return fTsignal;}
+  Double_t GetSignalAfterElect() const {return fSignalAfterElect;}
+  Double_t GetSumSignal()        const {return fTsignal+fNoise;}
+  Double_t GetNoise()            const {return fNoise;}
+  Int_t GetNsignals()            const {return kBuffSize;}
+  void AddSignal(Int_t track,Int_t hit,Double_t signal);
+  void AddSignalAfterElect(Double_t signal) {fSignalAfterElect += signal;}
+  void AddNoise(Double_t noise)  {fNoise += noise;}
+  void SetNoise(Double_t noise)  {fNoise = noise;}
+  Int_t GetTrack(Int_t i)        const {return ((i>=0&&i<kBuffSize) ? fTrack[i] : 0);}
+  Int_t GetHit(Int_t i)          const {return ((i>=0&&i<kBuffSize) ? fHits[i] : 0);}
+  Int_t GetModule()              const {return fModule;}
+  Int_t GetNTracks()             const {return fNTracks;}
+  //
+  void Add(const AliITSUSDigit *pl);
+  void AddTo(Int_t fileIndex, const AliITSUSDigit *pl);
+  void ShiftIndices(Int_t fileIndex);
+  void Print(ostream *os) const;
+  void Read(istream *is);
+  void Print(Option_t *option="")                 const;
+  Int_t Read(const char *name)                          {return TObject::Read(name);}
+  //
+  virtual Bool_t IsSortable()                     const {return kTRUE;}
+  virtual Bool_t IsEqual(const TObject* obj)      const {return GetUniqueID()==obj->GetUniqueID();}
+  virtual Int_t  Compare(const TObject* obj)      const;
+
+  //
+  static Int_t GetBuffSize() {return kBuffSize;};
+  //
+ private:
+  UShort_t fModule;            // module number
+  UShort_t fNTracks;           // number of tracks contributing
+  Int_t    fTrack[kBuffSize];  // track Number
+  Int_t    fHits[kBuffSize];   // hit number
+  Float_t  fSignal[kBuffSize]; // Signals
+  Float_t  fTsignal;           // Total signal (no noise)
+  Float_t  fNoise;             // Total noise, coupling, ...
+  Float_t  fSignalAfterElect;  // Signal after electronics
+  //
+  ClassDef(AliITSUSDigit,1) // Item list of signals and track numbers
+};     
+
+// Input and output functions for standard C++ input/output.
+ostream & operator<<(ostream &os,AliITSUSDigit &source);
+istream & operator>>(istream &is,AliITSUSDigit &source);
+
+
+#endif
similarity index 80%
rename from ITS/UPGRADE/AliITSsegmentationPixUpg.cxx
rename to ITS/UPGRADE/AliITSUSegmentationPix.cxx
index d7b163a..c83d288 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id: AliITSsegmentationPixUpg.cxx 47180 2011-02-08 09:42:29Z masera $ */
+/* $Id: AliITSUSegmentationPix.cxx 47180 2011-02-08 09:42:29Z masera $ */
 #include <TGeoManager.h>
 #include <TGeoVolume.h>
 #include <TGeoBBox.h>
@@ -21,7 +21,8 @@
 #include <TString.h>
 #include <TSystem.h>
 #include <TFile.h>
-#include "AliITSsegmentationPixUpg.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUSegmentationPix.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Segmentation class for pixels                                                                          //
 //                                                                                                        //
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ClassImp(AliITSsegmentationPixUpg)
+ClassImp(AliITSUSegmentationPix)
 
-const char* AliITSsegmentationPixUpg::fgkSegmListName = "ITSUpgradeSegmentations";
+const char* AliITSUSegmentationPix::fgkSegmListName = "ITSUpgradeSegmentations";
 
 //_____________________________________________________________________________RS
-AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(int nchips,int ncol,int nrow,
+AliITSUSegmentationPix::AliITSUSegmentationPix(UInt_t id, int nchips,int ncol,int nrow,
                                                   double pitchX,double pitchZ,
                                                   double thickness,
                                                   double pitchLftC,double pitchRgtC,
@@ -59,6 +60,7 @@ AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(int nchips,int ncol,int nrow,
   ,fNCol(ncol)
 {
   // Default constructor, sizes in microns
+  if (nchips) SetUniqueID( AliITSUGeomTGeo::ComposeDetTypeID(id) );
   fChipDZ = (fNColPerChip-2)*fPitchZ + fPitchZLftCol + fPitchZRgtCol;
   SetDetSize( fNRow*fPitchX /*+fGuardTop+fGuardBot*/,
              fNChips*fChipDZ /*+fGuardLft+fGuardRgt*/,
@@ -67,7 +69,7 @@ AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(int nchips,int ncol,int nrow,
 }
 
 //_____________________________________________________________________________RS
-void AliITSsegmentationPixUpg::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
+void AliITSUSegmentationPix::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
 {
   //  Returns pixel coordinates (ix,iz) for given real local coordinates (x,z)
   //  expects x, z in microns
@@ -80,7 +82,7 @@ void AliITSsegmentationPixUpg::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz
 }
 
 //_____________________________________________________________________________RS
-void AliITSsegmentationPixUpg::GetPadTxz(Float_t &x,Float_t &z) const
+void AliITSUSegmentationPix::GetPadTxz(Float_t &x,Float_t &z) const
 {
   //  local transformation of real local coordinates (x,z)
   //  expects x, z in microns
@@ -90,7 +92,7 @@ void AliITSsegmentationPixUpg::GetPadTxz(Float_t &x,Float_t &z) const
 }
 
 //_____________________________________________________________________________RS
-void AliITSsegmentationPixUpg::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
+void AliITSUSegmentationPix::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
 {
   // Transform from pixel to real local coordinates
   // returns x, z in microns
@@ -100,7 +102,7 @@ void AliITSsegmentationPixUpg::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z)
 }
 
 //_____________________________________________________________________________RS
-Float_t AliITSsegmentationPixUpg::Z2Col(Float_t z) const 
+Float_t AliITSUSegmentationPix::Z2Col(Float_t z) const 
 {
   // get column number (from 0) from local Z
   int chip = z/fChipDZ;
@@ -117,7 +119,7 @@ Float_t AliITSsegmentationPixUpg::Z2Col(Float_t z) const
 }
 
 //_____________________________________________________________________________RS
-Float_t AliITSsegmentationPixUpg::Col2Z(Int_t col) const 
+Float_t AliITSUSegmentationPix::Col2Z(Int_t col) const 
 {
   // convert column number (from 0) to Z coordinate
   int nchip = col/fNColPerChip;
@@ -132,7 +134,7 @@ Float_t AliITSsegmentationPixUpg::Col2Z(Int_t col) const
 }
 
 //______________________________________________________________________RS
-AliITSsegmentationPixUpg& AliITSsegmentationPixUpg::operator=(const AliITSsegmentationPixUpg &src)
+AliITSUSegmentationPix& AliITSUSegmentationPix::operator=(const AliITSUSegmentationPix &src)
 {
   // = operator
   if(this==&src) return *this;
@@ -156,7 +158,7 @@ AliITSsegmentationPixUpg& AliITSsegmentationPixUpg::operator=(const AliITSsegmen
 }
 
 //____________________________________________________________________________RS
-AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(const AliITSsegmentationPixUpg &src) :
+AliITSUSegmentationPix::AliITSUSegmentationPix(const AliITSUSegmentationPix &src) :
   AliITSsegmentation(src)
   ,fGuardLft(src.fGuardLft)
   ,fGuardRgt(src.fGuardRgt)
@@ -175,14 +177,14 @@ AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(const AliITSsegmentationPixUp
 }
 
 //____________________________________________________________________________RS
-Float_t AliITSsegmentationPixUpg::Dpx(Int_t ) const 
+Float_t AliITSUSegmentationPix::Dpx(Int_t ) const 
 {
   //returs x pixel pitch for a give pixel
   return fPitchX;
 }
 
 //____________________________________________________________________________RS
-Float_t AliITSsegmentationPixUpg::Dpz(Int_t col) const 
+Float_t AliITSUSegmentationPix::Dpz(Int_t col) const 
 {
   // returns z pixel pitch for a given pixel (cols starts from 0)
   col %= fNColPerChip;
@@ -193,7 +195,7 @@ Float_t AliITSsegmentationPixUpg::Dpz(Int_t col) const
 }
 
 //------------------------------
-void AliITSsegmentationPixUpg::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_t xlist[8], Int_t zlist[8]) const 
+void AliITSUSegmentationPix::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_t xlist[8], Int_t zlist[8]) const 
 {
   // returns the neighbouring pixels for use in Cluster Finders and the like.
   //
@@ -220,7 +222,7 @@ void AliITSsegmentationPixUpg::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_
 }
 
 //______________________________________________________________________
-Bool_t AliITSsegmentationPixUpg::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
+Bool_t AliITSUSegmentationPix::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
 {
   // Transformation from Geant detector centered local coordinates (cm) to
   // Pixel cell numbers ix and iz.
@@ -249,7 +251,7 @@ Bool_t AliITSsegmentationPixUpg::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t
 }
 
 //______________________________________________________________________
-void AliITSsegmentationPixUpg::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const
+void AliITSUSegmentationPix::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const
 {
 // Transformation from Detector cell coordiantes to Geant detector centerd 
 // local coordinates (cm).
@@ -275,7 +277,7 @@ void AliITSsegmentationPixUpg::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &
 }
 
 //______________________________________________________________________
-void AliITSsegmentationPixUpg::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Double_t &xu,Double_t &zl,Double_t &zu) const
+void AliITSUSegmentationPix::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Double_t &xu,Double_t &zl,Double_t &zu) const
 {
   // Transformation from Detector cell coordiantes to Geant detector centerd 
   // local coordinates (cm).
@@ -311,7 +313,7 @@ void AliITSsegmentationPixUpg::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Doub
 }
 
 //______________________________________________________________________
-Int_t AliITSsegmentationPixUpg::GetChipFromChannel(Int_t, Int_t iz) const 
+Int_t AliITSUSegmentationPix::GetChipFromChannel(Int_t, Int_t iz) const 
 {
   // returns chip number (in range 0-4) starting from channel number
   if(iz>=fNCol  || iz<0 ){
@@ -322,7 +324,7 @@ Int_t AliITSsegmentationPixUpg::GetChipFromChannel(Int_t, Int_t iz) const
 }
 
 //______________________________________________________________________
-Int_t AliITSsegmentationPixUpg::GetChipFromLocal(Float_t, Float_t zloc) const 
+Int_t AliITSUSegmentationPix::GetChipFromLocal(Float_t, Float_t zloc) const 
 {
   // returns chip number (in range 0-4) starting from local coordinates
   Int_t ix0,iz;
@@ -334,7 +336,7 @@ Int_t AliITSsegmentationPixUpg::GetChipFromLocal(Float_t, Float_t zloc) const
 }
 
 //______________________________________________________________________
-Int_t AliITSsegmentationPixUpg::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t, Float_t) const 
+Int_t AliITSUSegmentationPix::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t, Float_t) const 
 {
   // returns the number of chips containing a road defined by given local coordinate limits
   //
@@ -372,13 +374,13 @@ Int_t AliITSsegmentationPixUpg::GetChipsInLocalWindow(Int_t* array, Float_t zmin
 }
 
 //______________________________________________________________________
-void AliITSsegmentationPixUpg::Init()
+void AliITSUSegmentationPix::Init()
 {
   // init settings
 }
 
 //______________________________________________________________________
-Bool_t AliITSsegmentationPixUpg::StoreWithID(UInt_t id, const char* outf)
+Bool_t AliITSUSegmentationPix::Store(const char* outf)
 {
   // store in the special list under given ID
   TString fns = outf;
@@ -387,25 +389,16 @@ Bool_t AliITSsegmentationPixUpg::StoreWithID(UInt_t id, const char* outf)
   TFile* fout = TFile::Open(fns.Data(),"update");
   if (!fout) {AliFatal(Form("Failed to open output file %s",outf)); return kFALSE;}
   TObjArray* arr = (TObjArray*)fout->Get(fgkSegmListName);
+  int id = GetUniqueID();
   if (!arr) arr = new TObjArray();
-  else {
-    int nent = arr->GetEntriesFast();
-    for (int i=nent;i--;) {
-      AliITSsegmentationPixUpg* segm = dynamic_cast<AliITSsegmentationPixUpg*>(arr->At(i));
-      if (segm && segm->GetUniqueID()==id) {
-       AliFatal(Form("Segmenation %d already exists in file %s",id,outf)); 
-       return kFALSE;
-      }
-    }
-  }
+  else if (arr->At(id)) {AliFatal(Form("Segmenation %d already exists in file %s",id,outf));return kFALSE;}
   //
-  this->SetUniqueID(id);  
-  arr->AddLast(this);
+  arr->AddAtAndExpand(this,id);
   arr->SetOwner(kTRUE);
   fout->WriteObject(arr,fgkSegmListName,"kSingleKey");
   fout->Close();
   delete fout;
-  arr->Remove(this);
+  arr->RemoveAt(id);
   delete arr;
   AliInfo(Form("Stored segmentation %d in %s",id,outf));
   return kTRUE;
@@ -413,7 +406,7 @@ Bool_t AliITSsegmentationPixUpg::StoreWithID(UInt_t id, const char* outf)
 }
 
 //______________________________________________________________________
-AliITSsegmentationPixUpg* AliITSsegmentationPixUpg::LoadWithID(UInt_t id, const char* inpf)
+AliITSUSegmentationPix* AliITSUSegmentationPix::LoadWithID(UInt_t id, const char* inpf)
 {
   // store in the special list under given ID
   TString fns = inpf;
@@ -426,16 +419,10 @@ AliITSsegmentationPixUpg* AliITSsegmentationPixUpg::LoadWithID(UInt_t id, const
     AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf)); 
     return 0;
   }
-  AliITSsegmentationPixUpg* segm = 0;
-  int nent = arr->GetEntriesFast();
-  for (int i=nent;i--;) {
-    segm = dynamic_cast<AliITSsegmentationPixUpg*>(arr->At(i));
-    if (segm && segm->GetUniqueID()==id) {arr->RemoveAt(i); break;}
-    segm = 0;
-  }
-  //
-  if (!segm) {AliFatalGeneral("LoadWithID",Form("Failed to find segmenation %d in %s",id,inpf)); return 0;}
+  AliITSUSegmentationPix* segm = dynamic_cast<AliITSUSegmentationPix*>(arr->At(id));
+  if (!segm || segm->GetUniqueID()!=id) {AliFatalGeneral("LoadWithID",Form("Failed to find segmenation %d in %s",id,inpf)); return 0;}
   //
+  arr->RemoveAt(id);
   arr->SetOwner(kTRUE); // to not leave in memory other segmenations
   finp->Close();
   delete finp;
@@ -443,3 +430,27 @@ AliITSsegmentationPixUpg* AliITSsegmentationPixUpg::LoadWithID(UInt_t id, const
   //
   return segm;
 }
+
+//______________________________________________________________________
+void AliITSUSegmentationPix::LoadSegmentations(TObjArray* dest, const char* inpf)
+{
+  // store in the special list under given ID
+  if (!dest) return;
+  TString fns = inpf;
+  gSystem->ExpandPathName(fns);
+  if (fns.IsNull()) AliFatalGeneral("LoadWithID","No file name provided");
+  TFile* finp = TFile::Open(fns.Data());
+  if (!finp) AliFatalGeneral("LoadWithID",Form("Failed to open file %s",inpf));
+  TObjArray* arr = (TObjArray*)finp->Get(fgkSegmListName);
+  if (!arr) AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf)); 
+  int nent = arr->GetEntriesFast();
+  TObject *segm = 0;
+  for (int i=nent;i--;) if ((segm=arr->At(i))) dest->AddAtAndExpand(segm,segm->GetUniqueID());
+  AliInfoGeneral("LoadSegmentations",Form("Loaded %d segmantions from %s",arr->GetEntries(),inpf));
+  arr->SetOwner(kFALSE);
+  arr->Delete();
+  finp->Close();
+  delete finp;
+  delete arr;
+  //
+}
similarity index 78%
rename from ITS/UPGRADE/AliITSsegmentationPixUpg.h
rename to ITS/UPGRADE/AliITSUSegmentationPix.h
index 030be26..7a95044 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef ALIITSSEGMENTATIONPIXUPG_H
-#define ALIITSSEGMENTATIONPIXUPG_H
+#ifndef ALIITSUSEGMENTATIONPIX_H
+#define ALIITSUSEGMENTATIONPIX_H
 
 #include "AliITSsegmentation.h"
 
@@ -7,20 +7,20 @@
 
 // segmentation and response for pixels in ITS upgrade 
 
-class AliITSsegmentationPixUpg :
+class AliITSUSegmentationPix :
 public AliITSsegmentation {
  public:
   enum {kCM2MC=10000};
-  AliITSsegmentationPixUpg(int nchips=0,int ncol=0,int nrow=0,
+  AliITSUSegmentationPix(UInt_t id=0, int nchips=0,int ncol=0,int nrow=0,
                           double pitchX=0,double pitchZ=0,
                           double thickness=0,
                           double pitchLftC=-1,double pitchRgtC=-1,
                           double edgL=0,double edgR=0,double edgT=0,double edgB=0);
   
-  //  AliITSsegmentationPixUpg(Option_t *opt="" );
-  AliITSsegmentationPixUpg(const AliITSsegmentationPixUpg &source);
-  virtual ~AliITSsegmentationPixUpg() {}
-  AliITSsegmentationPixUpg& operator=(const AliITSsegmentationPixUpg &source);
+  //  AliITSUSegmentationPix(Option_t *opt="" );
+  AliITSUSegmentationPix(const AliITSUSegmentationPix &source);
+  virtual ~AliITSUSegmentationPix() {}
+  AliITSUSegmentationPix& operator=(const AliITSUSegmentationPix &source);
   //
   virtual void    Init();
   //  
@@ -56,8 +56,11 @@ public AliITSsegmentation {
   //
   virtual void PrintDefaultParameters() const {AliWarning("No def. parameters defined as const static data members");}
   //
-  Bool_t                           StoreWithID(UInt_t id, const char* outf);
-  static AliITSsegmentationPixUpg* LoadWithID(UInt_t id, const char* inpf);
+  virtual Int_t                    GetDetTypeID()              const {return GetUniqueID();}
+  //
+  Bool_t                           Store(const char* outf);
+  static AliITSUSegmentationPix* LoadWithID(UInt_t id, const char* inpf);
+  static void                      LoadSegmentations(TObjArray* dest, const char* inpf);
   //
  protected:
   Float_t Z2Col(Float_t z) const;
@@ -80,7 +83,7 @@ public AliITSsegmentation {
     //
     static const char* fgkSegmListName; // pattern for segmentations list name
     //
-  ClassDef(AliITSsegmentationPixUpg,1) //Segmentation class upgrade pixels 
+  ClassDef(AliITSUSegmentationPix,1) //Segmentation class upgrade pixels 
 
 };
 
diff --git a/ITS/UPGRADE/AliITSUSensMap.cxx b/ITS/UPGRADE/AliITSUSensMap.cxx
new file mode 100644 (file)
index 0000000..3b40849
--- /dev/null
@@ -0,0 +1,143 @@
+/**************************************************************************
+ * 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: AliITSUSensMap.cxx 39464 2010-03-09 14:59:19Z masera $ */
+
+//***********************************************************************
+//
+// It consist of a TClonesArray of 
+// AliITSUSensMapItem objects
+// This array can be accessed via 2 indexed
+// it is used at digitization level by 
+// all the 3 ITS subdetectors
+//
+//
+// The items should be added to the map like this:
+// map->RegisterItem( new(map->GetFree()) ItemConstructor(...) );
+//
+// The items must be sortable with the same sorting algorithm like 
+// for the dummy class AliITSUSensMap::TObjSortable
+//
+// ***********************************************************************
+
+#include "AliITSUSensMap.h"
+#include "AliLog.h"
+//______________________________________________________________________
+
+ClassImp(AliITSUSensMap)
+//______________________________________________________________________
+AliITSUSensMap::AliITSUSensMap() 
+:  fDim0(0)
+  ,fDim1(0)
+  ,fItems(0)
+  ,fBTree(0)
+  ,fProbe()
+{
+  // Default constructor
+}
+
+//______________________________________________________________________
+AliITSUSensMap::AliITSUSensMap(const char* className, UInt_t dim0,UInt_t dim1)
+  :fDim0(dim0)
+  ,fDim1(dim1)
+  ,fItems(new TClonesArray(className,100))
+  ,fBTree(new TBtree())
+  ,fProbe()
+{
+  // Standard constructor
+}
+
+//______________________________________________________________________
+AliITSUSensMap::~AliITSUSensMap() 
+{
+  // Default destructor
+  delete fItems;
+  delete fBTree;
+}
+
+
+//______________________________________________________________________
+AliITSUSensMap::AliITSUSensMap(const AliITSUSensMap &source)
+  :TObject(source)
+  ,fDim0(source.fDim0)
+  ,fDim1(source.fDim1)
+  ,fItems( source.fItems ? new TClonesArray(*source.fItems) : 0)
+  ,fBTree( 0 )
+  ,fProbe( source.fProbe)
+{
+  if (source.fBTree) {
+    fBTree = new TBtree();
+    for (int i=fItems->GetEntriesFast();i--;) {
+      TObject* obj = fItems->At(i);
+      if (obj && ! IsDisabled(obj)) continue;
+      RegisterItem(obj);
+    }
+  }
+}
+
+//______________________________________________________________________
+AliITSUSensMap& AliITSUSensMap::operator=(const AliITSUSensMap &source)
+{
+  // = operator
+  if (this!=&source) {
+    this->~AliITSUSensMap();
+    new(this) AliITSUSensMap(source);
+  }
+  return *this;
+}
+
+//______________________________________________________________________
+void AliITSUSensMap::Clear(Option_t*) 
+{
+  // clean everything
+  if (fItems) fItems->Clear();
+  if (fBTree) fBTree->Clear();
+  fProbe.Clear();
+}
+
+//______________________________________________________________________
+void AliITSUSensMap::DeleteItem(UInt_t i,UInt_t j)
+{
+  // Delete a particular AliITSUSensMapItems.
+  fProbe.SetUniqueID( GetIndex(i,j) );
+  TObject* fnd = fBTree->FindObject(&fProbe);
+  if (!fnd) return;
+  Disable(fnd);
+  fBTree->Remove(fnd);
+}
+
+//______________________________________________________________________
+void AliITSUSensMap::DeleteItem(TObject* obj)
+{
+  // Delete a particular AliITSUSensMapItems.
+  TObject* fnd = fBTree->FindObject(obj);
+  if (!fnd) return;
+  Disable(fnd);
+  fBTree->Remove(fnd);
+}
+
+//______________________________________________________________________
+void AliITSUSensMap::GetCell(UInt_t index,UInt_t &i,UInt_t &j) const 
+{
+  // returns the i,j index numbers from the linearized index computed
+  // with GetIndex
+  if(index>=fDim0*fDim1){
+    Warning("GetCell","Index out of range 0<=index=%d<%d",index,fDim0*fDim1);
+    i=-1;j=-1;
+    return;
+  } // end if
+  i = index/fDim1;
+  j = index%fDim1;
+  return;
+}
diff --git a/ITS/UPGRADE/AliITSUSensMap.h b/ITS/UPGRADE/AliITSUSensMap.h
new file mode 100644 (file)
index 0000000..5dfb894
--- /dev/null
@@ -0,0 +1,81 @@
+#ifndef ALIITSUSENSMAP_H
+#define ALIITSUSENSMAP_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+
+//***********************************************************************
+//
+// It consist of a TClonesArray of objects
+// and B-tree for fast sorted access
+// This array can be accessed via 2 indexed
+// it is used at digitization level by 
+// all the ITS subdetectors
+//
+// The items should be added to the map like this:
+// map->RegisterItem( new(map->GetFree()) ItemConstructor(...) );
+//
+// ***********************************************************************
+#include <TClonesArray.h>
+#include <TBtree.h>
+
+
+class AliITSUSensMap: public TObject 
+{
+
+ public:
+  enum {kDisableBit=BIT(14)};
+  //
+  AliITSUSensMap();
+  AliITSUSensMap(const char* className, UInt_t dim0,UInt_t dim1);
+  virtual ~AliITSUSensMap();
+  AliITSUSensMap(const AliITSUSensMap &source);
+  AliITSUSensMap& operator=(const AliITSUSensMap &source);
+  void Clear(Option_t* option = "");
+  void DeleteItem(UInt_t i,UInt_t j);
+  void DeleteItem(TObject* obj);
+  //
+  void  SetDimensions(UInt_t dim0,UInt_t dim1)   {fDim0 = dim0; fDim1 = dim1;}
+  void  GetMaxIndex(UInt_t &ni,UInt_t &nj) const {ni=fDim0;nj=fDim1;}
+  Int_t GetMaxIndex()                      const {return fDim0*fDim1;}
+  Int_t GetEntries()                       const {return fBTree->GetEntries();}
+  Int_t GetEntriesUnsorted()               const {return fItems->GetEntriesFast();}
+  void  GetMapIndex(UInt_t index,UInt_t &i,UInt_t &j) const {return GetCell(index, i,j);}
+  TObject* GetItem(UInt_t i,UInt_t j)            {fProbe.SetUniqueID(GetIndex(i,j)); return fBTree->FindObject(&fProbe);}
+  TObject* GetItem(UInt_t index)                 {fProbe.SetUniqueID(index);         return fBTree->FindObject(&fProbe);}
+  TObject* GetItem(const TObject* obj)           {return fBTree->FindObject(obj);}
+  TObject* At(Int_t i)                     const {return fBTree->At(i);}             //!!! Access in sorted order !!!
+  TObject* AtUnsorted(Int_t i)             const {return fItems->At(i);}             //!!! Access in unsorted order !!!
+  TObject* RegisterItem(TObject* obj)            {fBTree->Add(obj); return obj;}
+  TObject* GetFree()                             {return (*fItems)[fItems->GetEntriesFast()];}
+  //
+  void   GetCell(UInt_t index,UInt_t &i,UInt_t &j) const;
+  UInt_t GetIndex(UInt_t i,UInt_t j)       const  {return j+i*fDim1;}
+  //
+  TClonesArray* GetItems()                 const {return fItems;}
+  TBtree*       GetItemsBTree()            const {return fBTree;}
+  //
+  static Bool_t IsDisabled(TObject* obj)         {return obj ? obj->TestBit(kDisableBit) : kFALSE;}
+  static void   Disable(TObject* obj)            {if (obj) obj->SetBit(kDisableBit);}
+  static void   Enable(TObject* obj)             {if (obj) obj->ResetBit(kDisableBit);}
+  //
+ protected:
+  class TObjSortable : public TObject 
+  {
+  public:
+    Bool_t IsSortable()                const {return kTRUE;}
+    Bool_t IsEqual(const TObject* obj) const {return GetUniqueID()==obj->GetUniqueID();}
+    Int_t  Compare(const TObject* obj) const {return (GetUniqueID()<obj->GetUniqueID()) ? -1 : ((GetUniqueID()>obj->GetUniqueID()) ? 1 : 0 );}
+    ClassDef(TObjSortable,1)
+  };
+
+ protected:
+  //
+  UInt_t fDim0;              // 1st dimension of the matrix
+  UInt_t fDim1;              // 2nd dimention of the matrix
+  TClonesArray*    fItems;   // pListItems array
+  TBtree*          fBTree;   // tree for ordered access
+  TObjSortable     fProbe;   //! dummy object to test presence in the map
+  //
+  ClassDef(AliITSUSensMap,1) // list of sensor signals (should be sortable objects)
+};     
+#endif
diff --git a/ITS/UPGRADE/AliITSUSimuParam.cxx b/ITS/UPGRADE/AliITSUSimuParam.cxx
new file mode 100644 (file)
index 0000000..8559e74
--- /dev/null
@@ -0,0 +1,485 @@
+/**************************************************************************
+ * 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: AliITSUSimuParam.cxx 48165 2011-03-07 17:48:57Z masera $ */
+
+///////////////////////////////////////////////////////////////////
+//                                                               //
+// Implementation of the class to store the parameters used in   //
+// the simulation of SPD, SDD and SSD detectors                  //
+// Origin: F.Prino, Torino, prino@to.infn.it                     //
+//                                                               //
+///////////////////////////////////////////////////////////////////
+#include "AliITSUSimuParam.h"
+#include "AliLog.h"
+
+
+const Double_t  AliITSUSimuParam::fgkPixUpgBiasVoltageDefault = 18.182;
+const Double_t  AliITSUSimuParam::fgkPixUpgThreshDefault = 3000.;
+const Double_t  AliITSUSimuParam::fgkPixUpgThrSigmaDefault = 250.;
+const UInt_t    AliITSUSimuParam::fgkPixUpgCouplingOptDefault = AliITSUSimuParam::kOldCouplingPixUpg;
+const Double_t  AliITSUSimuParam::fgkPixUpgCouplColDefault = 0.;
+const Double_t  AliITSUSimuParam::fgkPixUpgCouplRowDefault = 0.055;
+const Double_t  AliITSUSimuParam::fgkPixUpgEccDiffDefault = 0.85;
+const Double_t  AliITSUSimuParam::fgkPixUpgLorentzHoleWeightDefault = 1.0;
+const Double_t  AliITSUSimuParam::fgkGeVtoChargeDefault = 3.6e-9;
+const Double_t  AliITSUSimuParam::fgkDOverVDefault = 0.000375;
+const Double_t  AliITSUSimuParam::fgkTDefault = 300;
+
+const Double_t  AliITSUSimuParam::fgkNsigmasDefault = 3.;
+const Int_t    AliITSUSimuParam::fgkNcompsDefault = 121;
+
+ClassImp(AliITSUSimuParam)
+
+//______________________________________________________________________
+AliITSUSimuParam::AliITSUSimuParam()
+:  fGeVcharge(fgkGeVtoChargeDefault)
+  ,fDOverV(fgkDOverVDefault)
+  ,fT(fgkTDefault)
+  //
+  ,fNPixUpg(0)
+  ,fPixUpgCouplOpt(kOldCouplingPixUpg)
+  ,fPixUpgCouplCol(fgkPixUpgCouplColDefault)
+  ,fPixUpgCouplRow(fgkPixUpgCouplRowDefault)
+  ,fPixUpgEccDiff(fgkPixUpgEccDiffDefault)
+  ,fPixUpgLorentzDrift(kTRUE)
+  ,fPixUpgLorentzHoleWeight(fgkPixUpgLorentzHoleWeightDefault)
+  ,fPixUpgAddNoisyFlag(kFALSE)
+  ,fPixUpgRemoveDeadFlag(kFALSE)
+  //
+  ,fPixUpgThreshDef(fgkPixUpgThreshDefault)
+  ,fPixUpgThrSigmaDef(fgkPixUpgThrSigmaDefault)
+  ,fPixUpgBiasVoltageDef(fgkPixUpgBiasVoltageDefault)
+  ,fPixUpgNoiseDef(0)
+  ,fPixUpgBaselineDef(0)
+  //
+  ,fPixUpgThresh(0)
+  ,fPixUpgThrSigma(0)
+  ,fPixUpgBiasVoltage(0)
+  ,fPixUpgSigma(0)
+  ,fPixUpgNoise(0)
+  ,fPixUpgBaseline(0)
+{  
+  // default constructor
+}
+
+//______________________________________________________________________
+AliITSUSimuParam::AliITSUSimuParam(UInt_t nPixUpg)
+  :fGeVcharge(fgkGeVtoChargeDefault)
+  ,fDOverV(fgkDOverVDefault)
+  ,fT(fgkTDefault)
+    //
+  ,fNPixUpg(nPixUpg)
+  ,fPixUpgCouplOpt(kOldCouplingPixUpg)
+  ,fPixUpgCouplCol(fgkPixUpgCouplColDefault)
+  ,fPixUpgCouplRow(fgkPixUpgCouplRowDefault)
+  ,fPixUpgEccDiff(fgkPixUpgEccDiffDefault)
+  ,fPixUpgLorentzDrift(kTRUE)
+  ,fPixUpgLorentzHoleWeight(fgkPixUpgLorentzHoleWeightDefault)
+  ,fPixUpgAddNoisyFlag(kFALSE)
+  ,fPixUpgRemoveDeadFlag(kFALSE)
+  //
+  ,fPixUpgThreshDef(fgkPixUpgThreshDefault)
+  ,fPixUpgThrSigmaDef(fgkPixUpgThrSigmaDefault)
+  ,fPixUpgBiasVoltageDef(fgkPixUpgBiasVoltageDefault)
+  ,fPixUpgNoiseDef(0)
+  ,fPixUpgBaselineDef(0)
+  //
+  ,fPixUpgThresh(0)
+  ,fPixUpgThrSigma(0)
+  ,fPixUpgBiasVoltage(0)
+  ,fPixUpgSigma(0)
+  ,fPixUpgNoise(0)
+  ,fPixUpgBaseline(0)
+{  
+  // regular constructor
+  if (fNPixUpg>0) {
+    fPixUpgBiasVoltage = new Double_t[fNPixUpg];
+    fPixUpgThresh      = new Double_t[fNPixUpg];
+    fPixUpgThrSigma    = new Double_t[fNPixUpg];
+    fPixUpgNoise       = new Double_t[fNPixUpg];
+    fPixUpgBaseline    = new Double_t[fNPixUpg];
+  }
+  SetPixUpgThreshold(fgkPixUpgThreshDefault,fgkPixUpgThrSigmaDefault);
+  SetPixUpgNoise(0.,0.);
+  SetPixUpgBiasVoltage(fgkPixUpgBiasVoltageDefault);
+  //
+}
+
+//______________________________________________________________________
+AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
+  :TObject(simpar)
+  ,fGeVcharge(simpar.fGeVcharge)
+  ,fDOverV(simpar.fDOverV)
+  ,fT(simpar.fT)
+   //
+  ,fNPixUpg(simpar.fNPixUpg)
+  ,fPixUpgCouplOpt(simpar.fPixUpgCouplOpt)
+  ,fPixUpgCouplCol(simpar.fPixUpgCouplCol)
+  ,fPixUpgCouplRow(simpar.fPixUpgCouplRow)
+  ,fPixUpgEccDiff(simpar.fPixUpgEccDiff)
+  ,fPixUpgLorentzDrift(simpar.fPixUpgLorentzDrift)
+  ,fPixUpgLorentzHoleWeight(simpar.fPixUpgLorentzHoleWeight)
+  ,fPixUpgAddNoisyFlag(simpar.fPixUpgAddNoisyFlag)
+  ,fPixUpgRemoveDeadFlag(simpar.fPixUpgRemoveDeadFlag)
+   //
+  ,fPixUpgThreshDef(simpar.fPixUpgThreshDef)
+  ,fPixUpgThrSigmaDef(simpar.fPixUpgThrSigmaDef)
+  ,fPixUpgBiasVoltageDef(simpar.fPixUpgBiasVoltageDef)
+  ,fPixUpgNoiseDef(simpar.fPixUpgNoiseDef)
+  ,fPixUpgBaselineDef(simpar.fPixUpgBaselineDef)
+  //
+  ,fPixUpgThresh(0)
+  ,fPixUpgThrSigma(0)
+  ,fPixUpgBiasVoltage(0)
+  ,fPixUpgSigma(0)
+  ,fPixUpgNoise(0)
+  ,fPixUpgBaseline(0)   
+   //
+{
+  // copy constructor
+  if (fNPixUpg) {
+    fPixUpgBiasVoltage = new Double_t[fNPixUpg];
+    fPixUpgThresh      = new Double_t[fNPixUpg];
+    fPixUpgThrSigma    = new Double_t[fNPixUpg];
+    fPixUpgNoise       = new Double_t[fNPixUpg];
+    fPixUpgBaseline    = new Double_t[fNPixUpg];
+  }
+  for (Int_t i=fNPixUpg;i--;) {
+    fPixUpgBiasVoltage[i] = simpar.fPixUpgBiasVoltage[i];
+    fPixUpgThresh[i]      = simpar.fPixUpgThresh[i];
+    fPixUpgThrSigma[i]    = simpar.fPixUpgThrSigma[i];
+    fPixUpgNoise[i]       = simpar.fPixUpgNoise[i];
+    fPixUpgBaseline[i]    = simpar.fPixUpgBaseline[i];
+  }
+  //
+}
+
+//______________________________________________________________________
+AliITSUSimuParam& AliITSUSimuParam::operator=(const AliITSUSimuParam& source)
+{
+  // Assignment operator. 
+  if (this==&source) return *this;
+  this->~AliITSUSimuParam();
+  new(this) AliITSUSimuParam(source);
+  return *this;
+  //
+}
+
+//______________________________________________________________________
+AliITSUSimuParam::~AliITSUSimuParam() 
+{
+  // destructor
+  delete[] fPixUpgBiasVoltage;
+  delete[] fPixUpgThresh;
+  delete[] fPixUpgThrSigma;
+  delete[] fPixUpgNoise;
+  delete[] fPixUpgBaseline;
+}
+
+//________________________________________________________________________
+void AliITSUSimuParam::Print(Option_t *) const
+{
+  // Dump all parameters
+  Dump();
+}
+
+//_______________________________________________________________________
+Double_t AliITSUSimuParam::ApplyPixUpgBaselineAndNoise(UInt_t mod) const 
+{
+  // generate random noise 
+  double base,noise;
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    base = fPixUpgBaselineDef;
+    noise = fPixUpgNoiseDef;
+  }
+  else {
+    base  = fPixUpgBaseline[mod];
+    noise = fPixUpgNoise[mod];    
+  }
+  return base+noise*gRandom->Gaus();
+}
+
+//_______________________________________________________________________
+Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(UInt_t mod) const 
+{
+  // calculate probability of noise exceeding the threshold
+  double base,noise,thresh;
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    base   = fPixUpgBaselineDef;
+    noise  = fPixUpgNoiseDef;
+    thresh = fPixUpgThreshDef;
+  }
+  else {
+    base   = fPixUpgBaseline[mod];
+    noise  = fPixUpgNoise[mod];
+    thresh = fPixUpgThresh[mod];
+  }
+  if (noise<1e-12) {
+    if (base>thresh) return 1;
+    else             return 0;
+  }
+  return CalcProbNoiseOverThreshold(base, noise, thresh);
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::SetPixUpgThreshold(Double_t thresh, Double_t sigma, int mod)
+{
+  // set threshold params
+  if (mod<0) {
+    fPixUpgThreshDef = thresh;
+    fPixUpgThrSigmaDef  = sigma;
+    for (int i=fNPixUpg;i--;) {
+      fPixUpgThresh[i] = thresh;
+      fPixUpgThrSigma[i]  = sigma;
+    }
+  }
+  else if (mod>=(int)fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    fPixUpgThreshDef = thresh;
+    fPixUpgThrSigmaDef  = sigma;
+  }
+  else {
+    fPixUpgThresh[mod] = thresh;
+    fPixUpgThrSigma[mod]  = sigma;
+  }
+  //
+}
+
+//_______________________________________________________________________
+Double_t AliITSUSimuParam::GetPixUpgThreshold(UInt_t mod) const
+{
+  // obtain threshold
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    return fPixUpgThreshDef;
+  }
+  else return fPixUpgThresh[mod];
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::GetPixUpgThreshold(UInt_t mod, Double_t &thresh, Double_t &sigma) const
+{
+  // obtain thresholds
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    thresh = fPixUpgThreshDef;
+    sigma  = fPixUpgThrSigmaDef;
+  }
+  else {
+    thresh = fPixUpgThresh[mod];
+    sigma  = fPixUpgThrSigma[mod];
+  }
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::SetPixUpgBiasVoltage(Double_t val, int mod)
+{
+  // set threshold params
+  if (mod<0) {
+    fPixUpgBiasVoltageDef = val;
+    for (int i=fNPixUpg;i--;) fPixUpgBiasVoltage[i] = val;
+  }
+  else if (mod>=(int)fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    fPixUpgBiasVoltageDef = val;
+  }
+  else fPixUpgBiasVoltage[mod] = val;
+  //
+}
+
+//_______________________________________________________________________
+Double_t AliITSUSimuParam::GetPixUpgBiasVoltage(UInt_t mod) const
+{
+  // obtain threshold
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    return fPixUpgBiasVoltageDef;
+  }
+  else return fPixUpgBiasVoltage[mod];
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::SetPixUpgNoise(Double_t noise, Double_t baseline, int mod)
+{
+  // set noise params
+  if (mod<0) {
+    fPixUpgNoiseDef = noise;
+    fPixUpgBaselineDef  = baseline;
+    for (int i=fNPixUpg;i--;) {
+      fPixUpgNoise[i] = noise;
+      fPixUpgBaseline[i]  = baseline;
+    }
+  }
+  else if (mod>=(int)fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    fPixUpgNoiseDef = noise;
+    fPixUpgBaselineDef  = baseline;
+  }
+  else {
+    fPixUpgNoise[mod] = noise;
+    fPixUpgBaseline[mod]  = baseline;
+  }
+  //
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::GetPixUpgNoise(UInt_t mod, Double_t &noise, Double_t &baseline) const
+{
+  // obtain noise
+  if (mod>=fNPixUpg) {
+    if (fNPixUpg>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPixUpg));}
+    noise     = fPixUpgNoiseDef;
+    baseline  = fPixUpgBaselineDef;
+  }
+  else {
+    noise     = fPixUpgNoise[mod];
+    baseline  = fPixUpgBaseline[mod];
+  }
+}
+
+//_______________________________________________________________________
+void AliITSUSimuParam::SetPixUpgCouplingOption(UInt_t opt)
+{
+  // set coupling option
+  if (opt>=kMaxCouplingOptPixUpg) AliFatal(Form("Coupling option %d should be less than %d",opt,kMaxCouplingOptPixUpg));
+  fPixUpgCouplOpt = opt;
+}
+
+
+//______________________________________________________________________
+Double_t AliITSUSimuParam::LorentzAngleHole(Double_t B) const 
+{
+  // Computes the Lorentz angle for electrons in Si
+  // Input: magnetic Field in KGauss
+  // Output: Lorentz angle in radians (positive if Bz is positive)
+  // Main Reference: NIM A 497 (2003) 389–396.
+  // "An algorithm for calculating the Lorentz angle in silicon detectors", V. Bartsch et al.
+  //
+  const Double_t krH=0.70; // Hall scattering factor for Hole
+  const Double_t kT0  = 300.;       // reference Temperature (degree K).
+  const Double_t kmulow0 = 470.5;   // cm^2/Volt-sec
+  const Double_t keT0 = -2.5;       // Power of Temp.
+  const Double_t beta0 = 1.213;     // beta coeff. at T0=300K
+  const Double_t keT1 = 0.17;       // Power of Temp. for beta
+  const Double_t kvsat0 = 8.37E+06; // saturated velocity at T0=300K (cm/sec)
+  const Double_t keT2 = 0.52;       // Power of Temp. for vsat
+  Double_t tT = fT;
+  Double_t eE= 1./fDOverV;
+  Double_t muLow=kmulow0*TMath::Power(tT/kT0,keT0);
+  Double_t beta=beta0*TMath::Power(tT/kT0,keT1);
+  Double_t vsat=kvsat0*TMath::Power(tT/kT0,keT2);
+  Double_t mu=muLow/TMath::Power(1+TMath::Power(muLow*eE/vsat,beta),1/beta);
+  Double_t angle=TMath::ATan(krH*mu*B*1.E-05); // Conversion Factor
+  return angle;
+}
+
+//______________________________________________________________________
+Double_t AliITSUSimuParam::LorentzAngleElectron(Double_t B) const 
+{
+  // Computes the Lorentz angle for electrons in Si
+  // Input: magnetic Field in KGauss
+  // Output: Lorentz angle in radians (positive if Bz is positive)
+  // Main Reference: NIM A 497 (2003) 389–396.
+  // "An algorithm for calculating the Lorentz angle in silicon detectors", V. Bartsch et al.
+  //
+  const Double_t krH=1.15; // Hall scattering factor for Electron
+  const Double_t kT0  = 300.;       // reference Temperature (degree K).
+  const Double_t kmulow0 = 1417.0;  // cm^2/Volt-sec
+  const Double_t keT0 = -2.2;       // Power of Temp.
+  const Double_t beta0 = 1.109;     // beta coeff. at T0=300K
+  const Double_t keT1 = 0.66;       // Power of Temp. for beta
+  const Double_t kvsat0 = 1.07E+07; // saturated velocity at T0=300K (cm/sec)
+  const Double_t keT2 = 0.87;       // Power of Temp. for vsat
+  Double_t tT = fT;
+  Double_t eE= 1./fDOverV;
+  Double_t muLow=kmulow0*TMath::Power(tT/kT0,keT0);
+  Double_t beta=beta0*TMath::Power(tT/kT0,keT1);
+  Double_t vsat=kvsat0*TMath::Power(tT/kT0,keT2);
+  Double_t mu=muLow/TMath::Power(1+TMath::Power(muLow*eE/vsat,beta),1/beta);
+  Double_t angle=TMath::ATan(krH*mu*B*1.E-05);
+  return angle;
+}
+
+//______________________________________________________________________
+Double_t AliITSSimuParam::SigmaDiffusion3D(Double_t l) const 
+{
+  // Returns the Gaussian sigma^2 == <x^2+y^2+z^2> [cm^2] due to the
+  // defusion of electrons or holes through a distance l [cm] caused
+  // by an applied voltage v [volt] through a distance d [cm] in any
+  //  material at a temperature T [degree K]. The sigma diffusion when
+  //  expressed in terms of the distance over which the diffusion
+  // occures, l=time/speed, is independent of the mobility and therefore
+  //  the properties of the material. The charge distributions is given by
+  // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <r^2> = 6Dt where D=mkT/e
+  // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
+  // charge. and vel=m*v/d. consiquently sigma^2=6kTdl/ev.
+  // Inputs:
+  //    Double_t l   Distance the charge has to travel.
+  // Output:
+  //    none.
+  // Return:
+  //    The Sigma due to the diffution of electrons. [cm]
+  const Double_t kcon = 5.17040258E-04; // == 6k/e [J/col or volts]  
+  return TMath::Sqrt(kcon*fT*fDOverV*l);  // [cm]
+}
+
+//______________________________________________________________________
+Double_t AliITSUSimuParam::SigmaDiffusion2D(Double_t l) const 
+{
+  // Returns the Gaussian sigma^2 == <x^2+z^2> [cm^2] due to the defusion
+  // of electrons or holes through a distance l [cm] caused by an applied
+  // voltage v [volt] through a distance d [cm] in any material at a
+  // temperature T [degree K]. The sigma diffusion when expressed in terms
+  // of the distance over which the diffusion occures, l=time/speed, is
+  // independent of the mobility and therefore the properties of the
+  // material. The charge distributions is given by
+  // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <x^2+z^2> = 4Dt where D=mkT/e
+  // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
+  // charge. and vel=m*v/d. consiquently sigma^2=4kTdl/ev.
+  // Inputs:
+  //    Double_t l   Distance the charge has to travel.
+  // Output:
+  //    none.
+  // Return:
+  //    The Sigma due to the diffution of electrons. [cm]
+  const Double_t kcon = 3.446935053E-04; // == 4k/e [J/col or volts]
+  return TMath::Sqrt(kcon*fT*fDOverV*l);  // [cm]
+}
+
+//______________________________________________________________________
+Double_t AliITSSimuParam::SigmaDiffusion1D(Double_t l) const 
+{
+  // Returns the Gaussian sigma^2 == <x^2> [cm^2] due to the defusion
+  // of electrons or holes through a distance l [cm] caused by an applied
+  // voltage v [volt] through a distance d [cm] in any material at a
+  // temperature T [degree K]. The sigma diffusion when expressed in terms
+  // of the distance over which the diffusion occures, l=time/speed, is
+  // independent of the mobility and therefore the properties of the
+  // material. The charge distributions is given by
+  // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <r^2> = 2Dt where D=mkT/e
+  // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
+  // charge. and vel=m*v/d. consiquently sigma^2=2kTdl/ev.
+  // Inputs:
+  //    Double_t l   Distance the charge has to travel.
+  // Output:
+  //    none.
+  // Return:
+  //    The Sigma due to the diffution of electrons. [cm]
+  const Double_t kcon = 1.723467527E-04; // == 2k/e [J/col or volts]
+  return TMath::Sqrt(kcon*fT*fDOverV*l);  // [cm]
+}
diff --git a/ITS/UPGRADE/AliITSUSimuParam.h b/ITS/UPGRADE/AliITSUSimuParam.h
new file mode 100644 (file)
index 0000000..88ea4f3
--- /dev/null
@@ -0,0 +1,151 @@
+#ifndef ALIITSUSIMUPARAM_H
+#define ALIITSUSIMUPARAM_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+///////////////////////////////////////////////////////////////////
+//                                                               //
+// Class to store the parameters used in the simulation ITS      //
+//                                                               //
+///////////////////////////////////////////////////////////////////
+#include <TRandom.h>
+#include <TObject.h>
+#include <TMath.h>
+
+class AliITSUSimuParam : public TObject {
+
+ public:
+  enum {kOldCouplingPixUpg,kNewCouplingPixUpg,kMaxCouplingOptPixUpg};
+  //
+  AliITSUSimuParam();
+  AliITSUSimuParam(UInt_t nPixUpg);
+  AliITSUSimuParam(const AliITSUSimuParam& simpar);
+  // assignment operator 
+  AliITSUSimuParam& operator=(const AliITSUSimuParam& source);
+  ~AliITSUSimuParam();
+
+  Double_t ApplyPixUpgBaselineAndNoise(UInt_t mod) const;
+  Double_t CalcProbNoiseOverThreshold(UInt_t mod) const;
+  //
+  void     SetPixUpgThreshold(Double_t thresh, Double_t sigma, int mod=-1);
+  void     GetPixUpgThreshold(UInt_t mod, Double_t& thresh, Double_t& sigma) const;
+  Double_t GetPixUpgThreshold(UInt_t mod)                                    const;
+  //
+  void     SetPixUpgNoise(Double_t noise, Double_t baseline, Int_t mod=-1);
+  void     GetPixUpgNoise(UInt_t mod,Double_t &noise, Double_t &baseline)    const;
+  //
+  void     SetPixUpgBiasVoltage(Double_t bias=18.182,Int_t mod=-1);
+  Double_t GetPixUpgBiasVoltage(UInt_t mod)                                  const;
+
+  void     SetGeVToCharge(Double_t gc=fgkNcompsDefault)                             {fGeVcharge = gc;}
+  Double_t GetGeVToCharge()                                                  const  {return fGeVcharge;}
+  Double_t GeVToCharge(Double_t gev)                                         const  {return gev/fGeVcharge;}
+  //
+  void     SetDistanceOverVoltage(Double_t d,Double_t v)                            {fDOverV = d/v;}
+  void     SetDistanceOverVoltage(Double_t dv=fgkDOverVDefault)                     {fDOverV = dv;}
+  Double_t GetDistanceOverVoltage()                                          const  {return fDOverV;}
+  //
+  void     SetPixUpgCouplingOption(UInt_t opt);
+  UInt_t   GetPixUpgCouplingOption()                                         const  {return fPixUpgCouplOpt;}
+
+  void     SetPixUpgCouplingParam(Double_t col, Double_t row)                       {fPixUpgCouplCol = col; fPixUpgCouplRow = row;}
+  void     GetPixUpgCouplingParam(Double_t &col, Double_t &row)              const  {col = fPixUpgCouplCol; row = fPixUpgCouplRow;}
+
+  void     SetPixUpgSigmaDiffusionAsymmetry(Double_t ecc)                           {fPixUpgEccDiff=ecc;}   
+  void     GetPixUpgSigmaDiffusionAsymmetry(Double_t &ecc)                   const  {ecc=fPixUpgEccDiff;}
+
+  void     SetPixUpgLorentzDrift(Bool_t ison)                                       {fPixUpgLorentzDrift=ison;}
+  Bool_t   GetPixUpgLorentzDrift()                                           const  {return fPixUpgLorentzDrift;}
+  void     SetPixUpgLorentzHoleWeight(Double_t weight)                               {fPixUpgLorentzHoleWeight=weight;}
+  Double_t GetPixUpgLorentzHoleWeight()                                      const  {return fPixUpgLorentzHoleWeight;}
+  
+  void     SetPixUpgAddNoisyFlag(Bool_t value)                                      {fPixUpgAddNoisyFlag = value;}
+  Bool_t   GetPixUpgAddNoisyFlag()                                           const  {return fPixUpgAddNoisyFlag;}
+  void     SetPixUpgRemoveDeadFlag(Bool_t value)                                    {fPixUpgRemoveDeadFlag = value;}
+  Bool_t   GetPixUpgRemoveDeadFlag()                                         const  {return fPixUpgRemoveDeadFlag;}
+  //
+  Double_t LorentzAngleElectron(Double_t bz)                                 const;
+  Double_t LorentzAngleHole(Double_t bz)                                     const;
+  //
+  Double_t SigmaDiffusion3D(Double_t  l)                                     const;
+  Double_t SigmaDiffusion2D(Double_t l)                                      const;
+  Double_t SigmaDiffusion1D(Double_t l)                                      const;
+  //
+  virtual void Print(Option_t *opt = "")                                     const; 
+  //
+  static Double_t CalcProbNoiseOverThreshold(double base, double noise, double thresh);
+  static Double_t GenerateNoiseQFunction(double prob, double mean, double sigma);
+  //
+ protected:
+
+  static const Double_t fgkPixUpgBiasVoltageDefault;//default for fPixUpgBiasVoltage
+  static const Double_t fgkPixUpgThreshDefault; //default for fThresh
+  static const Double_t fgkPixUpgThrSigmaDefault; //default for fSigma
+  static const Double_t fgkPixUpgCouplColDefault; //default for fPixUpgCouplCol
+  static const Double_t fgkPixUpgCouplRowDefault; //default for fPixUpgCouplRow
+  static const Double_t fgkPixUpgEccDiffDefault;//default for fPixUpgEccDiff
+  static const Double_t fgkPixUpgLorentzHoleWeightDefault;//default for fPixUpgLorentzHoleWeight
+  static const UInt_t   fgkPixUpgCouplingOptDefault;  // type of pixel Coupling (old or new)
+  static const Double_t fgkDOverVDefault;             // default distance over voltage 
+  static const Double_t fgkGeVtoChargeDefault;        // default energy to ionize (free an electron) in GeV
+  static const Double_t fgkTDefault;                  // default temperature
+
+  static const Double_t fgkNsigmasDefault; //default for fNsigmas
+  static const Int_t fgkNcompsDefault; //default for fNcomps
+
+ private:
+  //
+  Double_t   fGeVcharge;          // Energy to ionize (free an electron) in GeV
+  Double_t   fDOverV;             // The parameter d/v where d is the disance over which the the potential v is applied d/v [cm/volts]
+  Double_t   fT;                  // The temperature of the Si in Degree K.
+  //
+  UInt_t     fNPixUpg;            // number of PixUpg type detectors
+  UInt_t     fPixUpgCouplOpt;     // PixUpg Coupling Option
+  Double_t   fPixUpgCouplCol;     // PixUpg Coupling parameter along the cols
+  Double_t   fPixUpgCouplRow;     // PixUpg Coupling parameter along the rows
+  Double_t   fPixUpgEccDiff;      // Eccentricity (i.e. asymmetry parameter) in the  Gaussian diffusion for PixUpg  
+  Bool_t     fPixUpgLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in PixUpg
+  Double_t   fPixUpgLorentzHoleWeight;// Lorentz Angle is computed for PixUpg as average of Hole and Electron
+  //                                    this parameter gives the relative weights between the two
+  Bool_t     fPixUpgAddNoisyFlag;     // Flag saying whether noisy pixels should be added to digits
+  Bool_t     fPixUpgRemoveDeadFlag;   // Flag saying whether dead pixels should be removed from digits
+  //
+  Double_t   fPixUpgThreshDef;      // PixUpg Threshold value
+  Double_t   fPixUpgThrSigmaDef;    // PixUpg Threshold fluctuation
+  Double_t   fPixUpgBiasVoltageDef; // Bias Voltage for the PixUpg
+  Double_t   fPixUpgNoiseDef;       // PixUpg electronic noise: sigma
+  Double_t   fPixUpgBaselineDef;    // PixUpg electronic noise: baseline
+  //
+  Double_t*  fPixUpgThresh;      //[fNPixUpg] PixUpg Threshold value
+  Double_t*  fPixUpgThrSigma;    //[fNPixUpg] PixUpg Threshold fluctuation
+  Double_t*  fPixUpgBiasVoltage; //[fNPixUpg] Bias Voltage for the PixUpg
+  Double_t*  fPixUpgSigma;       //[fNPixUpg] PixUpg threshold fluctuations spread
+  Double_t*  fPixUpgNoise;       //[fNPixUpg] PixUpg electronic noise: sigma
+  Double_t*  fPixUpgBaseline;    //[fNPixUpg] PixUpg electronic noise: baseline
+  //
+
+  ClassDef(AliITSUSimuParam,1);
+};
+
+//_______________________________________________________________________
+inline Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(double mean, double sigma, double thresh) 
+{
+  // calculate probability of gaussian noise exceeding the threshold
+  const double ksqrt2 = 1.41421356237309515e+00;
+  return 0.5*TMath::Erfc( (thresh-mean)/(sigma*ksqrt2));
+}
+
+//_______________________________________________________________________
+inline Double_t AliITSUSimuParam::GenerateNoiseQFunction(double prob, double mean, double sigma) 
+{
+  // generate random noise exceeding threshold probability prob, i.e. find a random point in the right
+  // tail of the gaussian(base,noise), provided that the tail integral = prob
+  const double ksqrt2 = 1.41421356237309515e+00;
+  return mean+sigma*ksqrt2*TMath::ErfcInverse(2*prob*(1.-gRandom->Rndm()));
+}
+
+
+
+#endif
diff --git a/ITS/UPGRADE/AliITSUSimulation.cxx b/ITS/UPGRADE/AliITSUSimulation.cxx
new file mode 100644 (file)
index 0000000..71bd11d
--- /dev/null
@@ -0,0 +1,166 @@
+/**************************************************************************
+ * 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 is the base class for ITS detector signal simulations. Data members //
+// include are a pointer to the AliITSDetTypeSim clas in order to access    //
+// segmentation and response objects                                        // 
+// classes. See the detector specific implementations for the propper code. //
+//////////////////////////////////////////////////////////////////////////////
+#include <TRandom.h>
+#include "TSeqCollection.h"
+#include "AliITSUSimulation.h"
+#include "AliITSUSDigit.h"
+
+ClassImp(AliITSUSimulation)
+
+//______________________________________________________________________
+AliITSUSimulation::AliITSUSimulation()
+:  fSeg(0)
+  ,fCalibDead(0)
+  ,fCalibNoisy(0)
+  ,fSensMap(0)
+  ,fSimuParam(0)
+  ,fModule(0)
+  ,fEvent(0)
+  ,fDebug(0)
+{
+    // Default constructor
+}
+//______________________________________________________________________
+AliITSUSimulation::AliITSUSimulation(AliITSUSimuParam* sim,AliITSUSensMap* map)
+  :fSeg(0)
+  ,fCalibDead(0)
+  ,fCalibNoisy(0)
+  ,fSensMap(map)
+  ,fSimuParam(sim)
+  ,fModule(0)
+  ,fEvent(0)
+  ,fDebug(0)
+{
+    // Default constructor
+}
+
+//__________________________________________________________________________
+AliITSUSimulation::AliITSUSimulation(const AliITSUSimulation &s) 
+  :TObject(s)
+  ,fSeg(s.fSeg)
+  ,fCalibDead(s.fCalibDead)
+  ,fCalibNoisy(s.fCalibNoisy)
+  ,fSensMap(s.fSensMap)
+  ,fSimuParam(s.fSimuParam)   
+  ,fModule(s.fModule)
+  ,fEvent(s.fEvent)
+  ,fDebug(s.fDebug)
+{
+  //     Copy Constructor 
+}
+
+//_________________________________________________________________________
+AliITSUSimulation&  AliITSUSimulation::operator=(const AliITSUSimulation &s)
+{
+  //    Assignment operator
+  if(&s == this) return *this;
+  fSeg       = s.fSeg;
+  fCalibDead = s.fCalibDead;
+  fCalibNoisy= s.fCalibNoisy;
+  fSensMap   = s.fSensMap;
+  fSimuParam = s.fSimuParam;
+  fModule    = s.fModule;
+  fEvent     = s.fEvent;
+  return *this;
+}
+
+//______________________________________________________________________
+void AliITSUSimulation::InitSimulationModule(Int_t module, Int_t event, AliITSsegmentation* seg)
+{
+  //  This function creates maps to build the list of tracks for each
+  //  summable digit. Inputs defined by base class.
+  //
+  SetModule(module);
+  SetEvent(event);
+  SetSegmentation(seg);
+  ClearMap();
+}
+
+//______________________________________________________________________
+Bool_t AliITSUSimulation::AddSDigitsToModule(TSeqCollection *pItemArr,Int_t mask )
+{
+  // Add Summable digits to module maps.
+  // Inputs:
+  //    pItemArr  Array of AliITSpListItems (SDigits).
+  //    mask    Track number off set value 
+  //
+  Int_t nItems = pItemArr->GetEntries();
+  Bool_t sig = kFALSE;
+  // 
+  for( Int_t i=0; i<nItems; i++ ) {
+    AliITSUSDigit * pItem = (AliITSUSDigit *)(pItemArr->At( i ));
+    if( pItem->GetModule() != fModule ) AliFatal(Form("SDigits module %d != current module %d: exit", pItem->GetModule(), fModule ));
+    if(pItem->GetSumSignal()>0.0 ) sig = kTRUE;
+    AliITSUSDigit* oldItem = (AliITSUSDigit*)fSensMap->GetItem(pItem);
+    if (!oldItem) {
+      oldItem = (AliITSUSDigit*)fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(*pItem) );
+      if (mask) oldItem->ShiftIndices(mask);
+    }
+    else oldItem->AddTo(mask, pItem);
+  }
+  return sig;
+}
+
+//______________________________________________________________________
+void AliITSUSimulation::UpdateMapSignal(UInt_t dim0,UInt_t dim1,Int_t trk,Int_t ht,Double_t signal) 
+{
+  // update map with new hit
+  UInt_t ind = fSensMap->GetIndex(dim0,dim1);
+  AliITSUSDigit* oldItem = (AliITSUSDigit*)fSensMap->GetItem(ind);
+  if (!oldItem) fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(trk,ht,fModule,ind,signal) );
+  else oldItem->AddSignal(trk,ht,signal);
+}
+
+//______________________________________________________________________
+void AliITSUSimulation::UpdateMapNoise(UInt_t dim0,UInt_t dim1,Double_t noise) 
+{
+  // update map with new hit
+  UInt_t ind = fSensMap->GetIndex(dim0,dim1);
+  AliITSUSDigit* oldItem = (AliITSUSDigit*)fSensMap->GetItem(ind);
+  if (!oldItem) fSensMap->RegisterItem( new(fSensMap->GetFree()) AliITSUSDigit(fModule,ind,noise) );
+  else oldItem->AddNoise(noise);
+}
+
+//______________________________________________________________________
+Int_t AliITSUSimulation::GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &indx)
+{
+  // generate random sample [0:nmax] of ngen variables, and fill orreder indices 
+  // return actual number of generated values 
+  if (vals.GetSize()<(int)ngen) vals.Set(ngen);
+  if (indx.GetSize()<(int)ngen) indx.Set(ngen);
+  int* valA = vals.GetArray();
+  int* indA = indx.GetArray();
+  if (ngen>=nmax) {
+    ngen = nmax-1;
+    for (int i=(int)ngen;i--;) {valA[i]=indA[i]=i;}
+    return ngen;
+  }
+  Bool_t rep;
+  for (int i=0;i<(int)ngen;i++) {
+    do { // exclude repetitions
+      rep = kFALSE;
+      valA[i] = gRandom->Rndm()*nmax;
+      for (int j=i;j--;) if (valA[j]==valA[i]) {rep=kTRUE;break;}
+    } while(rep);
+  }
+  TMath::Sort((int)ngen,valA,indA,kFALSE);
+  return ngen;
+}
diff --git a/ITS/UPGRADE/AliITSUSimulation.h b/ITS/UPGRADE/AliITSUSimulation.h
new file mode 100644 (file)
index 0000000..d0df46c
--- /dev/null
@@ -0,0 +1,96 @@
+#ifndef ALIITSUSIMULATION_H
+#define ALIITSUSIMULATION_H
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include <TObject.h>
+#include "AliITSUSensMap.h"
+#include "AliITSsegmentation.h"
+
+class AliITSCalibration;
+class AliITSUSimuParam;
+class AliITSUModule;
+class TRandom;
+class TSegCollection;
+
+// This is the base class for ITS detector signal simulations. Data members
+// include are a pointer to the detectors specific response and segmentation
+// classes. See the detector specific implementations for the propper code.
+// The detector-specific implementations are responsible for processing detector type, 
+// which still may have different segmentations!
+// Note: the detector specific objects (segmentation, calib, etc.) are not owned
+// by the object but set externaly
+
+class AliITSUSimulation : public TObject 
+{
+ public:
+  AliITSUSimulation();
+  AliITSUSimulation(AliITSUSimuParam* sim, AliITSUSensMap* map);
+  virtual ~AliITSUSimulation() {} 
+  AliITSUSimulation(const AliITSUSimulation &source);
+  AliITSUSimulation& operator=(const AliITSUSimulation &source);
+  virtual void Init() = 0;
+  //
+  void UpdateMapSignal(UInt_t dim0,UInt_t dim1, Int_t trk,Int_t ht,Double_t signal);
+  void UpdateMapNoise(UInt_t dim0,UInt_t dim1, Double_t noise);
+  virtual void InitSimulationModule(Int_t, Int_t, AliITSsegmentation*);
+  //
+  // Hits -> SDigits
+  virtual void SDigitiseModule(AliITSUModule* mod, Int_t mask, Int_t event, AliITSsegmentation* seg) = 0;
+  virtual void FinishSDigitiseModule() = 0;
+  virtual Bool_t AddSDigitsToModule( TSeqCollection *pItemArray, Int_t mask );
+  //
+  // Hits -> Digits
+  virtual void DigitiseModule(AliITSUModule* mod, Int_t mask, Int_t event, AliITSsegmentation* seg) = 0;
+  virtual void CreateFastRecPoints(AliITSUModule *,Int_t,TRandom *,TClonesArray* /*recp*/) {}
+  //
+  AliITSCalibration*  GetCalibDead()                   const {return fCalibDead;}
+  AliITSCalibration*  GetCalibNoisy()                  const {return fCalibNoisy;}
+  AliITSsegmentation* GetSegmentation()                const {return fSeg;}
+  AliITSUSimuParam* GetSimuParam()                   const {return fSimuParam;}
+  AliITSUSensMap*   GetMap()                         const {return fSensMap;}
+  Int_t               GetModule()                      const {return fModule;}
+  Int_t               GetEvent()                       const {return fEvent;}
+  Bool_t              GetDebug(Int_t level=1)          const {return fDebug>=level;}
+
+  //
+  void SetCalibDead(AliITSCalibration *calib)              {fCalibDead = calib;}
+  void SetCalibNoisy(AliITSCalibration *calib)             {fCalibNoisy = calib;}
+  void SetSegmentation(AliITSsegmentation *seg)            {fSeg = seg; if (seg&&fSensMap) fSensMap->SetDimensions(seg->Npz(),seg->Npx());}
+  void SetSimuParam(AliITSUSimuParam *sp)                {fSimuParam = sp;}
+  void SetMap(AliITSUSensMap *p)                         {fSensMap = p;}
+  void SetModule(Int_t mod)                                {fModule=mod;} 
+  void SetEvent(Int_t evnt)                                {fEvent=evnt;} 
+  void SetDebug(Int_t level=5)                             {fDebug=level;}
+  void SetNoDebug()                                        {fDebug=0;}
+  void ClearMap()                                          {fSensMap->Clear();}
+  //
+  static  Int_t GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &ind);
+  //
+ protected:
+  AliITSsegmentation  *fSeg;            //! segmentation
+  AliITSCalibration   *fCalibDead;      //! dead channels
+  AliITSCalibration   *fCalibNoisy;     //! noisy channels
+  AliITSUSensMap    *fSensMap;        //! sensor map for hits manipulations
+  AliITSUSimuParam  *fSimuParam;      //! simulation parameters
+  Int_t                fModule;         //! module number being processed
+  Int_t                fEvent;          //! event number being processed
+  Int_t                fDebug;          //!  debug flag
+
+  ClassDef(AliITSUSimulation,1)       // Simulation base class 
+    
+};
+
+#endif
diff --git a/ITS/UPGRADE/AliITSUSimulationPix.cxx b/ITS/UPGRADE/AliITSUSimulationPix.cxx
new file mode 100644 (file)
index 0000000..4bc6ac3
--- /dev/null
@@ -0,0 +1,787 @@
+/*
+ questions to experts: why RemoveDeadPixels should be called before FrompListToDigits ? 
+
+*/
+
+/**************************************************************************
+* 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.                  *
+**************************************************************************/
+
+#include <Riostream.h>
+#include <TGeoGlobalMagField.h>
+#include <TH1.h>
+#include <TString.h>
+#include "AliITSU.h"
+#include "AliITSUDigitPix.h"
+#include "AliITSUHit.h"
+#include "AliITSUModule.h"
+#include "AliITSUSensMap.h"
+#include "AliITSUCalibrationPix.h"
+#include "AliITSUSegmentationPix.h"
+#include "AliITSUSimulationPix.h"
+#include "AliLog.h"
+#include "AliRun.h"
+#include "AliMagF.h"
+#include "AliMathBase.h"
+#include "AliITSUSimuParam.h"
+#include "AliITSUSDigit.h"
+
+ClassImp(AliITSUSimulationPix)
+////////////////////////////////////////////////////////////////////////
+//  Version: 1
+//  Modified by D. Elia, G.E. Bruno, H. Tydesjo 
+//  Fast diffusion code by Bjorn S. Nilsen
+//  March-April 2006
+//  October     2007: GetCalibrationObjects() removed
+//
+//  Version: 0
+//  Written by Boris Batyunya
+//  December 20 1999
+//
+//  Adapted for pixels of ITS upgrade July 2012, ruben.shahoyan@cern.ch
+//
+//  AliITSUSimulationPix is to do the simulation of pixels
+//
+////////////////////////////////////////////////////////////////////////
+
+//______________________________________________________________________
+AliITSUSimulationPix::AliITSUSimulationPix()
+:  fTanLorAng(0)
+  ,fStrobe(kTRUE)
+  ,fStrobeLenght(4)
+  ,fStrobePhase(-12.5e-9)
+{
+   // Default constructor.
+}
+
+//______________________________________________________________________
+AliITSUSimulationPix::AliITSUSimulationPix(AliITSUSimuParam* sim,AliITSUSensMap* map)
+  :AliITSUSimulation(sim,map)
+  ,fTanLorAng(0)
+  ,fStrobe(kTRUE)
+  ,fStrobeLenght(4)
+  ,fStrobePhase(-12.5e-9)
+{
+  // standard constructor
+  Init();
+}
+
+//______________________________________________________________________
+AliITSUSimulationPix::AliITSUSimulationPix(const AliITSUSimulationPix &s) 
+  :AliITSUSimulation(s)
+  ,fTanLorAng(s.fTanLorAng)
+  ,fStrobe(s.fStrobe)
+  ,fStrobeLenght(s.fStrobeLenght)
+  ,fStrobePhase(s.fStrobePhase)
+{
+  //     Copy Constructor
+}
+
+
+//______________________________________________________________________
+AliITSUSimulationPix::~AliITSUSimulationPix()
+{
+  // destructor
+  // only the sens map is owned and it is deleted by ~AliITSUSimulation
+}
+
+//______________________________________________________________________
+AliITSUSimulationPix& AliITSUSimulationPix::operator=(const AliITSUSimulationPix &s)
+{
+  //    Assignment operator
+  if (&s == this) return *this;
+  AliITSUSimulation::operator=(s);
+  fStrobe       = s.fStrobe;
+  fStrobeLenght = s.fStrobeLenght;
+  fStrobePhase  = s.fStrobePhase;
+  return *this;
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::Init()
+{
+  // Initilization
+  if (fSimuParam->GetPixUpgLorentzDrift()) SetTanLorAngle(fSimuParam->GetPixUpgLorentzHoleWeight());
+}
+
+//______________________________________________________________________
+Bool_t AliITSUSimulationPix::SetTanLorAngle(Double_t weightHole) 
+{
+  // This function set the Tangent of the Lorentz angle. 
+  // A weighted average is used for electrons and holes 
+  // Input: Double_t weightHole: wheight for hole: it should be in the range [0,1]
+  // output: Bool_t : kTRUE in case of success
+  //
+  if (weightHole<0) {
+    weightHole=0.;
+    AliWarning("You have asked for negative Hole weight");
+    AliWarning("I'm going to use only electrons");
+  }
+  if (weightHole>1) {
+    weightHole=1.;
+    AliWarning("You have asked for weight > 1");
+    AliWarning("I'm going to use only holes");
+  }
+  Double_t weightEle=1.-weightHole;
+  AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+  if (!fld) AliFatal("The field is not initialized");
+  Double_t bz = fld->SolenoidField();
+  fTanLorAng = TMath::Tan(weightHole*fSimuParam->LorentzAngleHole(bz) +
+                         weightEle*fSimuParam->LorentzAngleElectron(bz));
+  return kTRUE;
+}
+
+//_____________________________________________________________________
+void AliITSUSimulationPix::SDigitiseModule(AliITSUModule *mod, Int_t /*mask*/,Int_t event, AliITSsegmentation* seg)
+{
+  //  This function begins the work of creating S-Digits.
+  if (!(mod->GetNHits())) {
+    AliDebug(1,Form("In event %d module %d there are %d hits returning.",
+                   event, mod->GetIndex(),mod->GetNHits()));
+    return;
+  } 
+  //
+  if (fStrobe) if (event != fEvent) GenerateStrobePhase(); 
+  InitSimulationModule(mod->GetIndex(), event, seg );
+  // Hits2SDigits(mod);
+  Hits2SDigitsFast(mod);
+  if (fSimuParam->GetPixUpgAddNoisyFlag())   AddNoisyPixels();
+  if (fSimuParam->GetPixUpgRemoveDeadFlag()) RemoveDeadPixels();  
+  WriteSDigits();
+  ClearMap();
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::WriteSDigits()
+{
+  //  This function adds each S-Digit to pList
+  static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
+  int nsd = fSensMap->GetEntries();
+  for (int i=0;i<nsd;i++) {
+    AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->At(i); // ordered in index
+    if (!sd->GetSumSignal()>0 || fSensMap->IsDisabled(sd)) continue;
+    aliITS->AddSumDigit(*sd);
+  }
+  return; 
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::FinishSDigitiseModule()
+{
+   //  This function calls SDigitsToDigits which creates Digits from SDigits
+  FrompListToDigits();
+  ClearMap();
+  return;
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::DigitiseModule(AliITSUModule *mod,Int_t /*mask*/, Int_t event, AliITSsegmentation* seg)
+{
+  //  This function creates Digits straight from the hits and then adds
+  //  electronic noise to the digits before adding them to pList
+  //  Each of the input variables is passed along to Hits2SDigits
+  //
+  if (fStrobe) if (event != fEvent) GenerateStrobePhase();
+  InitSimulationModule( mod->GetIndex(), event, seg );
+  // Hits2SDigits(mod);
+  Hits2SDigitsFast(mod);
+  //
+  if (fSimuParam->GetPixUpgAddNoisyFlag())   AddNoisyPixels();
+  if (fSimuParam->GetPixUpgRemoveDeadFlag()) RemoveDeadPixels();
+  FrompListToDigits();
+  ClearMap();
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::Hits2SDigits(AliITSUModule *mod)
+{
+  // Does the charge distributions using Gaussian diffusion charge charing.
+  const Double_t kmictocm = 1.0e-4; // convert microns to cm.
+  const Double_t kcmtomic = 1.e4;
+  const Double_t kBunchLenght = 25e-9; // LHC clock
+  Int_t nhits = mod->GetNHits();
+  if (!nhits) return;
+  //
+  Int_t h,ix,iz,i;
+  Int_t idtrack;
+  Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
+  Double_t x,y,z,t,tp,st,dt=0.2,el,sig,sigx,sigz,fda;
+  Double_t thick = 0.5*kmictocm*fSeg->Dy();  // Half Thickness
+  fSimuParam->GetPixUpgSigmaDiffusionAsymmetry(fda);
+  //
+  for (h=0;h<nhits;h++) {
+    if (fStrobe && 
+       ((mod->GetHit(h)->GetTOF()<fStrobePhase) || 
+        (mod->GetHit(h)->GetTOF()>(fStrobePhase+fStrobeLenght*kBunchLenght)))
+       ) continue;
+    //
+    if (!mod->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,idtrack)) continue;
+    st = TMath::Sqrt(x1*x1+y1*y1+z1*z1);
+    if (st>0.0) {
+      st = (Double_t)((Int_t)(st*kcmtomic)); // number of microns
+      if (st<=1.0) st = 1.0;
+      dt = 1.0/st;
+      for (t=0.0;t<1.0;t+=dt) { // Integrate over t
+       tp  = t+0.5*dt;
+       x   = x0+x1*tp;
+       y   = y0+y1*tp;
+       z   = z0+z1*tp;
+       if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
+       el  = dt * de / fSimuParam->GetGeVToCharge();
+       //
+       if (GetDebug(1)) if (el<=0.0) cout<<"el="<<el<<" dt="<<dt<<" de="<<de<<endl; // end if GetDebug
+       //
+       sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y)); 
+       sigx=sig;
+       sigz=sig*fda;
+       if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+       SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
+      } // end for t
+    } else { // st == 0.0 deposit it at this point
+      x   = x0;
+      y   = y0;
+      z   = z0;
+      if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
+      el  = de / fSimuParam->GetGeVToCharge();
+      sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
+      sigx = sig;
+      sigz = sig*fda;
+      if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+      SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
+    } // end if st>0.0    
+  } // Loop over all hits h
+  //
+  // Coupling
+  int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
+  AliITSUSDigit* dg = 0;
+  switch (fSimuParam->GetPixUpgCouplingOption()) {
+  case AliITSUSimuParam::kNewCouplingPixUpg :
+    for (i=nd;i--;) {
+      dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
+      if (fSensMap->IsDisabled(dg)) continue;
+      SetCoupling(dg,idtrack,h);
+    } 
+    break;
+  case AliITSUSimuParam::kOldCouplingPixUpg:
+    for (i=nd;i--;) {
+      dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
+      if (fSensMap->IsDisabled(dg)) continue;
+      SetCouplingOld(dg,idtrack,h);
+    } 
+    break;
+  default:
+    break;
+    
+  } // end switch
+  if (GetDebug(2)) Info("Hits2SDigits","Finished fCoupling=%d",fSimuParam->GetPixUpgCouplingOption());
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::Hits2SDigitsFast(AliITSUModule *mod)
+{
+  // Does the charge distributions using Gaussian diffusion charge charing.    // Inputs:
+  //    AliITSUModule *mod  Pointer to this module
+  // Output:
+  //    none.
+  // Return:
+  //    none.
+  const Double_t kmictocm = 1.0e-4; // convert microns to cm.
+  const Int_t kn10=10;
+  const Double_t kti[kn10]={7.443716945e-3,2.166976971e-1,3.397047841e-1,
+                           4.325316833e-1,4.869532643e-1,5.130467358e-1,
+                           5.674683167e-1,6.602952159e-1,7.833023029e-1,
+                           9.255628306e-1};
+  const Double_t kwi[kn10]={1.477621124e-1,1.346333597e-1,1.095431813e-1,
+                           7.472567455e-2,3.333567215e-2,3.333567215e-2,
+                           7.472567455e-2,1.095431813e-1,1.346333597e-1,
+                           1.477621124e-1};
+  const Double_t kBunchLenght = 25e-9; // LHC clock
+  TObjArray *hits = mod->GetHits();
+  Int_t nhits = hits->GetEntriesFast();
+  if (nhits<=0) return;
+  //
+  Int_t h,ix,iz,i;
+  Int_t idtrack;
+  Double_t x0=0.0,x1=0.0,y0=0.0,y1=0.0,z0=0.0,z1=0.0,de=0.0,ld=0.0;
+  Double_t x,y,z,t,st,el,sig,sigx,sigz,fda;
+  Double_t thick = 0.5*kmictocm*fSeg->Dy();  // Half thickness
+  fSimuParam->GetPixUpgSigmaDiffusionAsymmetry(fda);
+  //
+  for (h=0;h<nhits;h++) {
+    // Check if the hit is inside readout window
+    if (fStrobe && 
+       ((mod->GetHit(h)->GetTOF()<fStrobePhase) || 
+        (mod->GetHit(h)->GetTOF()>(fStrobePhase+fStrobeLenght*kBunchLenght)))
+       ) continue;
+    //
+    if (!mod->LineSegmentL(h,x0,x1,y0,y1,z0,z1,de,idtrack)) continue;
+    st = TMath::Sqrt(x1*x1+y1*y1+z1*z1);
+    if (st>0.0) 
+      for (i=0;i<kn10;i++) { // Integrate over t
+       t   = kti[i];
+       x   = x0+x1*t;
+       y   = y0+y1*t;
+       z   = z0+z1*t;
+       if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
+       el  = kwi[i]*de/fSimuParam->GetGeVToCharge();
+       sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
+       sigx=sig;
+       sigz=sig*fda;
+       if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+       SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
+       //                cout << "sigx sigz " << sigx << " " << sigz << endl; // dom
+      } // end for i // End Integrate over t
+    else { // st == 0.0 deposit it at this point
+      x   = x0;
+      y   = y0;
+      z   = z0;
+      if (!(fSeg->LocalToDet(x,z,ix,iz))) continue; // outside
+      el  = de / fSimuParam->GetGeVToCharge();
+      sig = fSimuParam->SigmaDiffusion1D(TMath::Abs(thick + y));
+      sigx=sig;
+      sigz=sig*fda;
+      if (fSimuParam->GetPixUpgLorentzDrift()) ld=(y+thick)*fTanLorAng;
+      SpreadChargeAsym(x,z,ix,iz,el,sigx,sigz,ld,idtrack,h);
+    } // end if st>0.0
+    
+  } // Loop over all hits h
+  
+  // Coupling
+  int nd = fSensMap->GetEntriesUnsorted(); // use unsorted access when possible, since it is faster
+  AliITSUSDigit* dg = 0;
+  switch (fSimuParam->GetPixUpgCouplingOption()) {
+  case AliITSUSimuParam::kNewCouplingPixUpg :
+    for (i=nd;i--;) {
+      dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
+      if (fSensMap->IsDisabled(dg)) continue;
+      SetCoupling(dg,idtrack,h);
+    } 
+  case AliITSUSimuParam::kOldCouplingPixUpg:
+    for (i=nd;i--;) {
+      dg = (AliITSUSDigit*)fSensMap->AtUnsorted(i);
+      if (fSensMap->IsDisabled(dg)) continue;
+      SetCouplingOld(dg,idtrack,h);
+    } 
+    break;
+  default:
+    break;
+  } // end switch
+  if (GetDebug(2))Info("Hits2SDigits","Finished fCoupling=%d",fSimuParam->GetPixUpgCouplingOption());
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::SpreadCharge(Double_t x0,Double_t z0,
+                                         Int_t ix0,Int_t iz0,
+                                         Double_t el,Double_t sig,Double_t ld,
+                                         Int_t t,Int_t hi)
+{
+   // Spreads the charge over neighboring cells. Assume charge is distributed
+   // as charge(x,z) = (el/2*pi*sig*sig)*exp(-arg)
+   // arg=((x-x0)*(x-x0)/2*sig*sig)+((z-z0*z-z0)/2*sig*sig)
+   // if fSimuParam->GetPixUpgLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
+   // Defined this way, the integral over all x and z is el.
+   // Inputs:
+   //    Double_t x0   x position of point where charge is liberated
+   //    Double_t z0   z position of point where charge is liberated
+   //    Int_t    ix0  row of cell corresponding to point x0
+   //    Int_t    iz0  columb of cell corresponding to point z0
+   //    Double_t el   number of electrons liberated in this step
+   //    Double_t sig  Sigma difusion for this step (y0 dependent)
+   //    Double_t ld   lorentz drift in x for this step (y0 dependent)
+   //    Int_t    t    track number
+   //    Int_t    ti   hit track index number
+   //    Int_t    hi   hit "hit" index number
+   // Outputs:
+   //     none.
+   // Return:
+   //     none.
+   const Int_t knx = 3,knz = 2;
+   const Double_t kRoot2 = 1.414213562; // Sqrt(2).
+   const Double_t kmictocm = 1.0e-4; // convert microns to cm.
+   Int_t ix,iz,ixs,ixe,izs,ize;
+   Float_t x,z;
+   Double_t x1,x2,z1,z2,s,sp;
+   //
+   if (GetDebug(4)) Info("SpreadCharge","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sig,t,hi);
+   if (sig<=0.0) { // if sig<=0 No diffusion to simulate.
+     UpdateMapSignal(iz0,ix0,t,hi,el);
+     if (GetDebug(2)) cout << "sig<=0.0=" << sig << endl; // end if GetDebug
+     return;
+   } // end if
+   sp = 1.0/(sig*kRoot2);
+   if (GetDebug(2)) cout << "sig=" << sig << " sp=" << sp << endl; // end if GetDebug
+   ixs = TMath::Max(-knx+ix0,0);
+   ixe = TMath::Min(knx+ix0,fSeg->Npx()-1);
+   izs = TMath::Max(-knz+iz0,0);
+   ize = TMath::Min(knz+iz0,fSeg->Npz()-1);
+   for (ix=ixs;ix<=ixe;ix++) 
+     for (iz=izs;iz<=ize;iz++) {
+       fSeg->DetToLocal(ix,iz,x,z); // pixel center
+       x1  = x;
+       z1  = z;
+       x2  = x1 + 0.5*kmictocm*fSeg->Dpx(ix); // Upper
+       x1 -= 0.5*kmictocm*fSeg->Dpx(ix);  // Lower
+       z2  = z1 + 0.5*kmictocm*fSeg->Dpz(iz); // Upper
+       z1 -= 0.5*kmictocm*fSeg->Dpz(iz);  // Lower
+       x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+       x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+       z1 -= z0; // Distance from where track traveled
+       z2 -= z0; // Distance from where track traveled
+       s   = 0.25; // Correction based on definision of Erfc
+       s  *= AliMathBase::ErfcFast(sp*x1) - AliMathBase::ErfcFast(sp*x2);
+       if (GetDebug(3)) {
+        cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<
+          " iz0="<<iz0<<" iz="<<iz<<" z0="<<z<< 
+          " sp*x1="<<sp*x1<<" sp*x2="<<sp*x2<<" s="<<s;
+       } // end if GetDebug
+       s  *= AliMathBase::ErfcFast(sp*z1) - AliMathBase::ErfcFast(sp*z2);
+       if (GetDebug(3)) cout<<" sp*z1="<<sp*z1<<" sp*z2="<<sp*z2<<" s="<<s<< endl; // end if GetDebug
+       UpdateMapSignal(iz,ix,t,hi,s*el);
+     } // end for ix, iz
+   //
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::SpreadChargeAsym(Double_t x0,Double_t z0,
+                                             Int_t ix0,Int_t iz0,
+                                             Double_t el,Double_t sigx,Double_t sigz,
+                                             Double_t ld,Int_t t,Int_t hi)
+{
+  // Spreads the charge over neighboring cells. Assume charge is distributed
+  // as charge(x,z) = (el/2*pi*sigx*sigz)*exp(-arg)
+  // arg=((x-x0)*(x-x0)/2*sigx*sigx)+((z-z0*z-z0)/2*sigz*sigz)
+  // if fSimuParam->GetPixUpgLorentzDrift()=kTRUE, then x0=x0+ld (Lorentz drift taken into account)
+  // Defined this way, the integral over all x and z is el.
+  // Inputs:
+  //    Double_t x0   x position of point where charge is liberated
+  //    Double_t z0   z position of point where charge is liberated
+  //    Int_t    ix0  row of cell corresponding to point x0
+  //    Int_t    iz0  columb of cell corresponding to point z0
+  //    Double_t el   number of electrons liberated in this step
+  //    Double_t sigx Sigma difusion along x for this step (y0 dependent)
+  //    Double_t sigz Sigma difusion along z for this step (y0 dependent)
+  //    Double_t ld   lorentz drift in x for this stip (y0 dependent)
+  //    Int_t    t    track number
+  //    Int_t    ti   hit track index number
+  //    Int_t    hi   hit "hit" index number
+  // Outputs:
+  //     none.
+  // Return:
+  //     none.
+  const Int_t knx = 3,knz = 2;
+  const Double_t kRoot2 = 1.414213562; // Sqrt(2).
+  const Double_t kmictocm = 1.0e-4; // convert microns to cm.
+  Int_t ix,iz,ixs,ixe,izs,ize;
+  Float_t x,z;
+  Double_t x1,x2,z1,z2,s,spx,spz;
+  //
+  if (GetDebug(4)) Info("SpreadChargeAsym","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sigx=%e, sigz=%e, t=%d,i=%d)",x0,z0,ix0,iz0,el,sigx,sigz,t,hi);
+  if (sigx<=0.0 || sigz<=0.0) { // if sig<=0 No diffusion to simulate.
+    UpdateMapSignal(iz0,ix0,t,hi,el);
+    if (GetDebug(2)) {
+      cout << "sigx<=0.0=" << sigx << endl;
+      cout << "sigz<=0.0=" << sigz << endl;
+    } // end if GetDebug
+    return;
+  } // end if
+  spx = 1.0/(sigx*kRoot2);     
+  spz = 1.0/(sigz*kRoot2);
+  if (GetDebug(2)) {
+    cout << "sigx=" << sigx << " spx=" << spx << endl;
+    cout << "sigz=" << sigz << " spz=" << spz << endl;
+  } // end if GetDebug
+  ixs = TMath::Max(-knx+ix0,0);
+  ixe = TMath::Min(knx+ix0,fSeg->Npx()-1);
+  izs = TMath::Max(-knz+iz0,0);
+  ize = TMath::Min(knz+iz0,fSeg->Npz()-1);
+  for (ix=ixs;ix<=ixe;ix++) 
+    for (iz=izs;iz<=ize;iz++) {
+      fSeg->DetToLocal(ix,iz,x,z); // pixel center
+      x1  = x;
+      z1  = z;
+      x2  = x1 + 0.5*kmictocm*fSeg->Dpx(ix); // Upper
+      x1 -= 0.5*kmictocm*fSeg->Dpx(ix);  // Lower
+      z2  = z1 + 0.5*kmictocm*fSeg->Dpz(iz); // Upper
+      z1 -= 0.5*kmictocm*fSeg->Dpz(iz);  // Lower
+      x1 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+      x2 -= x0+ld; // Distance from where track traveled (taking into account the Lorentz drift)
+      z1 -= z0; // Distance from where track traveled
+      z2 -= z0; // Distance from where track traveled
+      s   = 0.25; // Correction based on definision of Erfc
+      s  *= AliMathBase::ErfcFast(spx*x1) - AliMathBase::ErfcFast(spx*x2);
+      if (GetDebug(3)) cout <<"el="<<el<<" ix0="<<ix0<<" ix="<<ix<<" x0="<<x<<" iz0="<<iz0<<" iz="<<iz<<" z0="<<z<<" spx*x1="<<spx*x1<<" spx*x2="<<spx*x2<<" s="<<s; // end if GetDebug
+      s  *= AliMathBase::ErfcFast(spz*z1) - AliMathBase::ErfcFast(spz*z2);
+      if (GetDebug(3)) cout<<" spz*z1="<<spz*z1<<" spz*z2="<<spz*z2<<" s="<<s<< endl; // end if GetDebug
+      UpdateMapSignal(iz,ix,t,hi,s*el);
+    } // end for ix, iz
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::RemoveDeadPixels() 
+{
+  // Removes dead pixels on each module (ladder)
+  // This should be called before going from sdigits to digits (FrompListToDigits)
+  
+  AliITSUCalibrationPix* calObj = (AliITSUCalibrationPix*) GetCalibDead();
+  if (!calObj) return;
+  //
+  if (calObj->IsBad()) {ClearMap(); return;} // whole module is masked
+  //
+  // remove single bad pixels one by one
+  int nsingle = calObj->GetNrBadSingle();
+  UInt_t col,row;
+  for (int i=nsingle;i--;) {
+    calObj->GetBadPixelSingle(i,row,col);
+    fSensMap->DeleteItem(col,row);
+  }
+  int nsd = fSensMap->GetEntriesUnsorted();
+  for (int isd=nsd;isd--;) {
+    AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->AtUnsorted(isd);
+    if (fSensMap->IsDisabled(sd)) continue;
+    fSensMap->GetMapIndex(sd->GetUniqueID(),col,row);
+    int chip = fSeg->GetChipFromChannel(0,col);
+    //    if (calObj->IsChipMarkedBad(chip)) fSensMap->Disable(sd); // this will simple mark the hit as bad
+    if (calObj->IsChipMarkedBad(chip)) fSensMap->DeleteItem(sd); // this will suppress hit in the sorted list
+  }
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::AddNoisyPixels() 
+{
+  // Adds noisy pixels on each module (ladder)
+  // This should be called before going from sdigits to digits (FrompListToDigits)
+  AliITSUCalibrationPix* calObj = (AliITSUCalibrationPix*) GetCalibNoisy();
+  if (!calObj) return;
+  for (Int_t i=calObj->GetNrBad(); i--;) UpdateMapNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i), 
+                                                       10*fSimuParam->GetPixUpgThreshold(fModule));
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::FrompListToDigits() 
+{
+  // add noise and electronics, perform the zero suppression and add the
+  // digit to the list
+  static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
+  UInt_t ix,iz;
+  Double_t sig;
+  const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
+  static AliITSUDigitPix dig;
+  // RS: in principle:
+  // 1) for every pixel w/o hit we have to generate a noise and activate the pixel if the noise exceeds the threshold. 
+  // 2) for every pixel with hit we should add random noise and check if the total signal exceeds the threshold
+  // With many channels this will be too time consuming, hence I do the following
+  // 1) Precalculate the probability that the nois alone will exceed the threshold. 
+  // 2) Chose randomly empty pixels according to this probability and apply the noise above threshold.
+  // 3) For pixels having a hits apply the usual noise and compare with threshold
+  //
+  // RS may use for ordered random sample generation dl.acm.org/ft_gateway.cfm?id=356313&type=pdf
+  //
+  int maxInd = fSensMap->GetMaxIndex();
+  double minProb = 0.1/maxInd;
+  //
+  int nsd = fSensMap->GetEntries();
+  Int_t prevID=0,curID=0;
+  TArrayI ordSampleInd(100),ordSample(100);
+  //
+  double probNoisy,noiseSig,noiseMean,thresh = fSimuParam->GetPixUpgThreshold(fModule);
+  fSimuParam->GetPixUpgNoise(fModule, noiseSig, noiseMean);
+  probNoisy = AliITSUSimuParam::CalcProbNoiseOverThreshold(noiseMean,noiseSig,thresh); // prob. to have noise above threshold
+  //
+  for (int i=0;i<nsd;i++) {
+    AliITSUSDigit* sd = (AliITSUSDigit*)fSensMap->At(i); // ordered in index
+    if (fSensMap->IsDisabled(sd)) continue;
+    curID = (int)sd->GetUniqueID();
+    //
+    if (probNoisy>minProb) { // generate randomly noisy pixels above the threshold, with ID's between previous hit and current
+      CreateNoisyDigits(prevID,curID,probNoisy, noiseSig, noiseMean);
+      prevID = curID+1;
+    }
+    //
+    if ((sig=sd->GetSumSignal())<=fSimuParam->GetPixUpgThreshold(fModule)) continue;
+    if (TMath::Abs(sig)>2147483647.0) { //RS?
+      //PH 2147483647 is the max. integer
+      //PH This apparently is a problem which needs investigation
+      AliWarning(Form("Too big or too small signal value %f",sig));
+    }
+    fSensMap->GetMapIndex(sd->GetUniqueID(),iz,ix);
+    dig.SetCoord1(iz);
+    dig.SetCoord2(ix);
+    dig.SetSignal(1);
+    dig.SetSignalPix((Int_t)sig);
+    int ntr = sd->GetNTracks();
+    for (int j=0;j<ntr;j++) {
+      dig.SetTrack(j,sd->GetTrack(j));
+      dig.SetHit(j,sd->GetHit(j));
+    }
+    for (int j=ntr;j<knmaxtrk;j++) {
+      dig.SetTrack(j,-3);
+      dig.SetHit(j,-1);
+    }
+    aliITS->AddSimDigit(AliITSUGeomTGeo::kDetTypePixUpg, &dig);
+  }
+  // if needed, add noisy pixels with id from last real hit to maxID
+  if (probNoisy>minProb) CreateNoisyDigits(prevID,maxInd,probNoisy, noiseSig, noiseMean);
+  // 
+}
+
+//______________________________________________________________________
+Int_t AliITSUSimulationPix::CreateNoisyDigits(Int_t minID,Int_t maxID,double probNoisy, double noise, double base)
+{
+  // create random noisy digits above threshold within id range [minID,maxID[
+  // see FrompListToDigits for details
+  //
+  static AliITSU *aliITS = (AliITSU*)gAlice->GetModule("ITS");
+  UInt_t ix,iz;
+  static AliITSUDigitPix dig;
+  static TArrayI ordSampleInd(100),ordSample(100); //RS!!! static is not thread-safe!!!
+  const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
+  //
+  Int_t ncand = 0;
+  int npix = maxID-minID;
+  if (npix<1 || (ncand=gRandom->Poisson(npix*probNoisy))<1) return ncand; // decide how many noisy pixels will be added
+  ncand = GenOrderedSample(npix,ncand,ordSample,ordSampleInd); 
+  int* ordV = ordSample.GetArray();
+  int* ordI = ordSampleInd.GetArray();
+  for (int j=0;j<ncand;j++) {
+    fSensMap->GetMapIndex((UInt_t)ordV[ordI[j]],iz,ix);   // create noisy digit
+    dig.SetCoord1(iz);
+    dig.SetCoord2(ix);
+    dig.SetSignal(1);
+    dig.SetSignalPix((Int_t)AliITSUSimuParam::GenerateNoiseQFunction(probNoisy,base,noise));
+    for (int k=knmaxtrk;k--;) {
+      dig.SetTrack(k,-3);
+      dig.SetHit(k,-1);
+    }
+    aliITS->AddSimDigit(AliITSUGeomTGeo::kDetTypePixUpg,&dig);
+    AliInfo(Form("Add noisy pixel %d(%d/%d) Noise=%d",ordV[ordI[j]],iz,ix,dig.GetSignalPix()));
+  }
+  return ncand;
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::SetCoupling(AliITSUSDigit* old, Int_t ntrack, Int_t idhit) 
+{
+  //  Take into account the coupling between adiacent pixels.
+  //  The parameters probcol and probrow are the probability of the
+  //  signal in one pixel shared in the two adjacent pixels along
+  //  the column and row direction, respectively.
+  //  Note pList is goten via GetMap() and module is not need any more.
+  //  Otherwise it is identical to that coded by Tiziano Virgili (BSN).
+  //Begin_Html
+  /*
+    <img src="picts/ITS/barimodel_3.gif">
+     </pre>
+     <br clear=left>
+     <font size=+2 color=red>
+     <a href="mailto:tiziano.virgili@cern.ch"></a>.
+     </font>
+     <pre>
+   */
+   //End_Html
+   // Inputs:
+  // old                  existing AliITSUSDigit
+  // Int_t ntrack         track incex number
+  // Int_t idhit          hit index number
+  UInt_t col,row;
+  Double_t pulse1,pulse2;
+  Double_t couplR=0.0,couplC=0.0;
+  Double_t xr=0.;
+  //
+  fSensMap->GetMapIndex(old->GetUniqueID(),col,row);
+  fSimuParam->GetPixUpgCouplingParam(couplC,couplR);
+  if (GetDebug(3)) Info("SetCoupling","(col=%d,row=%d,ntrack=%d,idhit=%d) "
+                       "Calling SetCoupling couplC=%e couplR=%e",
+                       col,row,ntrack,idhit,couplC,couplR);
+  pulse2 = pulse1 = old->GetSignal();
+  for (Int_t isign=-1;isign<=1;isign+=2) {
+    //
+    // loop in col direction
+    int j1 = int(col) + isign;
+    xr = gRandom->Rndm();
+    if ( !((j1<0) || (j1>fSeg->Npz()-1) || (xr>couplC)) ) UpdateMapSignal(UInt_t(j1),row,ntrack,idhit,pulse1);
+    //
+    // loop in row direction
+    int j2 = int(row) + isign;
+    xr = gRandom->Rndm();
+    if ( !((j2<0) || (j2>fSeg->Npx()-1) || (xr>couplR)) ) UpdateMapSignal(col,UInt_t(j2),ntrack,idhit,pulse2);
+  } 
+  //
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::SetCouplingOld(AliITSUSDigit* old, Int_t ntrack,Int_t idhit) 
+{
+  //  Take into account the coupling between adiacent pixels.
+  //  The parameters probcol and probrow are the fractions of the
+  //  signal in one pixel shared in the two adjacent pixels along
+  //  the column and row direction, respectively.
+  //Begin_Html
+  /*
+    <img src="picts/ITS/barimodel_3.gif">
+    </pre>
+    <br clear=left>
+    <font size=+2 color=red>
+    <a href="mailto:Rocco.Caliandro@ba.infn.it"></a>.
+    </font>
+    <pre>
+  */
+  //End_Html
+  // Inputs:
+  // old            existing AliITSUSDigit
+  // ntrack         track incex number
+  // idhit          hit index number
+  // module         module number
+  //
+  UInt_t col,row;
+  Double_t pulse1,pulse2;
+  Double_t couplR=0.0,couplC=0.0;
+  //
+  fSensMap->GetMapIndex(old->GetUniqueID(),col,row);
+  fSimuParam->GetPixUpgCouplingParam(couplC,couplR);
+  if (GetDebug(3)) Info("SetCouplingOld","(col=%d,row=%d,ntrack=%d,idhit=%d) "
+                        "Calling SetCoupling couplC=%e couplR=%e",
+                        col,row,ntrack,idhit,couplC,couplR);
+  //
+  for (Int_t isign=-1;isign<=1;isign+=2) {// loop in col direction
+    pulse2 = pulse1 = old->GetSignal();
+    //
+    int j1 = int(col)+isign;
+    pulse1 *= couplC;
+    if ((j1<0)||(j1>fSeg->Npz()-1)||(pulse1<fSimuParam->GetPixUpgThreshold(fModule))) pulse1 = old->GetSignal();
+    else UpdateMapSignal(UInt_t(j1),row,ntrack,idhit,pulse1);
+
+    // loop in row direction
+    int j2 = int(row) + isign;
+    pulse2 *= couplR;
+    if ((j2<0)||(j2>(fSeg->Npx()-1))||(pulse2<fSimuParam->GetPixUpgThreshold(fModule))) pulse2 = old->GetSignal();
+    else UpdateMapSignal(col,UInt_t(j2),ntrack,idhit,pulse2);
+  } // for isign
+}
+
+//______________________________________________________________________
+void AliITSUSimulationPix::GenerateStrobePhase()
+{
+  // Generate randomly the strobe
+  // phase w.r.t to the LHC clock
+  // Done once per event
+  const Double_t kBunchLenght = 25e-9; // LHC clock
+  fStrobePhase = ((Double_t)gRandom->Integer(fStrobeLenght))*kBunchLenght-
+    (Double_t)fStrobeLenght*kBunchLenght+
+    kBunchLenght/2;
+}
+
diff --git a/ITS/UPGRADE/AliITSUSimulationPix.h b/ITS/UPGRADE/AliITSUSimulationPix.h
new file mode 100644 (file)
index 0000000..b84b81c
--- /dev/null
@@ -0,0 +1,66 @@
+#ifndef ALIITSUSIMULATIONPIX_H
+#define ALIITSUSIMULATIONPIX_H
+
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////////////////
+// Simulation class for upgrade pixels                    //
+////////////////////////////////////////////////////////////
+
+#include "TObjArray.h"
+#include "AliITSUSimulation.h"
+#include "AliITSUSegmentationPix.h"
+
+class TH1F;
+class AliITSUModule;
+class AliITSUSimuParam;
+
+//-------------------------------------------------------------------
+
+class AliITSUSimulationPix : public AliITSUSimulation {
+public:
+  AliITSUSimulationPix();
+  AliITSUSimulationPix(AliITSUSimuParam* sim,AliITSUSensMap* map);
+  virtual ~AliITSUSimulationPix();
+  AliITSUSimulationPix(const AliITSUSimulationPix &source); 
+  AliITSUSimulationPix& operator=(const AliITSUSimulationPix &s);
+  void Init();
+  //
+  void FinishSDigitiseModule();
+  void DigitiseModule(AliITSUModule *mod,Int_t mask, Int_t event, AliITSsegmentation* seg);
+  //
+  void SDigitiseModule(AliITSUModule *mod, Int_t mask, Int_t event, AliITSsegmentation* seg);
+  void WriteSDigits();
+  void Hits2SDigits(AliITSUModule *mod);
+  void Hits2SDigitsFast(AliITSUModule *mod);
+  void AddNoisyPixels();   
+  void RemoveDeadPixels();
+  void FrompListToDigits();
+  Int_t CreateNoisyDigits(Int_t minID,Int_t maxID,double probNoisy, double noise, double base);
+  Bool_t SetTanLorAngle(Double_t WeightHole=1.0);
+  Double_t GetTanLorAngle() const {return fTanLorAng;};
+  //
+  // For backwards compatibility
+  void SDigitsToDigits(){ FinishSDigitiseModule();}
+  
+  // This sets fStrobe flag and allows generating the strobe and applying it to select hits 
+  void SetStrobeGeneration(Bool_t b=kFALSE) {fStrobe=b;};
+  void GenerateStrobePhase();
+  //
+  
+ private:
+  void SpreadCharge(Double_t x0,Double_t z0,Int_t ix0,Int_t iz0,Double_t el,Double_t sig,Double_t ld,Int_t t,Int_t hi);
+  void SpreadChargeAsym(Double_t x0,Double_t z0,Int_t ix0,Int_t iz0,Double_t el,Double_t sigx,Double_t sigz,Double_t ld,Int_t t,Int_t hi);
+  //
+  void SetCoupling(AliITSUSDigit* old,Int_t ntrack,Int_t idhit);     // "New" coupling routine  Tiziano Virgili
+  void SetCouplingOld(AliITSUSDigit* old,Int_t ntrack,Int_t idhit);  // "Old" coupling routine  Rocco Caliandro
+  //   
+ protected:
+   Double_t      fTanLorAng;    //! Tangent of the Lorentz Angle (weighted average for hole and electrons)
+   Bool_t        fStrobe;       // kTRUE if readout strobe with proper phase applied to select hits
+   Int_t         fStrobeLenght; // Strobe signal lenght in units of 25 ns
+   Double_t      fStrobePhase;  // The phase of the strobe signal with respect to the trigger
+   ClassDef(AliITSUSimulationPix,1)  // Simulation of pixel clusters
+ };
+#endif 
diff --git a/ITS/UPGRADE/AliITSUpg.cxx b/ITS/UPGRADE/AliITSUpg.cxx
deleted file mode 100644 (file)
index 1325c7d..0000000
+++ /dev/null
@@ -1,1393 +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: AliITSUpg.cxx $ */
-
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//      An overview of the basic philosophy of the ITS code development      //
-// and analysis is show in the figure below.                                 //
-//Begin_Html                                                                 //
-/*                                               
-<img src="picts/ITS/ITS_Analysis_schema.gif">
-</pre>
-<br clear=left>
-<font size=+2 color=red>
-<p>Roberto Barbera is in charge of the ITS Offline code (1999).
-<a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
-</font>
-<pre>
-*/
-//End_Html
-//
-//  AliITSUpg. Inner Traking System base class.
-//  This class contains the base procedures for the Inner Tracking System
-//
-//Begin_Html
-/*
-<img src="picts/ITS/AliITS_Class_Diagram.gif">
-</pre>
-<br clear=left>
-<font size=+2 color=red>
-<p>This show the class diagram of the different elements that are part of
-the AliITS class.
-</font>
-<pre>
-*/
-//End_Html
-//
-// Version: 0
-// Written by Rene Brun, Federico Carminati, and Roberto Barbera
-//
-// Version: 1
-// Modified and documented by Bjorn S. Nilsen
-// July 11 1999
-//
-// Version: 2
-// Modified and documented by A. Bologna
-// October 18 1999
-//
-// AliITSUpg is the general base class for the ITS. Also see AliDetector for
-// futher information.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <stdlib.h>
-#include <TClonesArray.h>
-#include <TFile.h>
-#include <TParticle.h>
-#include <TString.h>
-#include <TTree.h>
-#include <TVirtualMC.h>
-#include "AliDetector.h"
-#include "AliITSUpg.h"
-#include "AliITSDetTypeSim.h"
-#include "AliITSDDLRawData.h"
-#include "AliITSLoader.h"
-#include "AliITSLoaderUpg.h"
-#include "AliITShit.h"
-#include "AliITSmodule.h"
-#include "AliITSpListItem.h"
-#include "AliITSsimulation.h"
-#include "AliITSsimulationFastPoints.h"
-#include "AliMC.h"
-#include "AliITSDigitizer.h"
-#include "AliITSRecPoint.h"
-#include "AliITSsegmentationSPD.h"
-#include "AliITSsegmentationSDD.h"
-#include "AliITSsimulationSDD.h"
-#include "AliITSCalibrationSDD.h"
-#include "AliITSCalibrationSSD.h"
-#include "AliITSsegmentationSSD.h"
-#include "AliITSRawStreamSPD.h"
-#include "AliITSRawStreamSSD.h"
-#include "AliITSRawStreamSDD.h"
-#include "AliRawReader.h"
-#include "AliRun.h"
-#include "AliLog.h"
-#include "AliITSInitGeometryUpg.h"
-#include "AliITSFOSignalsSPD.h"
-
-ClassImp(AliITSUpg)
-
-//______________________________________________________________________
-AliITSUpg::AliITSUpg() : AliDetector(),
-fDetTypeSim(0),
-fEuclidOut(0),
-fOpt("All"),
-fIdN(0),
-fIdSens(0),
-fIdName(0),
-fITSmodules(0),
-fTiming(kFALSE),
-fSimuParam(0),
-fModA(0),
-fpSDigits(0)
-{
-  // Default initializer for ITS
-  //      The default constructor of the AliITS class. In addition to
-  // creating the AliITS class it zeros the variables fIshunt (a member
-  // of AliDetector class), fEuclidOut, and fIdN, and zeros the pointers
-  // fIdSens, and fIdName. The AliDetector default constructor
-  // is also called.
-  
-//    SetDetectors(); // default to fOpt="All". This variable not written out.
-//PH    SetMarkerColor(kRed);
-}
-//______________________________________________________________________
-AliITSUpg::AliITSUpg(const Char_t *title):
-  AliDetector("ITS",title),
-  fDetTypeSim(0),
-  fEuclidOut(0),
-  fOpt("All"),
-  fIdN(0),
-  fIdSens(0),
-  fIdName(0),
-  fITSmodules(0),
-  fTiming(kFALSE),
-  fSimuParam(0),
-  fModA(0),
-  fpSDigits(0)
-{
-    //     The standard Constructor for the ITS class. 
-    // It also zeros the variables
-    // fIshunt (a member of AliDetector class), fEuclidOut, and zeros
-    // the pointers fIdSens and fIdName. To help in displaying hits via the
-    // ROOT macro display.C AliITS also sets the marker color to red. The
-    // variables passes with this constructor, const char *name and *title,
-    // are used by the constructor of AliDetector class. See AliDetector
-    // class for a description of these parameters and its constructor
-    // functions.
-    // Inputs:
-    //   Char_t *title  Simulation title for the ITS
-    // Outputs:
-    //   none.
-    // Return:
-    //   none.
-  
-    fHits = new TClonesArray("AliITShit",1560); // from AliDetector
-    if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
-    //fNhits=0;  //done in AliDetector(name,title)
-    SetDetectors(); // default to fOpt="All". This variable not written out.
-    fDetTypeSim   = new AliITSDetTypeSim();
-    //PH  SetMarkerColor(kRed);
-    if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
-    fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-}
-//______________________________________________________________________
-AliITSUpg::AliITSUpg(const char *name, const char *title):
-  AliDetector(name,title),
-  fDetTypeSim(0),
-  fEuclidOut(0),
-  fOpt("All"),
-  fIdN(0),
-  fIdSens(0),
-  fIdName(0),
-  fITSmodules(0),
-  fTiming(kFALSE),
-  fSimuParam(0),
-  fModA(0),
-  fpSDigits(0)
-{
-  //     The standard Constructor for the ITS class. 
-  // It also zeros the variables
-  // fIshunt (a member of AliDetector class), fEuclidOut, and zeros
-  // the pointers fIdSens and fIdName. To help in displaying hits via the
-  // ROOT macro display.C AliITS also sets the marker color to red. The
-  // variables passes with this constructor, const char *name and *title,
-  // are used by the constructor of AliDetector class. See AliDetector
-  // class for a description of these parameters and its constructor
-  // functions.
-  
-  fHits = new TClonesArray("AliITShit",1560);
-  if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
-  //fNhits=0;  //done in AliDetector(name,title)
-
-  SetDetectors(); // default to fOpt="All". This variable not written out.
-    
-  fDetTypeSim   = new AliITSDetTypeSim();
-  //PH  SetMarkerColor(kRed);
-  if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-
-}
-//______________________________________________________________________
-AliITSUpg::~AliITSUpg(){
-    // Default destructor for ITS.
-    //     The default destructor of the AliITS class. In addition to deleting
-    // the AliITS class it deletes the memory pointed to by 
-    // fIdSens, fIdName, fDetTypeSim and it's contents.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-    if (fHits) {
-      fHits->Delete();
-      delete fHits;
-      fHits=0;
-    }
-    if(fITSmodules) {
-        this->ClearModules();
-        delete fITSmodules;
-       fITSmodules = 0;
-    }// end if fITSmodules!=0
-
-    delete[] fIdName;  // Array of TStrings
-    delete[] fIdSens;
-    Int_t size   = AliITSgeomTGeo::GetNModules();
-    if (fDetTypeSim){
-      delete fDetTypeSim;
-      fDetTypeSim = 0;
-    }
-    if(fSimuParam){
-      delete fSimuParam;
-      fSimuParam=0;
-    }
-    if(fModA){
-      if(size>0){
-       for(Int_t j=0; j<size; j++){
-         fModA[j]->Delete();
-         delete fModA[j];
-       }
-      }
-      delete []fModA;
-    }
-    if(fpSDigits){
-      fpSDigits->Delete();
-      delete fpSDigits;
-    }
-}
-
-//______________________________________________________________________
-AliDigitizer* AliITSUpg::CreateDigitizer(AliDigitizationInput* manager)const{
-    // Creates the AliITSDigitizer in a standard way for use via AliModule.
-    // This function can not be included in the .h file because of problems
-    // with the order of inclusion (recursive).
-    // Inputs:
-    //    AliDigitizationInput *manager  The Manger class for Digitization
-    // Output:
-    //    none.
-    // Return:
-    //    A new AliITSRunDigitizer (cast as a AliDigitizer).
-
-     return new AliITSDigitizer(manager);
-}
-//______________________________________________________________________
-void AliITSUpg::Init(){
-    // Initializer ITS after it has been built
-    //     This routine initializes the AliITS class. It is intended to be
-    // called from the Init function in AliITSv?. Besides displaying a banner
-    // indicating that it has been called it initializes the array fIdSens
-    // and sets the default segmentation, response, digit and raw cluster
-    // classes therefore it should be called after a call to CreateGeometry.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-    Int_t i;
-    // Array of TStrings
-    if(gMC) for(i=0;i<fIdN;i++) fIdSens[i] = gMC->VolId(fIdName[i]);
-}
-//______________________________________________________________________
-void AliITSUpg::SetDefaults(){
-    // sets the default segmentation, response, digit and raw cluster classes.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-    AliInfoClass("AliITSUpg::Setting Defaults");
-    if(!fDetTypeSim) { 
-     Error("SetDefaults()","fDetTypeSim is 0!"); 
-     return;
-    }
-
-    fDetTypeSim->SetDefaults();
-    if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-}
-//______________________________________________________________________
-void AliITSUpg::SetDefaultSimulation(){
-    // sets the default simulation.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-    if(!fDetTypeSim) { 
-     Error("SetDefaultSimulation()","fDetTypeSim is 0!"); 
-     return;
-    }
-
-    fDetTypeSim->SetDefaultSimulation();
-    if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-}
-
-
-//______________________________________________________________________
-void AliITSUpg::MakeBranch(Option_t* option){
-    // Creates Tree branches for the ITS.
-    // Inputs:
-    //      Option_t *option    String of Tree types S,D, and/or R.
-    //      const char *file    String of the file name where these branches
-    //                          are to be stored. If blank then these branches
-    //                          are written to the same tree as the Hits were
-    //                          read from.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-  if(!fDetTypeSim) {
-    Error("MakeBranch","fDetTypeSim is 0!");
-    return;
-  }
-
-  Bool_t cH = (strstr(option,"H")!=0);
-  Bool_t cS = (strstr(option,"S")!=0);
-  Bool_t cD = (strstr(option,"D")!=0);
-  
-  if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITShit", 1560);
-  AliDetector::MakeBranch(option);
-  
-  if(cS) MakeBranchS(0);
-  if(cD) MakeBranchD(0);
-
-
-}
-//___________________________________________________________________
-void AliITSUpg::MakeBranchS(const char* fl){
-
-  // Creates Tree Branch for the ITS summable digits.
-  // Inputs:
-  //      cont char *fl  File name where SDigits branch is to be written
-  //                     to. If blank it write the SDigits to the same
-  //                     file in which the Hits were found.
-
-  
-  if(!fDetTypeSim){
-    Error("MakeBranchS","fDetTypeSim is 0!");
-  }
-  Int_t buffersize = 4000;
-  char branchname[31];
-
-  // only one branch for SDigits.
-  snprintf(branchname,30,"%s",GetName());
-
-  if(fLoader->TreeS()){
-    TClonesArray* sdig = (TClonesArray*)fDetTypeSim->GetSDigits();
-    MakeBranchInTree(fLoader->TreeS(),branchname,&sdig,buffersize,fl);
-  } 
-}
-//______________________________________________________________________
-void AliITSUpg::MakeBranchD(const char* file){
-
-  //Make branch for digits
-  if(!fDetTypeSim) {
-    Warning("MakeBranchD","fDetTypeSim is 0!");
-    return;
-  }
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  MakeBranchInTreeD(fLoader->TreeD(),file);
-}
-
-//___________________________________________________________________
-void AliITSUpg:: MakeBranchInTreeD(TTree* treeD, const char* file){
-  // Creates Tree branches for the ITS.
-
-  if(!fDetTypeSim){
-    Error("MakeBranchS","fDetTypeSim is 0!");
-  }
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-  const Char_t *det[3] = {"SPD","SDD","SSD"};
-  const Char_t* digclass;
-  Int_t buffersize = 4000;
-  Char_t branchname[31];
-  
-  if(!fDetTypeSim->GetDigits()){
-    fDetTypeSim->SetDigits(new TObjArray(fgkNTYPES));
-  }
-  for(Int_t i=0;i<fgkNTYPES;i++){
-    digclass = fDetTypeSim->GetDigitClassName(i);
-    TString classn = digclass;
-    if(!((fDetTypeSim->GetDigits())->At(i))){
-      (fDetTypeSim->GetDigits())->AddAt(new TClonesArray(classn.Data(),1000),i);
-    }
-    else ResetDigits(i);  
-    if(fgkNTYPES==3) snprintf(branchname,30,"%sDigits%s",GetName(),det[i]);
-    else sprintf(branchname,"%sDigits%d",GetName(),i+1);
-    TObjArray* dig = DigitsAddress(i);
-    if(GetDigits() && treeD) AliDetector::MakeBranchInTree(treeD,branchname, &dig,buffersize,file);
-  }
-
-}
-//______________________________________________________________________
-void AliITSUpg::SetTreeAddress(){
-    // Set branch address for the Trees.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-    
-  if(!fDetTypeSim) {
-    Error("SetTreeAddress","fDetTypeSim is 0!");
-    return;
-  }
-
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-  TTree *treeS = fLoader->TreeS();
-  TTree *treeD = fLoader->TreeD();
-  if (fLoader->TreeH() && (fHits == 0x0)) {
-      fHits = new TClonesArray("AliITShit", 1560);
-  }
-  AliDetector::SetTreeAddress();
-
-  fDetTypeSim->SetTreeAddressS(treeS, (Char_t*)GetName());
-  fDetTypeSim->SetTreeAddressD(treeD, (Char_t*)GetName());
-}
-//______________________________________________________________________
-void AliITSUpg::AddHit(Int_t track, Int_t *vol, Float_t *hits){
-    // Add an ITS hit
-    //     The function to add information to the AliITShit class. See the
-    // AliITShit class for a full description. This function allocates the
-    // necessary new space for the hit information and passes the variable
-    // track, and the pointers *vol and *hits to the AliITShit constructor
-    // function.
-    // Inputs:
-    //      Int_t   track   Track number which produced this hit.
-    //      Int_t   *vol    Array of Integer Hit information. See AliITShit.h
-    //      Float_t *hits   Array of Floating Hit information.  see AliITShit.h
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-  TClonesArray &lhits = *fHits;
-  new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
-}
-
-//______________________________________________________________________
-void AliITSUpg::FillModules(Int_t /* evnt */,Int_t bgrev,Int_t /* nmodules */,
-                         Option_t *option, const char *filename){
-  // fill the modules with the sorted by module hits; add hits from
-  // background if option=Add.
-
-  static TTree *trH1;                 //Tree with background hits
-  static Bool_t first=kTRUE;
-  static TFile *file;
-  const char *addBgr = strstr(option,"Add");
-  
-  if (addBgr ) {
-    if(first) {
-      file=new TFile(filename);
-    } // end if first
-    first=kFALSE;
-    file->cd();
-    file->ls();
-    // Get Hits Tree header from file
-    if(trH1) delete trH1;
-    trH1=0;
-    
-    char treeName[21];
-    snprintf(treeName,20,"TreeH%d",bgrev);
-    trH1 = (TTree*)gDirectory->Get(treeName);
-    if (!trH1) {
-      Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
-    } // end if !trH1
-    // Set branch addresses
-  } // end if addBgr
-  
-  FillModules(fLoader->TreeH(),0); // fill from this file's tree.
-    
-  if (addBgr ) {
-    FillModules(trH1,10000000); // Default mask 10M.
-    TTree *fAli=fLoader->GetRunLoader()->TreeK();
-    TFile *fileAli=0;
-    if (fAli) {
-      fileAli =fAli->GetCurrentFile();
-      fileAli->cd();
-    }
-  } // end if add
-  
-  
-}
-//______________________________________________________________________
-void AliITSUpg::FillModules(TTree *treeH, Int_t mask) {
-    // fill the modules with the sorted by module hits; 
-    // can be called many times to do a merging
-    // Inputs:
-    //      TTree *treeH  The tree containing the hits to be copied into
-    //                    the modules.
-    //      Int_t mask    The track number mask to indecate which file
-    //                    this hits came from.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-    if (treeH == 0x0)
-     {
-       AliError("Tree H  is NULL");
-       return;
-     }
-    Int_t lay,lad,det,index;
-    AliITShit *itsHit=0;
-    AliITSmodule *mod=0;
-    char branchname[21];
-    snprintf(branchname,20,"%s",GetName());
-    TBranch *branch = treeH->GetBranch(branchname);
-    if (!branch) {
-        Error("FillModules","%s branch in TreeH not found",branchname);
-        return;
-    } // end if !branch
-    branch->SetAddress(&fHits);
-    Int_t nTracks =(Int_t) treeH->GetEntries();
-    Int_t iPrimTrack,h;
-    for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
-        ResetHits();
-        Int_t nBytes = treeH->GetEvent(iPrimTrack);
-        if (nBytes <= 0) continue;
-        Int_t nHits = fHits->GetEntriesFast();
-        for(h=0; h<nHits; h++){
-            itsHit = (AliITShit *)fHits->UncheckedAt(h);
-            itsHit->GetDetectorID(lay,lad,det);
-            if (GetITSgeom()) {
-                index = GetITSgeom()->GetModuleIndex(lay,lad,det);
-            } else {
-                index=det-1; // This should not be used.
-            } // end if [You must have fITSgeom for this to work!]
-            mod = GetModule(index);
-            itsHit->SetTrack(itsHit->GetTrack()+mask); // Set track mask.
-            mod->AddHit(itsHit,iPrimTrack,h);
-        } // end loop over hits 
-    } // end loop over tracks
-}
-
-//______________________________________________________________________
-Bool_t AliITSUpg::InitModules(Int_t size,Int_t &nmodules){
-    // Initialize the modules array.
-    // Inputs:
-    //      Int_t size  Size of array of the number of modules to be
-    //                  created. If size <=0 then the number of modules
-    //                  is gotten from AliITSgeom class kept in fITSgeom.
-    // Outputs:
-    //      Int_t &nmodules The number of modules existing.
-    // Return:
-    //      none.
-
-    if(fITSmodules){ 
-        fITSmodules->Delete();
-        delete fITSmodules;
-    } // end fir fITSmoudles
-
-    if(!fDetTypeSim) {
-      Error("InitModules","fDetTypeSim is null!");
-      return kFALSE;
-    }
-    if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-    Int_t nl,indexMAX,index;
-
-    if(size<=0){ // default to using data stored in AliITSgeom
-        if(fDetTypeSim->GetITSgeom()==0) {
-            Error("InitModules","fITSgeom not defined");
-            return kFALSE;
-        } // end if fITSgeom==0
-        nl = fDetTypeSim->GetITSgeom()->GetNlayers();
-        indexMAX = fDetTypeSim->GetITSgeom()->GetIndexMax();
-        nmodules = indexMAX;
-        fITSmodules = new TObjArray(indexMAX);
-        for(index=0;index<indexMAX;index++){
-            fITSmodules->AddAt( new AliITSmodule(index),index);
-        } // end for index
-    }else{
-        fITSmodules = new TObjArray(size);
-        for(index=0;index<size;index++) {
-            fITSmodules->AddAt( new AliITSmodule(index),index);
-        } // end for index
-
-        nmodules = size;
-    } // end i size<=0
-    return kTRUE;
-}
-//______________________________________________________________________
-void AliITSUpg::Hits2SDigits(){
-    // Standard Hits to summable Digits function.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-  
-
-   if(!fDetTypeSim) {
-     Error("Hits2SDigits","fDetTypeSim is null!");
-     return; 
-  } 
-     
-  SetDefaults();
-  fLoader->LoadHits("read");
-  fLoader->LoadSDigits("recreate");
-  AliRunLoader* rl = fLoader->GetRunLoader(); 
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-  for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
-        // Do the Hits to Digits operation. Use Standard input values.
-        // Event number from file, no background hit merging , use size from
-        // AliITSgeom class, option="All", input from this file only.
-    rl->GetEvent(iEvent);
-    if (!fLoader->TreeS()) fLoader->MakeTree("S");
-    MakeBranch("S");
-    SetTreeAddress();
-    HitsToPreDigits(iEvent,0,-1," ",fOpt," ");
-  } // end for iEvent
-    
-  fLoader->UnloadHits();
-  fLoader->UnloadSDigits();
-  
-}
-//______________________________________________________________________
-void AliITSUpg::Hits2Digits(){
-
-  //Conversion from hits to digits
-  if(!fDetTypeSim) {
-    Error("Hits2SDigits","fDetTypeSim is 0!");
-    return;
-  }
-   
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  SetDefaults();
-
-  fLoader->LoadHits("read");
-  fLoader->LoadDigits("recreate");
-  AliRunLoader* rl = fLoader->GetRunLoader(); 
-  for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
-    rl->GetEvent(iEvent);
-    if (!fLoader->TreeD()) fLoader->MakeTree("D");
-    MakeBranch("D");
-    SetTreeAddress();   
-    HitsToDigits(iEvent,0,-1," ",fOpt," ");
-  } 
-  
-  fLoader->UnloadHits();
-  fLoader->UnloadDigits();
-  
-}
-
-//______________________________________________________________________
-void AliITSUpg::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
-                          Option_t *option,Option_t *opt,
-                          const char *filename){
-    //   Keep galice.root for signal and name differently the file for 
-    // background when add! otherwise the track info for signal will be lost !
-    // the condition below will disappear when the geom class will be
-    // initialized for all versions - for the moment it is only for v5 !
-    // 7 is the SDD beam test version.
-    // Inputs:
-    //      Int_t evnt       Event to be processed.
-    //      Int_t bgrev      Background Hit tree number.
-    //      Int_t nmodules   Not used.
-    //      Option_t *option String indicating if merging hits or not. To
-    //                       merge hits set equal to "Add". Otherwise no
-    //                       background hits are considered.
-    //      Test_t *filename File name containing the background hits..
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-  if(!fDetTypeSim) {
-    Error("HitsToDigits","fDetTypeSim is null!");
-    return;
-  }
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  if(!GetITSgeom()) return; // need transformations to do digitization.
-  AliITSgeom *geom = GetITSgeom();
-
-  const char *all = strstr(opt,"All");
-  const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
-                       strstr(opt,"SSD")};
-  static Bool_t setDef=kTRUE;
-  if (setDef) SetDefaultSimulation();
-  setDef=kFALSE;
-  
-  Int_t nmodules;
-  InitModules(size,nmodules);
-  FillModules(evNumber,bgrev,nmodules,option,filename);
-  // Reset Fast-OR signals for this event
-//  fDetTypeSim->ResetFOSignals();
-
-  AliITSsimulation *sim      = 0;
-  AliITSmodule     *mod      = 0;
-  Int_t id;
-  for(Int_t module=0;module<geom->GetIndexMax();module++){
-    id       = geom->GetModuleType(module);
-    if (!all && !det[id]) continue;
-    sim      = (AliITSsimulation*)fDetTypeSim->GetSimulationModel(id);
-    if (!sim) {
-      Error("HitsToDigits","The simulation class was not "
-           "instanciated for module %d type %s!",module,
-           geom->GetModuleTypeName(module));
-      exit(1);
-    } // end if !sim
-    mod      = (AliITSmodule *)fITSmodules->At(module);
-    sim->DigitiseModule(mod,module,evNumber);
-    // fills all branches - wasted disk space
-    fLoader->TreeD()->Fill(); 
-    ResetDigits();
-  } // end for module
-  
-  ClearModules();
-  // Add Fast-OR signals to event (only one object per event)
-  if (all || det[0]) { // SPD present
-    WriteFOSignals();
-  }
-  
-  fLoader->TreeD()->GetEntries();
-  fLoader->TreeD()->AutoSave();
-  // reset tree
-  fLoader->TreeD()->Reset();
-}
-//_____________________________________________________________________
-void AliITSUpg::Hits2PreDigits(){ 
-  // Turn hits into SDigits
-
-  if(!fDetTypeSim) {
-    Error("Hits2SDigits","fDetTypeSim is 0!");
-    return;
-  }
-   
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  SetDefaults();
-  
-  HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
-                 0,-1," ",fOpt," ");
-}
-
-//______________________________________________________________________
-void AliITSUpg::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
-                             Option_t *option,Option_t *opt,
-                             const char *filename){
-    //   Keep galice.root for signal and name differently the file for 
-    // background when add! otherwise the track info for signal will be lost !
-    // the condition below will disappear when the geom class will be
-    // initialized for all versions - for the moment it is only for v5 !
-    // 7 is the SDD beam test version.
-    // Inputs:
-    //      Int_t evnt       Event to be processed.
-    //      Int_t bgrev      Background Hit tree number.
-    //      Int_t nmodules   Not used.
-    //      Option_t *option String indicating if merging hits or not. To
-    //                       merge hits set equal to "Add". Otherwise no
-    //                       background hits are considered.
-    //      Test_t *filename File name containing the background hits..
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-  if(!fDetTypeSim) {
-    Error("HitsToPreDigits","fDetTypeSim is null!");
-    return;
-  }
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-
-  if(!GetITSgeom()){
-    Error("HitsToPreDigits","fGeom is null!");
-    return; // need transformations to do digitization.
-  }
-  AliITSgeom *geom = GetITSgeom();
-
-  const char *all = strstr(opt,"All");
-  const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
-                       strstr(opt,"SSD")};
-  static Bool_t setDef=kTRUE;
-  if (setDef) SetDefaultSimulation();
-  setDef=kFALSE;
-  
-  Int_t nmodules;
-  InitModules(size,nmodules);
-  FillModules(evNumber,bgrev,nmodules,option,filename);
-  
-
-  AliITSsimulation *sim      = 0;
-  AliITSmodule     *mod      = 0;
-  Int_t id,module;
-  for(module=0;module<geom->GetIndexMax();module++){
-    id       = geom->GetModuleType(module);
-    if (!all && !det[id]) continue;
-    sim      = (AliITSsimulation*)GetSimulationModel(id);
-    if (!sim) {
-      Error("HitsToPreDigits","The simulation class was not "
-           "instanciated for module %d type %s!",module,
-           geom->GetModuleTypeName(module));
-      exit(1);
-    } // end if !sim
-    mod      = (AliITSmodule *)fITSmodules->At(module);
-    sim->SDigitiseModule(mod,module,evNumber);
-    // fills all branches - wasted disk space
-    fLoader->TreeS()->Fill(); 
-    fDetTypeSim->ResetSDigits();
-  } // end for module
-
-  ClearModules();
-
-  
-  fLoader->TreeS()->GetEntries();
-  fLoader->TreeS()->AutoSave();
-  fLoader->WriteSDigits("OVERWRITE");
-  // reset tree
-  fLoader->TreeS()->Reset();
-}
-
-//_____________________________________________________________________
-void AliITSUpg::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
-                                  Option_t *opt0,Option_t *opt1,
-                                 const char *flnm){
-    // keep galice.root for signal and name differently the file for 
-    // background when add! otherwise the track info for signal will be lost !
-    // the condition below will disappear when the geom class will be
-    // initialized for all versions - for the moment it is only for v5 !
-    // Inputs:
-    //      Int_t evnt       Event to be processed.
-    //      Int_t bgrev      Background Hit tree number.
-    //      Int_t size       Size used by InitModules. See InitModules.
-    //      Option_t *opt0   Option passed to FillModules. See FillModules.
-    //      Option_t *opt1   String indicating if merging hits or not. To
-    //                       merge hits set equal to "Add". Otherwise no
-    //                       background hits are considered.
-    //      Test_t *flnm     File name containing the background hits..
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-
-
-  if(!GetITSgeom()){
-    Error("HitsToPreDigits","fGeom is null!");
-    return; // need transformations to do digitization.
-  }
-  AliITSgeom *geom = GetITSgeom();
-
-  AliITSLoaderUpg *pITSloader = (AliITSLoaderUpg*)fLoader;
-
-  const char *all = strstr(opt1,"All");
-  const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
-                      strstr(opt1,"SSD")};
-  Int_t nmodules;
-  InitModules(size,nmodules);
-  FillModules(evNumber,bgrev,nmodules,opt0,flnm);
-
-  AliITSsimulation *sim      = 0;
-  AliITSmodule     *mod      = 0;
-  Int_t id,module;
-
-  TTree *lTR = pITSloader->TreeR();
-  if(!lTR) {
-    pITSloader->MakeTree("R");
-    lTR = pITSloader->TreeR();
-  }
-  
-  TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
-  TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
-  branch->SetAddress(&ptarray);
-  //m.b. : this change is nothing but a nice way to make sure
-  //the CPU goes up !    
-  for(module=0;module<geom->GetIndexMax();module++){
-    id       = geom->GetModuleType(module);
-    if (!all && !det[id]) continue;
-    sim      = (AliITSsimulation*)GetSimulationModel(id);
-    if (!sim) {
-      Error("HitsToFastPoints","The simulation class was not "
-           "instantiated for module %d type %s!",module,
-           geom->GetModuleTypeName(module));
-      exit(1);
-    } // end if !sim
-    mod      = (AliITSmodule *)fITSmodules->At(module);
-    sim->CreateFastRecPoints(mod,module,gRandom,ptarray);
-    lTR->Fill();
-    ptarray->Clear();
-  } // end for module
-
-  ClearModules();
-  fLoader->WriteRecPoints("OVERWRITE");
-  delete ptarray;
-}
-//_____________________________________________________________________
-Int_t AliITSUpg::Hits2Clusters(TTree *hTree, TTree *cTree) {
-  //------------------------------------------------------------
-  // This function creates ITS clusters
-  //------------------------------------------------------------
-  if(!GetITSgeom()){
-    Error("HitsToPreDigits","fGeom is null!");
-    return 1; // need transformations to do digitization.
-  }
-  AliITSgeom *geom=GetITSgeom();
-  Int_t mmax=geom->GetIndexMax();
-
-  InitModules(-1,mmax);
-  FillModules(hTree,0);
-
-  TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
-  TBranch *branch=cTree->GetBranch("ITSRecPoints");
-  if (!branch) cTree->Branch("ITSRecPoints",&points);
-  else branch->SetAddress(&points);
-
-  AliITSsimulationFastPoints sim;
-  Int_t ncl=0;
-  for (Int_t m=0; m<mmax; m++) {
-    AliITSmodule *mod=GetModule(m);      
-    sim.CreateFastRecPoints(mod,m,gRandom,points);      
-    ncl+=points->GetEntriesFast();
-    cTree->Fill();
-    points->Clear();
-  }
-
-  AliDebug(1,Form("Number of found fast clusters : %d",ncl));
-
-  //cTree->Write();
-
-  delete points;
-  return 0;
-}
-
-//_____________________________________________________________________
-void AliITSUpg::CheckLabels(Int_t lab[3]) const {
-  //------------------------------------------------------------
-  // Tries to find mother's labels
-  //------------------------------------------------------------
-
-  if(lab[0]<0 && lab[1]<0 && lab[2]<0) return; // In case of no labels just exit
-
-  Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
-  for (Int_t i=0;i<3;i++){
-    Int_t label = lab[i];
-    if (label>=0 && label<ntracks) {
-      TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
-      if (part->P() < 0.005) {
-       Int_t m=part->GetFirstMother();
-       if (m<0) {      
-         continue;
-       }
-       if (part->GetStatusCode()>0) {
-         continue;
-       }
-       lab[i]=m;       
-      }
-    }    
-  }
-  
-}
-
-//______________________________________________________________________
-void AliITSUpg::SDigitsToDigits(Option_t *opt){
-  // Standard Summable digits to Digits function.
-  // Inputs:
-  //      none.
-  // Outputs:
-  //      none.
-  if (!fDetTypeSim) {
-    AliError("fDetTypeSim is 0!");
-    return;
-  }
-  const char *all = strstr(opt,"All");
-  const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),
-                      strstr(opt,"SSD")};
-
-  // Reset Fast-OR signals for this event
-//  fDetTypeSim->ResetFOSignals();
-
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  SetDefaults();
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  fDetTypeSim->SDigitsToDigits(opt,(Char_t*)GetName());
-
-  // Add Fast-OR signals to event (only one object per event)
-  if (all || det[0]) { // SPD present
-   WriteFOSignals();
-  }
-}
-
-//______________________________________________________________________
-void AliITSUpg::ResetDigits(){
-    // Reset number of digits and the digits array for the ITS detector.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-    if(!fDetTypeSim) {
-      Error("ResetDigits","fDetTypeSim is 0!");
-      return;
-    }
-   
-    fDetTypeSim->ResetDigits();
-
-
-}
-//______________________________________________________________________
-void AliITSUpg::ResetDigits(Int_t branch){
-    // Reset number of digits and the digits array for this branch.
-    // Inputs:
-    //      none.
-    // Outputs:
-    //      none.
-
-    if(!fDetTypeSim) {
-      Error("ResetDigits","fDetTypeSim is 0!");
-      return;
-    }
-   
-    fDetTypeSim->ResetDigits(branch);
-
-}
-//______________________________________________________________________
-void AliITSUpg::AddSumDigit(AliITSpListItem &sdig){
-    // Adds the a module full of summable digits to the summable digits tree.
-    // Inputs:
-    //      AliITSpListItem &sdig   SDigit to be added to SDigits tree.
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-    if(!fDetTypeSim) {
-      Error("AddSumDigit","fDetTypeSim is 0!");
-      return;
-    }
-    fDetTypeSim->AddSumDigit(sdig);
-    
-}
-//______________________________________________________________________
-void AliITSUpg::AddSimDigit(Int_t branch, AliITSdigit *d){
-    //    Add a simulated digit.
-    // Inputs:
-    //      Int_t id        Detector type number.
-    //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
-    //                      AliITSdigit.h
-    // Outputs:
-    //      none.
-    // Return:
-    //      none.
-
-    if(!fDetTypeSim) {
-      Error("AddSimDigit","fDetTypeSim is 0!");
-      return;
-    }
-    fDetTypeSim->AddSimDigit(branch,d);
-
-}
-//______________________________________________________________________
-void AliITSUpg::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
-                         Int_t *hits,Float_t *charges, Int_t sigexpanded){
-  //   Add a simulated digit to the list.
-  // Inputs:
-  //      Int_t id        Detector type number.
-  //      Float_t phys    Physics indicator. See AliITSdigits.h
-  //      Int_t *digits   Integer array containing the digits info. See 
-  //                      AliITSdigit.h
-  //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
-  //                      containing the track numbers that contributed to
-  //                      this digit.
-  //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
-  //                      containing the hit numbers, from AliITSmodule, that
-  //                      contributed to this digit.
-  //      Float_t *charge Floating point array of the signals contributed
-  //                      to this digit by each track.
-  // Outputs:
-  //      none.
-  // Return:
-  //      none.
-
-    if(!fDetTypeSim) {
-      Error("AddSimDigit","fDetTypeSim is 0!");
-      return;
-    }
-    fDetTypeSim->AddSimDigit(branch,phys,digits,tracks,hits,charges,sigexpanded);
-
-}
-//______________________________________________________________________
-void AliITSUpg::Digits2Raw(){
-    // convert digits of the current event to raw data
-
-  if(!fDetTypeSim) {
-    Error("Digits2Raw","fDetTypeSim is 0!");
-    return;
-  }
-  fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-  SetDefaults();
-  if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
-  fDetTypeSim->GetLoader()->LoadDigits();
-  TTree* digits = fDetTypeSim->GetLoader()->TreeD();
-  if (!digits) {
-      Error("Digits2Raw", "no digits tree");
-      return;
-  }
-  fDetTypeSim->SetTreeAddressD(digits,(Char_t*)GetName());
-  
-   // Get the FO signals for this event
-  AliITSFOSignalsSPD* foSignals = NULL;
-  AliRunLoader* runLoader = AliRunLoader::Instance();
-  AliITSLoaderUpg* itsLoader = (AliITSLoaderUpg*) runLoader->GetLoader("ITSLoader");
-  if (!itsLoader) {
-    AliError("ITS loader is NULL.");
-  }
-   else {
-      if(!itsLoader->TreeD()) AliError("   !!! No TreeD available !!!");
-      foSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
-      if(!foSignals) AliError("FO signals not retrieved");
-     }
-  Bool_t deleteFOsignalsLater = kFALSE;
-  if (!foSignals) {
-    AliError("FO signals not available. No FO bits will be written.");
-    foSignals = new AliITSFOSignalsSPD(); // make a temporary dummy signals object
-    deleteFOsignalsLater = kTRUE;
-  }
-  
-  
-//  AliITSDDLModuleMapSDD* ddlsdd=fDetTypeSim->GetDDLModuleMapSDD();
-  Char_t rawSDD=fDetTypeSim->GetSimuParam()->GetSDDRawDataFormat();
-  AliITSDDLRawData rawWriter;
-  
-  rawWriter.SetSDDRawFormat(rawSDD);
-  //Verbose level
-  // 0: Silent
-  // 1: cout messages
-  // 2: txt files with digits 
-  //BE CAREFUL, verbose level 2 MUST be used only for debugging and
-  //it is highly suggested to use this mode only for debugging digits files
-  //reasonably small, because otherwise the size of the txt files can reach
-  //quickly several MB wasting time and disk space.
-  rawWriter.SetVerbose(0);
-    
-  //SILICON PIXEL DETECTOR
-  AliDebug(1,"Formatting raw data for SPD");
-  rawWriter.RawDataSPD(digits->GetBranch("ITSDigitsSPD"),foSignals);
-  if(deleteFOsignalsLater) delete foSignals;
-    
-  //SILICON DRIFT DETECTOR
-  AliDebug(1,Form("Formatting raw data for SDD - Format code =%d",rawSDD));
-//  rawWriter.RawDataSDD(digits->GetBranch("ITSDigitsSDD"),ddlsdd);
-    
-  //SILICON STRIP DETECTOR
-  AliDebug(1,"Formatting raw data for SSD");
-  rawWriter.RawDataSSD(digits->GetBranch("ITSDigitsSSD"));
-
-  fLoader->UnloadDigits();
-}
-//______________________________________________________________________
-AliLoader* AliITSUpg::MakeLoader(const char* topfoldername){ 
-    //builds ITSgetter (AliLoader type)
-    //if detector wants to use castomized getter, it must overload this method
-
-    AliDebug(1,Form("Creating AliITSLoaderUpg. Top folder is %s.",
-         topfoldername));
-    fLoader = new AliITSLoaderUpg(GetName(),topfoldername);
-    return fLoader;
-}
-//______________________________________________________________________
-Bool_t AliITSUpg::Raw2SDigits(AliRawReader* rawReader)
-{
-  //
-  // Converts RAW data to SDigits
-  //
-  // Get TreeS
-  //
-  Int_t last   = -1;
-  Int_t size   = AliITSgeomTGeo::GetNModules();
-  if(!fModA) {
-    fModA = new TClonesArray*[size];
-    for (Int_t mod = 0; mod < size; mod++) fModA[mod] = new TClonesArray("AliITSpListItem", 10000);
-  }
-  AliLoader* loader =  (AliRunLoader::Instance())->GetLoader("ITSLoader");
-  if (!loader){
-    Error("Open","Can not get ITS loader from Run Loader");
-    return kFALSE;
-  }
-
-  TTree* tree = 0;
-  tree = loader->TreeS();
-  if (!tree){
-    loader->MakeTree("S");
-    tree = loader->TreeS();
-  }
-  //
-  // Array for SDigits
-  // 
-  if(!fpSDigits){
-    fpSDigits = new TClonesArray("AliITSpListItem",10000);
-  }
-  TClonesArray& aSDigits = *fpSDigits;
-  Int_t bufsize = 32000;
-  tree->Branch("ITS", &fpSDigits, bufsize);
-  Int_t npx = 0;
-  //
-  // SPD
-  //
-  AliITSsegmentationSPD* segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
-  if(!segSPD){
-    AliWarning("Set AliITS defaults");
-    SetDefaults();
-    segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
-  }
-  npx = segSPD->Npx();
-  Double_t thr, sigma; 
-    
-  AliITSRawStreamSPD inputSPD(rawReader);
-  while(1){
-    Bool_t next  = inputSPD.Next();
-    if (!next) break;
-
-    Int_t module = inputSPD.GetModuleID();
-    Int_t column = inputSPD.GetColumn();
-    Int_t row    = inputSPD.GetRow();
-    Int_t index  = npx * column + row;
-
-    if (module >= size) continue;
-    last = (fModA[module])->GetEntries();
-    TClonesArray& dum = *fModA[module];
-    fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
-    thr += 1.;
-    new (dum[last]) AliITSpListItem(-1, -1, module, index, thr);
-  }
-  rawReader->Reset();
-
-  //
-  // SDD
-  // 
-  AliITSsegmentationSDD* segSDD = (AliITSsegmentationSDD*) fDetTypeSim->GetSegmentationModel(1);
-  npx = segSDD->Npx();
-  Int_t scalef=AliITSsimulationSDD::ScaleFourier(segSDD);
-  Int_t firstSDD=AliITSgeomTGeo::GetModuleIndex(3,1,1);
-  Int_t firstSSD=AliITSgeomTGeo::GetModuleIndex(5,1,1);
-
-  AliITSRawStream* inputSDD=AliITSRawStreamSDD::CreateRawStreamSDD(rawReader);
-  for(Int_t iMod=firstSDD; iMod<firstSSD; iMod++){
-    AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)fDetTypeSim->GetCalibrationModel(iMod);
-    Bool_t isZeroSupp=cal->GetZeroSupp();
-    if(isZeroSupp){ 
-      for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,cal->GetZSLowThreshold(iSid));
-    }else{
-      for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,0);
-    }
-  }
-
-//  AliITSDDLModuleMapSDD* ddlmap=fDetTypeSim->GetDDLModuleMapSDD();
-//  inputSDD->SetDDLModuleMap(ddlmap);
-  while(inputSDD->Next()){
-    if(inputSDD->IsCompletedModule()==kFALSE && 
-       inputSDD->IsCompletedDDL()==kFALSE){
-
-      Int_t module = inputSDD->GetModuleID();
-      Int_t anode  = inputSDD->GetCoord1()+segSDD->NpzHalf()*inputSDD->GetChannel();
-      Int_t time   = inputSDD->GetCoord2();
-      Int_t signal10 = inputSDD->GetSignal();
-      Int_t index = AliITSpList::GetIndex(anode,time,scalef*npx);
-
-      if (module >= size) continue;
-      last = fModA[module]->GetEntries();
-      TClonesArray& dum = *fModA[module];
-      new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal10));
-      ((AliITSpListItem*) dum.At(last))->AddSignalAfterElect(module, index, Double_t(signal10));
-    }
-  }
-  delete inputSDD;
-  rawReader->Reset();
-    
-  //
-  // SSD
-  // 
-  AliITSsegmentationSSD* segSSD = (AliITSsegmentationSSD*) fDetTypeSim->GetSegmentationModel(2);
-  npx = segSSD->Npx();
-  AliITSRawStreamSSD inputSSD(rawReader);
-  while(1){
-    Bool_t next  = inputSSD.Next();
-    if (!next) break;
-
-    Int_t module  = inputSSD.GetModuleID();
-    if(module<0)AliError(Form("Invalid SSD  module %d \n",module));
-    if(module<0)continue;
-    Int_t side    = inputSSD.GetSideFlag();
-    Int_t strip   = inputSSD.GetStrip();
-    Int_t signal  = inputSSD.GetSignal();
-    Int_t index  = npx * side + strip;
-
-    if (module >= size) continue;
-       
-    last = fModA[module]->GetEntries();
-    TClonesArray& dum = *fModA[module];
-    new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal));
-  }
-  rawReader->Reset();
-  AliITSpListItem* sdig = 0;
-    
-  Int_t firstssd = GetITSgeom()->GetStartDet(kSSD);
-  Double_t adcToEv = 1.;
-  for (Int_t mod = 0; mod < size; mod++)
-    {
-      if(mod>=firstssd) {
-       AliITSCalibrationSSD* calssd = (AliITSCalibrationSSD*)fDetTypeSim->GetCalibrationModel(mod);
-       adcToEv = 1./calssd->GetSSDDEvToADC(1.);
-      }
-      Int_t nsdig =  fModA[mod]->GetEntries();
-      for (Int_t ie = 0; ie < nsdig; ie++) {
-       sdig = (AliITSpListItem*) (fModA[mod]->At(ie));
-       Double_t digsig = sdig->GetSignal();
-       if(mod>=firstssd) digsig*=adcToEv; // for SSD: convert back charge from ADC to electron
-       new (aSDigits[ie]) AliITSpListItem(-1, -1, mod, sdig->GetIndex(), digsig);
-       Float_t sig = sdig->GetSignalAfterElect();
-       if(mod>=firstssd) sig*=adcToEv;
-       if (sig > 0.) {
-         sdig = (AliITSpListItem*)aSDigits[ie];
-         sdig->AddSignalAfterElect(mod, sdig->GetIndex(), Double_t(sig));
-       }
-      }
-       
-      tree->Fill();
-      aSDigits.Clear();
-      fModA[mod]->Clear();
-    }
-  loader->WriteSDigits("OVERWRITE");    
-  return kTRUE;
-}
-
-//______________________________________________________________________
-void AliITSUpg::UpdateInternalGeometry(){
-  //reads new geometry from TGeo 
-//   AliDebug(1,"Delete ITSgeom and create a new one reading TGeo");
-
-  AliITSVersion_t version = (AliITSVersion_t)IsVersion();
-  Int_t minor = 0;
-  AliITSInitGeometryUpg initgeom;
-  AliITSgeom* geom = initgeom.CreateAliITSgeom(version,minor);
-  SetITSgeom(geom);
-}
-//______________________________________________________________________
-AliTriggerDetector* AliITSUpg::CreateTriggerDetector() const {
-  // create an AliITSTrigger object (and set trigger conditions as input)
-  return new AliITSTrigger(fDetTypeSim->GetTriggerConditions());
-}
-//______________________________________________________________________
-void AliITSUpg::WriteFOSignals(){
-// This method write FO signals in Digits tree both in Hits2Digits
-// or SDigits2Digits
-
-//  fDetTypeSim->ProcessNoiseForFastOr();
-  fDetTypeSim->WriteFOSignals();
-}
diff --git a/ITS/UPGRADE/AliITSUpg.h b/ITS/UPGRADE/AliITSUpg.h
deleted file mode 100644 (file)
index 464b14e..0000000
+++ /dev/null
@@ -1,175 +0,0 @@
-#ifndef ALIITSUPG_H
-#define ALIITSUPG_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id: AliITSUpg.h */
-
-////////////////////////////////////////////////////////////////////////
-//           Manager class for set: ITS Upgrade                       //
-////////////////////////////////////////////////////////////////////////
-
-
-#include <TObjArray.h> // used in inline function GetModule.
-#include "AliDetector.h"
-#include "AliITSTrigger.h"
-#include "AliITSDetTypeSim.h"
-
-
-class TString;
-class TTree;
-class AliITSpListItem;
-class AliITSsimulation;
-class AliITSsegmentation;
-
-class AliITSCalibration;
-class AliITShit;
-class AliITSgeom;
-class AliITSdigit;
-class AliITSmodule;
-class AliDigitizationInput;
-
-
-class AliITSUpg : public AliDetector {
-
- public:
-    //================= Standard Classes ===============================
-    AliITSUpg();  // Default creator.
-    AliITSUpg(const Char_t *title); // standard Creator
-    AliITSUpg(const char *name, const char *title); // extended standard Creator
-    virtual ~AliITSUpg(); // destructor
-    virtual Int_t IsVersion() const {return 11;}
-
-    //===================== Simulation Geometry ========================
-    // get geometry version - detailed (major) or coarse (minor)
-    virtual Int_t GetMajorVersion() const {return -1;}
-    virtual Int_t GetMinorVersion() const {return -1;}
-    virtual void  GetGeometryVersion(Int_t &a,Int_t &b) const
-                          {a = GetMajorVersion();b=GetMinorVersion();return;}
-    virtual void  SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
-    virtual Bool_t GetEUCLID()const {return fEuclidOut;}
-    //-------------------- Geometry Transformations --------------------
-
-    // ITS geometry functions From Simulation
-    AliITSgeom* GetITSgeom() const {return fDetTypeSim->GetITSgeom();}
-    void   SetITSgeom(AliITSgeom *geom) {fDetTypeSim->SetITSgeom(geom);}
-    // return pointer to the array of modules
-    TObjArray *GetModules(){return fITSmodules;}
-
-    AliITSmodule *GetModule(Int_t index){
-        return (AliITSmodule*)(fITSmodules->At(index));}
-    virtual void SetSimuParam(AliITSSimuParam *sp){
-      fSimuParam=sp;
-      fDetTypeSim->SetSimuParam(sp);
-    }
-    AliITSSimuParam* GetSimuParam() const {return fSimuParam;}
-
-    virtual void SetDetTypeSim(AliITSDetTypeSim* dts) {fDetTypeSim=dts;}
-    AliITSDetTypeSim* GetDetTypeSim() const {return fDetTypeSim;}
-    //================ Necessary general Classes =======================
-    virtual void Init();
-    virtual AliLoader* MakeLoader(const char* topfoldername);
-    virtual void SetDefaults();
-    virtual void SetDefaultSimulation();
-    virtual void MakeBranch(Option_t *opt=" ");
-    virtual void MakeBranchS(const char* fl);
-    virtual void MakeBranchD(const char* file);
-    virtual void MakeBranchInTreeD(TTree* treeD, const char* file=0);
-    virtual void SetTreeAddress();
-     //---------- Configuration Methods (per detector type) -------------
-    // Determines which ITS subdetectors will be processed. Effects
-    // digitization, and Reconstruction only.
-    void SetDetectors(Option_t *opt="All"){fOpt = opt;}
-    // Returns the list of ITS subdetectors that will be processed.
-    Option_t* GetDetectors(){return fOpt;}
-
-    // Set calibration
-    virtual void SetCalibrationModel(Int_t dettype, AliITSCalibration *cal){
-        fDetTypeSim->SetCalibrationModel(dettype,cal);}
-    // Set segmentation for Simulation
-    virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
-        fDetTypeSim->SetSegmentationModel(id,seg);}
-    // Set simulation 
-    virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
-        fDetTypeSim->SetSimulationModel(id,sim);}
-    // Set simulation 
-    virtual AliITSsimulation* GetSimulationModel(Int_t id){
-       return fDetTypeSim->GetSimulationModel(id);}
-    //=================== Hits =========================================
-    virtual void StepManager() {} // See Step Manager for specific geometry.
-    //------------ sort hits by module for Digitisation ----------------
-    virtual void FillModules(Int_t /* evnt */,Int_t bgrev,Int_t /* nmodules */,
-                            Option_t *opt, const char *filename); 
-    virtual Bool_t InitModules(Int_t size,Int_t &nmodules);  
-    virtual void FillModules(TTree *treeH, Int_t mask = 0);
-    virtual void ClearModules(){if(fITSmodules) fITSmodules->Delete();}
-    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
-   // Trigger
-    virtual AliTriggerDetector* CreateTriggerDetector() const;
-
-    AliDigitizer* CreateDigitizer(AliDigitizationInput* manager) const;
-    virtual void UpdateInternalGeometry();
-    virtual void SDigitsToDigits(Option_t *opt="All");
-    virtual void SDigits2Digits(){SDigitsToDigits("All");}
-    virtual void Hits2Digits(); 
-    virtual void Hits2SDigits();
-    virtual void Hits2PreDigits();
-    virtual void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
-                          Option_t *option,Option_t *opt,
-                          const char *filename);
-    virtual void HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
-                             Option_t *option,Option_t *opt,
-               &n