[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)
  ,fGasMixture(0)
{
  //
  // 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;

  // The gas mixture, default Xenon
  fGasMixture        = kXenon;

  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)
  ,fGasMixture(p.fGasMixture)
{
  //
  // 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;
  target->fGasMixture         = fGasMixture;

  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
  //

  if      (fGasMixture == kXenon) {
    // 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;
  }
  else if (fGasMixture == kArgon) {
    // The range and the binwidth for the sampled TRF 
    fTRFbin =  50;
    // Start 0.2 mus before the signal
    fTRFlo  =  0.02;
    // End the maximum drift time after the signal 
    fTRFhi  =  1.98;
  }
  else {
    AliFatal("Not a valid gas mixture!");
    exit(1);
  }
  fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);

  // Create the sampled TRF
  SampleTRF();

}

//_____________________________________________________________________________
void AliTRDSimParam::SampleTRF()
{
  //
  // Samples the new time response function.
  //

  Int_t ipasa = 0;

  // Xenon
  // 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 xtalk[kNpasa];
  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 };
  signal[0] = 0.0;
  signal[1] = 0.0;
  signal[2] = 0.0;
  // With undershoot, positive peak corresponds to ~3% of the main signal:
  for (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;  

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