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.
+++ /dev/null
-/***************************************************************************
- * 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));
- }
-}
+++ /dev/null
-#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
--- /dev/null
+/*
+*/
+
+/**************************************************************************
+ * 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;
+ //
+}
--- /dev/null
+#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
* 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)
{
}
//______________________________________________________________________
-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)
{
}
//______________________________________________________________________
-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;}
}
//____________________________________________________________________________
-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;}
}
//____________________________________________________________________________
-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;
}
//____________________________________________________________________________
-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;
}
//____________________________________________________________________________
-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)
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++;
}
}
//___________________________________________________________________________
-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;
}
//______________________________________________________________________
-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;}
}
//______________________________________________________________________
-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;
-#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();
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!!!
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
* 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
}
//______________________________________________________________________
-AliITSdigitPixUpg::AliITSdigitPixUpg(const Int_t *digits):
+AliITSUDigitPix::AliITSUDigitPix(const Int_t *digits):
fSignalPix(digits[2])
{
// Creates a pixel digit object
}
//______________________________________________________________________
-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])
{
}
//______________________________________________________________________
-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
}
//______________________________________________________________________
-void AliITSdigitPixUpg::Print(ostream *os)
+void AliITSUDigitPix::Print(ostream *os)
{
//Standard output format for this class
Int_t i;
}
//______________________________________________________________________
-void AliITSdigitPixUpg::Read(istream *os)
+void AliITSUDigitPix::Read(istream *os)
{
//Standard input for this class
Int_t i;
}
//______________________________________________________________________
-ostream &operator<<(ostream &os,AliITSdigitPixUpg &source)
+ostream &operator<<(ostream &os,AliITSUDigitPix &source)
{
// Standard output streaming function.
}
//______________________________________________________________________
-istream &operator>>(istream &os,AliITSdigitPixUpg &source)
+istream &operator>>(istream &os,AliITSUDigitPix &source)
{
// Standard output streaming function.
#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);
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
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
**************************************************************************/
///////////////////////////////////////////////////////////////////////////
-// 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 //
// //
// 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;
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;
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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);
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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);
}
//______________________________________________________________________
-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
//
// 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;
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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();
}
//______________________________________________________________________
-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();
}
//______________________________________________________________________
-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();
}
//______________________________________________________________________
-Int_t AliITSgeomTGeoUpg::ExtractLayerDetType(const Int_t lay)
+Int_t AliITSUGeomTGeo::ExtractLayerDetType(Int_t lay) const
{
// Determines the layer detector type the Upgrade Geometry
//
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;
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * 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);
+}
--- /dev/null
+/**************************************************************************
+ * 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);
+}
--- /dev/null
+#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
**************************************************************************/
/*
-$Id: AliITSInitGeometryUpg.cxx $
+$Id: AliITSUInitGeometry.cxx $
*/
////////////////////////////////////////////////////////////////
// This class initializes the class AliITSgeom
#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);
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
SetVersion(kv11,minor);
break;
case kvUpgrade:
- SetGeometryName("AliITSvUpgrade");
+ SetGeometryName("AliITSUv11");
SetVersion(kvUpgrade,minor);
break;
case kvDefault:
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
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).
//______________________________________________________________________
-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.
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.
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;
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};
}
//_______________________________________________________________________
-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
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.
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
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
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
}
//______________________________________________________________________
-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:
}
//______________________________________________________________________
-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:
}
//______________________________________________________________________
-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.
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.
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
}
//______________________________________________________________________
-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
}
//______________________________________________________________________
-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
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);
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));
*/
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
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
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){
return ok;
}
//______________________________________________________________________
-Int_t AliITSInitGeometryUpg::GetNumberOfLayers(){
+Int_t AliITSUInitGeometry::GetNumberOfLayers(){
// Determines the number of layers in the Upgrade Geometry
//
// Inputs:
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++;
}
//______________________________________________________________________
-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:
}
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;
for (Int_t j=0; j<nNodes; j++)
if (strstr(gGeoManager->GetVolume(laynam)->GetNodes()->At(j)->GetName(),
- AliITSgeomTGeoUpg::GetITSLadderPattern()))
+ AliITSUGeomTGeo::GetITSLadderPattern()))
numberOfLadders++;
}
//______________________________________________________________________
-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
//
}
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));
}
//______________________________________________________________________
-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:
}
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;
for (Int_t j=0; j<nNodes; j++)
if (strstr(gGeoManager->GetVolume(laddnam)->GetNodes()->At(j)->GetName(),
- AliITSgeomTGeoUpg::GetITSModulePattern()))
+ AliITSUGeomTGeo::GetITSModulePattern()))
numberOfModules++;
-#ifndef ALIITSINITGEOMETRYUPG_H
-#define ALIITSINITGEOMETRYUPG_H
+#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: AliITSInitGeometryUpg.h $
+$Id: AliITSUInitGeometry.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{
+class AliITSUInitGeometry : public TObject{
public:
- AliITSInitGeometryUpg();//Default Constructor
- AliITSInitGeometryUpg(AliITSVersion_t version,
- Int_t minorversion=2);//Standard Constructor
- //virtual ~AliITSInitGeometryUpg(); // Destructor
+ 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
- // 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;
+ 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;
-
+ 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;
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
+ ClassDef(AliITSUInitGeometry,0) // create/Init AliITSgeom
// 0 in ClassDef indicates that this class will not be "saved" in a file.
};
* 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(
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(
/**********************************************************************/
-AliITSLoaderUpg::~AliITSLoaderUpg(){
+AliITSULoader::~AliITSULoader(){
//destructor
UnloadRawClusters();
AliDataLoader *dl = GetRawClLoader();
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.
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
}
*/
//----------------------------------------------------------------------
-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:
} // 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).
} // 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);
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;
-}
-#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,
// 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();}
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
--- /dev/null
+/**************************************************************************
+ * 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;
+}
+
+
--- /dev/null
+#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
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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");
+}
--- /dev/null
+#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
* 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>
#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,
,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*/,
}
//_____________________________________________________________________________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
}
//_____________________________________________________________________________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
}
//_____________________________________________________________________________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
}
//_____________________________________________________________________________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;
}
//_____________________________________________________________________________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;
}
//______________________________________________________________________RS
-AliITSsegmentationPixUpg& AliITSsegmentationPixUpg::operator=(const AliITSsegmentationPixUpg &src)
+AliITSUSegmentationPix& AliITSUSegmentationPix::operator=(const AliITSUSegmentationPix &src)
{
// = operator
if(this==&src) return *this;
}
//____________________________________________________________________________RS
-AliITSsegmentationPixUpg::AliITSsegmentationPixUpg(const AliITSsegmentationPixUpg &src) :
+AliITSUSegmentationPix::AliITSUSegmentationPix(const AliITSUSegmentationPix &src) :
AliITSsegmentation(src)
,fGuardLft(src.fGuardLft)
,fGuardRgt(src.fGuardRgt)
}
//____________________________________________________________________________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;
}
//------------------------------
-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.
//
}
//______________________________________________________________________
-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.
}
//______________________________________________________________________
-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).
}
//______________________________________________________________________
-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).
}
//______________________________________________________________________
-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 ){
}
//______________________________________________________________________
-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;
}
//______________________________________________________________________
-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
//
}
//______________________________________________________________________
-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;
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;
}
//______________________________________________________________________
-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;
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;
//
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;
+ //
+}
-#ifndef ALIITSSEGMENTATIONPIXUPG_H
-#define ALIITSSEGMENTATIONPIXUPG_H
+#ifndef ALIITSUSEGMENTATIONPIX_H
+#define ALIITSUSEGMENTATIONPIX_H
#include "AliITSsegmentation.h"
// 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();
//
//
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;
//
static const char* fgkSegmListName; // pattern for segmentations list name
//
- ClassDef(AliITSsegmentationPixUpg,1) //Segmentation class upgrade pixels
+ ClassDef(AliITSUSegmentationPix,1) //Segmentation class upgrade pixels
};
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * 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]
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
--- /dev/null
+/*
+ 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;
+}
+
--- /dev/null
+#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
+++ /dev/null
-/**************************************************************************
- * 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();
-}
+++ /dev/null
-#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,
- const char *filename);
- void HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
- Option_t *add, Option_t *det, const char *filename)
- {HitsToPreDigits(evNumber,bgrev,size,add,det,filename);}
-
- virtual void ResetDigits();
- virtual void ResetDigits(Int_t branch);
- virtual void AddSumDigit(AliITSpListItem &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 fDetTypeSim->GetDigits();}
- Int_t* GetNDigitArray() const {return fDetTypeSim->GetNDigitArray();}
- TClonesArray *DigitsAddress(Int_t id) {
- return fDetTypeSim->DigitsAddress(id);}
- //Fast simulation
- virtual void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
- Option_t *add, Option_t *det, 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();
-
- protected:
- static const Int_t fgkNTYPES=3; //number of detector types
- //================== Data Members ==================================
- AliITSDetTypeSim *fDetTypeSim; //detector type for simulation
- Bool_t fEuclidOut; // Flag to write geometry in euclid format
- Option_t *fOpt; //! Detector option ="All" unless changed.
- Int_t fIdN; // the number of layers
- Int_t *fIdSens; //[fIdN] layer identifier
- TString *fIdName; //[fIdN] layer identifier
- TObjArray *fITSmodules; //! Pointer to ITS modules
- Bool_t fTiming; // flag to turn on/off timers.
- AliITSSimuParam* fSimuParam; //simulation parameters
- TClonesArray** fModA; //! Used by Raw2SDigits (one TC per module)
- TClonesArray* fpSDigits; //! Branch address to build SD from raw data
-
- private:
- AliITSUpg(const AliITSUpg &source); // copy constructor. Not to be used!
- AliITSUpg& operator=(const AliITSUpg &source); // = operator. Not to be used!
- ClassDef(AliITSUpg,1) // Base class for ITS
-
-};
-
-#endif
--- /dev/null
+/**************************************************************************
+ * 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: AliITSUv11.cxx */
+
+
+//========================================================================
+//
+// Geometry for the Upgrade of the Inner Tracking System
+//
+// Mario Sitta (sitta@to.infn.it)
+//
+//========================================================================
+
+
+
+// $Log: AliITSUv11.cxx,v $
+
+#include <TClonesArray.h>
+#include <TGeoGlobalMagField.h>
+#include <TGeoManager.h>
+#include <TGeoMatrix.h>
+#include <TGeoPhysicalNode.h>
+#include <TGeoVolume.h>
+#include <TGeoXtru.h>
+#include <TLorentzVector.h>
+#include <TString.h>
+#include <TVirtualMC.h>
+
+#include "AliITSU.h"
+#include "AliITSUHit.h"
+#include "AliLog.h"
+#include "AliMC.h"
+#include "AliMagF.h"
+#include "AliRun.h"
+#include "AliTrackReference.h"
+#include "AliITSv11Geometry.h"
+#include "AliITSUv11Layer.h"
+#include "AliITSv11GeomBeamPipe.h"
+#include "AliITSUv11.h"
+#include "AliITSUGeomTGeo.h"
+#include "AliGeomManager.h"
+
+const Double_t AliITSUv11::fgkBeamPipeHalfZLen = 400;
+
+
+ClassImp(AliITSUv11)
+
+//______________________________________________________________________
+AliITSUv11::AliITSUv11()
+: fLayTurbo(0)
+ ,fLayRadii(0)
+ ,fLayZLength(0)
+ ,fLaddPerLay(0)
+ ,fModPerLadd(0)
+ ,fLadThick(0)
+ ,fLadWidth(0)
+ ,fLadTilt(0)
+ ,fDetThick(0)
+ ,fDetTypeID(0)
+ ,fBeamPipe(0)
+ ,fBeamPipeRmin(0)
+ ,fBeamPipeRmax(0)
+ ,fBeamPipeZlen(0)
+ ,fUpGeom(0)
+ ,fBPGeom(0)
+{
+ // Standard default constructor
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+}
+
+//______________________________________________________________________
+AliITSUv11::AliITSUv11(const char *title,const Int_t nlay)
+ :AliITSU(title,nlay)
+ ,fLayTurbo(0)
+ ,fLayRadii(0)
+ ,fLayZLength(0)
+ ,fLaddPerLay(0)
+ ,fModPerLadd(0)
+ ,fLadThick(0)
+ ,fLadWidth(0)
+ ,fLadTilt(0)
+ ,fDetThick(0)
+ ,fDetTypeID(0)
+ ,fBeamPipe(0)
+ ,fBeamPipeRmin(0)
+ ,fBeamPipeRmax(0)
+ ,fBeamPipeZlen(0)
+ ,fUpGeom(0)
+ ,fBPGeom(0)
+{
+ // Standard constructor for the Upgrade geometry.
+ // Inputs:
+ // const char * name Ignored, set to "ITS"
+ // const char * title Arbitrary title
+ // const Int_t nlay Number of layers
+ //
+ fLayerName = new TString[fNLayers];
+ //
+ for (Int_t j=0; j<fNLayers; j++) fLayerName[j].Form("%s%d",AliITSUGeomTGeo::GetITSSensorPattern(),j+1); // See AliITSUv11Layer
+ //
+ fLayTurbo = new Bool_t[fNLayers];
+ fLayRadii = new Double_t[fNLayers];
+ fLayZLength = new Double_t[fNLayers];
+ fLaddPerLay = new Int_t[fNLayers];
+ fModPerLadd = new Int_t[fNLayers];
+ fLadThick = new Double_t[fNLayers];
+ fLadWidth = new Double_t[fNLayers];
+ fLadTilt = new Double_t[fNLayers];
+ fDetThick = new Double_t[fNLayers];
+ fDetTypeID = new UInt_t[fNLayers];
+
+ fUpGeom = new AliITSUv11Layer*[fNLayers];
+
+ if (fNLayers > 0) { // if not, we'll Fatal-ize in CreateGeometry
+ for (Int_t j=0; j<fNLayers; j++) {
+ fLayRadii[j] = 0.;
+ fLayZLength[j] = 0.;
+ fLaddPerLay[j] = 0;
+ fModPerLadd[j] = 0;
+ fLadWidth[j] = 0.;
+ fDetThick[j] = 0.;
+ fDetTypeID[j] = 0.;
+ fUpGeom[j] = 0;
+ }
+ }
+}
+
+//______________________________________________________________________
+AliITSUv11::~AliITSUv11() {
+ // Standard destructor
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ delete [] fLayTurbo;
+ delete [] fLayRadii;
+ delete [] fLayZLength;
+ delete [] fLaddPerLay;
+ delete [] fModPerLadd;
+ delete [] fLadThick;
+ delete [] fLadWidth;
+ delete [] fLadTilt;
+ delete [] fDetThick;
+ delete [] fDetTypeID;
+ delete [] fUpGeom;
+
+}
+
+//______________________________________________________________________
+void AliITSUv11::SetT2Lmatrix(Int_t uid, Double_t yShift,
+ Bool_t yFlip, Bool_t yRot180) const {
+
+ //
+ // Creates the TGeo Local to Tracking transformation matrix
+ // and sends it to the corresponding TGeoPNEntry
+ //
+ // This function is used in AddAlignableVolumes()
+
+ TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntryByUID(uid);
+ TGeoHMatrix* globMatrix = alignableEntry->GetGlobalOrig();
+
+ Double_t *gtrans = globMatrix->GetTranslation(), rotMatrix[9];
+ memcpy(&rotMatrix[0], globMatrix->GetRotationMatrix(), 9*sizeof(Double_t));
+ Double_t al = TMath::ATan2(rotMatrix[1],rotMatrix[0]);
+ if (yRot180) {
+ al = TMath::ATan2(rotMatrix[1],-rotMatrix[0]);
+ }
+ Double_t xShift = gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al);
+ Double_t zShift = -gtrans[2];
+
+ TGeoHMatrix *matLtoT = new TGeoHMatrix;
+ matLtoT->SetDx( xShift ); // translation
+ matLtoT->SetDy( yShift );
+ matLtoT->SetDz( zShift );
+ rotMatrix[0]= 0; rotMatrix[1]= 1; rotMatrix[2]= 0; // + rotation
+ rotMatrix[3]= 1; rotMatrix[4]= 0; rotMatrix[5]= 0;
+ rotMatrix[6]= 0; rotMatrix[7]= 0; rotMatrix[8]=-1;
+ if (yFlip) rotMatrix[3] = -1; // flipping in y (for SPD1)
+ if (yFlip) rotMatrix[1] = -1; // flipping in y (for SPD1)
+
+ if (yRot180) { // rotation of pi around the axis perpendicular to the wafer
+ if (yFlip) matLtoT->SetDx( -xShift ); // flipping in y (for SPD1)
+ matLtoT->SetDy( -yShift );
+ matLtoT->SetDz( -zShift );
+ rotMatrix[8]=1;
+ rotMatrix[3] = -1;
+ if (yFlip) rotMatrix[3] = 1; // flipping in y (for SPD1)
+ }
+
+ TGeoRotation rot;
+ rot.SetMatrix(rotMatrix);
+ matLtoT->MultiplyLeft(&rot);
+ TGeoHMatrix *matTtoL = new TGeoHMatrix(matLtoT->Inverse());
+ delete matLtoT;
+ alignableEntry->SetMatrix(matTtoL);
+}
+
+//______________________________________________________________________
+void AliITSUv11::AddAlignableVolumes() const{
+ // Creates entries for alignable volumes associating the symbolic volume
+ // name with the corresponding volume path.
+ //
+ // Records in the alignable entries the transformation matrices converting
+ // TGeo local coordinates (in the RS of alignable volumes) to the tracking
+ // system
+ // For this, this function has to run before the misalignment because we
+ // are using the ideal positions in the AliITSgeom object.
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
+ AliInfo("Add ITS alignable volumes");
+
+ if (!gGeoManager) { AliFatal("TGeoManager doesn't exist !"); return; }
+ TString pth,snm;
+ //
+ pth = Form("ALIC_1/%s_2",AliITSUGeomTGeo::GetITSVolPattern());
+ // RS: to be checked with MS
+ if( !gGeoManager->SetAlignableEntry("ITS",pth.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s :: %s","ITS",pth.Data()));
+ //
+ for (int lr=0; lr<fNLayers; lr++) {
+ //
+ pth = Form("ALIC_1/%s_2/%s%d_1",AliITSUGeomTGeo::GetITSVolPattern(),AliITSUGeomTGeo::GetITSLayerPattern(),lr+1);
+ snm = Form("ITS/%s%d",AliITSUGeomTGeo::GetITSLayerPattern(),lr+1);
+ //printf("SetAlignable: %s %s\n",snm.Data(),pth.Data());
+ gGeoManager->SetAlignableEntry(snm.Data(),pth.Data());
+ int modNum = 0;
+ //
+ for (int ld=0; ld<fLaddPerLay[lr]; ld++) {
+ //
+ TString pthL = Form("%s/%s%d_%d",pth.Data(),AliITSUGeomTGeo::GetITSLadderPattern(),lr+1,ld+1);
+ TString snmL = Form("%s/%s%d",snm.Data(),AliITSUGeomTGeo::GetITSLadderPattern(),ld+1);
+ //printf("SetAlignable: %s %s\n",snmL.Data(),pthL.Data());
+ gGeoManager->SetAlignableEntry(snmL.Data(),pthL.Data());
+ //
+ for (int md=0; md<fModPerLadd[lr]; md++) {
+ //
+ TString pthM = Form("%s/%s%d_%d",pthL.Data(),AliITSUGeomTGeo::GetITSModulePattern(),lr+1,md+1);
+ TString snmM = Form("%s/%s%d",snmL.Data(),AliITSUGeomTGeo::GetITSModulePattern(),md+1);
+ //
+ int modUID = AliGeomManager::LayerToVolUID(lr+1,modNum++);
+ //
+ //printf("SetAlignable (UID=%d, ModNum=%d): %s %s\n",modUID,modNum-1,snmM.Data(),pthM.Data());
+ gGeoManager->SetAlignableEntry(snmM.Data(),pthM.Data(),modUID);
+ //
+ double yshift = -(fUpGeom[lr]->GetSensorThick()-fUpGeom[lr]->GetLadderThick())/2;
+ SetT2Lmatrix(modUID,yshift, kTRUE,kTRUE); // RS: do we need here special matrix, ask MS
+ //
+ }
+ }
+ }
+ //
+}
+
+//______________________________________________________________________
+void AliITSUv11::AddBeamPipe(const Double_t rmin, const Double_t rmax,
+ const Double_t halfzlen) {
+
+ // Define the parameters for the beam pipe
+ if (fBeamPipe)
+ AliWarning("Redefining beam pipe parameters");
+
+ if (rmin <= 0) {
+ AliError(Form("Beam pipe min radius (%f) wrong",rmin));
+ return;
+ } else
+ fBeamPipeRmin = rmin;
+
+ if (rmax <= 0) {
+ AliError(Form("Beam pipe max radius (%f) wrong",rmax));
+ return;
+ } else
+ fBeamPipeRmax = rmax;
+
+ if (halfzlen < 0) {
+ AliError(Form("Beam pipe half Zlength (%f) wrong",halfzlen));
+ return;
+ } else {
+ if (halfzlen == 0) // Use default value
+ fBeamPipeZlen = fgkBeamPipeHalfZLen;
+ else
+ fBeamPipeZlen = halfzlen;
+ }
+
+ fBeamPipe = kTRUE;
+}
+
+//______________________________________________________________________
+void AliITSUv11::CreateGeometry() {
+
+ // Create the geometry and insert it in the mother volume ITSV
+ TGeoManager *geoManager = gGeoManager;
+
+ TGeoVolume *vALIC = geoManager->GetVolume("ALIC");
+
+ new TGeoVolumeAssembly(AliITSUGeomTGeo::GetITSVolPattern());
+ TGeoVolume *vITSV = geoManager->GetVolume(AliITSUGeomTGeo::GetITSVolPattern());
+ vALIC->AddNode(vITSV, 2, 0); // Copy number is 2 to cheat AliGeoManager::CheckSymNamesLUT
+
+ //
+ const Int_t kLength=100;
+ Char_t vstrng[kLength] = "xxxRS"; //?
+ vITSV->SetTitle(vstrng);
+ //
+ // Check that we have all needed parameters
+ if (fNLayers <= 0) AliFatal(Form("Wrong number of layers (%d)",fNLayers));
+ //
+ for (Int_t j=0; j<fNLayers; j++) {
+ if (fLayRadii[j] <= 0) AliFatal(Form("Wrong layer radius for layer %d (%f)",j,fLayRadii[j]));
+ if (fLayZLength[j] <= 0) AliFatal(Form("Wrong layer length for layer %d (%f)",j,fLayZLength[j]));
+ if (fLaddPerLay[j] <= 0) AliFatal(Form("Wrong number of ladders for layer %d (%d)",j,fLaddPerLay[j]));
+ if (fModPerLadd[j] <= 0) AliFatal(Form("Wrong number of modules for layer %d (%d)",j,fModPerLadd[j]));
+ if (fLadThick[j] < 0) AliFatal(Form("Wrong ladder thickness for layer %d (%f)",j,fLadThick[j]));
+ if (fLayTurbo[j] && fLadWidth[j] <= 0) AliFatal(Form("Wrong ladder width for layer %d (%f)",j,fLadWidth[j]));
+ if (fDetThick[j] < 0) AliFatal(Form("Wrong module thickness for layer %d (%f)",j,fDetThick[j]));
+ //
+ if (j > 0) {
+ if (fLayRadii[j]<=fLayRadii[j-1]) AliFatal(Form("Layer %d radius (%f) is smaller than layer %d radius (%f)",
+ j,fLayRadii[j],j-1,fLayRadii[j-1]));
+ if (fLayZLength[j]<=fLayZLength[j-1]) AliFatal(Form("Layer %d length (%f) is smaller than layer %d length (%f)",
+ j,fLayZLength[j],j-1,fLayZLength[j-1]));
+ } // if (j > 0)
+
+ if (fLadThick[j] == 0) AliInfo(Form("Ladder thickness for layer %d not set, using default",j));
+ if (fDetThick[j] == 0) AliInfo(Form("Module thickness for layer %d not set, using default",j));
+
+ } // for (Int_t j=0; j<fNLayers; j++)
+
+ // Now create the actual geometry
+ for (Int_t j=0; j<fNLayers; j++) {
+ if (fLayTurbo[j]) {
+ fUpGeom[j] = new AliITSUv11Layer(j,kTRUE,kFALSE);
+ fUpGeom[j]->SetLadderWidth(fLadWidth[j]);
+ fUpGeom[j]->SetLadderTilt(fLadTilt[j]);
+ }
+ else fUpGeom[j] = new AliITSUv11Layer(j,kFALSE);
+ //
+ fUpGeom[j]->SetRadius(fLayRadii[j]);
+ fUpGeom[j]->SetZLength(fLayZLength[j]);
+ fUpGeom[j]->SetNLadders(fLaddPerLay[j]);
+ fUpGeom[j]->SetNModules(fModPerLadd[j]);
+ fUpGeom[j]->SetDetType(fDetTypeID[j]);
+ //
+ if (fLadThick[j] != 0) fUpGeom[j]->SetLadderThick(fLadThick[j]);
+ if (fDetThick[j] != 0) fUpGeom[j]->SetSensorThick(fDetThick[j]);
+ fUpGeom[j]->CreateLayer(vITSV);
+ }
+ //
+ // Finally add the beam pipe
+ if (fBeamPipe) {
+ fBPGeom = new AliITSv11GeomBeamPipe(fBeamPipeRmin, fBeamPipeRmax,fBeamPipeZlen, kFALSE);
+ fBPGeom->CreateBeamPipe(vALIC); // We put the BP in the ALIC volume
+ }
+}
+
+//______________________________________________________________________
+void AliITSUv11::CreateMaterials() {
+ // Create ITS materials
+ // This function defines the default materials used in the Geant
+ // Monte Carlo simulations for the geometries AliITSv1, AliITSv3,
+ // AliITSv11Hybrid.
+ // In general it is automatically replaced by
+ // the CreateMaterials routine defined in AliITSv?. Should the function
+ // CreateMaterials not exist for the geometry version you are using this
+ // one is used. See the definition found in AliITSv5 or the other routine
+ // for a complete definition.
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
+ Int_t ifield = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
+ Float_t fieldm = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
+
+ Float_t tmaxfd = 0.1; // 1.0; // Degree
+ Float_t stemax = 1.0; // cm
+ Float_t deemax = 0.1; // 30.0; // Fraction of particle's energy 0<deemax<=1
+ Float_t epsil = 1.0E-4; // 1.0; // cm
+ Float_t stmin = 0.0; // cm "Default value used"
+
+ Float_t tmaxfdSi = 0.1; // .10000E+01; // Degree
+ Float_t stemaxSi = 0.0075; // .10000E+01; // cm
+ Float_t deemaxSi = 0.1; // 0.30000E-02; // Fraction of particle's energy 0<deemax<=1
+ Float_t epsilSi = 1.0E-4;// .10000E+01;
+ Float_t stminSi = 0.0; // cm "Default value used"
+
+ Float_t tmaxfdAir = 0.1; // .10000E+01; // Degree
+ Float_t stemaxAir = .10000E+01; // cm
+ Float_t deemaxAir = 0.1; // 0.30000E-02; // Fraction of particle's energy 0<deemax<=1
+ Float_t epsilAir = 1.0E-4;// .10000E+01;
+ Float_t stminAir = 0.0; // cm "Default value used"
+
+ // AIR
+ Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
+ Float_t zAir[4]={6.,7.,8.,18.};
+ Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
+ Float_t dAir = 1.20479E-3;
+
+
+ AliMaterial(1,"SI$",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
+ AliMedium(1,"SI$",1,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
+
+ AliMixture(5,"AIR$",aAir,zAir,dAir,4,wAir);
+ AliMedium(5,"AIR$",5,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,epsilAir,stminAir);
+
+ AliMaterial(8,"BERILLIUM$",9.01, 4., 1.848, 35.3, 36.7);// From AliPIPEv3
+ AliMedium(8,"BERILLIUM$",8,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
+
+}
+
+//______________________________________________________________________
+void AliITSUv11::DefineLayer(const Int_t nlay, const Double_t r,
+ const Double_t zlen, const Int_t nladd,
+ const Int_t nmod, const Double_t lthick,
+ const Double_t dthick, const UInt_t dettypeID)
+{
+ // Sets the layer parameters
+ // Inputs:
+ // nlay layer number
+ // r layer radius
+ // zlen layer length
+ // nladd number of ladders
+ // nmod number of modules per ladder
+ // lthick ladder thickness (if omitted, defaults to 0)
+ // dthick detector thickness (if omitted, defaults to 0)
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
+ if (nlay >= fNLayers || nlay < 0) {
+ AliError(Form("Wrong layer number (%d)",nlay));
+ return;
+ }
+
+ fLayTurbo[nlay] = kFALSE;
+ fLayRadii[nlay] = r;
+ fLayZLength[nlay] = zlen;
+ fLaddPerLay[nlay] = nladd;
+ fModPerLadd[nlay] = nmod;
+ fLadThick[nlay] = lthick;
+ fDetThick[nlay] = dthick;
+ fDetTypeID[nlay] = dettypeID;
+
+}
+
+//______________________________________________________________________
+void AliITSUv11::DefineLayerTurbo(const Int_t nlay, const Double_t r,
+ const Double_t zlen, const Int_t nladd,
+ const Int_t nmod, const Double_t width,
+ const Double_t tilt,
+ const Double_t lthick,
+ const Double_t dthick,
+ const UInt_t dettypeID)
+{
+ // Sets the layer parameters for a "turbo" layer
+ // (i.e. a layer whose ladders overlap in phi)
+ // Inputs:
+ // nlay layer number
+ // r layer radius
+ // zlen layer length
+ // nladd number of ladders
+ // nmod number of modules per ladder
+ // width layer width
+ // tilt layer tilt angle (degrees)
+ // lthick ladder thickness (if omitted, defaults to 0)
+ // dthick detector thickness (if omitted, defaults to 0)
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
+ if (nlay >= fNLayers || nlay < 0) {
+ AliError(Form("Wrong layer number (%d)",nlay));
+ return;
+ }
+
+ fLayTurbo[nlay] = kTRUE;
+ fLayRadii[nlay] = r;
+ fLayZLength[nlay] = zlen;
+ fLaddPerLay[nlay] = nladd;
+ fModPerLadd[nlay] = nmod;
+ fLadThick[nlay] = lthick;
+ fLadWidth[nlay] = width;
+ fLadTilt[nlay] = tilt;
+ fDetThick[nlay] = dthick;
+ fDetTypeID[nlay] = dettypeID;
+ //
+}
+
+//______________________________________________________________________
+void AliITSUv11::GetBeamPipeParameters(Double_t &rmin, Double_t &rmax,
+ Double_t &hzlen){
+ // Gets the beam pipe parameters
+ // Inputs:
+ // none.
+ // Outputs:
+ // rmin min radius
+ // rmax max radius
+ // hzlen half Z length
+ // Return:
+ // none.
+
+ rmin = fBeamPipeRmin;
+ rmax = fBeamPipeRmax;
+ hzlen = fBeamPipeZlen;
+
+}
+
+//______________________________________________________________________
+void AliITSUv11::GetLayerParameters(const Int_t nlay,
+ Double_t &r, Double_t &zlen,
+ Int_t &nladd, Int_t &nmod,
+ Double_t &width, Double_t &tilt,
+ Double_t <hick, Double_t &dthick){
+ // Gets the layer parameters
+ // Inputs:
+ // nlay layer number
+ // Outputs:
+ // r layer radius
+ // zlen layer length
+ // nladd number of ladders
+ // nmod number of modules per ladder
+ // width ladder width
+ // tilt ladder tilt angle
+ // lthick ladder thickness
+ // dthick detector thickness
+ // Return:
+ // none.
+
+ if (nlay >= fNLayers || nlay < 0) {
+ AliError(Form("Wrong layer number (%d)",nlay));
+ return;
+ }
+
+ r = fLayRadii[nlay];
+ zlen = fLayZLength[nlay];
+ nladd = fLaddPerLay[nlay];
+ nmod = fModPerLadd[nlay];
+ width = fLadWidth[nlay];
+ tilt = fLadTilt[nlay];
+ lthick = fLadThick[nlay];
+ dthick = fDetThick[nlay];
+}
+
+//______________________________________________________________________
+void AliITSUv11::Init()
+{
+ // Initialise the ITS after it has been created.
+ UpdateInternalGeometry();
+ AliITSU::Init();
+
+}
+
+//______________________________________________________________________
+Bool_t AliITSUv11::IsLayerTurbo(const Int_t nlay)
+{
+ // Returns true if the layer is a "turbo" layer
+ if ( nlay < 0 || nlay > fNLayers ) {
+ AliError(Form("Wrong layer number %d",nlay));
+ return kFALSE;
+ }
+ else return fUpGeom[nlay]->IsTurbo();
+}
+
+//______________________________________________________________________
+void AliITSUv11::SetDefaults()
+{
+ // sets the default segmentation, response, digit and raw cluster classes
+}
+
+//______________________________________________________________________
+void AliITSUv11::StepManager()
+{
+ // Called for every step in the ITS, then calles the AliITSUHit class
+ // creator with the information to be recoreded about that hit.
+ // The value of the macro ALIITSPRINTGEOM if set to 1 will allow the
+ // printing of information to a file which can be used to create a .det
+ // file read in by the routine CreateGeometry(). If set to 0 or any other
+ // value except 1, the default behavior, then no such file is created nor
+ // it the extra variables and the like used in the printing allocated.
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ if(!(this->IsActive())) return;
+ if(!(gMC->TrackCharge())) return;
+ //
+ Int_t copy, lay = 0;
+ Int_t id = gMC->CurrentVolID(copy);
+
+ Bool_t notSens = kFALSE;
+ while ((lay<fNLayers) && (notSens = (id!=fIdSens[lay]))) ++lay;
+ //printf("R: %.1f | Lay: %d NotSens: %d\n",positionRS.Pt(), lay, notSens);
+
+ if (notSens) return;
+
+ if(gMC->IsTrackExiting()) {
+ AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
+ } // if Outer ITS mother Volume
+
+ static TLorentzVector position, momentum; // Saves on calls to construtors
+ static AliITSUHit hit;// Saves on calls to constructors
+
+ TClonesArray &lhits = *(Hits());
+ Int_t cpn0, cpn1, mod, status = 0;
+ //
+ // Track status
+ if(gMC->IsTrackInside()) status += 1;
+ if(gMC->IsTrackEntering()) status += 2;
+ if(gMC->IsTrackExiting()) status += 4;
+ if(gMC->IsTrackOut()) status += 8;
+ if(gMC->IsTrackDisappeared()) status += 16;
+ if(gMC->IsTrackStop()) status += 32;
+ if(gMC->IsTrackAlive()) status += 64;
+
+ //
+ // retrieve the indices with the volume path
+ //
+ if (lay < 0 || lay >= fNLayers) {
+ AliError(Form("Invalid value: lay=%d. Not an ITS sensitive volume",lay));
+ return; // not an ITS sensitive volume.
+ } else {
+ copy = 1;
+ gMC->CurrentVolOffID(1,cpn1);
+ gMC->CurrentVolOffID(2,cpn0);
+ } //
+
+ mod = fGeomTGeo->GetModuleIndex(lay,cpn0,cpn1);
+ //RS2DEL fInitGeom.DecodeDetector(mod,lay+1,cpn0,cpn1,copy);
+ //
+ // Fill hit structure.
+ //
+ hit.SetModule(mod);
+ hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
+ gMC->TrackPosition(position);
+ gMC->TrackMomentum(momentum);
+ hit.SetPosition(position);
+ hit.SetTime(gMC->TrackTime());
+ hit.SetMomentum(momentum);
+ hit.SetStatus(status);
+ hit.SetEdep(gMC->Edep());
+ hit.SetShunt(GetIshunt());
+ if(gMC->IsTrackEntering()){
+ hit.SetStartPosition(position);
+ hit.SetStartTime(gMC->TrackTime());
+ hit.SetStartStatus(status);
+ return; // don't save entering hit.
+ } // end if IsEntering
+ // Fill hit structure with this new hit.
+ //Info("StepManager","Calling Copy Constructor");
+ new(lhits[fNhits++]) AliITSUHit(hit); // Use Copy Construtor.
+ // Save old position... for next hit.
+ hit.SetStartPosition(position);
+ hit.SetStartTime(gMC->TrackTime());
+ hit.SetStartStatus(status);
+
+ return;
+}
+
+//______________________________________________________________________
+void AliITSUv11::SetLayerDetTypeID(Int_t lr, UInt_t id)
+{
+ // set det type
+ if (!fDetTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
+ fDetTypeID[lr] = id;
+}
+
+//______________________________________________________________________
+Int_t AliITSUv11::GetLayerDetTypeID(Int_t lr)
+{
+ // set det type
+ if (!fDetTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
+ return fDetTypeID[lr];
+}
--- /dev/null
+#ifndef ALIITSVUPGRADE_H
+#define ALIITSVUPGRADE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+//========================================================================
+//
+// Geometry for the Upgrade of the Inner Tracking System
+//
+// Mario Sitta (sitta@to.infn.it)
+//
+//========================================================================
+
+
+// $Id: AliITSUv11.h
+
+#include "AliITSU.h"
+
+class AliITSUv11Layer;
+class AliITSv11GeomBeamPipe;
+class TGeoVolume;
+class TGeoVolumeAssembly;
+
+class AliITSUv11 : public AliITSU {
+
+ public:
+ AliITSUv11();
+ AliITSUv11(const char *title, const Int_t nlay);
+ virtual ~AliITSUv11() ;
+
+ virtual void AddAlignableVolumes() const;
+ virtual void AddBeamPipe(const Double_t rmin, const Double_t rmax,const Double_t halfzlen=0.);
+ virtual void CreateGeometry();
+ virtual void CreateMaterials();
+ virtual void DefineLayer(const Int_t nlay, const Double_t r,
+ const Double_t zlen, const Int_t nladd,
+ const Int_t nmod, const Double_t lthick = 0.,
+ const Double_t dthick = 0.,
+ const UInt_t detType=0);
+ virtual void DefineLayerTurbo(const Int_t nlay, const Double_t r,
+ const Double_t zlen, const Int_t nladd,
+ const Int_t nmod, const Double_t width,
+ const Double_t tilt,
+ const Double_t lthick = 0.,
+ const Double_t dthick = 0.,
+ const UInt_t detType=0);
+ virtual void GetBeamPipeParameters(Double_t &rmin, Double_t &rmax,
+ Double_t &hzlen);
+ virtual void GetLayerParameters(const Int_t nlay,
+ Double_t &r, Double_t &zlen,
+ Int_t &nladd, Int_t &nmod,
+ Double_t &width, Double_t &tilt,
+ Double_t <hick, Double_t &mthick);
+ virtual Bool_t HasBeamPipe() const {return fBeamPipe;}
+ virtual void Init();
+ virtual Bool_t IsLayerTurbo(const Int_t nlay);
+ virtual Int_t IsVersion() const { return 20;} // vUpgrade ? do we need this
+ virtual void SetDefaults();
+ virtual void StepManager();
+ virtual void SetLayerDetTypeID(Int_t lr, UInt_t id);
+ virtual Int_t GetLayerDetTypeID(Int_t lr);
+ //
+ protected:
+ void SetT2Lmatrix(Int_t uid, Double_t yShift,Bool_t yFlip, Bool_t yRot180=kFALSE) const; // Set T2L matrix in TGeoPNEntries
+
+ private:
+ AliITSUv11(const AliITSUv11 &source); // copy constructor
+ AliITSUv11& operator=(const AliITSUv11 &source); // assignment operator
+ //
+ Bool_t *fLayTurbo; // True for "turbo" layers
+ Double_t *fLayRadii; // Vector of layer radii
+ Double_t *fLayZLength; // Vector of layer length along Z
+ Int_t *fLaddPerLay; // Vector of number of ladders per layer
+ Int_t *fModPerLadd; // Vector of number of modules per ladder
+ Double_t *fLadThick; // Vector of ladder thicknesses
+ Double_t *fLadWidth; // Vector of ladder width (only used for turbo)
+ Double_t *fLadTilt; // Vector of ladder tilt (only used for turbo)
+ Double_t *fDetThick; // Vector of detector thicknesses
+ UInt_t *fDetTypeID; // Vector of detector type id
+ Bool_t fBeamPipe; // True for creating the beam pipe
+ Double_t fBeamPipeRmin; // Rmin of beam pipe
+ Double_t fBeamPipeRmax; // Rmax of beam pipe
+ Double_t fBeamPipeZlen; // Half Z length of beam pipe
+ //
+ AliITSUv11Layer **fUpGeom; //! Geometry
+ AliITSv11GeomBeamPipe *fBPGeom; //! Beam Pipe Geometry
+
+ // Parameters for the Upgrade geometry
+
+ static const Double_t fgkBeamPipeHalfZLen; // Default value for beampipe Z
+
+ ClassDef(AliITSUv11,0)
+};
+
+#endif
//*************************************************************************
-/* $Id: AliITSv11GeometryUpgrade.cxx */
+/* $Id: AliITSUv11Layer.cxx */
// General Root includes
#include <TMath.h>
// Root Geometry includes
#include <TGeoXtru.h>
#include <TGeoCompositeShape.h>
#include <TGeoMatrix.h>
-#include "AliITSv11GeometryUpgrade.h"
-#include "AliITSgeomTGeoUpg.h"
+#include "AliITSUv11Layer.h"
+#include "AliITSUGeomTGeo.h"
-const Double_t AliITSv11GeometryUpgrade::fgkDefaultSensorThick = 300*fgkmicron;
-const Double_t AliITSv11GeometryUpgrade::fgkDefaultLadderThick = 1*fgkcm;
+const Double_t AliITSUv11Layer::fgkDefaultSensorThick = 300*fgkmicron;
+const Double_t AliITSUv11Layer::fgkDefaultLadderThick = 1*fgkcm;
-ClassImp(AliITSv11GeometryUpgrade)
+ClassImp(AliITSUv11Layer)
#define SQ(A) (A)*(A)
//________________________________________________________________________
-AliITSv11GeometryUpgrade::AliITSv11GeometryUpgrade():
+AliITSUv11Layer::AliITSUv11Layer():
AliITSv11Geometry(),
fLayerNumber(0),
fLayRadius(0),
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade::AliITSv11GeometryUpgrade(Int_t debug):
+AliITSUv11Layer::AliITSUv11Layer(Int_t debug):
AliITSv11Geometry(debug),
fLayerNumber(0),
fLayRadius(0),
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade::AliITSv11GeometryUpgrade(Int_t lay, Int_t debug):
+AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Int_t debug):
AliITSv11Geometry(debug),
fLayerNumber(lay),
fLayRadius(0),
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade::AliITSv11GeometryUpgrade(Int_t lay, Bool_t turbo, Int_t debug):
+AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Bool_t turbo, Int_t debug):
AliITSv11Geometry(debug),
fLayerNumber(lay),
fLayRadius(0),
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade::AliITSv11GeometryUpgrade(const AliITSv11GeometryUpgrade &s):
+AliITSUv11Layer::AliITSUv11Layer(const AliITSUv11Layer &s):
AliITSv11Geometry(s.GetDebug()),
fLayerNumber(s.fLayerNumber),
fLayRadius(s.fLayRadius),
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade& AliITSv11GeometryUpgrade::operator=(const AliITSv11GeometryUpgrade &s)
+AliITSUv11Layer& AliITSUv11Layer::operator=(const AliITSUv11Layer &s)
{
//
// Assignment operator
}
//________________________________________________________________________
-AliITSv11GeometryUpgrade::~AliITSv11GeometryUpgrade() {
+AliITSUv11Layer::~AliITSUv11Layer() {
//
// Destructor
//
}
//________________________________________________________________________
-void AliITSv11GeometryUpgrade::CreateLayer(TGeoVolume *moth,
+void AliITSUv11Layer::CreateLayer(TGeoVolume *moth,
const TGeoManager *mgr){
//
// Creates the actual Layer and places inside its mother volume
// We have all shapes: now create the real volumes
TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
- snprintf(volname, 30, "%s%d", AliITSgeomTGeoUpg::GetITSLayerPattern(),fLayerNumber);
+ snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(),fLayerNumber);
TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
layVol->SetUniqueID(fDetTypeID);
xpos = r*SinD(theta);
ypos = r*CosD(theta);
zpos = 0.;
- layVol->AddNode(laddVol, j+1, new TGeoCombiTrans( xpos, ypos, zpos,
+ layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
new TGeoRotation("",-theta,0,0)));
}
}
//________________________________________________________________________
-void AliITSv11GeometryUpgrade::CreateLayerTurbo(TGeoVolume *moth,
+void AliITSUv11Layer::CreateLayerTurbo(TGeoVolume *moth,
const TGeoManager *mgr){
//
// Creates the actual Layer and places inside its mother volume
// We have all shapes: now create the real volumes
TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
- snprintf(volname, 30, "%s%d", AliITSgeomTGeoUpg::GetITSLayerPattern(), fLayerNumber);
+ snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(), fLayerNumber);
TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
layVol->SetUniqueID(fDetTypeID);
layVol->SetVisibility(kTRUE);
xpos = r*SinD(theta);
ypos = r*CosD(theta);
zpos = 0.;
- layVol->AddNode(laddVol, j+1, new TGeoCombiTrans( xpos, ypos, zpos,
+ layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
new TGeoRotation("",-theta+fLadderTilt,0,0)));
}
}
//________________________________________________________________________
-TGeoVolume* AliITSv11GeometryUpgrade::CreateLadder(const TGeoManager *mgr){
+TGeoVolume* AliITSUv11Layer::CreateLadder(const TGeoManager *mgr){
//
// Creates the actual Ladder
//
// We have all shapes: now create the real volumes
TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
- snprintf(volname, 30, "%s%d", AliITSgeomTGeoUpg::GetITSLadderPattern(), fLayerNumber);
+ snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLadderPattern(), fLayerNumber);
TGeoVolume *laddVol = new TGeoVolume(volname, ladder, medAir);
// laddVol->SetVisibility(kFALSE);
xpos = 0.;
ypos = 0.;
zpos = -ladder->GetDZ() + j*2*zmod + zmod;
- laddVol->AddNode(modVol, j+1, new TGeoTranslation(xpos, ypos, zpos));
+ laddVol->AddNode(modVol, j, new TGeoTranslation(xpos, ypos, zpos));
}
}
//________________________________________________________________________
-TGeoVolume* AliITSv11GeometryUpgrade::CreateModule(const Double_t xlad,
+TGeoVolume* AliITSUv11Layer::CreateModule(const Double_t xlad,
const Double_t ylad,
const Double_t zlad,
const TGeoManager *mgr){
TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
TGeoMedium *medSi = mgr->GetMedium("ITS_SI$");
- snprintf(volname, 30, "%s%d", AliITSgeomTGeoUpg::GetITSModulePattern() ,fLayerNumber);
+ snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSModulePattern() ,fLayerNumber);
TGeoVolume *modVol = new TGeoVolume(volname, module, medAir);
modVol->SetVisibility(kFALSE);
modVol->SetLineColor(1);
- snprintf(volname, 30, "%s%d", AliITSgeomTGeoUpg::GetITSSensorPattern(), fLayerNumber);
+ snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSSensorPattern(), fLayerNumber);
TGeoVolume *sensVol = new TGeoVolume(volname, sensor, medSi);
sensVol->SetVisibility(kTRUE);
}
//________________________________________________________________________
-Double_t AliITSv11GeometryUpgrade::RadiusOfTurboContainer(){
+Double_t AliITSUv11Layer::RadiusOfTurboContainer(){
//
// Computes the inner radius of the air container for the Turbo configuration
// as the radius of either the circle tangent to the ladder or the circle
}
//________________________________________________________________________
-void AliITSv11GeometryUpgrade::SetLadderTilt(const Double_t t){
+void AliITSUv11Layer::SetLadderTilt(const Double_t t){
//
// Sets the Ladder tilt angle (for turbo layers only)
//
}
//________________________________________________________________________
-void AliITSv11GeometryUpgrade::SetLadderWidth(const Double_t w){
+void AliITSUv11Layer::SetLadderWidth(const Double_t w){
//
// Sets the Ladder width (for turbo layers only)
//
/*
- $Id: AliITSv11GeometryUpgrade.h
+ $Id: AliITSUv11Layer.h
*/
#include "AliITSv11Geometry.h"
class TGeoVolume;
-class AliITSv11GeometryUpgrade : public AliITSv11Geometry {
+class AliITSUv11Layer : public AliITSv11Geometry {
public:
- AliITSv11GeometryUpgrade();
- AliITSv11GeometryUpgrade(Int_t debug);
- AliITSv11GeometryUpgrade(Int_t lay, Int_t debug);
- AliITSv11GeometryUpgrade(Int_t lay, Bool_t turbo, Int_t debug);
- AliITSv11GeometryUpgrade(const AliITSv11GeometryUpgrade &source);
- AliITSv11GeometryUpgrade& operator=(const AliITSv11GeometryUpgrade &source);
- virtual ~AliITSv11GeometryUpgrade();
+ AliITSUv11Layer();
+ AliITSUv11Layer(Int_t debug);
+ AliITSUv11Layer(Int_t lay, Int_t debug);
+ AliITSUv11Layer(Int_t lay, Bool_t turbo, Int_t debug);
+ AliITSUv11Layer(const AliITSUv11Layer &source);
+ AliITSUv11Layer& operator=(const AliITSUv11Layer &source);
+ virtual ~AliITSUv11Layer();
//
Bool_t IsTurbo() {return fIsTurbo;};
static const Double_t fgkDefaultSensorThick; // Default sensor thickness
static const Double_t fgkDefaultLadderThick; // Default ladder thickness
- ClassDef(AliITSv11GeometryUpgrade,0) // ITS v11 Upgrade geometry
+ ClassDef(AliITSUv11Layer,0) // ITS v11 Upgrade geometry
};
#endif
+++ /dev/null
-#ifndef ALIITSGEOMTGEOUPG_H
-#define ALIITSGEOMTGEOUPG_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-
-/////////////////////////////////////////////////////////////////////////
-// AliITSgeomTGeoUpg 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. //
-// //
-/////////////////////////////////////////////////////////////////////////
-
-#include <TObject.h>
-#include <TGeoMatrix.h>
-
-class TGeoPNEntry;
-class TDatime;
-
-class AliITSgeomTGeoUpg : public TObject {
-
- public:
- enum {kNLayersOld = 6}; // The number of layers in OLD ITS.
- enum {kITSVNA, kITSVOld, kITSVUpg}; // ITS version
-
- AliITSgeomTGeoUpg() { } // Default constructor
- virtual ~AliITSgeomTGeoUpg() { }// Destructor
-
- // This function returns the total number of ITS modules
- static Int_t GetNModules() {CheckInit(); return fgNModules;}
- // This function returns the number of detectors/ladder for a given layer
- static Int_t GetNDetectors(Int_t lay) {CheckInit(); return (lay<1||lay>fgNLayers) ? 0:fgNDetectors[lay-1];}
- // This function returns the number of ladders for a given layer
- static Int_t GetNLadders(Int_t lay) {CheckInit(); return (lay<1||lay>fgNLayers) ? 0:fgNLadders[lay-1];}
- // This function returns the number of layers
- static Int_t GetNLayers() {CheckInit(); return fgNLayers;}
-
- // Two methods to map module index to layer,ladder,detector indeces
- static Int_t GetModuleIndex(Int_t lay,Int_t lad,Int_t det);
- static Bool_t GetModuleId(Int_t index,Int_t &lay,Int_t &lad,Int_t &det);
-
- static const char *GetSymName(Int_t index); // Get TGeoPNEntry symbolic name
- static const char *GetSymName(Int_t lay,Int_t lad,Int_t det)
- { return GetSymName(GetModuleIndex(lay,lad,det)); }
-
- // This function returns a pointer to the TGeoHMatrix (local->global)
- // of a given module index
- static TGeoHMatrix* GetMatrix(Int_t index);
- static TGeoHMatrix* GetMatrix(Int_t lay,Int_t lad,Int_t det) { return GetMatrix(GetModuleIndex(lay,lad,det)); }
-
- static Bool_t GetTranslation(Int_t index, Double_t t[3]);
- static Bool_t GetTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3]) { return GetTranslation(GetModuleIndex(lay,lad,det),t); }
-
- static Bool_t GetRotation(Int_t index, Double_t r[9]);
- static Bool_t GetRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9])
- { return GetRotation(GetModuleIndex(lay,lad,det),r); }
-
- // This function returns a pointer to the original TGeoHMatrix (local->global)
- // for a specific module index
- static Bool_t GetOrigMatrix(Int_t index, TGeoHMatrix &m);
- static Bool_t GetOrigMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m)
- { return GetOrigMatrix(GetModuleIndex(lay,lad,det),m); }
-
- static Bool_t GetOrigTranslation(Int_t index, Double_t t[3]);
- static Bool_t GetOrigTranslation(Int_t lay,Int_t lad,Int_t det, Double_t t[3])
- { return GetOrigTranslation(GetModuleIndex(lay,lad,det),t); }
-
- static Bool_t GetOrigRotation(Int_t index, Double_t r[9]);
- static Bool_t GetOrigRotation(Int_t lay,Int_t lad,Int_t det, Double_t r[9])
- { return GetOrigRotation(GetModuleIndex(lay,lad,det),r); }
-
- static const TGeoHMatrix* GetTracking2LocalMatrix(Int_t index);
- static const TGeoHMatrix* GetTracking2LocalMatrix(Int_t lay,Int_t lad,Int_t det)
- { return GetTracking2LocalMatrix(GetModuleIndex(lay,lad,det)); }
-
- static Bool_t GetTrackingMatrix(Int_t index, TGeoHMatrix &m);
- static Bool_t GetTrackingMatrix(Int_t lay,Int_t lad,Int_t det, TGeoHMatrix &m)
- { return GetTrackingMatrix(GetModuleIndex(lay,lad,det),m); }
-
- static Bool_t LocalToGlobal(Int_t index, const Double_t *loc, Double_t *glob);
- static Bool_t LocalToGlobal(Int_t lay, Int_t lad, Int_t det,
- const Double_t *loc, Double_t *glob)
- { return LocalToGlobal(GetModuleIndex(lay,lad,det), loc, glob);}
-
- static Bool_t GlobalToLocal(Int_t index, const Double_t *glob, Double_t *loc);
- static Bool_t GlobalToLocal(Int_t lay, Int_t lad, Int_t det,
- const Double_t *glob, Double_t *loc)
- { return GlobalToLocal(GetModuleIndex(lay,lad,det), glob, loc);}
-
- static Bool_t LocalToGlobalVect(Int_t index, const Double_t *loc, Double_t *glob);
- static Bool_t GlobalToLocalVect(Int_t index, const Double_t *glob, Double_t *loc);
- static void CheckInit() { if (fgVersion==kITSVNA) BuildITS(); }
- static Int_t GetLayerDetTypeID(Int_t lr) {CheckInit(); return (lr<1||lr>fgNLayers||!fgLrDetType) ? -1:fgLrDetType[lr-1];}
-
- 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;}
-
- private:
-
- static Bool_t GetLayer(Int_t index,Int_t &lay,Int_t &index2);
- static TGeoPNEntry* GetPNEntry(Int_t index);
- static Int_t ExtractNumberOfDetectors(const Int_t lay);
- static Int_t ExtractNumberOfLadders(const Int_t lay);
- static Int_t ExtractLayerDetType(const Int_t lay);
- static Int_t ExtractNumberOfLayers();
- static Bool_t ReadVersionString(const Char_t *str,Int_t &maj,Int_t &min,TDatime &dt);
- static void BuildITSUpg();
- static void BuildITSOld();
- static void BuildITS();
- //
- AliITSgeomTGeoUpg(const AliITSgeomTGeoUpg &geom); // Copy constructor
- AliITSgeomTGeoUpg& operator=(const AliITSgeomTGeoUpg &geom);// Assignment operator
-
- static Int_t fgVersion; // ITS Version
- static Int_t fgNLayers; // number of layers
- static Int_t fgNModules; // The total number of modules
- static Int_t *fgNLadders; // Array of the number of ladders/layer(layer)
- static Int_t *fgLrDetType; // Array of layer detector types
- static Int_t *fgNDetectors; // Array of the number of detector/ladder(layer)
-
-
- // these are hardwired settings for old ITS
- static const Int_t fgkNModulesOld; // The total number of modules
- static const Int_t fgkNLaddersOld[kNLayersOld]; // Array of the number of ladders/layer(layer)
- static const Int_t fgkNDetectorsOld[kNLayersOld];// Array of the number of detector/ladder(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
-
- ClassDef(AliITSgeomTGeoUpg, 0) // ITS geometry based on TGeo
-};
-
-#endif
+++ /dev/null
-/**************************************************************************
- * 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. *
- **************************************************************************/
-///////////////////////////////////////////////////////////////////////////
-// Base Response for pixels
-// It is used to set static data members
-// connected to parameters equal for all
-// the SPD modules
-//
-// Modified by D. Elia, G.E. Bruno
-// March-April 2006
-// September 2007: Coupling params taken out
-// left in AliITSCalibrationSPD only
-//
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliITSresponsePixUpg.h"
-
-const Float_t AliITSresponsePixUpg::fgkDiffCoeffDefault = 0.; //change this
-const TString AliITSresponsePixUpg::fgkCouplingOptDefault = "old";
-const Float_t AliITSresponsePixUpg::fgkEccentricityDiffDefault = 0.85;
-
-ClassImp(AliITSresponsePixUpg)
-//______________________________________________________________________
-AliITSresponsePixUpg::AliITSresponsePixUpg():
- AliITSresponse(),
-fCouplOpt(0),
-fEccDiff(0){
-
- // constructor
- SetCouplingOption(fgkCouplingOptDefault);
- SetDiffCoeff(fgkDiffCoeffDefault,0.);
- SetSigmaDiffusionAsymmetry(fgkEccentricityDiffDefault);
-
-}
+++ /dev/null
-#ifndef ALIITSRESPONSESPD_H
-#define ALIITSRESPONSESPD_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-
-
-#include "AliITSresponse.h"
-///////////////////////////////////////////
-// //
-// ITS response class for Pixels //
-///////////////////////////////////////////
-
-class AliITSresponsePixUpg : public AliITSresponse {
- public:
- AliITSresponsePixUpg(); // default constructor
- virtual ~AliITSresponsePixUpg() {;} // destructror
- //
- virtual void SetSigmaDiffusionAsymmetry(Double_t ecc) {fEccDiff=ecc;}
- virtual void GetSigmaDiffusionAsymmetry(Double_t &ecc) const {ecc=fEccDiff;}
- //
- protected:
- //
- static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
- static const TString fgkCouplingOptDefault; // type of pixel Coupling (old or new)
- static const Float_t fgkEccentricityDiffDefault;//default for fCouplRow
-
- TString fCouplOpt; // Coupling Option
- Float_t fEccDiff; // Eccentricity (i.e. asymmetry parameter) in the Gaussian Diffusion
-
-
- ClassDef(AliITSresponsePixUpg,1) // pixel upgrade base response class
-};
-
-#endif
+++ /dev/null
-/**************************************************************************
-* 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 "AliITS.h"
-#include "AliITSdigitPixUpg.h"
-#include "AliITShit.h"
-#include "AliITSmodule.h"
-#include "AliITSpList.h"
-#include "AliITSCalibrationPixUpg.h"
-#include "AliITSsegmentationPixUpg.h"
-#include "AliITSsimulationPixUpg.h"
-#include "AliLog.h"
-#include "AliRun.h"
-#include "AliMagF.h"
-#include "AliMathBase.h"
-
-//#define DEBUG
-
-using std::endl;
-using std::cout;
-ClassImp(AliITSsimulationPixUpg)
-////////////////////////////////////////////////////////////////////////
-// 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
-//
-// AliITSsimulationPixUpg is to do the simulation of pixels
-//
-////////////////////////////////////////////////////////////////////////
-
-//______________________________________________________________________
-AliITSsimulationPixUpg::AliITSsimulationPixUpg():
-AliITSsimulation(),
-fHistos(0),
-fHistName(),
-fCoupling(),
-fLorentz(kFALSE),
-fTanLorAng(0),
-fStrobe(kTRUE),
-fStrobeLenght(4),
-fStrobePhase(-12.5e-9)
-{
- // Default constructor.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // A default constructed AliITSsimulationPixUpg class.
-
- AliDebug(1,Form("Calling default constructor"));
-// Init();
-}
-
-//______________________________________________________________________
-AliITSsimulationPixUpg::AliITSsimulationPixUpg(AliITSDetTypeSimUpg *dettyp):
-AliITSsimulation(dettyp),
-fHistos(0),
-fHistName(),
-fCoupling(),
-fLorentz(kFALSE),
-fTanLorAng(0),
-fStrobe(kTRUE),
-fStrobeLenght(4),
-fStrobePhase(-12.5e-9)
-{
- // standard constructor
- // Inputs:
- // AliITSsegmentation *seg A pointer to the segmentation class
- // to be used for this simulation
- // AliITSCalibration *resp A pointer to the responce class to
- // be used for this simulation
- // Outputs:
- // none.
- // Return:
- // A default constructed AliITSsimulationPixUpg class.
-
- AliDebug(1,Form("Calling standard constructor "));
- Init();
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::Init()
-{
- // Initilization
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- const Double_t kmictocm = 1.0e-4; // convert microns to cm.
-
- SetModuleNumber(0);
- SetEventNumber(0);
- SetMap(new AliITSpList(GetNPixelsZ(),GetNPixelsX()));
- AliITSSimuParam* simpar = fDetType->GetSimuParam();
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- Double_t bias = simpar->GetSPDBiasVoltage(); //RS !!!
-// cout << "Bias Voltage --> " << bias << endl; // dom
- simpar->SetDistanceOverVoltage(kmictocm*seg->Dy(),bias);
-// set kind of coupling ("old" or "new")
- char opt[20] = {"new"};
- // simpar->GetSPDCouplingOption(opt); //RS !!!
- char *old = strstr(opt,"old");
- if (old) {
- fCoupling=2;
- } else {
- fCoupling=1;
- } // end if
- SetLorentzDrift(simpar->GetSPDLorentzDrift());
- if (fLorentz) SetTanLorAngle(simpar->GetSPDLorentzHoleWeight());
- //SetStrobeGeneration(kFALSE);
- if (fStrobe) GenerateStrobePhase();
-}
-
-//______________________________________________________________________
-Bool_t AliITSsimulationPixUpg::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 (!fDetType) {
- AliError("AliITSsimulationPixUpg::SetTanLorAngle: AliITSDetTypeSim* fDetType not set ");
- return kFALSE;}
- if (weightHole<0) {
- weightHole=0.;
- AliWarning("AliITSsimulationPixUpg::SetTanLorAngle: You have asked for negative Hole weight");
- AliWarning("AliITSsimulationPixUpg::SetTanLorAngle: I'm going to use only electrons");
- }
- if (weightHole>1) {
- weightHole=1.;
- AliWarning("AliITSsimulationPixUpg::SetTanLorAngle: You have asked for weight > 1");
- AliWarning("AliITSsimulationPixUpg::SetTanLorAngle: I'm going to use only holes");
- }
- Double_t weightEle=1.-weightHole;
- AliITSSimuParam* simpar = fDetType->GetSimuParam();
- AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
- if (!fld) AliFatal("The field is not initialized");
- Double_t bz = fld->SolenoidField();
- fTanLorAng = TMath::Tan(weightHole*simpar->LorentzAngleHole(bz) +
- weightEle*simpar->LorentzAngleElectron(bz));
- return kTRUE;
-}
-
-//______________________________________________________________________
-AliITSsimulationPixUpg::~AliITSsimulationPixUpg()
-{
- // destructor
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
- if (fHistos) {
- fHistos->Delete();
- delete fHistos;
- } // end if fHistos
-}
-
-//______________________________________________________________________
-AliITSsimulationPixUpg::AliITSsimulationPixUpg(const AliITSsimulationPixUpg &s) :
- AliITSsimulation(s),
- fHistos(s.fHistos),
- fHistName(s.fHistName),
- fCoupling(s.fCoupling),
- fLorentz(s.fLorentz),
- fTanLorAng(s.fTanLorAng),
- fStrobe(s.fStrobe),
- fStrobeLenght(s.fStrobeLenght),
- fStrobePhase(s.fStrobePhase)
-{
- // Copy Constructor
- // Inputs:
- // AliITSsimulationPixUpg &s The original class for which
- // this class is a copy of
- // Outputs:
- // none.
- // Return:
-
-}
-
-//______________________________________________________________________
-AliITSsimulationPixUpg& AliITSsimulationPixUpg::operator=(const AliITSsimulationPixUpg &s)
-{
- // Assignment operator
- // Inputs:
- // AliITSsimulationPixUpg &s The original class for which
- // this class is a copy of
- // Outputs:
- // none.
- // Return:
-
- if (&s == this) return *this;
- this->fHistos = s.fHistos;
- fCoupling = s.fCoupling;
- fHistName = s.fHistName;
- fLorentz = s.fLorentz;
- fTanLorAng = s.fTanLorAng;
- fStrobe = s.fStrobe;
- fStrobeLenght = s.fStrobeLenght;
- fStrobePhase = s.fStrobePhase;
- return *this;
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::InitSimulationModule(Int_t module, Int_t event)
-{
- // This function creates maps to build the list of tracks for each
- // summable digit. Inputs defined by base class.
- // Inputs:
- // Int_t module // Module number to be simulated
- // Int_t event // Event number to be simulated
- // Outputs:
- // none
- // Returns:
- // none
-
- AliDebug(1,Form("(module=%d,event=%d)",module,event));
- const Double_t kmictocm = 1.0e-4; // convert microns to cm.
- AliITSSimuParam* simpar = fDetType->GetSimuParam();
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- SetModuleNumber(module);
- SetEventNumber(event);
- simpar->SetDistanceOverVoltage(kmictocm*seg->Dy(),simpar->GetSPDBiasVoltage(module));
- ClearMap();
-}
-
-//_____________________________________________________________________
-void AliITSsimulationPixUpg::SDigitiseModule(AliITSmodule *mod,Int_t, Int_t event)
-{
- // This function begins the work of creating S-Digits. Inputs defined
- // by base class.
- // Inputs:
- // AliITSmodule *mod // module
- // Int_t // not used
- // Int_t event // Event number
- // Outputs:
- // none
- // Return:
- // test // test returns kTRUE if the module contained hits
- // // test returns kFALSE if it did not contain hits
-
- AliDebug(1,Form("(mod=%p, ,event=%d)",mod,event));
- if (!(mod->GetNhits())) {
- AliDebug(1,Form("In event %d module %d there are %d hits returning.",
- event, mod->GetIndex(),mod->GetNhits()));
- return;// if module has no hits don't create Sdigits
- } // end if
- SetModuleNumber(mod->GetIndex());
- if (fStrobe) if (event != GetEventNumber()) GenerateStrobePhase();
- SetEventNumber(event);
- InitSimulationModule( GetModuleNumber() , event );
- // HitToSDigit(mod);
- HitToSDigitFast(mod);
- if (fDetType->GetSimuParam()->GetSPDAddNoisyFlag()) AddNoisyPixels();
- if (fDetType->GetSimuParam()->GetSPDRemoveDeadFlag()) RemoveDeadPixels();
-
- // cout << "After Remove in SDigitiseModule !!!!!" << endl; // dom
- // cout << "Module " << mod->GetIndex() << " Event " << event << endl; // dom
- WriteSDigits();
- ClearMap();
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::WriteSDigits()
-{
- // This function adds each S-Digit to pList
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none
- Int_t ix, nix, iz, niz;
- static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
-
- AliDebug(1,Form("Writing SDigits for module %d",GetModuleNumber()));
-// cout << "WriteSDigits for module " << GetModuleNumber() << endl; // dom
- GetMap()->GetMaxMapIndex(niz, nix);
- for (iz=0; iz<niz; iz++)for (ix=0; ix<nix; ix++) {
- if (GetMap()->GetSignalOnly(iz,ix)>0.0) {
- // cout << " Signal gt 0 iz ix " << iz << ix << " Module " << GetModuleNumber() << endl; // dom
- aliITS->AddSumDigit(*(GetMap()->GetpListItem(iz,ix)));
- if (AliDebugLevel()>0) {
- AliDebug(1,Form("%d, %d",iz,ix));
- cout << *(GetMap()->GetpListItem(iz,ix)) << endl;
- } // end if GetDebug
- } // end if GetMap()->GetSignalOnly(iz,ix)>0.0
- } // end for iz,ix
- return;
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::FinishSDigitiseModule()
-{
- // This function calls SDigitsToDigits which creates Digits from SDigits
- // Inputs:
- // none
- // Outputs:
- // none
- // Return
- // none
-
- AliDebug(1,"()");
-// cout << "FinishSDigitiseModule for module " << GetModuleNumber() << endl; // dom
- FrompListToDigits(); // Charge To Signal both adds noise and
- ClearMap();
- return;
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::DigitiseModule(AliITSmodule *mod,Int_t, Int_t event)
-{
- // 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 HitToSDigit
- // Inputs:
- // AliITSmodule *mod module
- // Int_t Dummy.
- // Int_t Dummy
- // Outputs:
- // none.
- // Return:
- // none.
-
- if (fStrobe) if (event != GetEventNumber()) GenerateStrobePhase();
- AliDebug(1,Form("(mod=%p,,0)",mod));
- // HitToSDigit(mod);
- InitSimulationModule( mod->GetIndex(), event );
- HitToSDigitFast(mod);
-
- if (fDetType->GetSimuParam()->GetSPDAddNoisyFlag()) AddNoisyPixels();
- if (fDetType->GetSimuParam()->GetSPDRemoveDeadFlag()) RemoveDeadPixels();
- // cout << "After Remove in DigitiseModule in module " << mod->GetIndex() << endl; // dom
- FrompListToDigits();
- ClearMap();
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::HitToSDigit(AliITSmodule *mod)
-{
- // Does the charge distributions using Gaussian diffusion charge charing.
- // Inputs:
- // AliITSmodule *mod Pointer to this module
- // Output:
- // none.
- // Return:
- // none.
- const Double_t kmictocm = 1.0e-4; // convert microns to cm.
- const Double_t kBunchLenght = 25e-9; // LHC clock
- TObjArray *hits = mod->GetHits();
- Int_t nhits = hits->GetEntriesFast();
- 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;
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- AliITSSimuParam *simpar = fDetType->GetSimuParam();
- Double_t thick = 0.5*kmictocm*seg->Dy(); // Half Thickness
- simpar->GetSPDSigmaDiffusionAsymmetry(fda); //
-
- AliDebug(1,Form("(mod=%p) fCoupling=%d",mod,fCoupling));
- if (nhits<=0) return;
- for (h=0;h<nhits;h++) {
- if (AliDebugLevel()>0) {
- AliDebug(1,Form("Hits, %d", h));
- cout << *(mod->GetHit(h)) << endl;
- } // end if GetDebug
- // Check if the hit is inside readout window
- if (fStrobe)
- if ((mod->GetHit(h)->GetTOF() < fStrobePhase) ||
- (mod->GetHit(h)->GetTOF() > (fStrobePhase+(Double_t)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/kmictocm)); // 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 (!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
- //el = res->GeVToCharge((Double_t)(dt*de));
- el = dt * de / simpar->GetGeVToCharge();
- //
- if (GetDebug(1)) if (el<=0.0) cout<<"el="<<el<<" dt="<<dt<<" de="<<de<<endl; // end if GetDebug
- //
- sig = simpar->SigmaDiffusion1D(TMath::Abs(thick + y));
- sigx=sig;
- sigz=sig*fda;
- if (fLorentz) 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 (!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
- //el = res->GeVToCharge((Double_t)de);
- el = de / simpar->GetGeVToCharge();
- sig = simpar->SigmaDiffusion1D(TMath::Abs(thick + y));
- sigx=sig;
- sigz=sig*fda;
- if (fLorentz) 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
- switch (fCoupling) {
- default:
- break;
- case 1: //case 3:
- for (i=0;i<GetMap()->GetEntries();i++)
- if (GetMap()->GetpListItem(i)==0) continue;
- else{
- GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix);
- SetCoupling(iz,ix,idtrack,h);
- } // end for i
- break;
- case 2: // case 4:
- for (i=0;i<GetMap()->GetEntries();i++)
- if (GetMap()->GetpListItem(i)==0) continue;
- else{
- GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix);
- SetCouplingOld(iz,ix,idtrack,h);
- } // end for i
- break;
- } // end switch
- if (GetDebug(2)) Info("HitToSDigit","Finished fCoupling=%d",fCoupling);
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::HitToSDigitFast(AliITSmodule *mod)
-{
- // Does the charge distributions using Gaussian diffusion charge charing. // Inputs:
- // AliITSmodule *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();
- 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;
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- AliITSSimuParam* simpar = fDetType->GetSimuParam();
- Double_t thick = 0.5*kmictocm*seg->Dy(); // Half thickness
- simpar->GetSPDSigmaDiffusionAsymmetry(fda);
- // cout << "Half Thickness " << thick << endl; // dom
- // cout << "Diffusion asymm " << fda << endl; // dom
-
- AliDebug(1,Form("(mod=%p) fCoupling=%d",mod,fCoupling));
- if (nhits<=0) return;
- for (h=0;h<nhits;h++) {
- if (AliDebugLevel()>0) {
- AliDebug(1,Form("Hits, %d", h));
- cout << *(mod->GetHit(h)) << endl;
- } // end if GetDebug
- // Check if the hit is inside readout window
- if (fStrobe)
- if ((mod->GetHit(h)->GetTOF() < fStrobePhase) ||
- (mod->GetHit(h)->GetTOF() > (fStrobePhase+(Double_t)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 (!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
- el = kwi[i]*de/simpar->GetGeVToCharge();
- if (GetDebug(1)) {
- if (el<=0.0) cout<<"el="<<el<<" kwi["<<i<<"]="<<kwi[i]
- <<" de="<<de<<endl;
- } // end if GetDebug
- sig = simpar->SigmaDiffusion1D(TMath::Abs(thick + y));
- sigx=sig;
- sigz=sig*fda;
- if (fLorentz) 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 (!(seg->LocalToDet(x,z,ix,iz))) continue; // outside
- el = de / simpar->GetGeVToCharge();
- sig = simpar->SigmaDiffusion1D(TMath::Abs(thick + y));
- sigx=sig;
- sigz=sig*fda;
- if (fLorentz) 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
- switch (fCoupling) {
- default:
- break;
- case 1: // case 3:
- for (i=0;i<GetMap()->GetEntries();i++)
- if (GetMap()->GetpListItem(i)==0) continue;
- else{
- GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix);
- SetCoupling(iz,ix,idtrack,h);
- } // end for i
- break;
- case 2: // case 4:
- for (i=0;i<GetMap()->GetEntries();i++)
- if (GetMap()->GetpListItem(i)==0) continue;
- else {
- GetMap()->GetMapIndex(GetMap()->GetpListItem(i)->GetIndex(),iz,ix);
- SetCouplingOld(iz,ix,idtrack,h);
- } // end for i
- break;
- } // end switch
- if (GetDebug(2))Info("HitToSDigit","Finished fCoupling=%d",fCoupling);
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::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 fLorentz=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;
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- //
- 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.
- GetMap()->AddSignal(iz0,ix0,t,hi,GetModuleNumber(),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,seg->Npx()-1);
- izs = TMath::Max(-knz+iz0,0);
- ize = TMath::Min(knz+iz0,seg->Npz()-1);
- for (ix=ixs;ix<=ixe;ix++) for (iz=izs;iz<=ize;iz++) {
- seg->DetToLocal(ix,iz,x,z); // pixel center
- x1 = x;
- z1 = z;
- x2 = x1 + 0.5*kmictocm*seg->Dpx(ix); // Upper
- x1 -= 0.5*kmictocm*seg->Dpx(ix); // Lower
- z2 = z1 + 0.5*kmictocm*seg->Dpz(iz); // Upper
- z1 -= 0.5*kmictocm*seg->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
- GetMap()->AddSignal(iz,ix,t,hi,GetModuleNumber(),s*el);
- } // end for ix, iz
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::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 fLorentz=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;
- AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
- //
- 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.
- GetMap()->AddSignal(iz0,ix0,t,hi,GetModuleNumber(),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,seg->Npx()-1);
- izs = TMath::Max(-knz+iz0,0);
- ize = TMath::Min(knz+iz0,seg->Npz()-1);
- for (ix=ixs;ix<=ixe;ix++) for (iz=izs;iz<=ize;iz++) {
- seg->DetToLocal(ix,iz,x,z); // pixel center
- x1 = x;
- z1 = z;
- x2 = x1 + 0.5*kmictocm*seg->Dpx(ix); // Upper
- x1 -= 0.5*kmictocm*seg->Dpx(ix); // Lower
- z2 = z1 + 0.5*kmictocm*seg->Dpz(iz); // Upper
- z1 -= 0.5*kmictocm*seg->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
- GetMap()->AddSignal(iz,ix,t,hi,GetModuleNumber(),s*el);
- } // end for ix, iz
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::RemoveDeadPixels()
-{
- // Removes dead pixels on each module (ladder)
- // This should be called before going from sdigits to digits (FrompListToDigits)
- Int_t mod = GetModuleNumber();
- AliITSCalibrationPixUpg* calObj = (AliITSCalibrationPixUpg*) fDetType->GetCalibrationModel(mod);
-
- Int_t nrDead = calObj->GetNrBad();
- for (Int_t i=0; i<nrDead; i++) GetMap()->DeleteHit(calObj->GetBadColAt(i), calObj->GetBadRowAt(i));
- //
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::AddNoisyPixels()
-{
- // Adds noisy pixels on each module (ladder)
- // This should be called before going from sdigits to digits (FrompListToDigits)
- Int_t mod = GetModuleNumber();
- AliITSCalibrationPixUpg* calObj = (AliITSCalibrationPixUpg*) fDetType->GetSPDNoisyModel(mod); // RS !!!
- //
- Int_t nrNoisy = calObj->GetNrBad();
- for (Int_t i=0; i<nrNoisy; i++) {
- // adding 10 times the threshold will for sure make this pixel fire...
- GetMap()->AddNoise(calObj->GetBadColAt(i), calObj->GetBadRowAt(i), mod, 10*GetThreshold());
- }
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::FrompListToDigits()
-{
- // add noise and electronics, perform the zero suppression and add the
- // digit to the list
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
- static AliITS *aliITS = (AliITS*)gAlice->GetModule("ITS");
- Int_t j,ix,iz;
- Double_t electronics;
- Double_t sig;
- const Int_t knmaxtrk=AliITSdigit::GetNTracks();
- static AliITSdigitPixUpg dig;
- AliITSSimuParam *simpar = fDetType->GetSimuParam();
- if (GetDebug(1)) Info("FrompListToDigits","()");
- for (iz=0; iz<GetNPixelsZ(); iz++)
- for (ix=0; ix<GetNPixelsX(); ix++) {
- electronics = simpar->ApplySPDBaselineAndNoise();
- UpdateMapNoise(ix,iz,electronics);
- //
- // Apply Threshold and write Digits.
- sig = GetMap()->GetSignalOnly(iz,ix);
- FillHistograms(ix,iz,sig+electronics);
- if (GetDebug(3)) {
- cout<<sig<<"+"<<electronics<<">threshold("<<ix<<","<<iz
- <<")="<<GetThreshold() <<endl;
- } // end if GetDebug
- // if (sig+electronics <= GetThreshold()) continue;
- if (GetMap()->GetSignal(iz,ix) <= GetThreshold()) continue;
- dig.SetCoord1(iz);
- dig.SetCoord2(ix);
- dig.SetSignal(1);
-
- // dig.SetSignalSPD((Int_t) GetMap()->GetSignal(iz,ix));
- Double_t aSignal = GetMap()->GetSignal(iz,ix);
- if (TMath::Abs(aSignal)>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",aSignal));
- aSignal = TMath::Sign((Double_t)2147483647,aSignal);
- }
- dig.SetSignalPix((Int_t)aSignal);
-
- for (j=0;j<knmaxtrk;j++) {
- if (j<GetMap()->GetNEntries()) {
- dig.SetTrack(j,GetMap()->GetTrack(iz,ix,j));
- dig.SetHit(j,GetMap()->GetHit(iz,ix,j));
- }else { // Default values
- dig.SetTrack(j,-3);
- dig.SetHit(j,-1);
- } // end if GetMap()
- } // end for j
- if (GetDebug(3)) {
- cout<<iz<<","<<ix<<","<<*(GetMap()->GetpListItem(iz,ix))<<endl;
- } // end if GetDebug
- aliITS->AddSimDigit(0,&dig);
- // simulate fo signal response for this pixel hit:
- //RS fDetType->ProcessSPDDigitForFastOr(fModule, dig.GetCoord1(), dig.GetCoord2());
- } // for ix/iz
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::CreateHistograms()
-{
- // create 1D histograms for tests
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
- if (GetDebug(1)) Info("CreateHistograms","create histograms");
-
- fHistos = new TObjArray(GetNPixelsZ());
- fHistName="pix_";
- for (Int_t i=0;i<GetNPixelsZ();i++) {
- Char_t pixelz[4];
- snprintf(pixelz,3,"%d",i);
- fHistName.Append(pixelz);
- fHistos->AddAt(new TH1F(fHistName.Data(),"pixel maps",
- GetNPixelsX(),0.,(Double_t)GetNPixelsX()),i);
- } // end for i
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::FillHistograms(Int_t ix,Int_t iz,Double_t v)
-{
- // Fill the histogram
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
- if (!GetHistArray()) return; // Only fill if setup.
- if (GetDebug(2)) Info("FillHistograms","fill histograms");
- GetHistogram(iz)->Fill(ix,v);
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::ResetHistograms()
-{
- // Reset histograms for this detector
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
- if (!GetHistArray()) return; // Only fill if setup.
- if (GetDebug(2)) Info("FillHistograms","fill histograms");
- for ( int i=0;i<GetNPixelsZ();i++ ) if (fHistos->At(i)) ((TH1F*)fHistos->At(i))->Reset();
- //
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::SetCoupling(Int_t col, Int_t row, 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:
- // Int_t col z cell index
- // Int_t row x cell index
- // Int_t ntrack track incex number
- // Int_t idhit hit index number
- // Outputs:
- // none.
- // Return:
- // none.
- Int_t j1,j2,flag=0;
- Double_t pulse1,pulse2;
- Double_t couplR=0.0,couplC=0.0;
- Double_t xr=0.;
-
- GetCouplings(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);
- j1 = col;
- j2 = row;
- pulse1 = GetMap()->GetSignalOnly(col,row);
- pulse2 = pulse1;
- for (Int_t isign=-1;isign<=1;isign+=2) {// loop in col direction
- do {
- j1 += isign;
- xr = gRandom->Rndm();
- if ((j1<0) || (j1>GetNPixelsZ()-1) || (xr>couplC)) {
- j1 = col;
- flag = 1;
- } else {
- UpdateMapSignal(row,j1,ntrack,idhit,pulse1);
- // flag = 0;
- flag = 1; // only first next!!
- } // end if
- } while (flag == 0);
- // loop in row direction
- do {
- j2 += isign;
- xr = gRandom->Rndm();
- if ((j2<0) || (j2>GetNPixelsX()-1) || (xr>couplR)) {
- j2 = row;
- flag = 1;
- } else {
- UpdateMapSignal(j2,col,ntrack,idhit,pulse2);
- // flag = 0;
- flag = 1; // only first next!!
- } // end if
- } while(flag == 0);
- } // for isign
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::SetCouplingOld(Int_t col, Int_t row,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:
- // Int_t col z cell index
- // Int_t row x cell index
- // Int_t ntrack track incex number
- // Int_t idhit hit index number
- // Int_t module module number
- // Outputs:
- // none.
- // Return:
- // none.
- Int_t j1,j2,flag=0;
- Double_t pulse1,pulse2;
- Double_t couplR=0.0,couplC=0.0;
-
- GetCouplings(couplC,couplR);
-
- // Debugging ...
- // cout << "Threshold --> " << GetThreshold() << endl; // dom
- // cout << "Couplings --> " << couplC << " " << couplR << endl; // dom
-
- 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
- pulse1 = GetMap()->GetSignalOnly(col,row);
- pulse2 = pulse1;
- j1 = col;
- j2 = row;
- do{
- j1 += isign;
- pulse1 *= couplC;
- if ((j1<0)||(j1>GetNPixelsZ()-1)||(pulse1<GetThreshold())) {
- pulse1 = GetMap()->GetSignalOnly(col,row);
- j1 = col;
- flag = 1;
- }else{
- UpdateMapSignal(row,j1,ntrack,idhit,pulse1);
- // flag = 0;
- flag = 1; // only first next !!
- } // end if
- } while(flag == 0);
- // loop in row direction
- do{
- j2 += isign;
- pulse2 *= couplR;
- if ((j2<0)||(j2>(GetNPixelsX()-1))||(pulse2<GetThreshold())) {
- pulse2 = GetMap()->GetSignalOnly(col,row);
- j2 = row;
- flag = 1;
- }else{
- UpdateMapSignal(j2,col,ntrack,idhit,pulse2);
- // flag = 0;
- flag = 1; // only first next!!
- } // end if
- } while(flag == 0);
- } // for isign
-}
-
-//______________________________________________________________________
-void AliITSsimulationPixUpg::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;
-}
-
+++ /dev/null
-#ifndef ALIITSSIMULATIONPIXUPG_H
-#define ALIITSSIMULATIONPIXUPG_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 "AliITSsimulation.h"
-#include "AliITSsegmentationPixUpg.h"
-#include "AliITSDetTypeSimUpg.h"
-
-class TH1F;
-class AliITSmodule;
-
-//-------------------------------------------------------------------
-
-class AliITSsimulationPixUpg : public AliITSsimulation {
-public:
- AliITSsimulationPixUpg();
- AliITSsimulationPixUpg(AliITSDetTypeSimUpg *dettyp);
- virtual ~AliITSsimulationPixUpg();
- AliITSsimulationPixUpg(const AliITSsimulationPixUpg &source);
- AliITSsimulationPixUpg& operator=(const AliITSsimulationPixUpg &s);
- void Init();
- //
- // General User calling routines
- // Initilize simulation for a specific event and module
- void InitSimulationModule(Int_t module, Int_t event);
- // Finish and write S Digitization
- void FinishSDigitiseModule();
- // From hits to Digits, without creating SDigits
- void DigitiseModule(AliITSmodule *mod,Int_t,Int_t);
- //
- // More or less Internal Routines
- // Create S Digits from specific module
- void SDigitiseModule(AliITSmodule *mod, Int_t mask, Int_t event);
- // Write S Digits to the tree of SDigits.
- void WriteSDigits();
- // fill pList from hits, charge sharing, diffusion, coupling
- void HitToSDigit(AliITSmodule *mod);
- // fill pList from hits, charge sharing, diffusion, coupling (faster method optimized by Bjorne)
- void HitToSDigitFast(AliITSmodule *mod);
- // Adds noisy pixels to pList
- void AddNoisyPixels();
- // Removes dead pixels from pList
- void RemoveDeadPixels();
- // Take pList of signals and apply noise... create Digits
- void FrompListToDigits();
- // This set the Lorentz drift of Electrons and Holes: by deafult equal weights to Electrons and Holes
- void SetLorentzDrift(Bool_t b=kFALSE)
- {fLorentz=b; if(fLorentz) SetTanLorAngle();};
- // This function set the relative contribution between holes and electrons: use 0<=WeightHole<=1
- Bool_t SetTanLorAngle(Double_t WeightHole=1.0);
- // Getter for the Lorentz angle
- Double_t GetTanLorAngle() const {return fTanLorAng;};
- //
- void CreateHistograms();
- void FillHistograms(Int_t ix,Int_t iz,Double_t v=1.0);
- void ResetHistograms();
- TH1F* GetHistogram(Int_t i){return (TH1F*)(fHistos->At(i));}// get histogram
- TObjArray* GetHistArray() {return fHistos;}// get hist array
- TString& GetHistName(){return fHistName;}
- void SetHistName(TString &n){fHistName = n;}
- //
- // For backwards compatibility
- void SDigitsToDigits(){ FinishSDigitiseModule();};
- void HitToDigit(AliITSmodule *mod){
- // Standard interface to DigitiseModule Inputs: AliITSmodule *mod Pointer to this module
- DigitiseModule(mod,GetModuleNumber(),0);};
-
- // 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 UpdateMapSignal(Int_t ix,Int_t iz,Int_t trk,Int_t ht,Double_t signal){
- // This function adds a signal to the pList from the pList class
- // Inputs: iz column number ix row number trk track number ht hit number signal signal strength
- GetMap()->AddSignal(iz,ix,trk,ht,GetModuleNumber(),signal);};
- void UpdateMapNoise(Int_t ix,Int_t iz,Float_t noise){
- // This function adds noise to data in the MapA2 as well as the pList
- // Inputs: iz column number ix row number noise electronic noise generated by FrompListToDigits
- GetMap()->AddNoise(iz,ix,GetModuleNumber(),noise);}
- // Get a pointer to the segmentation object
- virtual AliITSsegmentation* GetSegmentationModel(Int_t /*dt*/){return fDetType->GetSegmentationModel(AliITSDetTypeSimUpg::kDetPixUpg);}
- // set pointer to segmentation objec
- virtual void SetSegmentationModel(Int_t /*dt*/, AliITSsegmentation *seg){fDetType->SetSegmentationModel(AliITSDetTypeSimUpg::kDetPixUpg,seg);}
- // Bari-Salerno Coupling parameters
- // "New" coupling routine Tiziano Virgili
- void SetCoupling(Int_t col,Int_t row,Int_t ntrack,Int_t idhit);
- // "Old" coupling routine Rocco Caliandro
- void SetCouplingOld(Int_t col, Int_t row,Int_t ntrack,Int_t idhit);
- // Getters for data kept in fSegmentation and fResponse.
- // Returns the Threshold in electrons
- Double_t GetThreshold(){
- Double_t th,sig;AliITSSimuParam* simpar = fDetType->GetSimuParam();
- simpar->SPDThresholds(GetModuleNumber(),th,sig);return th;};
- // Returns the couplings Columb and Row.
- void GetCouplings(Double_t &cc,Double_t &cr){
- AliITSSimuParam* simpar = fDetType->GetSimuParam();
- simpar->GetSPDCouplingParam(cc,cr);};
- // Returns the number of pixels in x
- Int_t GetNPixelsX(){return GetSegmentationModel(-1)->Npx();};
- // Returns the number of pixels in z
- Int_t GetNPixelsZ(){return GetSegmentationModel(-1)->Npz();};
-
- TObjArray *fHistos; //! just in case for histogramming
- TString fHistName; //! Histogram name
- Int_t fCoupling; // Sets the coupling to be used.
- // ==1 use SetCoupling, ==2 use SetCouplingOld
- Bool_t fLorentz; // kTRUE if Lorentz drift has been allowed
- 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(AliITSsimulationPixUpg,1) // Simulation of pixel clusters
- };
-#endif
v0/AliITSsegmentationUpgrade.cxx
v0/AliITSRecPointU.cxx
#
-AliITSInitGeometryUpg.cxx
-AliITSLoaderUpg.cxx
-AliITSgeomTGeoUpg.cxx
-AliITSCalibrationPixUpg.cxx
-AliITSsegmentationPixUpg.cxx
+AliITSULoader.cxx
+AliITSUGeomTGeo.cxx
+AliITSUCalibrationPix.cxx
+AliITSUSegmentationPix.cxx
+AliITSUSensMap.cxx
+AliITSUSDigit.cxx
)
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
v0/AliITSupgrade.cxx
v0/AliITSupgradeDigitizer.cxx
#
-AliITSUpg.cxx
-AliITSvUpgrade.cxx
-AliITSv11GeometryUpgrade.cxx
+AliITSU.cxx
+AliITSUv11.cxx
+AliITSUv11Layer.cxx
AliITSv11GeomBeamPipe.cxx
-AliITSDetTypeSimUpg.cxx
-AliITSsimulationPixUpg.cxx
-AliITSdigitPixUpg.cxx
+AliITSUModule.cxx
+AliITSUSimulation.cxx
+AliITSUSimulationPix.cxx
+AliITSUDigitPix.cxx
+AliITSUDigitizer.cxx
+AliITSUHit.cxx
)
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
#pragma link C++ class AliITSRecPointU+;
// v0 part <<<
//
-#pragma link C++ class AliITSInitGeometryUpg+;
-#pragma link C++ class AliITSLoaderUpg+;
-#pragma link C++ class AliITSgeomTGeoUpg+;
-#pragma link C++ class AliITSCalibrationPixUpg+;
-#pragma link C++ class AliITSsegmentationPixUpg+;
+#pragma link C++ class AliITSULoader+;
+#pragma link C++ class AliITSUGeomTGeo+;
+#pragma link C++ class AliITSUCalibrationPix+;
+#pragma link C++ class AliITSUSegmentationPix+;
+#pragma link C++ class AliITSUSensMap+;
+#pragma link C++ class AliITSUSDigit+;
#endif
#pragma link C++ class AliITSupgradeDigitizer+;
//v0 part <<<
//
-#pragma link C++ class AliITSUpg+;
-#pragma link C++ class AliITSvUpgrade+;
-#pragma link C++ class AliITSv11GeometryUpgrade+;
+#pragma link C++ class AliITSU+;
+#pragma link C++ class AliITSUv11+;
+#pragma link C++ class AliITSUv11Layer+;
#pragma link C++ class AliITSv11GeomBeamPipe+;
-#pragma link C++ class AliITSDetTypeSimUpg+;
-#pragma link C++ class AliITSsimulationPixUpg+;
-#pragma link C++ class AliITSdigitPixUpg+;
+#pragma link C++ class AliITSUModule+;
+#pragma link C++ class AliITSUSimulation+;
+#pragma link C++ class AliITSUSimulationPix+;
+#pragma link C++ class AliITSUDigitPix+;
+#pragma link C++ class AliITSUDigitizer+;
+#pragma link C++ class AliITSUHit+;
#endif