[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)
  ,fNTimeBins(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
  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;

  // The number of time bins
  fNTimeBins         = 24;

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

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