[u/mrichter/AliRoot.git] / FMD / AliFMDHitDigitizer.cxx

/**************************************************************************
 * Copyright(c) 2004, 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: AliFMDHitDigitizer.cxx 28055 2008-08-18 00:33:20Z cholm $ */
/** @file    AliFMDHitDigitizer.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:38:26 2006
    @brief   FMD Digitizers implementation
    @ingroup FMD_sim
*/
//////////////////////////////////////////////////////////////////////////////
//
//  This class contains the procedures simulation ADC  signal for the
//  Forward Multiplicity detector  : Hits->Digits
// 
//  Digits consists of
//   - Detector #
//   - Ring ID                                             
//   - Sector #     
//   - Strip #
//   - ADC count in this channel                                  
//
// As the Digits and SDigits have so much in common, the classes
// AliFMDHitDigitizer and AliFMDSDigitizer are implemented via a base
// class AliFMDBaseDigitizer.
//
//                 +---------------------+
//                 | AliFMDBaseDigitizer |
//                 +---------------------+
//                           ^
//                           |
//                +----------+---------+
//                |                    |
//      +-----------------+     +------------------+
//      | AliFMDHitDigitizer |	| AliFMDSDigitizer |
//      +-----------------+	+------------------+
//
// These classes has several paramters: 
//
//     fPedestal
//     fPedestalWidth
//         (Only AliFMDHitDigitizer)
//         Mean and width of the pedestal.  The pedestal is simulated
//         by a Guassian, but derived classes my override MakePedestal
//         to simulate it differently (or pick it up from a database).
//
//     fVA1MipRange
//         The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
//
//     fAltroChannelSize
//         The largest number plus one that can be stored in one
//         channel in one time step in the ALTRO ADC chip. 
//
//     fSampleRate
//         How many times the ALTRO ADC chip samples the VA1_ALICE
//         pre-amplifier signal.   The VA1_ALICE chip is read-out at
//         10MHz, while it's possible to drive the ALTRO chip at
//         25MHz.  That means, that the ALTRO chip can have time to
//         sample each VA1_ALICE signal up to 2 times.  Although it's
//         not certain this feature will be used in the production,
//         we'd like have the option, and so it should be reflected in
//         the code.
//
// These parameters are fetched from OCDB via the mananger AliFMDParameters.
//
// The shaping function of the VA1_ALICE is generally given by 
//
//      f(x) = A(1 - exp(-Bx))
//
// where A is the total charge collected in the pre-amp., and B is a
// paramter that depends on the shaping time of the VA1_ALICE circut.
// 
// When simulating the shaping function of the VA1_ALICe
// pre-amp. chip, we have to take into account, that the shaping
// function depends on the previous value of read from the pre-amp. 
//
// That results in the following algorithm:
//
//    last = 0;
//    FOR charge IN pre-amp. charge train DO 
//      IF last < charge THEN 
//        f(t) = (charge - last) * (1 - exp(-B * t)) + last
//      ELSE
//        f(t) = (last - charge) * exp(-B * t) + charge)
//      ENDIF
//      FOR i IN # samples DO 
//        adc_i = f(i / (# samples))
//      DONE
//      last = charge
//   DONE
//
// Here, 
//
//   pre-amp. charge train 
//       is a series of 128 charges read from the VA1_ALICE chip
//
//   # samples
//       is the number of times the ALTRO ADC samples each of the 128
//       charges from the pre-amp. 
//
// Where Q is the total charge collected by the VA1_ALICE
// pre-amplifier.   Q is then given by 
//
//           E S 
//      Q =  - -
//           e R
//
// where E is the total energy deposited in a silicon strip, R is the
// dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
// energy deposited by a single MIP, and S ALTRO channel size in each
// time step (fAltroChannelSize).  
//
// The energy deposited per MIP is given by 
//
//      e = M * rho * w 
//
// where M is the universal number 1.664, rho is the density of
// silicon, and w is the depth of the silicon sensor. 
//
// The final ADC count is given by 
//
//      C' = C + P
//
// where P is the (randomized) pedestal (see MakePedestal)
//
// This class uses the class template AliFMDMap<Type> to make an
// internal cache of the energy deposted of the hits.  The class
// template is instantasized as 
//
//  typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
//
// The first member of the values is the summed energy deposition in a
// given strip, while the second member of the values is the number of
// hits in a given strip.  Using the second member, it's possible to
// do some checks on just how many times a strip got hit, and what
// kind of error we get in our reconstructed hits.  Note, that this
// information is currently not written to the digits tree.  I think a
// QA (Quality Assurance) digit tree is better suited for that task.
// However, the information is there to be used in the future. 
//
//
// Latest changes by Christian Holm Christensen
//
//////////////////////////////////////////////////////////////////////////////

//      /1
//      |           A(-1 + B + exp(-B))
//      | f(x) dx = ------------------- = 1
//      |                    B
//      / 0
//
// and B is the a parameter defined by the shaping time (fShapingTime).  
//
// Solving the above equation, for A gives
//
//                 B
//      A = ----------------
//          -1 + B + exp(-B)
//
// So, if we define the function g: [0,1] -> [0:1] by 
//
//               / v
//               |              Bu + exp(-Bu) - Bv - exp(-Bv) 
//      g(u,v) = | f(x) dx = -A -----------------------------
//               |                            B
//               / u
//
// we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
// any two times (u, v), by 
//       
//
//                                B	    Bu + exp(-Bu) - Bv - exp(-Bv)
//      C = Q g(u,v) = - Q ---------------- -----------------------------
//		           -1 + B + exp(-B)              B	            
//
//               Bu + exp(-Bu) - Bv - exp(-Bv) 
//        = -  Q -----------------------------
//                    -1 + B + exp(-B)
//

#include <TTree.h>		// ROOT_TTree
#include "AliFMDDebug.h"        // Better debug macros
#include "AliFMDHitDigitizer.h"	// ALIFMDDIGITIZER_H
#include "AliFMD.h"		// ALIFMD_H
#include "AliFMDDigit.h"	// ALIFMDDIGIT_H
#include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
#include <AliRun.h>		// ALIRUN_H
#include <AliLoader.h>		// ALILOADER_H
#include <AliRunLoader.h>	// ALIRUNLOADER_H
#include <AliFMDHit.h>
#include <AliStack.h>
#include <TFile.h>
#include <TParticle.h>

//====================================================================
ClassImp(AliFMDHitDigitizer)    
#if 0
;
#endif

//____________________________________________________________________
AliFMDHitDigitizer::AliFMDHitDigitizer(AliFMD* fmd, Output_t  output)
  : AliFMDBaseDigitizer("FMD", (output == kDigits ? 
				"FMD Hit->Digit digitizer" :
				"FMD Hit->SDigit digitizer")),
    fOutput(output), 
    fHoldTime(2e-6),
    fStack(0)
{
  fFMD = fmd;
}

//____________________________________________________________________
AliFMDHitDigitizer& 
AliFMDHitDigitizer::operator=(const AliFMDHitDigitizer& o) 
{
  /** 
   * Assignment operator
   *
   * @param o Object to assign from 
   * @return Reference to this 
   */
  AliFMDBaseDigitizer::operator=(o);
  fHoldTime    = o.fHoldTime;
  fOutput      = o.fOutput;
  fStack       = o.fStack;
  return *this;
}

//____________________________________________________________________
void
AliFMDHitDigitizer::Exec(Option_t* /*option*/)
{
  // Run this digitizer 
  // Get an inititialize parameter manager
  AliFMDParameters::Instance()->Init();
  if (AliLog::GetDebugLevel("FMD","") >= 10) 
    AliFMDParameters::Instance()->Print("ALL");

  // Get loader, and ask it to read in the hits 
  AliLoader* loader = fFMD->GetLoader();
  if (!loader) { 
    AliError("Failed to get loader from detector object");
    return;
  }
  loader->LoadHits("READ");
  
  // Get the run loader 
  AliRunLoader* runLoader = loader->GetRunLoader();
  if (!runLoader) {
    AliError("Failed to get run loader from loader");
    return;
  }
  
  // Now loop over events
  Int_t nEvents = runLoader->GetNumberOfEvents();
  for (Int_t event = 0; event < nEvents; event++) { 
    // Get the current event folder. 
    TFolder* folder = loader->GetEventFolder();
    if (!folder) { 
      AliError("Failed to get event folder from loader");
      return;
    }

    // Get the run-loader of this event. 
    const char* loaderName = AliRunLoader::GetRunLoaderName();
    AliRunLoader* thisLoader = 
      static_cast<AliRunLoader*>(folder->FindObject(loaderName));
    if (!thisLoader) { 
      AliError(Form("Failed to get loader '%s' from event folder", loaderName));
      return;
    }
    
    // Read in the event
    AliFMDDebug(1, ("Now digitizing (Hits->%s) event # %d", 
		    (fOutput == kDigits ? "digits" : "sdigits"), event));
    thisLoader->GetEvent(event);
    
    // Load kinematics to get primary information for SDigits
    fStack = 0;
    if (fOutput == kSDigits) {
      if (thisLoader->LoadKinematics("READ")) {
	AliError("Failed to get kinematics from event loader");
	return;
      }
      AliFMDDebug(5, ("Loading stack of kinematics"));
      fStack = thisLoader->Stack();
    }

    // Check that we have the hits 
    if (!loader->TreeH() && loader->LoadHits()) {
      AliError("Failed to load hits");
      return;
    }
    TTree*   hitsTree = loader->TreeH();
    TBranch* hitsBranch = hitsTree->GetBranch(fFMD->GetName());
    if (!hitsBranch) { 
      AliError("Failed to get hits branch in tree");
      return;
    }
    // Check that we can make the output digits - This must come
    // before AliFMD::SetBranchAddress
    TTree* outTree = MakeOutputTree(loader);
    if (!outTree) { 
      AliError("Failed to get output tree");
      return;
    }
    AliFMDDebug(5, ("Output tree name for %s is '%s'", 
		    (fOutput == kDigits ? "digits" : "sdigits"),
		    outTree->GetName()));
    if (AliLog::GetDebugLevel("FMD","") >= 5) {
      TFile* file = outTree->GetCurrentFile();
      if (!file) {
	AliWarning("Output tree has no file!");
      }
      else { 
	AliFMDDebug(5, ("Output tree file %s content:", file->GetName()));
	file->ls();
      }
    }

    // Set-up the branch addresses 
    fFMD->SetTreeAddress();
    
    // Now sum all contributions in cache 
    SumContributions(hitsBranch);
    loader->UnloadHits();

    // And now digitize the hits 
    DigitizeHits();
    
    // Write digits to tree
    Int_t write = outTree->Fill();
    AliFMDDebug(5, ("Wrote %d bytes to digit tree", write));

    // Store the digits
    StoreDigits(loader);

  }  
}

//____________________________________________________________________
TTree*
AliFMDHitDigitizer::MakeOutputTree(AliLoader* loader)
{
  /** 
   * Make the output tree using the passed loader 
   *
   * @param loader 
   * @return The generated tree. 
   */
  if (fOutput == kDigits) 
    return AliFMDBaseDigitizer::MakeOutputTree(loader);
  
  AliFMDDebug(5, ("Making sdigits tree"));
  loader->LoadSDigits("UPDATE"); // RECREATE");
  TTree* out = loader->TreeS();
  if (!out) loader->MakeTree("S");
  out = loader->TreeS(); 
  if (out) { 
    out->Reset();
    fFMD->MakeBranch("S");
  }
  return out;
}


//____________________________________________________________________
void
AliFMDHitDigitizer::SumContributions(TBranch* hitsBranch) 
{
  // Sum energy deposited contributions from each hit in a cache
  // (fEdep).  
  
  // Clear array of deposited energies 
  fEdep.Reset();
  
  // Get a list of hits from the FMD manager 
  AliFMDDebug(5, ("Get array of FMD hits"));
  TClonesArray *fmdHits = fFMD->Hits();
  

  // Get number of entries in the tree 
  AliFMDDebug(5, ("Get # of tracks"));
  Int_t ntracks  = Int_t(hitsBranch->GetEntries());
  AliFMDDebug(5, ("We got %d tracks", ntracks));

  Int_t read = 0;
  // Loop over the tracks in the 
  for (Int_t track = 0; track < ntracks; track++)  {
    // Read in entry number `track' 
    read += hitsBranch->GetEntry(track);

    // Get the number of hits 
    Int_t nhits = fmdHits->GetEntries ();
    for (Int_t hit = 0; hit < nhits; hit++) {
      // Get the hit number `hit'
      AliFMDHit* fmdHit = 
	static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));

      // Ignore hits that arrive too late
      if (fmdHit->Time() > fHoldTime) continue;
      

      // Check if this is a primary particle
      Bool_t isPrimary = kTRUE;
      Int_t  trackno   = -1;
      if (fStack) {
	trackno = fmdHit->Track();
	AliFMDDebug(10, ("Will get track # %d/%d from entry # %d", 
			trackno, fStack->GetNtrack(), track));
	if (fStack->GetNtrack() < trackno) {
	  AliError(Form("Track number %d/%d out of bounds", 
			trackno, fStack->GetNtrack()));
	  continue;
	}
#if 1
	isPrimary = fStack->IsPhysicalPrimary(trackno);
#else // This is our hand-crafted code.  We use the ALICE definition
	TParticle* part    = fStack->Particle(trackno);
	isPrimary          = part->IsPrimary();
	if (!isPrimary) { 
	  // Extended testing of mother status - this is for Pythia6.
	  Int_t      mother1   = part->GetFirstMother();
	  TParticle* mother    = fStack->Particle(mother1);
	  if (!mother || mother->GetStatusCode() > 1)
	    isPrimary = kTRUE;
	  AliFMDDebug(15,
		      ("Track %d secondary, mother: %d - %s - status %d: %s", 
		       trackno, mother1, 
		       (mother ? "found"                 : "not found"), 
		       (mother ? mother->GetStatusCode() : -1),
		       (isPrimary ? "primary" : "secondary")));
	}
#endif
      }
    
      // Extract parameters 
      AliFMDDebug(15,("Adding contribution %7.5f for FMD%d%c[%2d,%3d] "
		      " for trackno %6d (%s)", 
		      fmdHit->Edep(),
		      fmdHit->Detector(), 
		      fmdHit->Ring(),
		      fmdHit->Sector(), 
		      fmdHit->Strip(), 
		      trackno, 
		      (isPrimary ? "primary" : "secondary")));
      AddContribution(fmdHit->Detector(),
		      fmdHit->Ring(),
		      fmdHit->Sector(),
		      fmdHit->Strip(),
		      fmdHit->Edep(), 
		      isPrimary, 
		      1, 
		      &trackno);
    }  // hit loop
  } // track loop
  AliFMDDebug(5, ("Size of cache: %d bytes, read %d bytes", 
		  int(sizeof(fEdep)), read));
}


//____________________________________________________________________
UShort_t
AliFMDHitDigitizer::MakePedestal(UShort_t  detector, 
				 Char_t    ring, 
				 UShort_t  sector, 
				 UShort_t  strip) const 
{
  // Make a pedestal 
  if (fOutput == kSDigits) return 0;
  return AliFMDBaseDigitizer::MakePedestal(detector, ring, sector, strip);
}


//____________________________________________________________________
void
AliFMDHitDigitizer::AddDigit(UShort_t        detector, 
			     Char_t          ring,
			     UShort_t        sector, 
			     UShort_t        strip, 
			     Float_t         edep, 
			     UShort_t        count1, 
			     Short_t         count2, 
			     Short_t         count3,
			     Short_t         count4, 
			     UShort_t        ntotal,
			     UShort_t        nprim, 
			     const TArrayI&  refs) const
{
  // Add a digit or summable digit
  if (fOutput == kDigits) { 
    AliFMDDebug(15,("Adding digit for FMD%d%c[%2d,%3d] = (%x,%x,%x,%x)",
		    detector, ring, sector, strip, 
		    count1, count2, count3, count4));
    AliFMDBaseDigitizer::AddDigit(detector, ring, sector, strip, 0,
				  count1, count2, count3, count4, 
				  ntotal, nprim, refs);
    return;
  }
  if (edep <= 0) { 
    AliFMDDebug(15, ("Digit edep = %f <= 0 for FMD%d%c[%2d,%3d]", 
		    edep, detector, ring, sector, strip));
    return;
  }
  if (count1 == 0 && count2 <= 0 && count3 <= 0 && count4 <= 0) {
    AliFMDDebug(15, ("Digit counts = (%x,%x,%x,%x) <= 0 for FMD%d%c[%2d,%3d]", 
		    count1, count2, count3, count4, 
		    detector, ring, sector, strip));
    return;
  }
  AliFMDDebug(15, ("Adding sdigit for FMD%d%c[%2d,%3d] = "
		   "(%x,%x,%x,%x) [%d/%d] %d",
		   detector, ring, sector, strip, 
		   count1, count2, count3, count4, nprim, ntotal, refs.fN));
  fFMD->AddSDigitByFields(detector, ring, sector, strip, edep,
			  count1, count2, count3, count4, 
			  ntotal, nprim, fStoreTrackRefs ? refs.fArray : 0);
  if (fStoreTrackRefs && nprim > 3) fIgnoredLabels += nprim - 3;
}

//____________________________________________________________________
void
AliFMDHitDigitizer::CheckDigit(AliFMDDigit*    digit,
			       UShort_t        nhits,
			       const TArrayI&  counts) 
{
  // Check that digit is consistent
  AliFMDParameters* param = AliFMDParameters::Instance();
  UShort_t          det   = digit->Detector();
  Char_t            ring  = digit->Ring();
  UShort_t          sec   = digit->Sector();
  UShort_t          str   = digit->Strip();
  Float_t           mean  = param->GetPedestal(det,ring,sec,str);
  Float_t           width = param->GetPedestalWidth(det,ring,sec,str);
  UShort_t          range = param->GetVA1MipRange();
  UShort_t          size  = param->GetAltroChannelSize();
  Int_t             integral = counts[0];
  if (counts[1] >= 0) integral += counts[1];
  if (counts[2] >= 0) integral += counts[2];
  if (counts[3] >= 0) integral += counts[3];
  integral -= Int_t(mean + 2 * width);
  if (integral < 0) integral = 0;
  
  Float_t convF = Float_t(range) / size;
  Float_t mips  = integral * convF;
  if (mips > Float_t(nhits) + .5 || mips < Float_t(nhits) - .5) 
    Warning("CheckDigit", "Digit -> %4.2f MIPS != %d +/- .5 hits", 
	    mips, nhits);
}

//____________________________________________________________________
void
AliFMDHitDigitizer::StoreDigits(const AliLoader* loader)
{
  /** 
   * Store the data using the loader 
   *
   * @param loader The loader 
   */
  if (fOutput == kDigits) { 
    AliFMDBaseDigitizer::StoreDigits(loader);
    return;
  }
  AliFMDDebug(5, ("Storing %d sdigits",   fFMD->SDigits()->GetEntries()));
  // Write the digits to disk 
  loader->WriteSDigits("OVERWRITE");
  loader->UnloadSDigits();
  // Reset the digits in the AliFMD object 
  fFMD->ResetSDigits();
}


//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
ef8e8623	1	/**************************************************************************
	2	* Copyright(c) 2004, 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	/* $Id: AliFMDHitDigitizer.cxx 28055 2008-08-18 00:33:20Z cholm $ */
	16	/** @file AliFMDHitDigitizer.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:38:26 2006
	19	@brief FMD Digitizers implementation
	20	@ingroup FMD_sim
	21	*/
	22	//////////////////////////////////////////////////////////////////////////////
	23	//
	24	// This class contains the procedures simulation ADC signal for the
	25	// Forward Multiplicity detector : Hits->Digits
	26	//
	27	// Digits consists of
	28	// - Detector #
	29	// - Ring ID
	30	// - Sector #
	31	// - Strip #
	32	// - ADC count in this channel
	33	//
	34	// As the Digits and SDigits have so much in common, the classes
	35	// AliFMDHitDigitizer and AliFMDSDigitizer are implemented via a base
	36	// class AliFMDBaseDigitizer.
	37	//
	38	// +---------------------+
	39	// \| AliFMDBaseDigitizer \|
	40	// +---------------------+
	41	// ^
	42	// \|
	43	// +----------+---------+
	44	// \| \|
	45	// +-----------------+ +------------------+
	46	// \| AliFMDHitDigitizer \| \| AliFMDSDigitizer \|
	47	// +-----------------+ +------------------+
	48	//
	49	// These classes has several paramters:
	50	//
	51	// fPedestal
	52	// fPedestalWidth
	53	// (Only AliFMDHitDigitizer)
	54	// Mean and width of the pedestal. The pedestal is simulated
	55	// by a Guassian, but derived classes my override MakePedestal
	56	// to simulate it differently (or pick it up from a database).
	57	//
	58	// fVA1MipRange
	59	// The dymamic MIP range of the VA1_ALICE pre-amplifier chip
	60	//
	61	// fAltroChannelSize
	62	// The largest number plus one that can be stored in one
	63	// channel in one time step in the ALTRO ADC chip.
	64	//
65	// fSampleRate
66	// How many times the ALTRO ADC chip samples the VA1_ALICE
67	// pre-amplifier signal. The VA1_ALICE chip is read-out at
68	// 10MHz, while it's possible to drive the ALTRO chip at
69	// 25MHz. That means, that the ALTRO chip can have time to
70	// sample each VA1_ALICE signal up to 2 times. Although it's
71	// not certain this feature will be used in the production,
72	// we'd like have the option, and so it should be reflected in
73	// the code.
74	//
75	// These parameters are fetched from OCDB via the mananger AliFMDParameters.
76	//
77	// The shaping function of the VA1_ALICE is generally given by
78	//
79	// f(x) = A(1 - exp(-Bx))
80	//
81	// where A is the total charge collected in the pre-amp., and B is a
82	// paramter that depends on the shaping time of the VA1_ALICE circut.
83	//
84	// When simulating the shaping function of the VA1_ALICe
85	// pre-amp. chip, we have to take into account, that the shaping
86	// function depends on the previous value of read from the pre-amp.
87	//
88	// That results in the following algorithm:
89	//
90	// last = 0;
91	// FOR charge IN pre-amp. charge train DO
92	// IF last < charge THEN
93	// f(t) = (charge - last) * (1 - exp(-B * t)) + last
94	// ELSE
95	// f(t) = (last - charge) * exp(-B * t) + charge)
96	// ENDIF
97	// FOR i IN # samples DO
98	// adc_i = f(i / (# samples))
99	// DONE
100	// last = charge
101	// DONE
102	//
103	// Here,
104	//
105	// pre-amp. charge train
106	// is a series of 128 charges read from the VA1_ALICE chip
107	//
108	// # samples
109	// is the number of times the ALTRO ADC samples each of the 128
110	// charges from the pre-amp.
111	//
112	// Where Q is the total charge collected by the VA1_ALICE
113	// pre-amplifier. Q is then given by
114	//
115	// E S
116	// Q = - -
117	// e R
118	//
119	// where E is the total energy deposited in a silicon strip, R is the
120	// dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
121	// energy deposited by a single MIP, and S ALTRO channel size in each
122	// time step (fAltroChannelSize).
123	//
124	// The energy deposited per MIP is given by
125	//
126	// e = M * rho * w
127	//
128	// where M is the universal number 1.664, rho is the density of
129	// silicon, and w is the depth of the silicon sensor.
130	//
131	// The final ADC count is given by
132	//
133	// C' = C + P
134	//
135	// where P is the (randomized) pedestal (see MakePedestal)
136	//
137	// This class uses the class template AliFMDMap<Type> to make an
138	// internal cache of the energy deposted of the hits. The class
139	// template is instantasized as
140	//
141	// typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
142	//
143	// The first member of the values is the summed energy deposition in a
144	// given strip, while the second member of the values is the number of
145	// hits in a given strip. Using the second member, it's possible to
146	// do some checks on just how many times a strip got hit, and what
147	// kind of error we get in our reconstructed hits. Note, that this
148	// information is currently not written to the digits tree. I think a
149	// QA (Quality Assurance) digit tree is better suited for that task.
150	// However, the information is there to be used in the future.
151	//
152	//
153	// Latest changes by Christian Holm Christensen
154	//
155	//////////////////////////////////////////////////////////////////////////////
156
157	// /1
158	// \| A(-1 + B + exp(-B))
159	// \| f(x) dx = ------------------- = 1
160	// \| B
161	// / 0
162	//
163	// and B is the a parameter defined by the shaping time (fShapingTime).
164	//
165	// Solving the above equation, for A gives
166	//
167	// B
168	// A = ----------------
169	// -1 + B + exp(-B)
170	//
171	// So, if we define the function g: [0,1] -> [0:1] by
172	//
173	// / v
174	// \| Bu + exp(-Bu) - Bv - exp(-Bv)
175	// g(u,v) = \| f(x) dx = -A -----------------------------
176	// \| B
177	// / u
178	//
179	// we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
180	// any two times (u, v), by
181	//
182	//
183	// B Bu + exp(-Bu) - Bv - exp(-Bv)
184	// C = Q g(u,v) = - Q ---------------- -----------------------------
185	// -1 + B + exp(-B) B
186	//
187	// Bu + exp(-Bu) - Bv - exp(-Bv)
188	// = - Q -----------------------------
189	// -1 + B + exp(-B)
190	//
191
192	#include <TTree.h> // ROOT_TTree
193	#include "AliFMDDebug.h" // Better debug macros
194	#include "AliFMDHitDigitizer.h" // ALIFMDDIGITIZER_H
195	#include "AliFMD.h" // ALIFMD_H
196	#include "AliFMDDigit.h" // ALIFMDDIGIT_H
197	#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
198	#include <AliRun.h> // ALIRUN_H
199	#include <AliLoader.h> // ALILOADER_H
200	#include <AliRunLoader.h> // ALIRUNLOADER_H
201	#include <AliFMDHit.h>
83ad576a	202	#include <AliStack.h>
ef8e8623	203	#include <TFile.h>
83ad576a	204	#include <TParticle.h>
ef8e8623	205
	206	//====================================================================
	207	ClassImp(AliFMDHitDigitizer)
	208	#if 0
	209	;
	210	#endif
	211
	212	//____________________________________________________________________
	213	AliFMDHitDigitizer::AliFMDHitDigitizer(AliFMD* fmd, Output_t output)
133f1578	214	: AliFMDBaseDigitizer("FMD", (output == kDigits ?
ef8e8623	215	"FMD Hit->Digit digitizer" :
ef8e8623	216	"FMD Hit->SDigit digitizer")),
83ad576a	217	fOutput(output),
b2e6f0b0	218	fHoldTime(2e-6),
83ad576a	219	fStack(0)
ef8e8623	220	{
	221	fFMD = fmd;
	222	}
	223
09b6c804	224	//____________________________________________________________________
	225	AliFMDHitDigitizer&
	226	AliFMDHitDigitizer::operator=(const AliFMDHitDigitizer& o)
	227	{
	228	/**
	229	* Assignment operator
	230	*
	231	* @param o Object to assign from
	232	* @return Reference to this
	233	*/
	234	AliFMDBaseDigitizer::operator=(o);
	235	fHoldTime = o.fHoldTime;
	236	fOutput = o.fOutput;
	237	fStack = o.fStack;
	238	return *this;
	239	}
	240
ef8e8623	241	//____________________________________________________________________
	242	void
	243	AliFMDHitDigitizer::Exec(Option_t* /option/)
	244	{
	245	// Run this digitizer
	246	// Get an inititialize parameter manager
	247	AliFMDParameters::Instance()->Init();
	248	if (AliLog::GetDebugLevel("FMD","") >= 10)
	249	AliFMDParameters::Instance()->Print("ALL");
	250
	251	// Get loader, and ask it to read in the hits
	252	AliLoader* loader = fFMD->GetLoader();
	253	if (!loader) {
	254	AliError("Failed to get loader from detector object");
	255	return;
	256	}
	257	loader->LoadHits("READ");
	258
	259	// Get the run loader
	260	AliRunLoader* runLoader = loader->GetRunLoader();
	261	if (!runLoader) {
	262	AliError("Failed to get run loader from loader");
	263	return;
	264	}
	265
	266	// Now loop over events
	267	Int_t nEvents = runLoader->GetNumberOfEvents();
	268	for (Int_t event = 0; event < nEvents; event++) {
	269	// Get the current event folder.
	270	TFolder* folder = loader->GetEventFolder();
	271	if (!folder) {
	272	AliError("Failed to get event folder from loader");
	273	return;
	274	}
	275
	276	// Get the run-loader of this event.
	277	const char* loaderName = AliRunLoader::GetRunLoaderName();
	278	AliRunLoader* thisLoader =
	279	static_cast<AliRunLoader*>(folder->FindObject(loaderName));
	280	if (!thisLoader) {
	281	AliError(Form("Failed to get loader '%s' from event folder", loaderName));
	282	return;
	283	}
	284
	285	// Read in the event
8d00dfa3	286	AliFMDDebug(1, ("Now digitizing (Hits->%s) event # %d",
ef8e8623	287	(fOutput == kDigits ? "digits" : "sdigits"), event));
	288	thisLoader->GetEvent(event);
	289
83ad576a	290	// Load kinematics to get primary information for SDigits
	291	fStack = 0;
	292	if (fOutput == kSDigits) {
	293	if (thisLoader->LoadKinematics("READ")) {
	294	AliError("Failed to get kinematics from event loader");
	295	return;
	296	}
	297	AliFMDDebug(5, ("Loading stack of kinematics"));
	298	fStack = thisLoader->Stack();
	299	}
	300
ef8e8623	301	// Check that we have the hits
	302	if (!loader->TreeH() && loader->LoadHits()) {
	303	AliError("Failed to load hits");
	304	return;
	305	}
	306	TTree* hitsTree = loader->TreeH();
	307	TBranch* hitsBranch = hitsTree->GetBranch(fFMD->GetName());
	308	if (!hitsBranch) {
	309	AliError("Failed to get hits branch in tree");
	310	return;
	311	}
	312	// Check that we can make the output digits - This must come
	313	// before AliFMD::SetBranchAddress
	314	TTree* outTree = MakeOutputTree(loader);
	315	if (!outTree) {
	316	AliError("Failed to get output tree");
	317	return;
	318	}
	319	AliFMDDebug(5, ("Output tree name for %s is '%s'",
	320	(fOutput == kDigits ? "digits" : "sdigits"),
	321	outTree->GetName()));
	322	if (AliLog::GetDebugLevel("FMD","") >= 5) {
	323	TFile* file = outTree->GetCurrentFile();
	324	if (!file) {
	325	AliWarning("Output tree has no file!");
	326	}
	327	else {
	328	AliFMDDebug(5, ("Output tree file %s content:", file->GetName()));
	329	file->ls();
	330	}
	331	}
	332
	333	// Set-up the branch addresses
	334	fFMD->SetTreeAddress();
	335
	336	// Now sum all contributions in cache
	337	SumContributions(hitsBranch);
	338	loader->UnloadHits();
	339
	340	// And now digitize the hits
	341	DigitizeHits();
	342
	343	// Write digits to tree
	344	Int_t write = outTree->Fill();
83ad576a	345	AliFMDDebug(5, ("Wrote %d bytes to digit tree", write));
ef8e8623	346
	347	// Store the digits
	348	StoreDigits(loader);
	349
	350	}
	351	}
	352
	353	//____________________________________________________________________
	354	TTree*
	355	AliFMDHitDigitizer::MakeOutputTree(AliLoader* loader)
	356	{
09b6c804	357	/**
	358	* Make the output tree using the passed loader
	359	*
	360	* @param loader
	361	* @return The generated tree.
	362	*/
ef8e8623	363	if (fOutput == kDigits)
	364	return AliFMDBaseDigitizer::MakeOutputTree(loader);
	365
	366	AliFMDDebug(5, ("Making sdigits tree"));
	367	loader->LoadSDigits("UPDATE"); // RECREATE");
	368	TTree* out = loader->TreeS();
	369	if (!out) loader->MakeTree("S");
	370	out = loader->TreeS();
	371	if (out) {
	372	out->Reset();
	373	fFMD->MakeBranch("S");
	374	}
	375	return out;
	376	}
	377
	378
	379	//____________________________________________________________________
	380	void
	381	AliFMDHitDigitizer::SumContributions(TBranch* hitsBranch)
	382	{
	383	// Sum energy deposited contributions from each hit in a cache
	384	// (fEdep).
	385
	386	// Clear array of deposited energies
	387	fEdep.Reset();
	388
	389	// Get a list of hits from the FMD manager
	390	AliFMDDebug(5, ("Get array of FMD hits"));
	391	TClonesArray *fmdHits = fFMD->Hits();
	392
	393
	394	// Get number of entries in the tree
	395	AliFMDDebug(5, ("Get # of tracks"));
	396	Int_t ntracks = Int_t(hitsBranch->GetEntries());
	397	AliFMDDebug(5, ("We got %d tracks", ntracks));
	398
	399	Int_t read = 0;
	400	// Loop over the tracks in the
	401	for (Int_t track = 0; track < ntracks; track++) {
	402	// Read in entry number `track'
	403	read += hitsBranch->GetEntry(track);
83ad576a	404
ef8e8623	405	// Get the number of hits
	406	Int_t nhits = fmdHits->GetEntries ();
	407	for (Int_t hit = 0; hit < nhits; hit++) {
	408	// Get the hit number `hit'
	409	AliFMDHit* fmdHit =
	410	static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));
b2e6f0b0	411
	412	// Ignore hits that arrive too late
	413	if (fmdHit->Time() > fHoldTime) continue;
ef8e8623	414
b2e6f0b0	415
83ad576a	416	// Check if this is a primary particle
83ad576a	417	Bool_t isPrimary = kTRUE;
b2e6f0b0	418	Int_t trackno = -1;
83ad576a	419	if (fStack) {
b2e6f0b0	420	trackno = fmdHit->Track();
83ad576a	421	AliFMDDebug(10, ("Will get track # %d/%d from entry # %d",
	422	trackno, fStack->GetNtrack(), track));
	423	if (fStack->GetNtrack() < trackno) {
	424	AliError(Form("Track number %d/%d out of bounds",
	425	trackno, fStack->GetNtrack()));
	426	continue;
	427	}
b2e6f0b0	428	#if 1
	429	isPrimary = fStack->IsPhysicalPrimary(trackno);
	430	#else // This is our hand-crafted code. We use the ALICE definition
83ad576a	431	TParticle* part = fStack->Particle(trackno);
	432	isPrimary = part->IsPrimary();
	433	if (!isPrimary) {
	434	// Extended testing of mother status - this is for Pythia6.
	435	Int_t mother1 = part->GetFirstMother();
	436	TParticle* mother = fStack->Particle(mother1);
	437	if (!mother \|\| mother->GetStatusCode() > 1)
	438	isPrimary = kTRUE;
	439	AliFMDDebug(15,
	440	("Track %d secondary, mother: %d - %s - status %d: %s",
	441	trackno, mother1,
	442	(mother ? "found" : "not found"),
	443	(mother ? mother->GetStatusCode() : -1),
	444	(isPrimary ? "primary" : "secondary")));
	445	}
b2e6f0b0	446	#endif
83ad576a	447	}
83ad576a	448
ef8e8623	449	// Extract parameters
8d00dfa3	450	AliFMDDebug(15,("Adding contribution %7.5f for FMD%d%c[%2d,%3d] "
	451	" for trackno %6d (%s)",
	452	fmdHit->Edep(),
	453	fmdHit->Detector(),
	454	fmdHit->Ring(),
	455	fmdHit->Sector(),
	456	fmdHit->Strip(),
	457	trackno,
	458	(isPrimary ? "primary" : "secondary")));
ef8e8623	459	AddContribution(fmdHit->Detector(),
	460	fmdHit->Ring(),
	461	fmdHit->Sector(),
	462	fmdHit->Strip(),
83ad576a	463	fmdHit->Edep(),
b2e6f0b0	464	isPrimary,
faf80567	465	1,
faf80567	466	&trackno);
ef8e8623	467	} // hit loop
	468	} // track loop
	469	AliFMDDebug(5, ("Size of cache: %d bytes, read %d bytes",
a828379a	470	int(sizeof(fEdep)), read));
ef8e8623	471	}
	472
	473
	474	//____________________________________________________________________
	475	UShort_t
	476	AliFMDHitDigitizer::MakePedestal(UShort_t detector,
	477	Char_t ring,
	478	UShort_t sector,
	479	UShort_t strip) const
	480	{
	481	// Make a pedestal
	482	if (fOutput == kSDigits) return 0;
	483	return AliFMDBaseDigitizer::MakePedestal(detector, ring, sector, strip);
	484	}
	485
	486
	487
	488	//____________________________________________________________________
	489	void
b2e6f0b0	490	AliFMDHitDigitizer::AddDigit(UShort_t detector,
	491	Char_t ring,
	492	UShort_t sector,
	493	UShort_t strip,
	494	Float_t edep,
	495	UShort_t count1,
	496	Short_t count2,
	497	Short_t count3,
	498	Short_t count4,
	499	UShort_t ntotal,
	500	UShort_t nprim,
	501	const TArrayI& refs) const
ef8e8623	502	{
	503	// Add a digit or summable digit
	504	if (fOutput == kDigits) {
faf80567	505	AliFMDDebug(15,("Adding digit for FMD%d%c[%2d,%3d] = (%x,%x,%x,%x)",
	506	detector, ring, sector, strip,
	507	count1, count2, count3, count4));
ef8e8623	508	AliFMDBaseDigitizer::AddDigit(detector, ring, sector, strip, 0,
8d00dfa3	509	count1, count2, count3, count4,
8d00dfa3	510	ntotal, nprim, refs);
83ad576a	511	return;
	512	}
	513	if (edep <= 0) {
	514	AliFMDDebug(15, ("Digit edep = %f <= 0 for FMD%d%c[%2d,%3d]",
	515	edep, detector, ring, sector, strip));
	516	return;
	517	}
	518	if (count1 == 0 && count2 <= 0 && count3 <= 0 && count4 <= 0) {
	519	AliFMDDebug(15, ("Digit counts = (%x,%x,%x,%x) <= 0 for FMD%d%c[%2d,%3d]",
	520	count1, count2, count3, count4,
	521	detector, ring, sector, strip));
ef8e8623	522	return;
ef8e8623	523	}
faf80567	524	AliFMDDebug(15, ("Adding sdigit for FMD%d%c[%2d,%3d] = "
faf80567	525	"(%x,%x,%x,%x) [%d/%d] %d",
83ad576a	526	detector, ring, sector, strip,
faf80567	527	count1, count2, count3, count4, nprim, ntotal, refs.fN));
ef8e8623	528	fFMD->AddSDigitByFields(detector, ring, sector, strip, edep,
83ad576a	529	count1, count2, count3, count4,
8d00dfa3	530	ntotal, nprim, fStoreTrackRefs ? refs.fArray : 0);
2180cab3	531	if (fStoreTrackRefs && nprim > 3) fIgnoredLabels += nprim - 3;
ef8e8623	532	}
	533
	534	//____________________________________________________________________
	535	void
	536	AliFMDHitDigitizer::CheckDigit(AliFMDDigit* digit,
	537	UShort_t nhits,
	538	const TArrayI& counts)
	539	{
	540	// Check that digit is consistent
	541	AliFMDParameters* param = AliFMDParameters::Instance();
	542	UShort_t det = digit->Detector();
	543	Char_t ring = digit->Ring();
	544	UShort_t sec = digit->Sector();
	545	UShort_t str = digit->Strip();
	546	Float_t mean = param->GetPedestal(det,ring,sec,str);
	547	Float_t width = param->GetPedestalWidth(det,ring,sec,str);
	548	UShort_t range = param->GetVA1MipRange();
	549	UShort_t size = param->GetAltroChannelSize();
	550	Int_t integral = counts[0];
	551	if (counts[1] >= 0) integral += counts[1];
	552	if (counts[2] >= 0) integral += counts[2];
	553	if (counts[3] >= 0) integral += counts[3];
	554	integral -= Int_t(mean + 2 * width);
	555	if (integral < 0) integral = 0;
	556
	557	Float_t convF = Float_t(range) / size;
	558	Float_t mips = integral * convF;
	559	if (mips > Float_t(nhits) + .5 \|\| mips < Float_t(nhits) - .5)
	560	Warning("CheckDigit", "Digit -> %4.2f MIPS != %d +/- .5 hits",
	561	mips, nhits);
	562	}
	563
	564	//____________________________________________________________________
	565	void
aa24869b	566	AliFMDHitDigitizer::StoreDigits(const AliLoader* loader)
ef8e8623	567	{
09b6c804	568	/**
	569	* Store the data using the loader
	570	*
	571	* @param loader The loader
	572	*/
ef8e8623	573	if (fOutput == kDigits) {
	574	AliFMDBaseDigitizer::StoreDigits(loader);
	575	return;
	576	}
	577	AliFMDDebug(5, ("Storing %d sdigits", fFMD->SDigits()->GetEntries()));
	578	// Write the digits to disk
	579	loader->WriteSDigits("OVERWRITE");
	580	loader->UnloadSDigits();
	581	// Reset the digits in the AliFMD object
	582	fFMD->ResetSDigits();
	583	}
	584
	585
	586	//____________________________________________________________________
	587	//
	588	// EOF
	589	//
	590
	591
	592
	593