[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUSimulation.h

#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"
#include "AliMathBase.h"
#include <TArrayS.h>

class AliITSCalibration;
class AliITSUSimuParam;
class AliITSUChip;
class TRandom;
class TSegCollection;
class AliITSUParamList;

// 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:
  enum {kMaxROCycleAccept=126};             // flag for read-out cycle to discard
  //
  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 col,UInt_t row, Int_t trk,Int_t ht,Double_t signal, Int_t roCycle=0);
  void UpdateMapNoise(UInt_t col,UInt_t row, Double_t noise, Int_t roCycle=0);
  virtual void InitSimulationChip(AliITSUChip* mod, Int_t ev, AliITSsegmentation* seg, AliITSUParamList* resp);
  //
  // Hits -> SDigits
  virtual void SDigitiseChip() = 0;
  virtual void FinishSDigitiseChip() = 0;
  virtual Bool_t AddSDigitsToChip( TSeqCollection *pItemArray, Int_t mask );
  //
  // Hits -> Digits
  virtual void DigitiseChip() = 0;
  virtual void CreateFastRecPoints(AliITSUChip *,Int_t,TRandom *,TClonesArray* /*recp*/) {}
  //
  // readout phase (strobe, timing etc) generation
  virtual Double_t GenerateReadOutCycleOffset();
  //
  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;}
  AliITSUChip*      GetChip()                      const {return fChip;}
  AliITSUParamList*   GetResponseParam()               const {return fResponseParam;}
  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(),kMaxROCycleAccept);}
  void SetSimuParam(AliITSUSimuParam *sp)                  {fSimuParam = sp;}
  virtual void SetResponseParam(AliITSUParamList* resp)    {fResponseParam = resp;}
  void SetMap(AliITSUSensMap *p)                           {fSensMap = p;}
  void SetChip(AliITSUChip* mod)                       {fChip=mod;} 
  void SetEvent(Int_t evnt)                                {fEvent=evnt;} 
  void SetDebug(Int_t level=5)                             {fDebug=level;}
  void SetNoDebug()                                        {fDebug=0;}
  void ClearMap()                                          {fSensMap->Clear();}
  //
  Double_t GetReadOutCycleOffset()              const      {return fReadOutCycleOffset;}
  void     SetReadOutCycleOffset(Double_t v=0)             {fReadOutCycleOffset = v;}
  //
  Double_t GetReadOutCycleLength()              const      {return fReadOutCycleLength;}
  void     SetReadOutCycleLength(Double_t v=25e-6)         {fReadOutCycleLength = v;}
  //
  static  Int_t GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &ind);
  //
  static  Double_t GausInt1D(Double_t sig,Double_t a,Double_t b);
  static  Double_t GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
			     Double_t sig1,Double_t a1,Double_t b1);
  //
 protected:
  AliITSsegmentation  *fSeg;            //! segmentation
  AliITSCalibration   *fCalibDead;      //! dead channels
  AliITSCalibration   *fCalibNoisy;     //! noisy channels
  AliITSUSensMap      *fSensMap;        //! sensor map for hits manipulations
  AliITSUSimuParam    *fSimuParam;      //! simulation parameters
  AliITSUParamList    *fResponseParam;  //! response parameterization data
  AliITSUChip       *fChip;         //! chip being processed
  Float_t              fReadOutCycleOffset; //! The phase of the RO with respect to the trigger
  Float_t              fReadOutCycleLength; //! readout cycle lenght in s

  Int_t                fEvent;          //! event number being processed
  Int_t                fDebug;          //!  debug flag
  Bool_t               fCyclesID[2*kMaxROCycleAccept+1]; //! status of RO cycles

  ClassDef(AliITSUSimulation,2)       // Simulation base class 
    
};

//_____________________________________________________________________________
inline Double_t AliITSUSimulation::GausInt1D(Double_t sig,Double_t a,Double_t b)
{
  // calculate gaussian integral from a to b (with respecto to mean)
  const Double_t kRoot2 = 1.414213562; // Sqrt(2).
  double sp = 1.0/(sig*kRoot2);
  return 0.5*TMath::Abs( AliMathBase::ErfcFast(sp*a) - AliMathBase::ErfcFast(sp*b) );
}

//_____________________________________________________________________________
inline Double_t AliITSUSimulation::GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
					     Double_t sig1,Double_t a1,Double_t b1)
{
  // calculate gaussian 2D integral from x0 to x1 (with respect to mean)
  const Double_t kRoot2 = 1.414213562; // Sqrt(2).
  double sp0 = 1.0/(sig0*kRoot2);
  double sp1 = 1.0/(sig1*kRoot2);
  return 0.25*TMath::Abs( (AliMathBase::ErfcFast(sp0*a0) - AliMathBase::ErfcFast(sp0*b0)) *
			  (AliMathBase::ErfcFast(sp1*a1) - AliMathBase::ErfcFast(sp1*b1)));
}

#endif
Commit	Line	Data
451f5018	1	#ifndef ALIITSUSIMULATION_H
	2	#define ALIITSUSIMULATION_H
	3	/**************************************************************************
	4	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Author: The ALICE Off-line Project. *
	7	* Contributors are mentioned in the code where appropriate. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	#include <TObject.h>
	19	#include "AliITSUSensMap.h"
	20	#include "AliITSsegmentation.h"
c92b1537	21	#include "AliMathBase.h"
fbcb7a55	22	#include <TArrayS.h>
451f5018	23
	24	class AliITSCalibration;
	25	class AliITSUSimuParam;
852af72e	26	class AliITSUChip;
451f5018	27	class TRandom;
451f5018	28	class TSegCollection;
29ad4146	29	class AliITSUParamList;
451f5018	30
	31	// This is the base class for ITS detector signal simulations. Data members
	32	// include are a pointer to the detectors specific response and segmentation
	33	// classes. See the detector specific implementations for the propper code.
	34	// The detector-specific implementations are responsible for processing detector type,
	35	// which still may have different segmentations!
	36	// Note: the detector specific objects (segmentation, calib, etc.) are not owned
	37	// by the object but set externaly
	38
	39	class AliITSUSimulation : public TObject
	40	{
	41	public:
b2679935	42	enum {kMaxROCycleAccept=126}; // flag for read-out cycle to discard
b2679935	43	//
451f5018	44	AliITSUSimulation();
	45	AliITSUSimulation(AliITSUSimuParam* sim, AliITSUSensMap* map);
	46	virtual ~AliITSUSimulation() {}
	47	AliITSUSimulation(const AliITSUSimulation &source);
	48	AliITSUSimulation& operator=(const AliITSUSimulation &source);
	49	virtual void Init() = 0;
	50	//
b2679935	51	void UpdateMapSignal(UInt_t col,UInt_t row, Int_t trk,Int_t ht,Double_t signal, Int_t roCycle=0);
b2679935	52	void UpdateMapNoise(UInt_t col,UInt_t row, Double_t noise, Int_t roCycle=0);
852af72e	53	virtual void InitSimulationChip(AliITSUChip* mod, Int_t ev, AliITSsegmentation* seg, AliITSUParamList* resp);
451f5018	54	//
451f5018	55	// Hits -> SDigits
852af72e	56	virtual void SDigitiseChip() = 0;
	57	virtual void FinishSDigitiseChip() = 0;
	58	virtual Bool_t AddSDigitsToChip( TSeqCollection *pItemArray, Int_t mask );
451f5018	59	//
451f5018	60	// Hits -> Digits
852af72e	61	virtual void DigitiseChip() = 0;
852af72e	62	virtual void CreateFastRecPoints(AliITSUChip ,Int_t,TRandom ,TClonesArray* /recp/) {}
451f5018	63	//
c92b1537	64	// readout phase (strobe, timing etc) generation
344d4ff3	65	virtual Double_t GenerateReadOutCycleOffset();
c92b1537	66	//
451f5018	67	AliITSCalibration* GetCalibDead() const {return fCalibDead;}
	68	AliITSCalibration* GetCalibNoisy() const {return fCalibNoisy;}
	69	AliITSsegmentation* GetSegmentation() const {return fSeg;}
c92b1537	70	AliITSUSimuParam* GetSimuParam() const {return fSimuParam;}
c92b1537	71	AliITSUSensMap* GetMap() const {return fSensMap;}
852af72e	72	AliITSUChip* GetChip() const {return fChip;}
29ad4146	73	AliITSUParamList* GetResponseParam() const {return fResponseParam;}
451f5018	74	Int_t GetEvent() const {return fEvent;}
451f5018	75	Bool_t GetDebug(Int_t level=1) const {return fDebug>=level;}
c92b1537	76
451f5018	77	//
	78	void SetCalibDead(AliITSCalibration *calib) {fCalibDead = calib;}
	79	void SetCalibNoisy(AliITSCalibration *calib) {fCalibNoisy = calib;}
367763c9	80	void SetSegmentation(AliITSsegmentation *seg) {fSeg = seg; if (seg&&fSensMap) fSensMap->SetDimensions(seg->Npz(),seg->Npx(),kMaxROCycleAccept);}
c92b1537	81	void SetSimuParam(AliITSUSimuParam *sp) {fSimuParam = sp;}
29ad4146	82	virtual void SetResponseParam(AliITSUParamList* resp) {fResponseParam = resp;}
c92b1537	83	void SetMap(AliITSUSensMap *p) {fSensMap = p;}
852af72e	84	void SetChip(AliITSUChip* mod) {fChip=mod;}
451f5018	85	void SetEvent(Int_t evnt) {fEvent=evnt;}
	86	void SetDebug(Int_t level=5) {fDebug=level;}
	87	void SetNoDebug() {fDebug=0;}
	88	void ClearMap() {fSensMap->Clear();}
	89	//
344d4ff3	90	Double_t GetReadOutCycleOffset() const {return fReadOutCycleOffset;}
	91	void SetReadOutCycleOffset(Double_t v=0) {fReadOutCycleOffset = v;}
	92	//
35a853ed	93	Double_t GetReadOutCycleLength() const {return fReadOutCycleLength;}
	94	void SetReadOutCycleLength(Double_t v=25e-6) {fReadOutCycleLength = v;}
	95	//
451f5018	96	static Int_t GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &ind);
451f5018	97	//
c92b1537	98	static Double_t GausInt1D(Double_t sig,Double_t a,Double_t b);
	99	static Double_t GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
	100	Double_t sig1,Double_t a1,Double_t b1);
	101	//
451f5018	102	protected:
	103	AliITSsegmentation *fSeg; //! segmentation
	104	AliITSCalibration *fCalibDead; //! dead channels
	105	AliITSCalibration *fCalibNoisy; //! noisy channels
c92b1537	106	AliITSUSensMap *fSensMap; //! sensor map for hits manipulations
c92b1537	107	AliITSUSimuParam *fSimuParam; //! simulation parameters
29ad4146	108	AliITSUParamList *fResponseParam; //! response parameterization data
852af72e	109	AliITSUChip *fChip; //! chip being processed
344d4ff3	110	Float_t fReadOutCycleOffset; //! The phase of the RO with respect to the trigger
	111	Float_t fReadOutCycleLength; //! readout cycle lenght in s
	112
451f5018	113	Int_t fEvent; //! event number being processed
451f5018	114	Int_t fDebug; //! debug flag
6b847cde	115	Bool_t fCyclesID[2*kMaxROCycleAccept+1]; //! status of RO cycles
451f5018	116
344d4ff3	117	ClassDef(AliITSUSimulation,2) // Simulation base class
451f5018	118
	119	};
	120
c92b1537	121	//_____________________________________________________________________________
	122	inline Double_t AliITSUSimulation::GausInt1D(Double_t sig,Double_t a,Double_t b)
	123	{
	124	// calculate gaussian integral from a to b (with respecto to mean)
	125	const Double_t kRoot2 = 1.414213562; // Sqrt(2).
	126	double sp = 1.0/(sig*kRoot2);
	127	return 0.5TMath::Abs( AliMathBase::ErfcFast(spa) - AliMathBase::ErfcFast(sp*b) );
	128	}
	129
	130	//_____________________________________________________________________________
	131	inline Double_t AliITSUSimulation::GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
	132	Double_t sig1,Double_t a1,Double_t b1)
	133	{
	134	// calculate gaussian 2D integral from x0 to x1 (with respect to mean)
	135	const Double_t kRoot2 = 1.414213562; // Sqrt(2).
	136	double sp0 = 1.0/(sig0*kRoot2);
	137	double sp1 = 1.0/(sig1*kRoot2);
	138	return 0.25TMath::Abs( (AliMathBase::ErfcFast(sp0a0) - AliMathBase::ErfcFast(sp0b0))
	139	(AliMathBase::ErfcFast(sp1a1) - AliMathBase::ErfcFast(sp1b1)));
	140	}
	141
451f5018	142	#endif