[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)
  ,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
  // 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)
  ,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->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 };

// 	// Andronic & Bercuci parametrization
// 	// define new TRF parametrization
// 		// normalizing constant to Fe signal
// 	const Float_t k1=1.055;
// 	// time constants
// 	const Float_t t1=0.04;
// 	const Float_t t2=.9;
// 	// the relative fraction of the long component
// 	const Float_t k2=.15;
// 	// time offset for Fe
// 	const Float_t t0=-.29;
// 	Float_t x = t0; Int_t index;
// 	for(int i=0; i<kNpasa; i++) signal[i] = 0.;
//   for(int i=0; i<kNpasa; i++){
// 		index = i+6;
// 		if(index >= kNpasa) break;
// 		x += .02;
// 		signal[index]=k1*(TMath::Power((x-t0)/t1, 2.5)*(exp(-(x-t0)/t1))+k2*exp(-(x-t0)/t2));
// 	}

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