[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;
}

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()
{
  //
  // default constructor
  //
  
  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;
  
  fTCOn               = kFALSE;
  
  fTCnexp             = 0;
  
  fAnodeWireOffset    = 0.0;
  fPadCoupling        = 0.0;
  fTimeCoupling       = 0.0;
  fTimeStructOn       = kFALSE;
  
  fPRFOn              = kFALSE;
  
  Init();
}

//_____________________________________________________________________________
void AliTRDSimParam::Init()
{
  // 
  // default initializiation
  //
  
  // The default parameter for the digitization
  fGasGain        = 4000.;
  fChipGain       = 12.4;
  fNoise          = 1000.;
  fADCoutRange    = 1023.;          // 10-bit ADC
  fADCinRange     = 2000.;          // 2V input range
  fADCthreshold   = 1;
  fADCbaseline    = 0;

  // 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 tail cancelation
  fTCOn           = kTRUE;
  
  // The number of exponentials
  fTCnexp         = 1;

  // The pad coupling factor
  //fPadCoupling    = 0.3;
  // Use 0.46 instead which 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)
{
  //
  // copy constructor
  //

  ((AliTRDSimParam &) p).Copy(*this);
}


//_____________________________________________________________________________
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->fField              = fField;
  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;
  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];
  }
  target->fTRFbin             = fTRFbin;
  target->fTRFlo              = fTRFlo;
  target->fTRFhi              = fTRFhi;
  target->fTRFwid             = fTRFwid;
  
  target->fCTOn               = fCTOn;
  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];
  }
  
  target->fTCOn               = fTCOn;
  target->fTCnexp             = fTCnexp;

  target->fAnodeWireOffset    = fAnodeWireOffset;
  target->fPadCoupling        = fPadCoupling;
  target->fTimeCoupling       = fTimeCoupling;
  
  target->fPRFOn              = fPRFOn;
}

//_____________________________________________________________________________
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];

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

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