[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) {
    return *this;
  }

  Init();

  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;

  Int_t iBin = 0;

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

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

  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
089086d3	235	if (this == &p) {
089086d3	236	return *this;
b43a3e17	237	}
4d18a639	238
1a0c151e	239	Init();
1a0c151e	240
089086d3	241	fGasGain = p.fGasGain;
	242	fNoise = p.fNoise;
	243	fChipGain = p.fChipGain;
	244	fADCoutRange = p.fADCoutRange;
	245	fADCinRange = p.fADCinRange;
	246	fADCbaseline = p.fADCbaseline;
	247	fDiffusionOn = p.fDiffusionOn;
	248	fElAttachOn = p.fElAttachOn;
	249	fElAttachProp = p.fElAttachProp;
	250	fTRFOn = p.fTRFOn;
	251	fTRFsmp = 0;
	252	fTRFbin = p.fTRFbin;
	253	fTRFlo = p.fTRFlo;
	254	fTRFhi = p.fTRFhi;
	255	fTRFwid = p.fTRFwid;
	256	fCTOn = p.fCTOn;
	257	fCTsmp = 0;
	258	fPadCoupling = p.fPadCoupling;
	259	fTimeCoupling = p.fTimeCoupling;
	260	fTimeStructOn = p.fTimeStructOn;
	261	fPRFOn = p.fPRFOn;
	262	fNTimeBins = p.fNTimeBins;
	263	fNTBoverwriteOCDB = p.fNTBoverwriteOCDB;
	264
	265	Int_t iBin = 0;
	266
	267	if (fTRFsmp) {
	268	delete[] fTRFsmp;
	269	}
	270	fTRFsmp = new Float_t[fTRFbin];
	271	for (iBin = 0; iBin < fTRFbin; iBin++) {
	272	fTRFsmp[iBin] = ((AliTRDSimParam &) p).fTRFsmp[iBin];
	273	}
	274
	275	if (fCTsmp) {
	276	delete[] fCTsmp;
	277	}
	278	fCTsmp = new Float_t[fTRFbin];
	279	for (iBin = 0; iBin < fTRFbin; iBin++) {
	280	fCTsmp[iBin] = ((AliTRDSimParam &) p).fCTsmp[iBin];
	281	}
	282
3551db50	283	return *this;
4d18a639	284
3551db50	285	}
	286
	287	//_____________________________________________________________________________
	288	void AliTRDSimParam::Copy(TObject &p) const
	289	{
	290	//
	291	// Copy function
	292	//
	293
b43a3e17	294	AliTRDSimParam target = dynamic_cast<AliTRDSimParam > (&p);
4d18a639	295	if (!target) {
3551db50	296	return;
4d18a639	297	}
3551db50	298
3551db50	299	target->fGasGain = fGasGain;
3551db50	300	target->fNoise = fNoise;
4d18a639	301	target->fChipGain = fChipGain;
3551db50	302	target->fADCoutRange = fADCoutRange;
3551db50	303	target->fADCinRange = fADCinRange;
3551db50	304	target->fADCbaseline = fADCbaseline;
3551db50	305	target->fDiffusionOn = fDiffusionOn;
3551db50	306	target->fElAttachOn = fElAttachOn;
3551db50	307	target->fElAttachProp = fElAttachProp;
3551db50	308	target->fTRFOn = fTRFOn;
3551db50	309	target->fTRFbin = fTRFbin;
	310	target->fTRFlo = fTRFlo;
	311	target->fTRFhi = fTRFhi;
	312	target->fTRFwid = fTRFwid;
3551db50	313	target->fCTOn = fCTOn;
4d18a639	314	target->fPadCoupling = fPadCoupling;
	315	target->fTimeCoupling = fTimeCoupling;
	316	target->fPRFOn = fPRFOn;
966f6939	317	target->fNTimeBins = fNTimeBins;
876a928e	318	target->fNTBoverwriteOCDB = fNTBoverwriteOCDB;
4d18a639	319
	320	if (target->fTRFsmp) {
	321	delete[] target->fTRFsmp;
	322	}
	323	target->fTRFsmp = new Float_t[fTRFbin];
	324	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
	325	target->fTRFsmp[iBin] = fTRFsmp[iBin];
	326	}
	327
	328	if (target->fCTsmp) {
3551db50	329	delete[] target->fCTsmp;
4d18a639	330	}
3551db50	331	target->fCTsmp = new Float_t[fTRFbin];
	332	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
	333	target->fCTsmp[iBin] = fCTsmp[iBin];
	334	}
	335
3551db50	336	}
	337
	338	//_____________________________________________________________________________
	339	void AliTRDSimParam::ReInit()
	340	{
	341	//
	342	// Reinitializes the parameter class after a change
	343	//
	344
a076fc2f	345	if (AliTRDCommonParam::Instance()->IsXenon()) {
f2979d08	346	// The range and the binwidth for the sampled TRF
	347	fTRFbin = 200;
	348	// Start 0.2 mus before the signal
	349	fTRFlo = -0.4;
	350	// End the maximum drift time after the signal
	351	fTRFhi = 3.58;
0a17cc30	352	// Standard gas gain
0a17cc30	353	fGasGain = 4000.0;
f2979d08	354	}
a076fc2f	355	else if (AliTRDCommonParam::Instance()->IsArgon()) {
f2979d08	356	// The range and the binwidth for the sampled TRF
0a17cc30	357	fTRFbin = 50;
f2979d08	358	// Start 0.2 mus before the signal
0a17cc30	359	fTRFlo = 0.02;
f2979d08	360	// End the maximum drift time after the signal
0a17cc30	361	fTRFhi = 1.98;
	362	// Higher gas gain
	363	fGasGain = 8000.0;
f2979d08	364	}
	365	else {
	366	AliFatal("Not a valid gas mixture!");
	367	exit(1);
	368	}
3551db50	369	fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
	370
	371	// Create the sampled TRF
	372	SampleTRF();
3551db50	373
4d18a639	374	}
915f999b	375
3551db50	376	//_____________________________________________________________________________
	377	void AliTRDSimParam::SampleTRF()
	378	{
	379	//
915f999b	380	// Samples the new time response function.
3551db50	381	//
3551db50	382
f2979d08	383	Int_t ipasa = 0;
915f999b	384
f2979d08	385	// Xenon
	386	// From Antons measurements with Fe55 source, adjusted by C. Lippmann.
	387	// time bins are -0.4, -0.38, -0.36, ...., 3.54, 3.56, 3.58 microseconds
	388	const Int_t kNpasa = 200; // kNpasa should be equal to fTRFbin!
	389	Float_t xtalk[kNpasa];
	390	Float_t signal[kNpasa] = { 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000
	391	, 0.0002, 0.0007, 0.0026, 0.0089, 0.0253, 0.0612, 0.1319
	392	, 0.2416, 0.3913, 0.5609, 0.7295, 0.8662, 0.9581, 1.0000
	393	, 0.9990, 0.9611, 0.8995, 0.8269, 0.7495, 0.6714, 0.5987
	394	, 0.5334, 0.4756, 0.4249, 0.3811, 0.3433, 0.3110, 0.2837
	395	, 0.2607, 0.2409, 0.2243, 0.2099, 0.1974, 0.1868, 0.1776
	396	, 0.1695, 0.1627, 0.1566, 0.1509, 0.1457, 0.1407, 0.1362
	397	, 0.1317, 0.1274, 0.1233, 0.1196, 0.1162, 0.1131, 0.1102
	398	, 0.1075, 0.1051, 0.1026, 0.1004, 0.0979, 0.0956, 0.0934
	399	, 0.0912, 0.0892, 0.0875, 0.0858, 0.0843, 0.0829, 0.0815
	400	, 0.0799, 0.0786, 0.0772, 0.0757, 0.0741, 0.0729, 0.0718
	401	, 0.0706, 0.0692, 0.0680, 0.0669, 0.0655, 0.0643, 0.0630
	402	, 0.0618, 0.0607, 0.0596, 0.0587, 0.0576, 0.0568, 0.0558
	403	, 0.0550, 0.0541, 0.0531, 0.0522, 0.0513, 0.0505, 0.0497
	404	, 0.0490, 0.0484, 0.0474, 0.0465, 0.0457, 0.0449, 0.0441
	405	, 0.0433, 0.0425, 0.0417, 0.0410, 0.0402, 0.0395, 0.0388
	406	, 0.0381, 0.0374, 0.0368, 0.0361, 0.0354, 0.0348, 0.0342
	407	, 0.0336, 0.0330, 0.0324, 0.0318, 0.0312, 0.0306, 0.0301
	408	, 0.0296, 0.0290, 0.0285, 0.0280, 0.0275, 0.0270, 0.0265
	409	, 0.0260, 0.0256, 0.0251, 0.0246, 0.0242, 0.0238, 0.0233
	410	, 0.0229, 0.0225, 0.0221, 0.0217, 0.0213, 0.0209, 0.0206
	411	, 0.0202, 0.0198, 0.0195, 0.0191, 0.0188, 0.0184, 0.0181
	412	, 0.0178, 0.0175, 0.0171, 0.0168, 0.0165, 0.0162, 0.0159
	413	, 0.0157, 0.0154, 0.0151, 0.0148, 0.0146, 0.0143, 0.0140
	414	, 0.0138, 0.0135, 0.0133, 0.0131, 0.0128, 0.0126, 0.0124
	415	, 0.0121, 0.0119, 0.0120, 0.0115, 0.0113, 0.0111, 0.0109
	416	, 0.0107, 0.0105, 0.0103, 0.0101, 0.0100, 0.0098, 0.0096
	417	, 0.0094, 0.0092, 0.0091, 0.0089, 0.0088, 0.0086, 0.0084
	418	, 0.0083, 0.0081, 0.0080, 0.0078 };
	419	signal[0] = 0.0;
	420	signal[1] = 0.0;
	421	signal[2] = 0.0;
4d18a639	422	// With undershoot, positive peak corresponds to ~3% of the main signal:
f2979d08	423	for (ipasa = 3; ipasa < kNpasa; ipasa++) {
4d18a639	424	xtalk[ipasa] = 0.2 * (signal[ipasa-2] - signal[ipasa-3]);
3551db50	425	}
4d18a639	426	xtalk[0] = 0.0;
	427	xtalk[1] = 0.0;
	428	xtalk[2] = 0.0;
915f999b	429
f2979d08	430	// Argon
	431	// Ar measurement with Fe55 source by Anton
	432	// time bins are 0.02, 0.06, 0.10, ...., 1.90, 1.94, 1.98 microseconds
	433	const Int_t kNpasaAr = 50;
	434	Float_t xtalkAr[kNpasaAr];
	435	Float_t signalAr[kNpasaAr] = { -0.01, 0.01, 0.00, 0.00, 0.01
	436	, -0.01, 0.01, 2.15, 22.28, 55.53
	437	, 68.52, 58.21, 40.92, 27.12, 18.49
	438	, 13.42, 10.48, 8.67, 7.49, 6.55
	439	, 5.71, 5.12, 4.63, 4.22, 3.81
	440	, 3.48, 3.20, 2.94, 2.77, 2.63
	441	, 2.50, 2.37, 2.23, 2.13, 2.03
	442	, 1.91, 1.83, 1.75, 1.68, 1.63
	443	, 1.56, 1.49, 1.50, 1.49, 1.29
	444	, 1.19, 1.21, 1.21, 1.20, 1.10 };
	445	// Normalization to maximum
93ff78d6	446	for (ipasa = 0; ipasa < kNpasaAr; ipasa++) {
f2979d08	447	signalAr[ipasa] /= 68.52;
	448	}
	449	signalAr[0] = 0.0;
	450	signalAr[1] = 0.0;
	451	signalAr[2] = 0.0;
	452	// With undershoot, positive peak corresponds to ~3% of the main signal:
93ff78d6	453	for (ipasa = 3; ipasa < kNpasaAr; ipasa++) {
f2979d08	454	xtalkAr[ipasa] = 0.2 * (signalAr[ipasa-2] - signalAr[ipasa-3]);
	455	}
	456	xtalkAr[0] = 0.0;
	457	xtalkAr[1] = 0.0;
	458	xtalkAr[2] = 0.0;
4d18a639	459
	460	if (fTRFsmp) {
	461	delete [] fTRFsmp;
	462	}
3551db50	463	fTRFsmp = new Float_t[fTRFbin];
4d18a639	464
	465	if (fCTsmp) {
	466	delete [] fCTsmp;
	467	}
3551db50	468	fCTsmp = new Float_t[fTRFbin];
3551db50	469
a076fc2f	470	if (AliTRDCommonParam::Instance()->IsXenon()) {
0a17cc30	471	if (fTRFbin != kNpasa) {
	472	AliError("Array mismatch (xenon)\n\n");
	473	}
	474	}
a076fc2f	475	else if (AliTRDCommonParam::Instance()->IsArgon()) {
0a17cc30	476	if (fTRFbin != kNpasaAr) {
	477	AliError("Array mismatch (argon)\n\n");
	478	}
	479	}
	480
3551db50	481	for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
a076fc2f	482	if (AliTRDCommonParam::Instance()->IsXenon()) {
f2979d08	483	fTRFsmp[iBin] = signal[iBin];
	484	fCTsmp[iBin] = xtalk[iBin];
	485	}
a076fc2f	486	else if (AliTRDCommonParam::Instance()->IsArgon()) {
f2979d08	487	fTRFsmp[iBin] = signalAr[iBin];
	488	fCTsmp[iBin] = xtalkAr[iBin];
	489	}
3551db50	490	}
	491
	492	}
	493
	494	//_____________________________________________________________________________
	495	Double_t AliTRDSimParam::TimeResponse(Double_t time) const
	496	{
	497	//
	498	// Applies the preamp shaper time response
915f999b	499	// (We assume a signal rise time of 0.2us = fTRFlo/2.
3551db50	500	//
3551db50	501
a076fc2f	502	Double_t rt = (time - .5*fTRFlo) / fTRFwid;
	503	Int_t iBin = (Int_t) rt;
	504	Double_t dt = rt - iBin;
7093fb4f	505	if ((iBin >= 0) && (iBin+1 < fTRFbin)) {
7093fb4f	506	return fTRFsmp[iBin] + (fTRFsmp[iBin+1] - fTRFsmp[iBin])*dt;
a076fc2f	507	}
	508	else {
	509	return 0.0;
	510	}
	511
3551db50	512	}
	513
	514	//_____________________________________________________________________________
	515	Double_t AliTRDSimParam::CrossTalk(Double_t time) const
	516	{
	517	//
	518	// Applies the pad-pad capacitive cross talk
	519	//
	520
a076fc2f	521	Double_t rt = (time - fTRFlo) / fTRFwid;
	522	Int_t iBin = (Int_t) rt;
	523	Double_t dt = rt - iBin;
7093fb4f	524	if ((iBin >= 0) && (iBin+1 < fTRFbin)) {
7093fb4f	525	return fCTsmp[iBin] + (fCTsmp[iBin+1] - fCTsmp[iBin])*dt;
a076fc2f	526	}
	527	else {
	528	return 0.0;
	529	}
	530
3551db50	531	}