else fDrSpeed1=arr;
}
- virtual void SetElectronics(Int_t p1=1) {((AliITSresponseSDD*)fResponse)->SetElectronics(p1);}
- virtual Int_t GetElectronics() const {return ((AliITSresponseSDD*)fResponse)->Electronics();}
- virtual void SetMaxAdc(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetMaxAdc(p1);}
- virtual Float_t GetMaxAdc() const {return ((AliITSresponseSDD*)fResponse)->MaxAdc();}
- virtual void SetChargeLoss(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetChargeLoss(p1);}
- virtual Float_t GetChargeLoss() const {return ((AliITSresponseSDD*)fResponse)->ChargeLoss();}
- virtual void SetDynamicRange(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetDynamicRange(p1);}
- virtual Float_t GetDynamicRange() const {return ((AliITSresponseSDD*)fResponse)->DynamicRange();}
virtual Float_t GetTimeOffset() const {return ((AliITSresponseSDD*)fResponse)->TimeOffset();}
virtual Float_t GetADC2keV() const {return ((AliITSresponseSDD*)fResponse)->ADC2keV();}
virtual void SetZeroSupp (const char *opt) {((AliITSresponseSDD*)fResponse)->SetZeroSupp(opt);}
virtual const char *GetZeroSuppOption() const {return ((AliITSresponseSDD*)fResponse)->ZeroSuppOption();}
- virtual void SetNSigmaIntegration(Double_t p1) {((AliITSresponseSDD*)fResponse)->SetNSigmaIntegration(p1);}
- virtual Float_t GetNSigmaIntegration() const {return ((AliITSresponseSDD*)fResponse)->NSigmaIntegration();}
- virtual void SetNLookUp(Int_t p1) {((AliITSresponseSDD*)fResponse)->SetNLookUp(p1);}
- virtual Int_t GetGausNLookUp() const {return ((AliITSresponseSDD*)fResponse)->GausNLookUp();}
- virtual Float_t GetGausLookUp(Int_t i) const {return ((AliITSresponseSDD*)fResponse)->GausLookUp(i);}
-
- virtual void SetJitterError(Double_t jitter=20) {((AliITSresponseSDD*)fResponse)->SetJitterError(jitter);}
- virtual Float_t GetJitterError() const {return ((AliITSresponseSDD*)fResponse)->JitterError();}
+
virtual Float_t GetDriftPath(Float_t time, Float_t xAnode) const {return time*GetDriftSpeedAtAnode(xAnode);}
void GetCorrections(Float_t z, Float_t x, Float_t &devz, Float_t &devx, AliITSsegmentationSDD* seg);
virtual Float_t GetThresholdAnode(Int_t anode,Int_t nsigma=3) const {
// par[i+2] = zpos
// par[i+3] = tau
// par[i+4] = sigma.
- Int_t electronics = GetResp(fModule)->GetElectronics(); // 1 = PASCAL, 2 = OLA
+ Int_t electronics = 1; // 1 = PASCAL, 2 = OLA
const Int_t knParam = 5;
Int_t npeak = (Int_t)par[0];
Double_t fTimeStep = GetSeg()->Dpx( dummy );
Double_t fSddLength = GetSeg()->Dx();
Double_t anodePitch = GetSeg()->Dpz( dummy );
- Int_t electronics =GetResp(fModule)->GetElectronics(); // 1 = PASCAL, 2 = OLA
+ Int_t electronics =1;//GetResp(fModule)->GetElectronics(); // 1 = PASCAL, 2 = OLA
AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)GetResp(fModule);
AliITSresponseSDD* res = (AliITSresponseSDD*)cal->GetResponse();
const char *option=res->ZeroSuppOption();
fNDigits(0), //! number of Digits
fRunNumber(0), //! Run number (to access DB)
fDigits(), //! [NMod][NDigits]
+fSimuPar(0),
fDDLMapSDD(0),
fHitClassName(), // String with Hit class name.
fSDigClassName(),// String with SDigit class name.
fDigits = new TObjArray(fgkNdettypes);
fNDigits = new Int_t[fgkNdettypes];
fDDLMapSDD=new AliITSDDLModuleMapSDD();
+ fSimuPar= new AliITSSimuParam();
fNMod[0] = fgkDefaultNModulesSPD;
fNMod[1] = fgkDefaultNModulesSDD;
fNMod[2] = fgkDefaultNModulesSSD;
delete fPostProcess;
}
fPostProcess = 0;
+ if(fSimuPar) delete fSimuPar;
if(fDDLMapSDD) delete fDDLMapSDD;
if(fNDigits) delete [] fNDigits;
fNDigits = 0;
fNDigits(source.fNDigits), //! number of Digits
fRunNumber(source.fRunNumber), //! Run number (to access DB)
fDigits(source.fDigits), //! [NMod][NDigits]
+fSimuPar(source.fSimuPar),
fDDLMapSDD(source.fDDLMapSDD),
fHitClassName(source.fHitClassName), // String with Hit class name.
fSDigClassName(source.fSDigClassName),// String with SDigit class name.
#include <TObjArray.h>
#include <TClonesArray.h>
#include "AliITSCalibration.h"
+#include "AliITSSimuParam.h"
#include "AliITSDDLModuleMapSDD.h"
#include "AliITSLoader.h"
#include "AliITSgeom.h"
virtual AliITSresponse* GetResponse(Int_t dettype) {
return GetCalibrationModel(
GetITSgeom()->GetStartDet(dettype))->GetResponse();}
+
+ virtual void SetSimuParam(AliITSSimuParam* spar){
+ if(fSimuPar) delete fSimuPar;
+ fSimuPar = new AliITSSimuParam(*spar);
+ }
+ virtual AliITSSimuParam* GetSimuParam() const {return fSimuPar;}
+
virtual AliITSDDLModuleMapSDD* GetDDLModuleMapSDD()const { return fDDLMapSDD;}
TObjArray* GetCalibrationArray() const {return fCalibration;}
TObjArray* GetSegmentation() const {return fSegmentation;}
Int_t* fNDigits; //! [NDet] number of Digits for det.
Int_t fRunNumber; //! run number (to access DB)
TObjArray *fDigits; //! [NMod][NDigits]
+ AliITSSimuParam *fSimuPar; //! detector simulation parameters
AliITSDDLModuleMapSDD *fDDLMapSDD; //! mapping DDL/module -> SDD module number
TString fHitClassName; //! String with Hit class name
TString fSDigClassName;//! String with SDigit class name.
AliITSLoader* fLoader; //! loader
Bool_t fFirstcall; //! flag
- ClassDef(AliITSDetTypeSim,6) // ITS Simulation structure
+ ClassDef(AliITSDetTypeSim,7) // ITS Simulation structure
};
--- /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:$ */
+
+///////////////////////////////////////////////////////////////////
+// //
+// 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 "AliITSSimuParam.h"
+#include <TMath.h>
+
+const Float_t AliITSSimuParam::fgkSPDBiasVoltageDefault = 18.182;
+const Double_t AliITSSimuParam::fgkSPDThreshDefault = 3000.;
+const Double_t AliITSSimuParam::fgkSPDSigmaDefault = 250.;
+const TString AliITSSimuParam::fgkSPDCouplingOptDefault = "old";
+const Double_t AliITSSimuParam::fgkSPDCouplColDefault = 0.;
+const Double_t AliITSSimuParam::fgkSPDCouplRowDefault = 0.055;
+const Float_t AliITSSimuParam::fgkSPDEccDiffDefault = 0.85;
+const Float_t AliITSSimuParam::fgkSDDDiffCoeffDefault = 3.23;
+const Float_t AliITSSimuParam::fgkSDDDiffCoeff1Default = 30.;
+const Float_t AliITSSimuParam::fgkSDDJitterErrorDefault = 20.; // 20 um from beam test 2001
+const Float_t AliITSSimuParam::fgkSDDDynamicRangeDefault = 132.;
+const Int_t AliITSSimuParam::fgkSDDMaxAdcDefault = 1024;
+const Float_t AliITSSimuParam::fgkSDDChargeLossDefault = 0.;
+const Double_t AliITSSimuParam::fgkSSDCouplingPRDefault = 0.01;
+const Double_t AliITSSimuParam::fgkSSDCouplingPLDefault = 0.01;
+const Double_t AliITSSimuParam::fgkSSDCouplingNRDefault = 0.01;
+const Double_t AliITSSimuParam::fgkSSDCouplingNLDefault = 0.01;
+const Int_t AliITSSimuParam::fgkSSDZSThresholdDefault = 3;
+
+const Float_t AliITSSimuParam::fgkNsigmasDefault = 3.;
+const Int_t AliITSSimuParam::fgkNcompsDefault = 121;
+
+ClassImp(AliITSSimuParam)
+
+//______________________________________________________________________
+AliITSSimuParam::AliITSSimuParam():
+ TObject(),
+fGeVcharge(0.),
+fDOverV(0.),
+fSPDBiasVoltage(fgkSPDBiasVoltageDefault),
+fSPDThresh(fgkSPDThreshDefault),
+fSPDSigma(fgkSPDSigmaDefault),
+fSPDCouplOpt(0),
+fSPDCouplCol(fgkSPDCouplColDefault),
+fSPDCouplRow(fgkSPDCouplRowDefault),
+fSPDEccDiff(0.),
+fSDDElectronics(0),
+fSDDDiffCoeff(0.),
+fSDDDiffCoeff1(0.),
+fSDDJitterError(fgkSDDJitterErrorDefault),
+fSDDDynamicRange(fgkSDDDynamicRangeDefault),
+fSDDMaxAdc(0.),
+fSDDChargeLoss(fgkSDDChargeLossDefault),
+fSSDADCpereV(0.),
+fSSDCouplingPR(0),
+fSSDCouplingPL(0),
+fSSDCouplingNR(0),
+fSSDCouplingNL(0),
+fSSDZSThreshold(fgkSSDZSThresholdDefault),
+fNsigmas(fgkNsigmasDefault),
+fNcomps(fgkNcompsDefault),
+fGaus()
+{
+ // default constructor
+ SetGeVToCharge();
+ SetDistanceOverVoltage();
+ SetSPDCouplingOption(fgkSPDCouplingOptDefault);
+ SetSPDSigmaDiffusionAsymmetry(fgkSPDEccDiffDefault);
+ SetSDDElectronics();
+ SetSDDDiffCoeff(fgkSDDDiffCoeffDefault,fgkSDDDiffCoeff1Default);
+ SetSDDMaxAdc((Double_t)fgkSDDMaxAdcDefault);
+ SetSSDADCpereV();
+ SetSSDCouplings(fgkSSDCouplingPRDefault,fgkSSDCouplingPLDefault,fgkSSDCouplingNRDefault,fgkSSDCouplingNLDefault);
+}
+//______________________________________________________________________
+AliITSSimuParam::AliITSSimuParam(const AliITSSimuParam &simpar):
+TObject(),
+fGeVcharge(simpar.fGeVcharge),
+fDOverV(simpar.fDOverV),
+fSPDBiasVoltage(simpar.fSPDBiasVoltage),
+fSPDThresh(simpar.fSPDThresh),
+fSPDSigma(simpar.fSPDSigma),
+fSPDCouplOpt(simpar.fSPDCouplOpt),
+fSPDCouplCol(simpar.fSPDCouplCol),
+fSPDCouplRow(simpar.fSPDCouplRow),
+fSPDEccDiff(simpar.fSPDEccDiff),
+fSDDElectronics(simpar.fSDDElectronics),
+fSDDDiffCoeff(simpar.fSDDDiffCoeff),
+fSDDDiffCoeff1(simpar.fSDDDiffCoeff1),
+fSDDJitterError(simpar.fSDDJitterError),
+fSDDDynamicRange(simpar.fSDDDynamicRange),
+fSDDMaxAdc(simpar.fSDDMaxAdc),
+fSDDChargeLoss(simpar.fSDDChargeLoss),
+fSSDADCpereV(simpar.fSSDADCpereV),
+fSSDCouplingPR(simpar.fSSDCouplingPR),
+fSSDCouplingPL(simpar.fSSDCouplingPL),
+fSSDCouplingNR(simpar.fSSDCouplingNR),
+fSSDCouplingNL(simpar.fSSDCouplingNL),
+fSSDZSThreshold(simpar.fSSDZSThreshold),
+fNsigmas(simpar.fNsigmas),
+fNcomps(simpar.fNcomps),
+fGaus(){
+ // copy constructor
+}
+
+//______________________________________________________________________
+AliITSSimuParam& AliITSSimuParam::operator=(const AliITSSimuParam& source){
+ // Assignment operator.
+ this->~AliITSSimuParam();
+ new(this) AliITSSimuParam(source);
+ return *this;
+
+}
+
+
+//______________________________________________________________________
+AliITSSimuParam::~AliITSSimuParam() {
+ // destructor
+ if(fGaus) delete fGaus;
+}
+//________________________________________________________________________
+void AliITSSimuParam::SetNLookUp(Int_t p1){
+ // Set number of sigmas over which cluster disintegration is performed
+ fNcomps=p1;
+ if (fGaus) delete fGaus;
+ fGaus = new TArrayF(fNcomps+1);
+ for(Int_t i=0; i<=fNcomps; i++) {
+ Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
+ (*fGaus)[i] = exp(-((x*x)/2));
+ }
+}
+//________________________________________________________________________
+void AliITSSimuParam::PrintParameters() const{
+ printf("GeVToCharge = %G\n",fGeVcharge);
+ printf("DistanveOverVoltage = %f \n",fDOverV);
+ printf("\n");
+ printf("===== SPD parameters =====\n");
+ printf("Bias Voltage = %f \n",fSPDBiasVoltage);
+ printf("Threshold and sigma = %f %f\n",fSPDThresh,fSPDSigma);
+ printf("Coupling Option = %s\n",fSPDCouplOpt.Data());
+ printf("Coupling value (column) = %f\n",fSPDCouplCol);
+ printf("Coupling value (row) = %f\n",fSPDCouplRow);
+ printf("Eccentricity in diffusion = %f\n",fSPDEccDiff);
+ printf("\n");
+ printf("===== SDD parameters =====\n");
+ printf("Electronic chips = %d\n",fSDDElectronics);
+ printf("Diffusion Coefficients = %f %f\n",fSDDDiffCoeff,fSDDDiffCoeff1);
+ printf("Jitter Error = %f um\n",fSDDJitterError);
+ printf("Dynamic Range = %f\n",fSDDDynamicRange);
+ printf("Max. ADC = %f\n",fSDDMaxAdc);
+ printf("Charge Loss = %f\n",fSDDChargeLoss);
+ printf("\n");
+ printf("===== SSD parameters =====\n");
+ printf("ADC per eV = %f\n",fSSDADCpereV);
+ printf("Coupling PR = %f\n",fSSDCouplingPR);
+ printf("Coupling PL = %f\n",fSSDCouplingPL);
+ printf("Coupling NR = %f\n",fSSDCouplingNR);
+ printf("Coupling NL = %f\n",fSSDCouplingNL);
+ printf("Zero Supp threshold = %d\n",fSSDZSThreshold);
+}
--- /dev/null
+#ifndef ALIITSSIMUPARAM_H
+#define ALIITSSIMUPARAM_H
+/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id:$ */
+
+///////////////////////////////////////////////////////////////////
+// //
+// Class to store the parameters used in the simulation of //
+// SPD, SDD and SSD detectors //
+// Origin: F.Prino, Torino, prino@to.infn.it //
+// //
+///////////////////////////////////////////////////////////////////
+
+#include<TObject.h>
+#include <TString.h>
+#include <TArrayF.h>
+
+class AliITSSimuParam : public TObject {
+
+ public:
+ AliITSSimuParam();
+ AliITSSimuParam(const AliITSSimuParam& simpar);
+ // assignment operator
+ AliITSSimuParam& operator=(const AliITSSimuParam& source);
+ ~AliITSSimuParam();
+
+
+ void SetGeVToCharge(Double_t gc=3.6e-9){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=0.000375){fDOverV = dv;}
+ Double_t GetDistanceOverVoltage() const {return fDOverV;}
+
+
+
+ void SetSPDBiasVoltage(Double_t bias=18.182) {fSPDBiasVoltage=bias;}
+ Double_t GetSPDBiasVoltage() const {return fSPDBiasVoltage;}
+
+ void SetSPDThresholds(Double_t thresh, Double_t sigma)
+ {fSPDThresh=thresh; fSPDSigma=sigma;}
+ void Thresholds(Double_t &thresh, Double_t &sigma) const
+ {thresh=fSPDThresh; sigma=fSPDSigma;}
+
+ void SetSPDCouplingOption(const char *opt) {fSPDCouplOpt=opt;}
+ void GetSPDCouplingOption(char *opt) const {strcpy(opt,fSPDCouplOpt.Data());}
+
+ void SetSPDCouplingParam(Double_t col, Double_t row)
+ {fSPDCouplCol = col; fSPDCouplRow = row;}
+ void GetSPDCouplingParam(Double_t &col, Double_t &row) const
+ {col = fSPDCouplCol; row = fSPDCouplRow;}
+
+ void SetSPDSigmaDiffusionAsymmetry(Double_t ecc) {fSPDEccDiff=ecc;}
+ void GetSPDSigmaDiffusionAsymmetry(Double_t &ecc) const {ecc=fSPDEccDiff;}
+
+ void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1; }
+ Int_t GetSDDElectronics() const {return fSDDElectronics;}
+
+ void SetSDDDiffCoeff(Float_t p1, Float_t p2) {
+ fSDDDiffCoeff=p1; fSDDDiffCoeff1=p2;}
+ void GetSDDDiffCoeff(Float_t &diff,Float_t &diff1) const {
+ diff=fSDDDiffCoeff; diff1=fSDDDiffCoeff1;}
+
+ void SetSDDJitterError(Float_t jitter) {fSDDJitterError=jitter;}
+ Float_t GetSDDJitterError() const {return fSDDJitterError;}
+
+ void SetSDDDynamicRange(Double_t p1) {fSDDDynamicRange = p1;}
+ Float_t GetSDDDynamicRange() const {return fSDDDynamicRange;}
+
+ void SetSDDMaxAdc(Double_t p1) {fSDDMaxAdc=p1;}
+ Float_t GetSDDMaxAdc() const {return fSDDMaxAdc;}
+
+ void SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;}
+ Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;}
+
+
+ void SetSSDADCpereV(Double_t a=120./24888.9){fSSDADCpereV = a;}
+ Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
+ Int_t GetSSDIEvToADC(Double_t eV) const {
+ return ((Int_t) GetSSDDEvToADC(eV)); }
+
+ void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) {
+ fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; }
+ Double_t GetSSDCouplingPR() const {return fSSDCouplingPR;}
+ Double_t GetSSDCouplingPL() const {return fSSDCouplingPL;}
+ Double_t GetSSDCouplingNR() const {return fSSDCouplingNR;}
+ Double_t GetSSDCouplingNL() const {return fSSDCouplingNL;}
+
+ void SetNSigmaIntegration(Double_t p1) {fNsigmas=p1;}
+ Float_t GetNSigmaIntegration() const {return fNsigmas;}
+ void SetNLookUp(Int_t p1);
+ Int_t GetGausNLookUp() const {return fNcomps;}
+ Float_t GetGausLookUp(Int_t i) {
+ if (!fGaus) SetNLookUp(fgkNcompsDefault);
+ if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);
+ }
+
+ void PrintParameters() const;
+
+ protected:
+
+ static const Float_t fgkSPDBiasVoltageDefault;//default for fSPDBiasVoltage
+ static const Double_t fgkSPDThreshDefault; //default for fThresh
+ static const Double_t fgkSPDSigmaDefault; //default for fSigma
+ static const TString fgkSPDCouplingOptDefault; // type of pixel Coupling (old or new)
+ static const Double_t fgkSPDCouplColDefault; //default for fSPDCouplCol
+ static const Double_t fgkSPDCouplRowDefault; //default for fSPDCouplRow
+ static const Float_t fgkSPDEccDiffDefault;//default for fSPDEccDiff
+ static const Float_t fgkSDDDiffCoeffDefault; // default for fSDDDiffCoeff
+ static const Float_t fgkSDDDiffCoeff1Default; // default for fSDDDiffCoeff1
+ static const Float_t fgkSDDJitterErrorDefault; // default for fSDDJitterError
+ static const Float_t fgkSDDDynamicRangeDefault; // default for fSDDDynamicRange
+ static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc
+ static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss
+
+ static const Double_t fgkSSDCouplingPRDefault; // default values
+ static const Double_t fgkSSDCouplingPLDefault; // for the
+ static const Double_t fgkSSDCouplingNRDefault; // various SSD
+ static const Double_t fgkSSDCouplingNLDefault; // couplings
+ static const Int_t fgkSSDZSThresholdDefault; // default for fSSDZSThreshold
+
+ static const Float_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 fSPDBiasVoltage; // Bias Voltage for the SPD
+ Double_t fSPDThresh; // SPD Threshold value
+ Double_t fSPDSigma; // SPD Noise + threshold fluctuations value
+ TString fSPDCouplOpt; // SPD Coupling Option
+ Double_t fSPDCouplCol; // SPD Coupling parameter along the cols
+ Double_t fSPDCouplRow; // SPD Coupling parameter along the rows
+ Float_t fSPDEccDiff; // Eccentricity (i.e. asymmetry parameter) in the
+ // Gaussian diffusion for SPD
+
+ Int_t fSDDElectronics; // SDD Electronics Pascal (1) or OLA (2)
+ Float_t fSDDDiffCoeff; // SDD Diffusion Coefficient (scaling the time)
+ Float_t fSDDDiffCoeff1; // SDD Diffusion Coefficient (constant term)
+ Float_t fSDDJitterError; // SDD jitter error
+ Float_t fSDDDynamicRange; // SDD Dynamic Range
+ Float_t fSDDMaxAdc; // SDD ADC saturation value
+ Float_t fSDDChargeLoss; // Set Linear Coefficient for Charge Loss
+
+ Double_t fSSDADCpereV; // Constant to convert eV to ADC for SSD.
+ Double_t fSSDCouplingPR; // SSD couplings
+ Double_t fSSDCouplingPL; // SSD couplings
+ Double_t fSSDCouplingNR; // SSD couplings
+ Double_t fSSDCouplingNL; // SSD couplings
+ Int_t fSSDZSThreshold; // SSD threshold for the zero suppresion
+
+ Float_t fNsigmas; // Number of sigmas over which charge disintegration
+ // is performed
+ Int_t fNcomps; // Number of samplings along the gaussian
+ TArrayF *fGaus; // Gaussian lookup table for signal generation
+
+ ClassDef(AliITSSimuParam,1);
+};
+#endif
#include "AliITSresponseSDD.h"
-const Int_t AliITSresponseSDD::fgkMaxAdcDefault = 1024;
-const Float_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
-const Float_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
-const Float_t AliITSresponseSDD::fgkDiffCoeffDefault = 3.23;
-const Float_t AliITSresponseSDD::fgkDiffCoeff1Default = 30.;
const TString AliITSresponseSDD::fgkOptionDefault = "ZS";
const Float_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
const Float_t AliITSresponseSDD::fgkTimeOffsetDefault = 54.30;
const Float_t AliITSresponseSDD::fgkADC2keVDefault = 5.243;
-const Float_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
-const Int_t AliITSresponseSDD::fgkNcompsDefault = 121;
ClassImp(AliITSresponseSDD)
//_________________________________________________________________________
AliITSresponseSDD::AliITSresponseSDD():
AliITSresponse(),
-fJitterError(0.),
-fDynamicRange(0.),
-fChargeLoss(0.),
fTimeOffset(fgkTimeOffsetDefault),
fADC2keV(fgkADC2keVDefault),
-fElectronics(0),
-fMaxAdc(fgkMaxAdcDefault),
-fNsigmas(fgkNsigmasDefault),
-fGaus(),
-fNcomps(fgkNcompsDefault),
fOption(){
// default constructor
- fGaus = 0;
- SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
- // SetNLookUp(fgkNcompsDefault);
-
- SetJitterError();
- SetElectronics();
- SetDynamicRange(fgkDynamicRangeDefault);
- SetChargeLoss(fgkfChargeLossDefault);
SetZeroSupp(fgkOptionDefault);
}
-//______________________________________________________________________
-AliITSresponseSDD::~AliITSresponseSDD() {
-
- if(fGaus) delete fGaus;
-}
-
-
-//________________________________________________________________________
-void AliITSresponseSDD::SetNLookUp(Int_t p1){
- // Set number of sigmas over which cluster disintegration is performed
- fNcomps=p1;
- if (fGaus) delete fGaus;
- fGaus = new TArrayF(fNcomps+1);
- for(Int_t i=0; i<=fNcomps; i++) {
- Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
- (*fGaus)[i] = exp(-((x*x)/2));
- }
-}
public:
AliITSresponseSDD();
- virtual ~AliITSresponseSDD();
-
- virtual void SetElectronics(Int_t p1=1)
- {fElectronics=p1; /* Electronics: Pascal (1) or OLA (2) */ }
- virtual Int_t Electronics() const {// Electronics: 1 = Pascal; 2 = OLA
- return fElectronics;}
- virtual void SetMaxAdc(Double_t p1) {// Adc-count saturation value
- fMaxAdc=p1;}
- virtual Float_t MaxAdc() const {// Get maximum Adc-count value
- return fMaxAdc;}
- virtual void SetChargeLoss(Double_t p1) {
- // Set Linear Charge Loss Steepness // 0.01 for 20%
- fChargeLoss=p1;}
- virtual Float_t ChargeLoss() const {// Get Charge Loss Coefficient
- return fChargeLoss;}
- virtual void SetDynamicRange(Double_t p1) {// Set Dynamic Range
- fDynamicRange = p1;}
- virtual Float_t DynamicRange() const {// Get Dynamic Range
- return fDynamicRange;}
+ virtual ~AliITSresponseSDD(){};
static Float_t DefaultDriftSpeed() {return fgkDriftSpeedDefault;}
const char *ZeroSuppOption() const {// Get zero-suppression option
return fOption.Data();}
// Detector type response methods
- virtual void SetNSigmaIntegration(Double_t p1) {
- // Set number of sigmas over which cluster disintegration is performed
- fNsigmas=p1;}
- virtual Float_t NSigmaIntegration() const {
- // Get number of sigmas over which cluster disintegration is performed
- return fNsigmas;}
- virtual void SetNLookUp(Int_t p1);
- // Get number of intervals in which the gaussian lookup table is divided
- virtual Int_t GausNLookUp() const {return fNcomps;}
- virtual Float_t GausLookUp(Int_t i) {
- if (!fGaus) SetNLookUp(fgkNcompsDefault);
- if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);
- }
-
- void SetJitterError(Float_t jitter=20) {
- // set Jitter error (20 um for ALICE from beam test measurements 2001)
- fJitterError=jitter;}
- Float_t JitterError() const {// set Jitter error
- return fJitterError;}
protected:
- static const Int_t fgkMaxAdcDefault; // default for fMaxAdc
- static const Float_t fgkDynamicRangeDefault; // default for fDynamicRange
- static const Float_t fgkfChargeLossDefault; // default for fChargeLoss
- static const Float_t fgkDiffCoeffDefault; // default for fDiffCoeff
- static const Float_t fgkDiffCoeff1Default; // default for fDiffCoeff1
static const TString fgkOptionDefault; // default for fOption
static const Float_t fgkDriftSpeedDefault; // default for drift speed
static const Float_t fgkTimeOffsetDefault; // default for fTimeOffset
static const Float_t fgkADC2keVDefault; // default for fADC2keV
- static const Float_t fgkNsigmasDefault; //default for fNsigmas
- static const Int_t fgkNcompsDefault; //default for fNcomps
-
- Float_t fJitterError; // jitter error
- Float_t fDynamicRange; // Set Dynamic Range
- Float_t fChargeLoss; // Set Linear Coefficient for Charge Loss
Float_t fTimeOffset; // Time offset due to electronic delays
Float_t fADC2keV; // Conversion factor from ADC to keV
- Int_t fElectronics; // Electronics
- Float_t fMaxAdc; // Adc saturation value
- Float_t fNsigmas; // Number of sigmas over which charge disintegration
- // is performed
- TArrayF *fGaus; // Gaussian lookup table for signal generation
- Int_t fNcomps; // Number of samplings along the gaussian
TString fOption; // Zero-suppresion option (ZS or non-ZS)
private:
AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor
AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op.
- ClassDef(AliITSresponseSDD,12) // Base response class
+ ClassDef(AliITSresponseSDD,13) // Base response class
};
#endif
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
- AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
+ AliITSSimuParam* simpar = fDetType->GetSimuParam();
fpList = new AliITSpList( seg->Npz(),
fScaleSize*seg->Npx() );
fHitSigMap2 = new AliITSMapA2(seg,fScaleSize,1);
fElectronics = new AliITSetfSDD(timeStep/fScaleSize,
- res->Electronics());
+ simpar->GetSDDElectronics());
fITS = (AliITS*)gAlice->GetModule("ITS");
Bool_t AliITSsimulationSDD::AddSDigitsToModule(TClonesArray *pItemArray,
Int_t mask ) {
// Add Summable digits to module maps.
- AliITSresponseSDD* res = (AliITSresponseSDD*)fDetType->GetResponse(1);
+ AliITSSimuParam* simpar = fDetType->GetSimuParam();
Int_t nItems = pItemArray->GetEntries();
- Double_t maxadc = res->MaxAdc();
+ Double_t maxadc = simpar->GetSDDMaxAdc();
Bool_t sig = kFALSE;
// cout << "Adding "<< nItems <<" SDigits to module " << fModule << endl;
// create maps to build the lists of tracks for each digit
AliITSsegmentationSDD* seg = (AliITSsegmentationSDD*)GetSegmentationModel(1);
AliITSCalibrationSDD* res = (AliITSCalibrationSDD*)GetCalibrationModel(fModule);
+ AliITSSimuParam* simpar = fDetType->GetSimuParam();
+
TObjArray *hits = mod->GetHits();
Int_t nhits = hits->GetEntriesFast();
Double_t anodePitch = seg->Dpz(0);
Double_t timeStep = seg->Dpx(0);
Double_t driftSpeed ; // drift velocity (anode dependent)
- //Float_t maxadc = res->GetMaxAdc();
- //Float_t topValue = res->GetDynamicRange();
- Double_t norm = res->GetMaxAdc()/res->GetDynamicRange(); // maxadc/topValue;
- Double_t cHloss = res->GetChargeLoss();
- Float_t dfCoeff, s1; res->DiffCoeff(dfCoeff,s1); // Signal 2d Shape
- Double_t eVpairs = res->GetGeVToCharge()*1.0E9; // 3.6 eV by def.
- Double_t nsigma = res->GetNSigmaIntegration(); //
- Int_t nlookups = res->GetGausNLookUp(); //
- Float_t jitter = res->GetJitterError(); //
-
+ Double_t norm = simpar->GetSDDMaxAdc()/simpar->GetSDDDynamicRange(); // maxadc/topValue;
+ Double_t cHloss = simpar->GetSDDChargeLoss();
+ Float_t dfCoeff, s1;
+ simpar->GetSDDDiffCoeff(dfCoeff,s1); // Signal 2d Shape
+ Double_t eVpairs = simpar->GetGeVToCharge()*1.0E9; // 3.6 eV by def.
+ Double_t nsigma = simpar->GetNSigmaIntegration(); //
+ Int_t nlookups = simpar->GetGausNLookUp(); //
+ Float_t jitter = simpar->GetSDDJitterError(); //
+
// Piergiorgio's part (apart for few variables which I made float
// when i thought that can be done
// Fill detector maps with GEANT hits
if(TMath::Abs(aExpo) > nsigma) anodeAmplitude = 0.;
else {
Int_t theBin = (Int_t) ((aExpo+nsigma)/width+0.5);
- anodeAmplitude = amplitude*res->GetGausLookUp(theBin);
+ anodeAmplitude = amplitude*simpar->GetGausLookUp(theBin);
} // end if TMath::Abs(aEspo) > nsigma
// index starts from 0
index = iWing*nofAnodes+ia-1;
if(TMath::Abs(tExpo) > nsigma) timeAmplitude = 0.;
else {
Int_t theBin = (Int_t) ((tExpo+nsigma)/width+0.5);
- timeAmplitude = anodeAmplitude*res->GetGausLookUp(theBin);
+ timeAmplitude = anodeAmplitude*simpar->GetGausLookUp(theBin);
} // end if TMath::Abs(tExpo) > nsigma
// build the list of Sdigits for this module
// arg[0] = index;
Double_t gain=0;
Float_t contrib=0;
Int_t i,k,kk;
- Float_t maxadc = res->GetMaxAdc();
+ AliITSSimuParam* simpar = fDetType->GetSimuParam();
+ Float_t maxadc = simpar->GetSDDMaxAdc();
for (i=0;i<fNofMaps;i++) {
if( !fAnodeFire[i] ) continue;
#pragma link C++ class AliITSTableSSD+;
#pragma link C++ class AliITSsimulationFastPoints+;
#pragma link C++ class AliITSsimulationFastPointsV0+;
+#pragma link C++ class AliITSSimuParam+;
#pragma link C++ class AliITSDetTypeSim+;
#pragma link C++ class AliITSstatistics+;
#pragma link C++ class AliITSstatistics2+;
AliITSvtest.cxx \
AliITSvSSD03.cxx \
AliITShit.cxx \
+ AliITSSimuParam.cxx \
AliITSDetTypeSim.cxx \
AliITSmodule.cxx \
AliITSsimulationFastPoints.cxx \