[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"
#include "AliLog.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)
  ,fNTBoverwriteOCDB(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
  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         = 27;
  fNTBoverwriteOCDB  = kFALSE;

  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)
  ,fNTBoverwriteOCDB(p.fNTBoverwriteOCDB)
{
  //
  // Copy constructor
  //

  Int_t iBin = 0;

  fTRFsmp = new Float_t[fTRFbin];
  for (iBin = 0; iBin < fTRFbin; iBin++) {
    fTRFsmp[iBin] = ((AliTRDSimParam &) p).fTRFsmp[iBin];
  }                                                                             

  fCTsmp  = new Float_t[fTRFbin];
  for (iBin = 0; iBin < fTRFbin; iBin++) {
    fCTsmp[iBin]  = ((AliTRDSimParam &) p).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;
  target->fNTBoverwriteOCDB   = fNTBoverwriteOCDB;

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