[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;
    // Standard gas gain
    fGasGain = 4000.0;
  }
  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;
    // Higher gas gain
    fGasGain = 8000.0;
  }
  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];

  if      (fGasMixture == kXenon) {
    if (fTRFbin != kNpasa) {
      AliError("Array mismatch (xenon)\n\n");
    }
  }
  else if (fGasMixture == kArgon) {
    if (fTRFbin != kNpasaAr) {
      AliError("Array mismatch (argon)\n\n");
    }
  }

  for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
    if      (fGasMixture == kXenon) {
      fTRFsmp[iBin] = signal[iBin];
      fCTsmp[iBin]  = xtalk[iBin];
    }
    else if (fGasMixture == kArgon) {
      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;
0a17cc30	316	// Standard gas gain
0a17cc30	317	fGasGain = 4000.0;
f2979d08	318	}
	319	else if (fGasMixture == kArgon) {
	320	// The range and the binwidth for the sampled TRF
0a17cc30	321	fTRFbin = 50;
f2979d08	322	// Start 0.2 mus before the signal
0a17cc30	323	fTRFlo = 0.02;
f2979d08	324	// End the maximum drift time after the signal
0a17cc30	325	fTRFhi = 1.98;
	326	// Higher gas gain
	327	fGasGain = 8000.0;
f2979d08	328	}
	329	else {
	330	AliFatal("Not a valid gas mixture!");
	331	exit(1);
	332	}
3551db50	333	fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
	334
	335	// Create the sampled TRF
	336	SampleTRF();
3551db50	337
4d18a639	338	}
915f999b	339
3551db50	340	//_____________________________________________________________________________
	341	void AliTRDSimParam::SampleTRF()
	342	{
	343	//
915f999b	344	// Samples the new time response function.
3551db50	345	//
3551db50	346
f2979d08	347	Int_t ipasa = 0;
915f999b	348
f2979d08	349	// Xenon
	350	// From Antons measurements with Fe55 source, adjusted by C. Lippmann.
	351	// time bins are -0.4, -0.38, -0.36, ...., 3.54, 3.56, 3.58 microseconds
	352	const Int_t kNpasa = 200; // kNpasa should be equal to fTRFbin!
	353	Float_t xtalk[kNpasa];
	354	Float_t signal[kNpasa] = { 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000
	355	, 0.0002, 0.0007, 0.0026, 0.0089, 0.0253, 0.0612, 0.1319
	356	, 0.2416, 0.3913, 0.5609, 0.7295, 0.8662, 0.9581, 1.0000
	357	, 0.9990, 0.9611, 0.8995, 0.8269, 0.7495, 0.6714, 0.5987
	358	, 0.5334, 0.4756, 0.4249, 0.3811, 0.3433, 0.3110, 0.2837
	359	, 0.2607, 0.2409, 0.2243, 0.2099, 0.1974, 0.1868, 0.1776
	360	, 0.1695, 0.1627, 0.1566, 0.1509, 0.1457, 0.1407, 0.1362
	361	, 0.1317, 0.1274, 0.1233, 0.1196, 0.1162, 0.1131, 0.1102
	362	, 0.1075, 0.1051, 0.1026, 0.1004, 0.0979, 0.0956, 0.0934
	363	, 0.0912, 0.0892, 0.0875, 0.0858, 0.0843, 0.0829, 0.0815
	364	, 0.0799, 0.0786, 0.0772, 0.0757, 0.0741, 0.0729, 0.0718
	365	, 0.0706, 0.0692, 0.0680, 0.0669, 0.0655, 0.0643, 0.0630
	366	, 0.0618, 0.0607, 0.0596, 0.0587, 0.0576, 0.0568, 0.0558
	367	, 0.0550, 0.0541, 0.0531, 0.0522, 0.0513, 0.0505, 0.0497
	368	, 0.0490, 0.0484, 0.0474, 0.0465, 0.0457, 0.0449, 0.0441
	369	, 0.0433, 0.0425, 0.0417, 0.0410, 0.0402, 0.0395, 0.0388
	370	, 0.0381, 0.0374, 0.0368, 0.0361, 0.0354, 0.0348, 0.0342
	371	, 0.0336, 0.0330, 0.0324, 0.0318, 0.0312, 0.0306, 0.0301
	372	, 0.0296, 0.0290, 0.0285, 0.0280, 0.0275, 0.0270, 0.0265
	373	, 0.0260, 0.0256, 0.0251, 0.0246, 0.0242, 0.0238, 0.0233
	374	, 0.0229, 0.0225, 0.0221, 0.0217, 0.0213, 0.0209, 0.0206
	375	, 0.0202, 0.0198, 0.0195, 0.0191, 0.0188, 0.0184, 0.0181
	376	, 0.0178, 0.0175, 0.0171, 0.0168, 0.0165, 0.0162, 0.0159
	377	, 0.0157, 0.0154, 0.0151, 0.0148, 0.0146, 0.0143, 0.0140
	378	, 0.0138, 0.0135, 0.0133, 0.0131, 0.0128, 0.0126, 0.0124
	379	, 0.0121, 0.0119, 0.0120, 0.0115, 0.0113, 0.0111, 0.0109
	380	, 0.0107, 0.0105, 0.0103, 0.0101, 0.0100, 0.0098, 0.0096
	381	, 0.0094, 0.0092, 0.0091, 0.0089, 0.0088, 0.0086, 0.0084
	382	, 0.0083, 0.0081, 0.0080, 0.0078 };
	383	signal[0] = 0.0;
	384	signal[1] = 0.0;
	385	signal[2] = 0.0;
4d18a639	386	// With undershoot, positive peak corresponds to ~3% of the main signal:
f2979d08	387	for (ipasa = 3; ipasa < kNpasa; ipasa++) {
4d18a639	388	xtalk[ipasa] = 0.2 * (signal[ipasa-2] - signal[ipasa-3]);
3551db50	389	}
4d18a639	390	xtalk[0] = 0.0;
	391	xtalk[1] = 0.0;
	392	xtalk[2] = 0.0;
915f999b	393
f2979d08	394	// Argon
	395	// Ar measurement with Fe55 source by Anton
	396	// time bins are 0.02, 0.06, 0.10, ...., 1.90, 1.94, 1.98 microseconds
	397	const Int_t kNpasaAr = 50;
	398	Float_t xtalkAr[kNpasaAr];
	399	Float_t signalAr[kNpasaAr] = { -0.01, 0.01, 0.00, 0.00, 0.01
	400	, -0.01, 0.01, 2.15, 22.28, 55.53
	401	, 68.52, 58.21, 40.92, 27.12, 18.49
	402	, 13.42, 10.48, 8.67, 7.49, 6.55
	403	, 5.71, 5.12, 4.63, 4.22, 3.81
	404	, 3.48, 3.20, 2.94, 2.77, 2.63
	405	, 2.50, 2.37, 2.23, 2.13, 2.03
	406	, 1.91, 1.83, 1.75, 1.68, 1.63
	407	, 1.56, 1.49, 1.50, 1.49, 1.29
	408	, 1.19, 1.21, 1.21, 1.20, 1.10 };
	409	// Normalization to maximum
93ff78d6	410	for (ipasa = 0; ipasa < kNpasaAr; ipasa++) {
f2979d08	411	signalAr[ipasa] /= 68.52;
	412	}
	413	signalAr[0] = 0.0;
	414	signalAr[1] = 0.0;
	415	signalAr[2] = 0.0;
	416	// With undershoot, positive peak corresponds to ~3% of the main signal:
93ff78d6	417	for (ipasa = 3; ipasa < kNpasaAr; ipasa++) {
f2979d08	418	xtalkAr[ipasa] = 0.2 * (signalAr[ipasa-2] - signalAr[ipasa-3]);
	419	}
	420	xtalkAr[0] = 0.0;
	421	xtalkAr[1] = 0.0;
	422	xtalkAr[2] = 0.0;
4d18a639	423
	424	if (fTRFsmp) {
	425	delete [] fTRFsmp;
	426	}
3551db50	427	fTRFsmp = new Float_t[fTRFbin];
4d18a639	428
	429	if (fCTsmp) {
	430	delete [] fCTsmp;
	431	}
3551db50	432	fCTsmp = new Float_t[fTRFbin];
3551db50	433
0a17cc30	434	if (fGasMixture == kXenon) {
	435	if (fTRFbin != kNpasa) {
	436	AliError("Array mismatch (xenon)\n\n");
	437	}
	438	}
	439	else if (fGasMixture == kArgon) {
	440	if (fTRFbin != kNpasaAr) {
	441	AliError("Array mismatch (argon)\n\n");
	442	}
	443	}
	444
3551db50	445	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
0a17cc30	446	if (fGasMixture == kXenon) {
f2979d08	447	fTRFsmp[iBin] = signal[iBin];
	448	fCTsmp[iBin] = xtalk[iBin];
	449	}
0a17cc30	450	else if (fGasMixture == kArgon) {
f2979d08	451	fTRFsmp[iBin] = signalAr[iBin];
	452	fCTsmp[iBin] = xtalkAr[iBin];
	453	}
3551db50	454	}
	455
	456	}
	457
	458	//_____________________________________________________________________________
	459	Double_t AliTRDSimParam::TimeResponse(Double_t time) const
	460	{
	461	//
	462	// Applies the preamp shaper time response
915f999b	463	// (We assume a signal rise time of 0.2us = fTRFlo/2.
3551db50	464	//
3551db50	465
4d18a639	466	Int_t iBin = ((Int_t) ((time - fTRFlo/2.0) / fTRFwid));
	467	if ((iBin >= 0) &&
	468	(iBin < fTRFbin)) {
3551db50	469	return fTRFsmp[iBin];
	470	}
	471	else {
	472	return 0.0;
	473	}
	474
	475	}
	476
	477	//_____________________________________________________________________________
	478	Double_t AliTRDSimParam::CrossTalk(Double_t time) const
	479	{
	480	//
	481	// Applies the pad-pad capacitive cross talk
	482	//
	483
	484	Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid));
4d18a639	485	if ((iBin >= 0) &&
4d18a639	486	(iBin < fTRFbin)) {
3551db50	487	return fCTsmp[iBin];
	488	}
	489	else {
	490	return 0.0;
	491	}
	492
	493	}