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