[u/mrichter/AliRoot.git] / EMCAL / AliEMCAL.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$ */

//_________________________________________________________________________
// Base Class for EMCAL description:
// This class contains material definitions    
// for the EMCAL - It does not place the detector in Alice
//*-- Author: Yves Schutz (SUBATECH) 
//
//*-- Additional Contributions: Sahal Yacoob (LBNL/UCT)
//
//////////////////////////////////////////////////////////////////////////////

// --- ROOT system ---
class TFile;
#include <TFolder.h> 
#include <TTree.h>
#include <TVirtualMC.h> 
#include <TH1F.h> 
#include <TF1.h> 
#include <TRandom.h> 

// --- Standard library ---

// --- AliRoot header files ---
#include "AliMagF.h"
#include "AliEMCAL.h"
#include "AliRun.h"
#include "AliEMCALLoader.h"
#include "AliEMCALSDigitizer.h"
#include "AliEMCALDigitizer.h"
#include "AliEMCALDigit.h"
#include "AliAltroBuffer.h"

ClassImp(AliEMCAL)
Double_t AliEMCAL::fgCapa        = 1.;        // 1pF 
Int_t    AliEMCAL::fgOrder       = 2 ;
Double_t AliEMCAL::fgTimeMax     = 2.56E-5 ;  // each sample is over 100 ns fTimeMax/fTimeBins
Double_t AliEMCAL::fgTimePeak    = 4.1E-6 ;   // 4 micro seconds
Double_t AliEMCAL::fgTimeTrigger = 100E-9 ;      // 100ns, just for a reference
 
//____________________________________________________________________________
AliEMCAL::AliEMCAL():AliDetector()
{
  // Default ctor 
  fName = "EMCAL" ;
}

//____________________________________________________________________________
AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title)
{
  //   ctor : title is used to identify the layout

  fHighCharge        = 8.2 ;          // adjusted for a high gain range of 5.12 GeV (10 bits)
  fHighGain          = 6.64 ; 
  fHighLowGainFactor = 16. ;          // adjusted for a low gain range of 82 GeV (10 bits) 
  fLowGainOffset     = 1 ;            // offset added to the module id to distinguish high and low gain data
}

//____________________________________________________________________________
AliEMCAL::~AliEMCAL()
{

}

//____________________________________________________________________________
void AliEMCAL::Copy(AliEMCAL & emcal) const
{
  TObject::Copy(emcal) ; 
  emcal.fHighCharge        = fHighCharge ;
  emcal.fHighGain          = fHighGain ; 
  emcal.fHighLowGainFactor = fHighLowGainFactor ;  
  emcal.fLowGainOffset     = fLowGainOffset;   
}

//____________________________________________________________________________
AliDigitizer* AliEMCAL::CreateDigitizer(AliRunDigitizer* manager) const
{
  return new AliEMCALDigitizer(manager);
}

//____________________________________________________________________________
void AliEMCAL::CreateMaterials()
{
  // Definitions of materials to build EMCAL and associated tracking media.
  // media number in idtmed are 1599 to 1698.

  // --- Air ---               
  Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
  Float_t zAir[4]={6.,7.,8.,18.};
  Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
  Float_t dAir = 1.20479E-3;
  AliMixture(0, "Air$", aAir, zAir, dAir, 4, wAir) ;

  // --- Lead ---                                                                     
  AliMaterial(1, "Pb$", 207.2, 82, 11.35, 0.56, 0., 0, 0) ;


  // --- The polysterene scintillator (CH) ---
  Float_t aP[2] = {12.011, 1.00794} ;
  Float_t zP[2] = {6.0, 1.0} ;
  Float_t wP[2] = {1.0, 1.0} ;
  Float_t dP = 1.032 ;

  AliMixture(2, "Polystyrene$", aP, zP, dP, -2, wP) ;

  // --- Aluminium ---
  AliMaterial(3, "Al$", 26.98, 13., 2.7, 8.9, 999., 0, 0) ;
  // ---         Absorption length is ignored ^

  // 25-aug-04 by PAI - see  PMD/AliPMDv0.cxx for STEEL definition
  Float_t asteel[4] = { 55.847,51.9961,58.6934,28.0855 };
  Float_t zsteel[4] = { 26.,24.,28.,14. };
  Float_t wsteel[4] = { .715,.18,.1,.005 };
  AliMixture(4, "STAINLESS STEEL$", asteel, zsteel, 7.88, 4, wsteel);

  // DEFINITION OF THE TRACKING MEDIA

  // for EMCAL: idtmed[1599->1698] equivalent to fIdtmed[0->100]
  Int_t * idtmed = fIdtmed->GetArray() - 1599 ; 
  Int_t   isxfld = gAlice->Field()->Integ() ;
  Float_t sxmgmx = gAlice->Field()->Max() ;

  // Air                                                                         -> idtmed[1599]
 AliMedium(0, "Air$", 0, 0,
	     isxfld, sxmgmx, 10.0, 1.0, 0.1, 0.1, 10.0, 0, 0) ;

  // The Lead                                                                      -> idtmed[1600]
 
  AliMedium(1, "Lead$", 1, 0,
	     isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.1, 0.1, 0, 0) ;

 // The scintillator of the CPV made of Polystyrene scintillator                   -> idtmed[1601]
  AliMedium(2, "Scintillator$", 2, 1,
            isxfld, sxmgmx, 10.0, 0.001, 0.1, 0.001, 0.001, 0, 0) ;

  // Various Aluminium parts made of Al                                            -> idtmed[1602]
  AliMedium(3, "Al$", 3, 0,
             isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.001, 0.001, 0, 0) ;

  // 25-aug-04 by PAI : see  PMD/AliPMDv0.cxx for STEEL definition                 -> idtmed[1603]
  AliMedium(4, "S steel$", 4, 0, 
             isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.001, 0.001, 0, 0) ;

// --- Set decent energy thresholds for gamma and electron tracking

  // Tracking threshold for photons and electrons in Lead 
  Float_t cutgam=10.e-5; // 100 kev;
  Float_t cutele=10.e-5; // 100 kev;
  TString ntmp(GetTitle()); 
  ntmp.ToUpper();
  if(ntmp.Contains("10KEV")) {
    cutele = cutgam = 1.e-5;
  } else if(ntmp.Contains("50KEV")) {
    cutele = cutgam = 5.e-5;
  } else if(ntmp.Contains("100KEV")) {
    cutele = cutgam = 1.e-4;
  } else if(ntmp.Contains("200KEV")) {
    cutele = cutgam = 2.e-4;
  } else if(ntmp.Contains("500KEV")) {
    cutele = cutgam = 5.e-4;
  }

  gMC->Gstpar(idtmed[1600],"CUTGAM", cutgam);
  gMC->Gstpar(idtmed[1600],"CUTELE", cutele); // 1MEV -> 0.1MEV; 15-aug-05
  gMC->Gstpar(idtmed[1600],"BCUTE",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1600],"BCUTM",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  // --- Generate explicitly delta rays in Lead ---
  gMC->Gstpar(idtmed[1600], "LOSS",3.) ;
  gMC->Gstpar(idtmed[1600], "DRAY",1.) ;
  gMC->Gstpar(idtmed[1600], "DCUTE", cutele) ;
  gMC->Gstpar(idtmed[1600], "DCUTM", cutele) ;

// --- in aluminium parts ---
  gMC->Gstpar(idtmed[1602],"CUTGAM", cutgam) ;
  gMC->Gstpar(idtmed[1602],"CUTELE", cutele) ;
  gMC->Gstpar(idtmed[1602],"BCUTE",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1602],"BCUTM",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1602], "LOSS",3.) ;
  gMC->Gstpar(idtmed[1602], "DRAY",1.) ;
  gMC->Gstpar(idtmed[1602], "DCUTE", cutele) ;
  gMC->Gstpar(idtmed[1602], "DCUTM", cutele) ;

// --- and finally thresholds for photons and electrons in the scintillator ---
  gMC->Gstpar(idtmed[1601],"CUTGAM", cutgam) ;
  gMC->Gstpar(idtmed[1601],"CUTELE", cutele) ;// 1MEV -> 0.1MEV; 15-aug-05
  gMC->Gstpar(idtmed[1601],"BCUTE",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1601],"BCUTM",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1601], "LOSS",3.) ; // generate delta rays 
  gMC->Gstpar(idtmed[1601], "DRAY",1.) ;
  gMC->Gstpar(idtmed[1601], "DCUTE", cutele) ;
  gMC->Gstpar(idtmed[1601], "DCUTM", cutele) ;

  // S steel - 
  gMC->Gstpar(idtmed[1603],"CUTGAM", cutgam);
  gMC->Gstpar(idtmed[1603],"CUTELE", cutele);
  gMC->Gstpar(idtmed[1603],"BCUTE",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  gMC->Gstpar(idtmed[1603],"BCUTM",  cutgam);  // BCUTE and BCUTM start from GUTGUM
  // --- Generate explicitly delta rays 
  gMC->Gstpar(idtmed[1603], "LOSS",3.);
  gMC->Gstpar(idtmed[1603], "DRAY",1.);
  gMC->Gstpar(idtmed[1603], "DCUTE", cutele) ;
  gMC->Gstpar(idtmed[1603], "DCUTM", cutele) ;

  //set constants for Birk's Law implentation
  fBirkC0 =  1;
  fBirkC1 =  0.013/dP;
  fBirkC2 =  9.6e-6/(dP * dP);

}
      
//____________________________________________________________________________
void AliEMCAL::Digits2Raw()
{
  // convert digits of the current event to raw data
  AliEMCALLoader * loader = dynamic_cast<AliEMCALLoader*>(fLoader) ; 

  // get the digits
  loader->LoadDigits();
  TClonesArray* digits = loader->Digits() ;

  if (!digits) {
    Error("Digits2Raw", "no digits found !");
    return;
  }

  // get the digitizer 
  loader->LoadDigitizer();
  AliEMCALDigitizer * digitizer = dynamic_cast<AliEMCALDigitizer *>(loader->Digitizer())  ; 
  
  // get the geometry
  AliEMCALGeometry* geom = GetGeometry();
  if (!geom) {
    Error("Digits2Raw", "no geometry found !");
    return;
  }

  // some digitization constants
  const Int_t    kDDLOffset = 0x800;
  const Int_t    kThreshold = 1;
  const Int_t    kChannelsperDDL = 897 ; 
  AliAltroBuffer* buffer = NULL;
  Int_t prevDDL = -1;
  Int_t adcValuesLow[fkTimeBins];
  Int_t adcValuesHigh[fkTimeBins];
  
  // loop over digits (assume ordered digits)
  for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
    AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
    if (digit->GetAmp() < kThreshold) 
      continue;
    Int_t iDDL = digit->GetId() / kChannelsperDDL ;
    // for each DDL id is numbered from 1 to  kChannelsperDDL -1 
    Int_t idDDL = digit->GetId() - iDDL * ( kChannelsperDDL - 1 ) ;  
    // new DDL
    if (iDDL != prevDDL) {
      // write real header and close previous file
      if (buffer) {
	buffer->Flush();
	buffer->WriteDataHeader(kFALSE, kFALSE);
	delete buffer;
      }

      // open new file and write dummy header
      TString fileName("EMCAL_") ;
      fileName += (iDDL + kDDLOffset) ; 
      fileName += ".ddl" ; 
      buffer = new AliAltroBuffer(fileName.Data(), 1);
      buffer->WriteDataHeader(kTRUE, kFALSE);  //Dummy;

      prevDDL = iDDL;
    }

    // out of time range signal (?)
    if (digit->GetTimeR() > GetRawFormatTimeMax() ) {
      buffer->FillBuffer(digit->GetAmp());
      buffer->FillBuffer(GetRawFormatTimeBins() );  // time bin
      buffer->FillBuffer(3);          // bunch length
      buffer->WriteTrailer(3, idDDL, 0, 0);  // trailer

      // calculate the time response function
    } else {
      Double_t energy = 0 ;  
      energy = digit->GetAmp() * digitizer->GetECAchannel() + digitizer->GetECApedestal() ; 
      
      Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), energy, adcValuesHigh, adcValuesLow) ; 
      
      if (lowgain) 
	buffer->WriteChannel(iDDL, 0, fLowGainOffset, 
			     GetRawFormatTimeBins(), adcValuesLow, kThreshold);
      else 
	buffer->WriteChannel(iDDL, 0, 0, 
			     GetRawFormatTimeBins(), adcValuesHigh, kThreshold);
      
    }
  }
  
  // write real header and close last file
  if (buffer) {
    buffer->Flush();
    buffer->WriteDataHeader(kFALSE, kFALSE);
    delete buffer;
  }

  loader->UnloadDigits();
}

//____________________________________________________________________________
void AliEMCAL::Hits2SDigits()  
{ 
// create summable digits

  AliEMCALSDigitizer emcalDigitizer(fLoader->GetRunLoader()->GetFileName().Data()) ;
  emcalDigitizer.SetEventRange(0, -1) ; // do all the events
  emcalDigitizer.ExecuteTask() ;
}

//____________________________________________________________________________

AliLoader* AliEMCAL::MakeLoader(const char* topfoldername)
{
//different behaviour than standard (singleton getter)
// --> to be discussed and made eventually coherent
 fLoader = new AliEMCALLoader(GetName(),topfoldername);
 return fLoader;
}

//__________________________________________________________________
Double_t AliEMCAL::RawResponseFunction(Double_t *x, Double_t *par)
{
  // Shape of the electronics raw reponse:
  // It is a semi-gaussian, 2nd order Gamma function of the general form
  // v(t) = n**n * Q * A**n / C *(t/tp)**n * exp(-n * t/tp) with 
  // tp : peaking time par[0]
  // n  : order of the function
  // C  : integrating capacitor in the preamplifier
  // A  : open loop gain of the preamplifier
  // Q  : the total APD charge to be measured Q = C * energy
  
  Double_t signal ;
  Double_t xx = x[0] - ( fgTimeTrigger + par[3] ) ; 
  
  if (xx < 0 || xx > fgTimeMax) 
    signal = 0. ;  
  else { 
    Double_t fac = par[0] * TMath::Power(fgOrder, fgOrder) * TMath::Power(par[1], fgOrder) / fgCapa ; 
    signal = fac * par[2] * TMath::Power(xx / fgTimePeak, fgOrder) * TMath::Exp(-fgOrder * (xx / fgTimePeak)) ; 
  }
  return signal ;  
}

//__________________________________________________________________
Double_t AliEMCAL::RawResponseFunctionMax(Double_t charge, Double_t gain) 
{
  return ( charge * TMath::Power(fgOrder, fgOrder) * TMath::Power(gain, fgOrder) 
     / ( fgCapa * TMath::Exp(fgOrder) ) );  

}
//__________________________________________________________________
Bool_t AliEMCAL::RawSampledResponse(
const Double_t dtime, const Double_t damp, Int_t * adcH, Int_t * adcL) const 
{
  // for a start time dtime and an amplitude damp given by digit, 
  // calculates the raw sampled response AliEMCAL::RawResponseFunction

  const Int_t kRawSignalOverflow = 0x3FF ; 
  Bool_t lowGain = kFALSE ; 

  TF1 signalF("signal", RawResponseFunction, 0, GetRawFormatTimeMax(), 4);

  for (Int_t iTime = 0; iTime < GetRawFormatTimeBins(); iTime++) {
    signalF.SetParameter(0, GetRawFormatHighCharge() ) ; 
    signalF.SetParameter(1, GetRawFormatHighGain() ) ; 
    signalF.SetParameter(2, damp) ; 
    signalF.SetParameter(3, dtime) ; 
    Double_t time = iTime * GetRawFormatTimeMax() / GetRawFormatTimeBins() ;
    Double_t signal = signalF.Eval(time) ;     
    if ( static_cast<Int_t>(signal+0.5) > kRawSignalOverflow ){  // larger than 10 bits 
      signal = kRawSignalOverflow ;
      lowGain = kTRUE ; 
    }
    adcH[iTime] =  static_cast<Int_t>(signal + 0.5) ;

    signalF.SetParameter(0, GetRawFormatLowCharge() ) ;     
    signalF.SetParameter(1, GetRawFormatLowGain() ) ; 
    signal = signalF.Eval(time) ;  
    if ( static_cast<Int_t>(signal+0.5) > kRawSignalOverflow)  // larger than 10 bits 
      signal = kRawSignalOverflow ;
    adcL[iTime] = static_cast<Int_t>(0.5 + signal ) ; 

  }
  return lowGain ; 
}
Commit	Line	Data
2012850d	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
	18	//_________________________________________________________________________
	19	// Base Class for EMCAL description:
ffa6d63b	20	// This class contains material definitions
ffa6d63b	21	// for the EMCAL - It does not place the detector in Alice
2012850d	22	//*-- Author: Yves Schutz (SUBATECH)
b13bbe81	23	//
	24	//*-- Additional Contributions: Sahal Yacoob (LBNL/UCT)
	25	//
2012850d	26	//////////////////////////////////////////////////////////////////////////////
2012850d	27
2012850d	28	// --- ROOT system ---
b13bbe81	29	class TFile;
88cb7938	30	#include <TFolder.h>
88cb7938	31	#include <TTree.h>
88cb7938	32	#include <TVirtualMC.h>
046ae904	33	#include <TH1F.h>
	34	#include <TF1.h>
	35	#include <TRandom.h>
2012850d	36
05a92d59	37	// --- Standard library ---
2012850d	38
05a92d59	39	// --- AliRoot header files ---
2012850d	40	#include "AliMagF.h"
88cb7938	41	#include "AliEMCAL.h"
85a5290f	42	#include "AliRun.h"
5dee926e	43	#include "AliEMCALLoader.h"
85a5290f	44	#include "AliEMCALSDigitizer.h"
85a5290f	45	#include "AliEMCALDigitizer.h"
5dee926e	46	#include "AliEMCALDigit.h"
f51151a0	47	#include "AliAltroBuffer.h"
2012850d	48
2012850d	49	ClassImp(AliEMCAL)
56088960	50	Double_t AliEMCAL::fgCapa = 1.; // 1pF
	51	Int_t AliEMCAL::fgOrder = 2 ;
	52	Double_t AliEMCAL::fgTimeMax = 2.56E-5 ; // each sample is over 100 ns fTimeMax/fTimeBins
	53	Double_t AliEMCAL::fgTimePeak = 4.1E-6 ; // 4 micro seconds
	54	Double_t AliEMCAL::fgTimeTrigger = 100E-9 ; // 100ns, just for a reference
	55
2012850d	56	//____________________________________________________________________________
	57	AliEMCAL::AliEMCAL():AliDetector()
	58	{
05a92d59	59	// Default ctor
046ae904	60	fName = "EMCAL" ;
2012850d	61	}
05a92d59	62
2012850d	63	//____________________________________________________________________________
05a92d59	64	AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title)
	65	{
	66	// ctor : title is used to identify the layout
046ae904	67
56088960	68	fHighCharge = 8.2 ; // adjusted for a high gain range of 5.12 GeV (10 bits)
	69	fHighGain = 6.64 ;
	70	fHighLowGainFactor = 16. ; // adjusted for a low gain range of 82 GeV (10 bits)
	71	fLowGainOffset = 1 ; // offset added to the module id to distinguish high and low gain data
2012850d	72	}
05a92d59	73
2012850d	74	//____________________________________________________________________________
05a92d59	75	AliEMCAL::~AliEMCAL()
	76	{
	77
2012850d	78	}
2012850d	79
8367ce9a	80	//____________________________________________________________________________
5dee926e	81	void AliEMCAL::Copy(AliEMCAL & emcal) const
8367ce9a	82	{
8367ce9a	83	TObject::Copy(emcal) ;
56088960	84	emcal.fHighCharge = fHighCharge ;
	85	emcal.fHighGain = fHighGain ;
	86	emcal.fHighLowGainFactor = fHighLowGainFactor ;
	87	emcal.fLowGainOffset = fLowGainOffset;
8367ce9a	88	}
	89
	90	//____________________________________________________________________________
	91	AliDigitizer* AliEMCAL::CreateDigitizer(AliRunDigitizer* manager) const
	92	{
	93	return new AliEMCALDigitizer(manager);
	94	}
	95
2012850d	96	//____________________________________________________________________________
05a92d59	97	void AliEMCAL::CreateMaterials()
05a92d59	98	{
2012850d	99	// Definitions of materials to build EMCAL and associated tracking media.
	100	// media number in idtmed are 1599 to 1698.
	101
996cf306	102	// --- Air ---
	103	Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
	104	Float_t zAir[4]={6.,7.,8.,18.};
	105	Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
	106	Float_t dAir = 1.20479E-3;
	107	AliMixture(0, "Air$", aAir, zAir, dAir, 4, wAir) ;
b13bbe81	108
2012850d	109	// --- Lead ---
	110	AliMaterial(1, "Pb$", 207.2, 82, 11.35, 0.56, 0., 0, 0) ;
	111
b13bbe81	112
	113	// --- The polysterene scintillator (CH) ---
	114	Float_t aP[2] = {12.011, 1.00794} ;
	115	Float_t zP[2] = {6.0, 1.0} ;
	116	Float_t wP[2] = {1.0, 1.0} ;
	117	Float_t dP = 1.032 ;
	118
	119	AliMixture(2, "Polystyrene$", aP, zP, dP, -2, wP) ;
	120
	121	// --- Aluminium ---
	122	AliMaterial(3, "Al$", 26.98, 13., 2.7, 8.9, 999., 0, 0) ;
	123	// --- Absorption length is ignored ^
	124
1963b290	125	// 25-aug-04 by PAI - see PMD/AliPMDv0.cxx for STEEL definition
	126	Float_t asteel[4] = { 55.847,51.9961,58.6934,28.0855 };
	127	Float_t zsteel[4] = { 26.,24.,28.,14. };
	128	Float_t wsteel[4] = { .715,.18,.1,.005 };
	129	AliMixture(4, "STAINLESS STEEL$", asteel, zsteel, 7.88, 4, wsteel);
	130
2012850d	131	// DEFINITION OF THE TRACKING MEDIA
	132
	133	// for EMCAL: idtmed[1599->1698] equivalent to fIdtmed[0->100]
	134	Int_t * idtmed = fIdtmed->GetArray() - 1599 ;
	135	Int_t isxfld = gAlice->Field()->Integ() ;
	136	Float_t sxmgmx = gAlice->Field()->Max() ;
	137
996cf306	138	// Air -> idtmed[1599]
905263da	139	AliMedium(0, "Air$", 0, 0,
996cf306	140	isxfld, sxmgmx, 10.0, 1.0, 0.1, 0.1, 10.0, 0, 0) ;
2012850d	141
a63e0d5e	142	// The Lead -> idtmed[1600]
2012850d	143
905263da	144	AliMedium(1, "Lead$", 1, 0,
2012850d	145	isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.1, 0.1, 0, 0) ;
2012850d	146
b13bbe81	147	// The scintillator of the CPV made of Polystyrene scintillator -> idtmed[1601]
905263da	148	AliMedium(2, "Scintillator$", 2, 1,
61e0abb5	149	isxfld, sxmgmx, 10.0, 0.001, 0.1, 0.001, 0.001, 0, 0) ;
b13bbe81	150
a63e0d5e	151	// Various Aluminium parts made of Al -> idtmed[1602]
905263da	152	AliMedium(3, "Al$", 3, 0,
b13bbe81	153	isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.001, 0.001, 0, 0) ;
b13bbe81	154
1963b290	155	// 25-aug-04 by PAI : see PMD/AliPMDv0.cxx for STEEL definition -> idtmed[1603]
	156	AliMedium(4, "S steel$", 4, 0,
	157	isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.001, 0.001, 0, 0) ;
2012850d	158
b13bbe81	159	// --- Set decent energy thresholds for gamma and electron tracking
2012850d	160
2012850d	161	// Tracking threshold for photons and electrons in Lead
905263da	162	Float_t cutgam=10.e-5; // 100 kev;
	163	Float_t cutele=10.e-5; // 100 kev;
	164	TString ntmp(GetTitle());
	165	ntmp.ToUpper();
	166	if(ntmp.Contains("10KEV")) {
	167	cutele = cutgam = 1.e-5;
	168	} else if(ntmp.Contains("50KEV")) {
	169	cutele = cutgam = 5.e-5;
	170	} else if(ntmp.Contains("100KEV")) {
	171	cutele = cutgam = 1.e-4;
	172	} else if(ntmp.Contains("200KEV")) {
	173	cutele = cutgam = 2.e-4;
	174	} else if(ntmp.Contains("500KEV")) {
	175	cutele = cutgam = 5.e-4;
	176	}
2012850d	177
905263da	178	gMC->Gstpar(idtmed[1600],"CUTGAM", cutgam);
	179	gMC->Gstpar(idtmed[1600],"CUTELE", cutele); // 1MEV -> 0.1MEV; 15-aug-05
	180	gMC->Gstpar(idtmed[1600],"BCUTE", cutgam); // BCUTE and BCUTM start from GUTGUM
	181	gMC->Gstpar(idtmed[1600],"BCUTM", cutgam); // BCUTE and BCUTM start from GUTGUM
2012850d	182	// --- Generate explicitly delta rays in Lead ---
	183	gMC->Gstpar(idtmed[1600], "LOSS",3.) ;
	184	gMC->Gstpar(idtmed[1600], "DRAY",1.) ;
905263da	185	gMC->Gstpar(idtmed[1600], "DCUTE", cutele) ;
905263da	186	gMC->Gstpar(idtmed[1600], "DCUTM", cutele) ;
05a92d59	187
a63e0d5e	188	// --- in aluminium parts ---
905263da	189	gMC->Gstpar(idtmed[1602],"CUTGAM", cutgam) ;
	190	gMC->Gstpar(idtmed[1602],"CUTELE", cutele) ;
	191	gMC->Gstpar(idtmed[1602],"BCUTE", cutgam); // BCUTE and BCUTM start from GUTGUM
	192	gMC->Gstpar(idtmed[1602],"BCUTM", cutgam); // BCUTE and BCUTM start from GUTGUM
b13bbe81	193	gMC->Gstpar(idtmed[1602], "LOSS",3.) ;
b13bbe81	194	gMC->Gstpar(idtmed[1602], "DRAY",1.) ;
905263da	195	gMC->Gstpar(idtmed[1602], "DCUTE", cutele) ;
905263da	196	gMC->Gstpar(idtmed[1602], "DCUTM", cutele) ;
b13bbe81	197
ffa6d63b	198	// --- and finally thresholds for photons and electrons in the scintillator ---
905263da	199	gMC->Gstpar(idtmed[1601],"CUTGAM", cutgam) ;
	200	gMC->Gstpar(idtmed[1601],"CUTELE", cutele) ;// 1MEV -> 0.1MEV; 15-aug-05
	201	gMC->Gstpar(idtmed[1601],"BCUTE", cutgam); // BCUTE and BCUTM start from GUTGUM
	202	gMC->Gstpar(idtmed[1601],"BCUTM", cutgam); // BCUTE and BCUTM start from GUTGUM
	203	gMC->Gstpar(idtmed[1601], "LOSS",3.) ; // generate delta rays
	204	gMC->Gstpar(idtmed[1601], "DRAY",1.) ;
	205	gMC->Gstpar(idtmed[1601], "DCUTE", cutele) ;
	206	gMC->Gstpar(idtmed[1601], "DCUTM", cutele) ;
	207
	208	// S steel -
	209	gMC->Gstpar(idtmed[1603],"CUTGAM", cutgam);
	210	gMC->Gstpar(idtmed[1603],"CUTELE", cutele);
	211	gMC->Gstpar(idtmed[1603],"BCUTE", cutgam); // BCUTE and BCUTM start from GUTGUM
	212	gMC->Gstpar(idtmed[1603],"BCUTM", cutgam); // BCUTE and BCUTM start from GUTGUM
	213	// --- Generate explicitly delta rays
1963b290	214	gMC->Gstpar(idtmed[1603], "LOSS",3.);
1963b290	215	gMC->Gstpar(idtmed[1603], "DRAY",1.);
905263da	216	gMC->Gstpar(idtmed[1603], "DCUTE", cutele) ;
905263da	217	gMC->Gstpar(idtmed[1603], "DCUTM", cutele) ;
1963b290	218
ab37d09c	219	//set constants for Birk's Law implentation
	220	fBirkC0 = 1;
	221	fBirkC1 = 0.013/dP;
	222	fBirkC2 = 9.6e-6/(dP * dP);
	223
2012850d	224	}
f6019cda	225
f51151a0	226	//____________________________________________________________________________
	227	void AliEMCAL::Digits2Raw()
	228	{
56088960	229	// convert digits of the current event to raw data
56088960	230	AliEMCALLoader * loader = dynamic_cast<AliEMCALLoader*>(fLoader) ;
f51151a0	231
f51151a0	232	// get the digits
56088960	233	loader->LoadDigits();
56088960	234	TClonesArray* digits = loader->Digits() ;
f51151a0	235
	236	if (!digits) {
	237	Error("Digits2Raw", "no digits found !");
	238	return;
	239	}
	240
56088960	241	// get the digitizer
	242	loader->LoadDigitizer();
	243	AliEMCALDigitizer * digitizer = dynamic_cast<AliEMCALDigitizer *>(loader->Digitizer()) ;
	244
f51151a0	245	// get the geometry
56088960	246	AliEMCALGeometry* geom = GetGeometry();
f51151a0	247	if (!geom) {
	248	Error("Digits2Raw", "no geometry found !");
	249	return;
	250	}
	251
	252	// some digitization constants
	253	const Int_t kDDLOffset = 0x800;
56088960	254	const Int_t kThreshold = 1;
f51151a0	255	const Int_t kChannelsperDDL = 897 ;
f51151a0	256	AliAltroBuffer* buffer = NULL;
f51151a0	257	Int_t prevDDL = -1;
046ae904	258	Int_t adcValuesLow[fkTimeBins];
046ae904	259	Int_t adcValuesHigh[fkTimeBins];
56088960	260
f51151a0	261	// loop over digits (assume ordered digits)
f51151a0	262	for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
56088960	263	AliEMCALDigit* digit = dynamic_cast<AliEMCALDigit *>(digits->At(iDigit)) ;
f51151a0	264	if (digit->GetAmp() < kThreshold)
	265	continue;
	266	Int_t iDDL = digit->GetId() / kChannelsperDDL ;
	267	// for each DDL id is numbered from 1 to kChannelsperDDL -1
	268	Int_t idDDL = digit->GetId() - iDDL * ( kChannelsperDDL - 1 ) ;
	269	// new DDL
	270	if (iDDL != prevDDL) {
	271	// write real header and close previous file
	272	if (buffer) {
	273	buffer->Flush();
	274	buffer->WriteDataHeader(kFALSE, kFALSE);
	275	delete buffer;
	276	}
	277
	278	// open new file and write dummy header
	279	TString fileName("EMCAL_") ;
	280	fileName += (iDDL + kDDLOffset) ;
	281	fileName += ".ddl" ;
	282	buffer = new AliAltroBuffer(fileName.Data(), 1);
	283	buffer->WriteDataHeader(kTRUE, kFALSE); //Dummy;
	284
	285	prevDDL = iDDL;
	286	}
	287
	288	// out of time range signal (?)
56088960	289	if (digit->GetTimeR() > GetRawFormatTimeMax() ) {
f51151a0	290	buffer->FillBuffer(digit->GetAmp());
56088960	291	buffer->FillBuffer(GetRawFormatTimeBins() ); // time bin
f51151a0	292	buffer->FillBuffer(3); // bunch length
f51151a0	293	buffer->WriteTrailer(3, idDDL, 0, 0); // trailer
56088960	294
56088960	295	// calculate the time response function
f51151a0	296	} else {
56088960	297	Double_t energy = 0 ;
	298	energy = digit->GetAmp() * digitizer->GetECAchannel() + digitizer->GetECApedestal() ;
	299
	300	Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), energy, adcValuesHigh, adcValuesLow) ;
	301
	302	if (lowgain)
	303	buffer->WriteChannel(iDDL, 0, fLowGainOffset,
	304	GetRawFormatTimeBins(), adcValuesLow, kThreshold);
	305	else
	306	buffer->WriteChannel(iDDL, 0, 0,
	307	GetRawFormatTimeBins(), adcValuesHigh, kThreshold);
	308
f51151a0	309	}
f51151a0	310	}
56088960	311
f51151a0	312	// write real header and close last file
	313	if (buffer) {
	314	buffer->Flush();
	315	buffer->WriteDataHeader(kFALSE, kFALSE);
	316	delete buffer;
	317	}
56088960	318
56088960	319	loader->UnloadDigits();
f51151a0	320	}
f51151a0	321
8367ce9a	322	//____________________________________________________________________________
	323	void AliEMCAL::Hits2SDigits()
	324	{
	325	// create summable digits
	326
4d33c797	327	AliEMCALSDigitizer emcalDigitizer(fLoader->GetRunLoader()->GetFileName().Data()) ;
	328	emcalDigitizer.SetEventRange(0, -1) ; // do all the events
	329	emcalDigitizer.ExecuteTask() ;
da480a28	330	}
da480a28	331
8367ce9a	332	//____________________________________________________________________________
5dee926e	333
8367ce9a	334	AliLoader* AliEMCAL::MakeLoader(const char* topfoldername)
	335	{
	336	//different behaviour than standard (singleton getter)
	337	// --> to be discussed and made eventually coherent
	338	fLoader = new AliEMCALLoader(GetName(),topfoldername);
	339	return fLoader;
	340	}
	341
046ae904	342	//__________________________________________________________________
	343	Double_t AliEMCAL::RawResponseFunction(Double_t x, Double_t par)
	344	{
	345	// Shape of the electronics raw reponse:
56088960	346	// It is a semi-gaussian, 2nd order Gamma function of the general form
	347	// v(t) = n*n Q * A*n / C (t/tp)*n exp(-n * t/tp) with
	348	// tp : peaking time par[0]
	349	// n : order of the function
	350	// C : integrating capacitor in the preamplifier
	351	// A : open loop gain of the preamplifier
	352	// Q : the total APD charge to be measured Q = C * energy
046ae904	353
56088960	354	Double_t signal ;
56088960	355	Double_t xx = x[0] - ( fgTimeTrigger + par[3] ) ;
046ae904	356
56088960	357	if (xx < 0 \|\| xx > fgTimeMax)
	358	signal = 0. ;
	359	else {
	360	Double_t fac = par[0] * TMath::Power(fgOrder, fgOrder) * TMath::Power(par[1], fgOrder) / fgCapa ;
	361	signal = fac * par[2] * TMath::Power(xx / fgTimePeak, fgOrder) * TMath::Exp(-fgOrder * (xx / fgTimePeak)) ;
	362	}
	363	return signal ;
046ae904	364	}
	365
	366	//__________________________________________________________________
56088960	367	Double_t AliEMCAL::RawResponseFunctionMax(Double_t charge, Double_t gain)
	368	{
	369	return ( charge * TMath::Power(fgOrder, fgOrder) * TMath::Power(gain, fgOrder)
	370	/ ( fgCapa * TMath::Exp(fgOrder) ) );
	371
	372	}
	373	//__________________________________________________________________
	374	Bool_t AliEMCAL::RawSampledResponse(
	375	const Double_t dtime, const Double_t damp, Int_t * adcH, Int_t * adcL) const
046ae904	376	{
046ae904	377	// for a start time dtime and an amplitude damp given by digit,
56088960	378	// calculates the raw sampled response AliEMCAL::RawResponseFunction
046ae904	379
046ae904	380	const Int_t kRawSignalOverflow = 0x3FF ;
56088960	381	Bool_t lowGain = kFALSE ;
	382
	383	TF1 signalF("signal", RawResponseFunction, 0, GetRawFormatTimeMax(), 4);
	384
	385	for (Int_t iTime = 0; iTime < GetRawFormatTimeBins(); iTime++) {
	386	signalF.SetParameter(0, GetRawFormatHighCharge() ) ;
	387	signalF.SetParameter(1, GetRawFormatHighGain() ) ;
	388	signalF.SetParameter(2, damp) ;
	389	signalF.SetParameter(3, dtime) ;
	390	Double_t time = iTime * GetRawFormatTimeMax() / GetRawFormatTimeBins() ;
	391	Double_t signal = signalF.Eval(time) ;
	392	if ( static_cast<Int_t>(signal+0.5) > kRawSignalOverflow ){ // larger than 10 bits
	393	signal = kRawSignalOverflow ;
	394	lowGain = kTRUE ;
	395	}
	396	adcH[iTime] = static_cast<Int_t>(signal + 0.5) ;
	397
	398	signalF.SetParameter(0, GetRawFormatLowCharge() ) ;
	399	signalF.SetParameter(1, GetRawFormatLowGain() ) ;
	400	signal = signalF.Eval(time) ;
	401	if ( static_cast<Int_t>(signal+0.5) > kRawSignalOverflow) // larger than 10 bits
	402	signal = kRawSignalOverflow ;
	403	adcL[iTime] = static_cast<Int_t>(0.5 + signal ) ;
	404
046ae904	405	}
56088960	406	return lowGain ;
046ae904	407	}