[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"
#include "AliTRDCommonParam.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)
  ,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;

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

  if      (AliTRDCommonParam::Instance()->IsXenon()) {
    // 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 (AliTRDCommonParam::Instance()->IsArgon()) {
    // 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      (AliTRDCommonParam::Instance()->IsXenon()) {
    if (fTRFbin != kNpasa) {
      AliError("Array mismatch (xenon)\n\n");
    }
  }
  else if (AliTRDCommonParam::Instance()->IsArgon()) {
    if (fTRFbin != kNpasaAr) {
      AliError("Array mismatch (argon)\n\n");
    }
  }

  for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
    if      (AliTRDCommonParam::Instance()->IsXenon()) {
      fTRFsmp[iBin] = signal[iBin];
      fCTsmp[iBin]  = xtalk[iBin];
    }
    else if (AliTRDCommonParam::Instance()->IsArgon()) {
      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.
  //

  Double_t rt   = (time - .5*fTRFlo) / fTRFwid;
  Int_t    iBin = (Int_t) rt; 
  Double_t dt   = rt - iBin; 
  if ((iBin >= 0) && (iBin+1 < fTRFbin)) {
    return fTRFsmp[iBin] + (fTRFsmp[iBin+1] - fTRFsmp[iBin])*dt;
  } 
  else {
    return 0.0;
  }

}

//_____________________________________________________________________________
Double_t AliTRDSimParam::CrossTalk(Double_t time) const
{
  //
  // Applies the pad-pad capacitive cross talk
  //

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