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