[u/mrichter/AliRoot.git] / TRD / AliTRDSimParam.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// Class containing constant simulation parameters                        //
//                                                                        //
// Request an instance with AliTRDSimParam::Instance()                    //
// Then request the needed values                                         //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <TMath.h>

#include "AliRun.h"

#include "AliTRDSimParam.h"

ClassImp(AliTRDSimParam)

AliTRDSimParam *AliTRDSimParam::fgInstance   = 0;
Bool_t          AliTRDSimParam::fgTerminated = kFALSE;

//_ singleton implementation __________________________________________________
AliTRDSimParam* AliTRDSimParam::Instance()
{
  //
  // Singleton implementation
  // Returns an instance of this class, it is created if neccessary
  // 
  
  if (fgTerminated != kFALSE) {
    return 0;
  }

  if (fgInstance == 0) {
    fgInstance = new AliTRDSimParam();
  }  

  return fgInstance;

}

//_ singleton implementation __________________________________________________
void AliTRDSimParam::Terminate()
{
  //
  // Singleton implementation
  // Deletes the instance of this class and sets the terminated flag,
  // instances cannot be requested anymore
  // This function can be called several times.
  //
  
  fgTerminated = kTRUE;
  
  if (fgInstance != 0) {
    delete fgInstance;
    fgInstance = 0;
  }

}

//_____________________________________________________________________________
AliTRDSimParam::AliTRDSimParam()
  :TObject()
  ,fGasGain(0.0)
  ,fNoise(0.0)
  ,fChipGain(0.0)
  ,fADCoutRange(0.0)
  ,fADCinRange(0.0)
  ,fADCthreshold(0)
  ,fADCbaseline(0)
  ,fDiffusionOn(kFALSE)
  ,fElAttachOn(kFALSE)
  ,fElAttachProp(0.0)
  ,fTRFOn(kFALSE)
  ,fTRFsmp(0)
  ,fTRFbin(0)
  ,fTRFlo(0.0)
  ,fTRFhi(0.0)
  ,fTRFwid(0.0)
  ,fCTOn(kFALSE)
  ,fCTsmp(0)
  ,fAnodeWireOffset(0.0)
  ,fPadCoupling(0.0)
  ,fTimeCoupling(0.0)
  ,fTimeStructOn(kFALSE)
  ,fPRFOn(kFALSE)
{
  //
  // Default constructor
  //
  
  Init();

}

//_____________________________________________________________________________
void AliTRDSimParam::Init()
{
  // 
  // Default initializiation
  //
  
  // The default parameter for the digitization
  fGasGain           = 4000.0;
  fChipGain          =   12.4;
  fNoise             = 1250.0;
  fADCoutRange       = 1023.0;          // 10-bit ADC
  fADCinRange        = 2000.0;          // 2V input range
  fADCthreshold      =    3;
  // Go back to 0 again, just to be consistent with reconstruction
  fADCbaseline       =    0;
  //fADCbaseline       =   10;

  // Diffusion on
  fDiffusionOn       = kTRUE;
  
  // Propability for electron attachment
  fElAttachOn        = kFALSE;
  fElAttachProp      = 0.0;

  // The time response function
  fTRFOn             = kTRUE;

  // The cross talk
  fCTOn              = kTRUE;

  // The pad coupling factor
  // Use 0.46, instead of the theroetical value 0.3, since it reproduces better 
  // the test beam data, even tough it is not understood why.
  fPadCoupling       = 0.46;

  // The time coupling factor (same number as for the TPC)
  fTimeCoupling      = 0.4;

  // Distance of first Anode wire from first pad edge
  fAnodeWireOffset   = 0.25;

  // Use drift time maps
  fTimeStructOn      = kTRUE;
  
  // The pad response function
  fPRFOn             = kTRUE;

  ReInit();

}

//_____________________________________________________________________________
AliTRDSimParam::~AliTRDSimParam() 
{
  //
  // Destructor
  //
  
  if (fTRFsmp) {
    delete [] fTRFsmp;
    fTRFsmp = 0;
  }

  if (fCTsmp) {
    delete [] fCTsmp;
    fCTsmp  = 0;
  }

}

//_____________________________________________________________________________
AliTRDSimParam::AliTRDSimParam(const AliTRDSimParam &p)
  :TObject(p)
  ,fGasGain(p.fGasGain)
  ,fNoise(p.fNoise)
  ,fChipGain(p.fChipGain)
  ,fADCoutRange(p.fADCoutRange)
  ,fADCinRange(p.fADCinRange)
  ,fADCthreshold(p.fADCthreshold)
  ,fADCbaseline(p.fADCbaseline)
  ,fDiffusionOn(p.fDiffusionOn)
  ,fElAttachOn(p.fElAttachOn)
  ,fElAttachProp(p.fElAttachProp)
  ,fTRFOn(p.fTRFOn)
  ,fTRFsmp(0)
  ,fTRFbin(p.fTRFbin)
  ,fTRFlo(p.fTRFlo)
  ,fTRFhi(p.fTRFhi)
  ,fTRFwid(p.fTRFwid)
  ,fCTOn(p.fCTOn)
  ,fCTsmp(0)
  ,fAnodeWireOffset(p.fAnodeWireOffset)
  ,fPadCoupling(p.fPadCoupling)
  ,fTimeCoupling(p.fTimeCoupling)
  ,fTimeStructOn(p.fTimeStructOn)
  ,fPRFOn(p.fPRFOn)
{
  //
  // Copy constructor
  //

  Int_t iBin = 0;

  if (((AliTRDSimParam &) p).fTRFsmp) {
    delete [] ((AliTRDSimParam &) p).fTRFsmp;
  }
  ((AliTRDSimParam &) p).fTRFsmp = new Float_t[fTRFbin];
  for (iBin = 0; iBin < fTRFbin; iBin++) {
    ((AliTRDSimParam &) p).fTRFsmp[iBin] = fTRFsmp[iBin];
  }                                                                             

  if (((AliTRDSimParam &) p).fCTsmp) {
    delete [] ((AliTRDSimParam &) p).fCTsmp;
  }
  ((AliTRDSimParam &) p).fCTsmp  = new Float_t[fTRFbin];
  for (iBin = 0; iBin < fTRFbin; iBin++) {
    ((AliTRDSimParam &) p).fCTsmp[iBin] = fCTsmp[iBin];
  }                                                                             

}

//_____________________________________________________________________________
AliTRDSimParam &AliTRDSimParam::operator=(const AliTRDSimParam &p)
{
  //
  // Assignment operator
  //

  if (this != &p) {
    ((AliTRDSimParam &) p).Copy(*this);
  }

  return *this;

}

//_____________________________________________________________________________
void AliTRDSimParam::Copy(TObject &p) const
{
  //
  // Copy function
  //
  
  AliTRDSimParam *target = dynamic_cast<AliTRDSimParam *> (&p);
  if (!target) {
    return;
  }

  target->fGasGain            = fGasGain;
  target->fNoise              = fNoise;
  target->fChipGain           = fChipGain;  
  target->fADCoutRange        = fADCoutRange;
  target->fADCinRange         = fADCinRange;
  target->fADCthreshold       = fADCthreshold;
  target->fADCbaseline        = fADCbaseline; 
  target->fDiffusionOn        = fDiffusionOn; 
  target->fElAttachOn         = fElAttachOn;
  target->fElAttachProp       = fElAttachProp;
  target->fTRFOn              = fTRFOn;
  target->fTRFbin             = fTRFbin;
  target->fTRFlo              = fTRFlo;
  target->fTRFhi              = fTRFhi;
  target->fTRFwid             = fTRFwid;
  target->fCTOn               = fCTOn;
  target->fAnodeWireOffset    = fAnodeWireOffset;
  target->fPadCoupling        = fPadCoupling;
  target->fTimeCoupling       = fTimeCoupling;
  target->fPRFOn              = fPRFOn;

  if (target->fTRFsmp) {
    delete[] target->fTRFsmp;
  }
  target->fTRFsmp = new Float_t[fTRFbin];
  for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
    target->fTRFsmp[iBin] = fTRFsmp[iBin];
  }

  if (target->fCTsmp) {
    delete[] target->fCTsmp;
  }
  target->fCTsmp  = new Float_t[fTRFbin];
  for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
    target->fCTsmp[iBin]  = fCTsmp[iBin];
  }
  
}

//_____________________________________________________________________________
void AliTRDSimParam::ReInit()
{
  //
  // Reinitializes the parameter class after a change
  //

  // The range and the binwidth for the sampled TRF 
  fTRFbin = 200;
  // Start 0.2 mus before the signal
  fTRFlo  = -0.4;
  // End the maximum drift time after the signal 
  fTRFhi  =  3.58;
  fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);

  // Create the sampled TRF
  SampleTRF();

}

//_____________________________________________________________________________
void AliTRDSimParam::SampleTRF()
{
  //
  // Samples the new time response function.
  // From Antons measurements with Fe55 source, adjusted by C. Lippmann.
  // time bins are -0.4, -0.38, -0.36, ...., 3.54, 3.56, 3.58 microseconds
  //

  const Int_t kNpasa     = 200;  // kNpasa should be equal to fTRFbin!

  Float_t signal[kNpasa]={ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000
			 , 0.0002, 0.0007, 0.0026, 0.0089, 0.0253, 0.0612, 0.1319
			 , 0.2416, 0.3913, 0.5609, 0.7295, 0.8662, 0.9581, 1.0000
			 , 0.9990, 0.9611, 0.8995, 0.8269, 0.7495, 0.6714, 0.5987
			 , 0.5334, 0.4756, 0.4249, 0.3811, 0.3433, 0.3110, 0.2837
			 , 0.2607, 0.2409, 0.2243, 0.2099, 0.1974, 0.1868, 0.1776
			 , 0.1695, 0.1627, 0.1566, 0.1509, 0.1457, 0.1407, 0.1362
			 , 0.1317, 0.1274, 0.1233, 0.1196, 0.1162, 0.1131, 0.1102
			 , 0.1075, 0.1051, 0.1026, 0.1004, 0.0979, 0.0956, 0.0934
			 , 0.0912, 0.0892, 0.0875, 0.0858, 0.0843, 0.0829, 0.0815
			 , 0.0799, 0.0786, 0.0772, 0.0757, 0.0741, 0.0729, 0.0718
			 , 0.0706, 0.0692, 0.0680, 0.0669, 0.0655, 0.0643, 0.0630
			 , 0.0618, 0.0607, 0.0596, 0.0587, 0.0576, 0.0568, 0.0558
			 , 0.0550, 0.0541, 0.0531, 0.0522, 0.0513, 0.0505, 0.0497
			 , 0.0490, 0.0484, 0.0474, 0.0465, 0.0457, 0.0449, 0.0441
			 , 0.0433, 0.0425, 0.0417, 0.0410, 0.0402, 0.0395, 0.0388
			 , 0.0381, 0.0374, 0.0368, 0.0361, 0.0354, 0.0348, 0.0342
			 , 0.0336, 0.0330, 0.0324, 0.0318, 0.0312, 0.0306, 0.0301
			 , 0.0296, 0.0290, 0.0285, 0.0280, 0.0275, 0.0270, 0.0265
			 , 0.0260, 0.0256, 0.0251, 0.0246, 0.0242, 0.0238, 0.0233
			 , 0.0229, 0.0225, 0.0221, 0.0217, 0.0213, 0.0209, 0.0206
			 , 0.0202, 0.0198, 0.0195, 0.0191, 0.0188, 0.0184, 0.0181
			 , 0.0178, 0.0175, 0.0171, 0.0168, 0.0165, 0.0162, 0.0159
			 , 0.0157, 0.0154, 0.0151, 0.0148, 0.0146, 0.0143, 0.0140
			 , 0.0138, 0.0135, 0.0133, 0.0131, 0.0128, 0.0126, 0.0124
			 , 0.0121, 0.0119, 0.0120, 0.0115, 0.0113, 0.0111, 0.0109
			 , 0.0107, 0.0105, 0.0103, 0.0101, 0.0100, 0.0098, 0.0096
			 , 0.0094, 0.0092, 0.0091, 0.0089, 0.0088, 0.0086, 0.0084
			 , 0.0083, 0.0081, 0.0080, 0.0078 };

  Float_t xtalk[kNpasa];

  // With undershoot, positive peak corresponds to ~3% of the main signal:
  for (Int_t ipasa = 3; ipasa < kNpasa; ipasa++) {
    xtalk[ipasa] = 0.2 * (signal[ipasa-2] - signal[ipasa-3]);
  }

  xtalk[0]  = 0.0;   
  xtalk[1]  = 0.0;  
  xtalk[2]  = 0.0;  

  signal[0] = 0.0;
  signal[1] = 0.0;
  signal[2] = 0.0;

  if (fTRFsmp) {
    delete [] fTRFsmp;
  }
  fTRFsmp = new Float_t[fTRFbin];

  if (fCTsmp)  {
    delete [] fCTsmp;
  }
  fCTsmp  = new Float_t[fTRFbin];

  for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
    fTRFsmp[iBin] = signal[iBin];
    fCTsmp[iBin]  = xtalk[iBin];
  }

}

//_____________________________________________________________________________
Double_t AliTRDSimParam::TimeResponse(Double_t time) const
{
  //
  // Applies the preamp shaper time response
  // (We assume a signal rise time of 0.2us = fTRFlo/2.
  //

  Int_t iBin = ((Int_t) ((time - fTRFlo/2.0) / fTRFwid)); 
  if ((iBin >=       0) && 
      (iBin <  fTRFbin)) {
    return fTRFsmp[iBin];
  }
  else {
    return 0.0;
  }    

}

//_____________________________________________________________________________
Double_t AliTRDSimParam::CrossTalk(Double_t time) const
{
  //
  // Applies the pad-pad capacitive cross talk
  //

  Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid)); 
  if ((iBin >=       0) && 
      (iBin <  fTRFbin)) {
    return fCTsmp[iBin];
  }
  else {
    return 0.0;
  }    

}
Commit	Line	Data
3551db50	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
4d18a639	18	////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Class containing constant simulation parameters //
	21	// //
	22	// Request an instance with AliTRDSimParam::Instance() //
	23	// Then request the needed values //
	24	// //
	25	////////////////////////////////////////////////////////////////////////////
3551db50	26
	27	#include <TMath.h>
	28
	29	#include "AliRun.h"
	30
	31	#include "AliTRDSimParam.h"
	32
	33	ClassImp(AliTRDSimParam)
	34
4d18a639	35	AliTRDSimParam *AliTRDSimParam::fgInstance = 0;
4d18a639	36	Bool_t AliTRDSimParam::fgTerminated = kFALSE;
3551db50	37
	38	//_ singleton implementation __________________________________________________
	39	AliTRDSimParam* AliTRDSimParam::Instance()
	40	{
	41	//
	42	// Singleton implementation
	43	// Returns an instance of this class, it is created if neccessary
	44	//
	45
4d18a639	46	if (fgTerminated != kFALSE) {
3551db50	47	return 0;
4d18a639	48	}
3551db50	49
4d18a639	50	if (fgInstance == 0) {
3551db50	51	fgInstance = new AliTRDSimParam();
4d18a639	52	}
4d18a639	53
3551db50	54	return fgInstance;
4d18a639	55
3551db50	56	}
3551db50	57
4d18a639	58	//_ singleton implementation __________________________________________________
3551db50	59	void AliTRDSimParam::Terminate()
	60	{
	61	//
	62	// Singleton implementation
4d18a639	63	// Deletes the instance of this class and sets the terminated flag,
4d18a639	64	// instances cannot be requested anymore
3551db50	65	// This function can be called several times.
	66	//
	67
	68	fgTerminated = kTRUE;
	69
4d18a639	70	if (fgInstance != 0) {
3551db50	71	delete fgInstance;
	72	fgInstance = 0;
	73	}
4d18a639	74
3551db50	75	}
	76
	77	//_____________________________________________________________________________
	78	AliTRDSimParam::AliTRDSimParam()
4d18a639	79	:TObject()
	80	,fGasGain(0.0)
	81	,fNoise(0.0)
	82	,fChipGain(0.0)
	83	,fADCoutRange(0.0)
	84	,fADCinRange(0.0)
	85	,fADCthreshold(0)
	86	,fADCbaseline(0)
	87	,fDiffusionOn(kFALSE)
	88	,fElAttachOn(kFALSE)
	89	,fElAttachProp(0.0)
	90	,fTRFOn(kFALSE)
	91	,fTRFsmp(0)
	92	,fTRFbin(0)
	93	,fTRFlo(0.0)
	94	,fTRFhi(0.0)
	95	,fTRFwid(0.0)
	96	,fCTOn(kFALSE)
	97	,fCTsmp(0)
	98	,fAnodeWireOffset(0.0)
	99	,fPadCoupling(0.0)
	100	,fTimeCoupling(0.0)
	101	,fTimeStructOn(kFALSE)
	102	,fPRFOn(kFALSE)
3551db50	103	{
3551db50	104	//
4d18a639	105	// Default constructor
3551db50	106	//
3551db50	107
3551db50	108	Init();
4d18a639	109
3551db50	110	}
	111
	112	//_____________________________________________________________________________
	113	void AliTRDSimParam::Init()
	114	{
	115	//
4d18a639	116	// Default initializiation
3551db50	117	//
	118
	119	// The default parameter for the digitization
b43a3e17	120	fGasGain = 4000.0;
b43a3e17	121	fChipGain = 12.4;
60243ea4	122	fNoise = 1250.0;
b43a3e17	123	fADCoutRange = 1023.0; // 10-bit ADC
	124	fADCinRange = 2000.0; // 2V input range
	125	fADCthreshold = 3;
c2798013	126	// Go back to 0 again, just to be consistent with reconstruction
	127	fADCbaseline = 0;
	128	//fADCbaseline = 10;
3551db50	129
3551db50	130	// Diffusion on
b43a3e17	131	fDiffusionOn = kTRUE;
3551db50	132
3551db50	133	// Propability for electron attachment
b43a3e17	134	fElAttachOn = kFALSE;
b43a3e17	135	fElAttachProp = 0.0;
3551db50	136
3551db50	137	// The time response function
b43a3e17	138	fTRFOn = kTRUE;
3551db50	139
3551db50	140	// The cross talk
b43a3e17	141	fCTOn = kTRUE;
3551db50	142
3551db50	143	// The pad coupling factor
4d18a639	144	// Use 0.46, instead of the theroetical value 0.3, since it reproduces better
4d18a639	145	// the test beam data, even tough it is not understood why.
b43a3e17	146	fPadCoupling = 0.46;
3551db50	147
3551db50	148	// The time coupling factor (same number as for the TPC)
b43a3e17	149	fTimeCoupling = 0.4;
3551db50	150
3551db50	151	// Distance of first Anode wire from first pad edge
b43a3e17	152	fAnodeWireOffset = 0.25;
3551db50	153
3551db50	154	// Use drift time maps
b43a3e17	155	fTimeStructOn = kTRUE;
3551db50	156
cc7cef99	157	// The pad response function
b43a3e17	158	fPRFOn = kTRUE;
cc7cef99	159
3551db50	160	ReInit();
4d18a639	161
ab0a4106	162	}
3551db50	163
	164	//_____________________________________________________________________________
	165	AliTRDSimParam::~AliTRDSimParam()
	166	{
	167	//
4d18a639	168	// Destructor
3551db50	169	//
	170
	171	if (fTRFsmp) {
	172	delete [] fTRFsmp;
	173	fTRFsmp = 0;
	174	}
	175
	176	if (fCTsmp) {
	177	delete [] fCTsmp;
	178	fCTsmp = 0;
	179	}
4d18a639	180
ab0a4106	181	}
3551db50	182
3551db50	183	//_____________________________________________________________________________
4d18a639	184	AliTRDSimParam::AliTRDSimParam(const AliTRDSimParam &p)
	185	:TObject(p)
	186	,fGasGain(p.fGasGain)
	187	,fNoise(p.fNoise)
	188	,fChipGain(p.fChipGain)
	189	,fADCoutRange(p.fADCoutRange)
	190	,fADCinRange(p.fADCinRange)
	191	,fADCthreshold(p.fADCthreshold)
	192	,fADCbaseline(p.fADCbaseline)
	193	,fDiffusionOn(p.fDiffusionOn)
	194	,fElAttachOn(p.fElAttachOn)
	195	,fElAttachProp(p.fElAttachProp)
	196	,fTRFOn(p.fTRFOn)
	197	,fTRFsmp(0)
	198	,fTRFbin(p.fTRFbin)
	199	,fTRFlo(p.fTRFlo)
	200	,fTRFhi(p.fTRFhi)
	201	,fTRFwid(p.fTRFwid)
	202	,fCTOn(p.fCTOn)
	203	,fCTsmp(0)
	204	,fAnodeWireOffset(p.fAnodeWireOffset)
	205	,fPadCoupling(p.fPadCoupling)
	206	,fTimeCoupling(p.fTimeCoupling)
	207	,fTimeStructOn(p.fTimeStructOn)
	208	,fPRFOn(p.fPRFOn)
3551db50	209	{
3551db50	210	//
4d18a639	211	// Copy constructor
3551db50	212	//
3551db50	213
4d18a639	214	Int_t iBin = 0;
	215
	216	if (((AliTRDSimParam &) p).fTRFsmp) {
	217	delete [] ((AliTRDSimParam &) p).fTRFsmp;
	218	}
	219	((AliTRDSimParam &) p).fTRFsmp = new Float_t[fTRFbin];
	220	for (iBin = 0; iBin < fTRFbin; iBin++) {
	221	((AliTRDSimParam &) p).fTRFsmp[iBin] = fTRFsmp[iBin];
	222	}
	223
	224	if (((AliTRDSimParam &) p).fCTsmp) {
	225	delete [] ((AliTRDSimParam &) p).fCTsmp;
	226	}
	227	((AliTRDSimParam &) p).fCTsmp = new Float_t[fTRFbin];
	228	for (iBin = 0; iBin < fTRFbin; iBin++) {
	229	((AliTRDSimParam &) p).fCTsmp[iBin] = fCTsmp[iBin];
	230	}
3551db50	231
4d18a639	232	}
3551db50	233
	234	//_____________________________________________________________________________
	235	AliTRDSimParam &AliTRDSimParam::operator=(const AliTRDSimParam &p)
	236	{
	237	//
	238	// Assignment operator
	239	//
	240
b43a3e17	241	if (this != &p) {
	242	((AliTRDSimParam &) p).Copy(*this);
	243	}
4d18a639	244
3551db50	245	return *this;
4d18a639	246
3551db50	247	}
	248
	249	//_____________________________________________________________________________
	250	void AliTRDSimParam::Copy(TObject &p) const
	251	{
	252	//
	253	// Copy function
	254	//
	255
b43a3e17	256	AliTRDSimParam target = dynamic_cast<AliTRDSimParam > (&p);
4d18a639	257	if (!target) {
3551db50	258	return;
4d18a639	259	}
3551db50	260
3551db50	261	target->fGasGain = fGasGain;
3551db50	262	target->fNoise = fNoise;
4d18a639	263	target->fChipGain = fChipGain;
3551db50	264	target->fADCoutRange = fADCoutRange;
	265	target->fADCinRange = fADCinRange;
	266	target->fADCthreshold = fADCthreshold;
	267	target->fADCbaseline = fADCbaseline;
3551db50	268	target->fDiffusionOn = fDiffusionOn;
3551db50	269	target->fElAttachOn = fElAttachOn;
3551db50	270	target->fElAttachProp = fElAttachProp;
3551db50	271	target->fTRFOn = fTRFOn;
3551db50	272	target->fTRFbin = fTRFbin;
	273	target->fTRFlo = fTRFlo;
	274	target->fTRFhi = fTRFhi;
	275	target->fTRFwid = fTRFwid;
3551db50	276	target->fCTOn = fCTOn;
4d18a639	277	target->fAnodeWireOffset = fAnodeWireOffset;
	278	target->fPadCoupling = fPadCoupling;
	279	target->fTimeCoupling = fTimeCoupling;
	280	target->fPRFOn = fPRFOn;
	281
	282	if (target->fTRFsmp) {
	283	delete[] target->fTRFsmp;
	284	}
	285	target->fTRFsmp = new Float_t[fTRFbin];
	286	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
	287	target->fTRFsmp[iBin] = fTRFsmp[iBin];
	288	}
	289
	290	if (target->fCTsmp) {
3551db50	291	delete[] target->fCTsmp;
4d18a639	292	}
3551db50	293	target->fCTsmp = new Float_t[fTRFbin];
	294	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
	295	target->fCTsmp[iBin] = fCTsmp[iBin];
	296	}
	297
3551db50	298	}
	299
	300	//_____________________________________________________________________________
	301	void AliTRDSimParam::ReInit()
	302	{
	303	//
	304	// Reinitializes the parameter class after a change
	305	//
	306
	307	// The range and the binwidth for the sampled TRF
915f999b	308	fTRFbin = 200;
3551db50	309	// Start 0.2 mus before the signal
915f999b	310	fTRFlo = -0.4;
3551db50	311	// End the maximum drift time after the signal
4d18a639	312	fTRFhi = 3.58;
3551db50	313	fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
	314
	315	// Create the sampled TRF
	316	SampleTRF();
3551db50	317
4d18a639	318	}
915f999b	319
3551db50	320	//_____________________________________________________________________________
	321	void AliTRDSimParam::SampleTRF()
	322	{
	323	//
915f999b	324	// Samples the new time response function.
	325	// From Antons measurements with Fe55 source, adjusted by C. Lippmann.
	326	// time bins are -0.4, -0.38, -0.36, ...., 3.54, 3.56, 3.58 microseconds
3551db50	327	//
3551db50	328
915f999b	329	const Int_t kNpasa = 200; // kNpasa should be equal to fTRFbin!
915f999b	330
4d18a639	331	Float_t signal[kNpasa]={ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000
	332	, 0.0002, 0.0007, 0.0026, 0.0089, 0.0253, 0.0612, 0.1319
	333	, 0.2416, 0.3913, 0.5609, 0.7295, 0.8662, 0.9581, 1.0000
	334	, 0.9990, 0.9611, 0.8995, 0.8269, 0.7495, 0.6714, 0.5987
	335	, 0.5334, 0.4756, 0.4249, 0.3811, 0.3433, 0.3110, 0.2837
	336	, 0.2607, 0.2409, 0.2243, 0.2099, 0.1974, 0.1868, 0.1776
	337	, 0.1695, 0.1627, 0.1566, 0.1509, 0.1457, 0.1407, 0.1362
	338	, 0.1317, 0.1274, 0.1233, 0.1196, 0.1162, 0.1131, 0.1102
	339	, 0.1075, 0.1051, 0.1026, 0.1004, 0.0979, 0.0956, 0.0934
	340	, 0.0912, 0.0892, 0.0875, 0.0858, 0.0843, 0.0829, 0.0815
	341	, 0.0799, 0.0786, 0.0772, 0.0757, 0.0741, 0.0729, 0.0718
	342	, 0.0706, 0.0692, 0.0680, 0.0669, 0.0655, 0.0643, 0.0630
	343	, 0.0618, 0.0607, 0.0596, 0.0587, 0.0576, 0.0568, 0.0558
	344	, 0.0550, 0.0541, 0.0531, 0.0522, 0.0513, 0.0505, 0.0497
	345	, 0.0490, 0.0484, 0.0474, 0.0465, 0.0457, 0.0449, 0.0441
	346	, 0.0433, 0.0425, 0.0417, 0.0410, 0.0402, 0.0395, 0.0388
	347	, 0.0381, 0.0374, 0.0368, 0.0361, 0.0354, 0.0348, 0.0342
	348	, 0.0336, 0.0330, 0.0324, 0.0318, 0.0312, 0.0306, 0.0301
	349	, 0.0296, 0.0290, 0.0285, 0.0280, 0.0275, 0.0270, 0.0265
	350	, 0.0260, 0.0256, 0.0251, 0.0246, 0.0242, 0.0238, 0.0233
	351	, 0.0229, 0.0225, 0.0221, 0.0217, 0.0213, 0.0209, 0.0206
	352	, 0.0202, 0.0198, 0.0195, 0.0191, 0.0188, 0.0184, 0.0181
	353	, 0.0178, 0.0175, 0.0171, 0.0168, 0.0165, 0.0162, 0.0159
	354	, 0.0157, 0.0154, 0.0151, 0.0148, 0.0146, 0.0143, 0.0140
	355	, 0.0138, 0.0135, 0.0133, 0.0131, 0.0128, 0.0126, 0.0124
	356	, 0.0121, 0.0119, 0.0120, 0.0115, 0.0113, 0.0111, 0.0109
	357	, 0.0107, 0.0105, 0.0103, 0.0101, 0.0100, 0.0098, 0.0096
	358	, 0.0094, 0.0092, 0.0091, 0.0089, 0.0088, 0.0086, 0.0084
	359	, 0.0083, 0.0081, 0.0080, 0.0078 };
915f999b	360
	361	Float_t xtalk[kNpasa];
	362
4d18a639	363	// With undershoot, positive peak corresponds to ~3% of the main signal:
915f999b	364	for (Int_t ipasa = 3; ipasa < kNpasa; ipasa++) {
4d18a639	365	xtalk[ipasa] = 0.2 * (signal[ipasa-2] - signal[ipasa-3]);
3551db50	366	}
3551db50	367
4d18a639	368	xtalk[0] = 0.0;
	369	xtalk[1] = 0.0;
	370	xtalk[2] = 0.0;
915f999b	371
4d18a639	372	signal[0] = 0.0;
	373	signal[1] = 0.0;
	374	signal[2] = 0.0;
	375
	376	if (fTRFsmp) {
	377	delete [] fTRFsmp;
	378	}
3551db50	379	fTRFsmp = new Float_t[fTRFbin];
4d18a639	380
	381	if (fCTsmp) {
	382	delete [] fCTsmp;
	383	}
3551db50	384	fCTsmp = new Float_t[fTRFbin];
3551db50	385
3551db50	386	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
915f999b	387	fTRFsmp[iBin] = signal[iBin];
915f999b	388	fCTsmp[iBin] = xtalk[iBin];
3551db50	389	}
	390
	391	}
	392
	393	//_____________________________________________________________________________
	394	Double_t AliTRDSimParam::TimeResponse(Double_t time) const
	395	{
	396	//
	397	// Applies the preamp shaper time response
915f999b	398	// (We assume a signal rise time of 0.2us = fTRFlo/2.
3551db50	399	//
3551db50	400
4d18a639	401	Int_t iBin = ((Int_t) ((time - fTRFlo/2.0) / fTRFwid));
	402	if ((iBin >= 0) &&
	403	(iBin < fTRFbin)) {
3551db50	404	return fTRFsmp[iBin];
	405	}
	406	else {
	407	return 0.0;
	408	}
	409
	410	}
	411
	412	//_____________________________________________________________________________
	413	Double_t AliTRDSimParam::CrossTalk(Double_t time) const
	414	{
	415	//
	416	// Applies the pad-pad capacitive cross talk
	417	//
	418
	419	Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid));
4d18a639	420	if ((iBin >= 0) &&
4d18a639	421	(iBin < fTRFbin)) {
3551db50	422	return fCTsmp[iBin];
	423	}
	424	else {
	425	return 0.0;
	426	}
	427
	428	}