ROOT logo
/**************************************************************************
 * 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$ */
/** @file    AliFMD.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Sun Mar 26 17:59:18 2006
    @brief   Implementation of AliFMD base class 
*/
//____________________________________________________________________
//                                                                          
// Forward Multiplicity Detector based on Silicon wafers. This class
// is the driver for especially simulation. 
//
// The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
// FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors. 
//                                                       
// This is the base class for all FMD manager classes. 
//                    
// The actual code is done by various separate classes.   Below is
// diagram showing the relationship between the various FMD classes
// that handles the simulation
//
//
//       +----------+   +----------+   
//       | AliFMDv1 |	| AliFMDv0 |   
//       +----------+   +----------+   
//            |              |                    +-----------------+
//       +----+--------------+                 +--| AliFMDDigitizer |
//       |                                     |  +-----------------+
//       |           +---------------------+   |
//       |        +--| AliFMDBaseDigitizer |<--+
//       V     1  |  +---------------------+   |
//  +--------+<>--+                            |  +------------------+
//  | AliFMD |                                 +--| AliFMDSDigitizer |    
//  +--------+<>--+                               +------------------+       
//	       1  |  +---------------------+
//	          +--| AliFMDReconstructor |
//	  	     +---------------------+
//
// *  AliFMD 
//    This defines the interface for the various parts of AliROOT that
//    uses the FMD, like AliFMDSimulator, AliFMDDigitizer, 
//    AliFMDReconstructor, and so on. 
//
// *  AliFMDv0
//    This is a concrete implementation of the AliFMD interface. 
//    It is the responsibility of this class to create the FMD
//    geometry.
//
// *  AliFMDv1 
//    This is a concrete implementation of the AliFMD interface. 
//    It is the responsibility of this class to create the FMD
//    geometry, process hits in the FMD, and serve hits and digits to
//    the various clients. 
//  
// *  AliFMDSimulator
//    This is the base class for the FMD simulation tasks.   The
//    simulator tasks are responsible to implment the geoemtry, and
//    process hits. 
//                                                                          
// *  AliFMDReconstructor
//    This is a concrete implementation of the AliReconstructor that
//    reconstructs pseudo-inclusive-multiplicities from digits (raw or
//    from simulation)
//
// Calibration and geometry parameters are managed by separate
// singleton managers.  These are AliFMDGeometry and
// AliFMDParameters.  Please refer to these classes for more
// information on these.
//

// These files are not in the same directory, so there's no reason to
// ask the preprocessor to search in the current directory for these
// files by including them with `#include "..."' 
#include <TBrowser.h>		// ROOT_TBrowser
#include <TClonesArray.h>	// ROOT_TClonesArray
#include <TGeoGlobalMagField.h> // ROOT_TGeoGlobalMagField
#include <TGeoManager.h>        // ROOT_TGeoManager
#include <TRotMatrix.h>		// ROOT_TRotMatrix
#include <TTree.h>		// ROOT_TTree
#include <TVector2.h>           // ROOT_TVector2 
#include <TVirtualMC.h>	        // ROOT_TVirtualMC
#include <cmath>                // __CMATH__

#include <AliDigitizationInput.h>	// ALIRUNDIGITIZER_H
#include <AliLoader.h>		// ALILOADER_H
#include <AliRun.h>		// ALIRUN_H
#include <AliMC.h>		// ALIMC_H
#include <AliMagF.h>		// ALIMAGF_H
// #include <AliLog.h>		// ALILOG_H
#include "AliFMDDebug.h" // Better debug macros
#include "AliFMD.h"		// ALIFMD_H
#include "AliFMDDigit.h"	// ALIFMDDIGIT_H
#include "AliFMDSDigit.h"	// ALIFMDSDIGIT_H
#include "AliFMDHit.h"		// ALIFMDHIT_H
#include "AliFMDGeometry.h"	// ALIFMDGEOMETRY_H
#include "AliFMDDetector.h"	// ALIFMDDETECTOR_H
#include "AliFMDRing.h"		// ALIFMDRING_H
#include "AliFMDDigitizer.h"	// ALIFMDDIGITIZER_H
#include "AliFMDHitDigitizer.h"	// ALIFMDSDIGITIZER_H
// #define USE_SSDIGITIZER 
//#ifdef USE_SSDIGITIZER
//# include "AliFMDSSDigitizer.h"	// ALIFMDSDIGITIZER_H
//#endif
// #include "AliFMDGeometryBuilder.h"
#include "AliFMDRawWriter.h"	// ALIFMDRAWWRITER_H
#include "AliFMDRawReader.h"	// ALIFMDRAWREADER_H
#include "AliTrackReference.h" 
#include "AliFMDStripIndex.h"
#include "AliFMDEncodedEdx.h"
#include "AliFMDParameters.h"
#include "AliFMDReconstructor.h"

//____________________________________________________________________
ClassImp(AliFMD)
#if 0
  ; // This is to keep Emacs from indenting the next line 
#endif 

//____________________________________________________________________
AliFMD::AliFMD()
  : AliDetector(),
    fSDigits(0), 
    fNsdigits(0),
    fDetailed(kTRUE),
    fUseOld(kFALSE),
    fUseAssembly(kTRUE),
    fBad(0) 
{
  //
  // Default constructor for class AliFMD
  //
  AliFMDDebug(10, ("\tDefault CTOR"));
  fHits        = 0;
  fDigits      = 0;
  fIshunt      = 0;
  // fBad         = new TClonesArray("AliFMDHit");
}

//____________________________________________________________________
AliFMD::AliFMD(const char *name, const char *title)
  : AliDetector (name, title),
    fSDigits(0),
    fNsdigits(0),
    fDetailed(kTRUE),
    fUseOld(kFALSE),
    fUseAssembly(kFALSE),
    fBad(0)
{
  //
  // Standard constructor for Forward Multiplicity Detector
  //
  AliFMDDebug(10, ("\tStandard CTOR"));
  // fBad         = new TClonesArray("AliFMDHit");
  
  // Initialise Hit array
  // HitsArray();
  // gAlice->GetMCApp()->AddHitList(fHits);

  // (S)Digits for the detectors disk
  // DigitsArray();
  // SDigitsArray();
  
  // CHC: What is this?
  fIshunt = 0;
  //PH  SetMarkerColor(kRed);
  //PH  SetLineColor(kYellow);
}

//____________________________________________________________________
AliFMD::~AliFMD ()
{
  // Destructor for base class AliFMD
  if (fHits) {
    fHits->Delete();
    delete fHits;
    fHits = 0;
  }
  if (fDigits) {
    fDigits->Delete();
    delete fDigits;
    fDigits = 0;
  }
  if (fSDigits) {
    fSDigits->Delete();
    delete fSDigits;
    fSDigits = 0;
  }
  if (fBad) {
    fBad->Delete();
    delete fBad;
    fBad = 0;
  }
}


//====================================================================
//
// GEometry ANd Traking
//
//____________________________________________________________________
void 
AliFMD::CreateGeometry()
{
  //
  // Create the geometry of Forward Multiplicity Detector.  The actual
  // construction of the geometry is delegated to the class
  // AliFMDGeometryBuilder, invoked by the singleton manager
  // AliFMDGeometry. 
  //
  AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
  fmd->SetDetailed(fDetailed);
  fmd->UseAssembly(fUseAssembly);
  fmd->Build();
}    

//____________________________________________________________________
void AliFMD::CreateMaterials() 
{
  // Define the materials and tracking mediums needed by the FMD
  // simulation.   These mediums are made by sending the messages
  // AliMaterial, AliMixture, and AliMedium to the passed AliModule
  // object module.   The defined mediums are 
  // 
  //	FMD Si$		Silicon (active medium in sensors)
  //	FMD C$		Carbon fibre (support cone for FMD3 and vacuum pipe)
  //	FMD Al$		Aluminium (honeycomb support plates)
  //	FMD PCB$	Printed Circuit Board (FEE board with VA1_3)
  //	FMD Chip$	Electronics chips (currently not used)
  //	FMD Air$	Air (Air in the FMD)
  //	FMD Plastic$	Plastic (Support legs for the hybrid cards)
  //
  // The geometry builder should really be the one that creates the
  // materials, but the architecture of AliROOT makes that design
  // akward.  What should happen, was that the AliFMDGeometryBuilder
  // made the mediums, and that this class retrives pointers from the
  // TGeoManager, and registers the mediums here.  Alas, it's not
  // really that easy. 
  //
  AliFMDDebug(10, ("\tCreating materials"));
  // Get pointer to geometry singleton object. 
  AliFMDGeometry* geometry = AliFMDGeometry::Instance();
  geometry->Init();
#if 0
  if (gGeoManager && gGeoManager->GetMedium("FMD Si$")) {
    // We need to figure out the some stuff about the geometry
    fmd->ExtractGeomInfo();
    return;
  }
#endif  
  Int_t    id;
  Double_t a                = 0;
  Double_t z                = 0;
  Double_t density          = 0;
  Double_t radiationLength  = 0;
  Double_t absorbtionLength = 999;
  Int_t    fieldType        = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();     // Field type 
  Double_t maxField         = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();     // Field max.
  Double_t maxBending       = 0;     // Max Angle
  Double_t maxStepSize      = 0.001; // Max step size 
  Double_t maxEnergyLoss    = 1;     // Max Delta E
  Double_t precision        = 0.001; // Precision
  Double_t minStepSize      = 0.001; // Minimum step size 
 
  // Silicon 
  a                = 28.0855;
  z                = 14.;
  density          = geometry->GetSiDensity();
  radiationLength  = 9.36;
  maxBending       = 1;
  maxStepSize      = .001;
  precision        = .001;
  minStepSize      = .001;
  id               = kSiId;
  AliMaterial(id, "Si$", a, z, density, radiationLength, absorbtionLength);
  AliMedium(kSiId, "Si$", id,1,fieldType,maxField,maxBending,
	    maxStepSize,maxEnergyLoss,precision,minStepSize);
  

  // Carbon 
  a                = 12.011;
  z                = 6.;
  density          = 2.265;
  radiationLength  = 18.8;
  maxBending       = 10;
  maxStepSize      = .01;
  precision        = .003;
  minStepSize      = .003;
  id               = kCarbonId;
  AliMaterial(id, "Carbon$", a, z, density, radiationLength, absorbtionLength);
  AliMedium(kCarbonId, "Carbon$", id,0,fieldType,maxField,maxBending,
		    maxStepSize,maxEnergyLoss,precision,minStepSize);

  // Aluminum
  a                = 26.981539;
  z                = 13.;
  density          = 2.7;
  radiationLength  = 8.9;
  id               = kAlId;
  AliMaterial(id, "Aluminum$",a,z, density, radiationLength, absorbtionLength);
  AliMedium(kAlId, "Aluminum$", id, 0, fieldType, maxField, maxBending,
	    maxStepSize, maxEnergyLoss, precision, minStepSize);
  
  
  // Copper 
  a                = 63.546;
  z                = 29;
  density          =  8.96;
  radiationLength  =  1.43;
  id               = kCopperId;
  AliMaterial(id, "Copper$", 
		      a, z, density, radiationLength, absorbtionLength);
  AliMedium(kCopperId, "Copper$", id, 0, fieldType, maxField, maxBending,
	    maxStepSize, maxEnergyLoss, precision, minStepSize);
  

  // Silicon chip 
  {
    Float_t as[] = { 12.0107,      14.0067,      15.9994,
		      1.00794,     28.0855,     107.8682 };
    Float_t zs[] = {  6.,           7.,           8.,
		      1.,          14.,          47. };
    Float_t ws[] = {  0.039730642,  0.001396798,  0.01169634,
		      0.004367771,  0.844665,     0.09814344903 };
    density          = 2.36436;
    maxBending       = 10;
    maxStepSize      = .01;
    precision        = .003;
    minStepSize      = .003;
    id               = kSiChipId;
    AliMixture(id, "Si Chip$", as, zs, density, 6, ws);
    AliMedium(kSiChipId, "Si Chip$",  id, 0, fieldType, maxField, maxBending, 
	      maxStepSize, maxEnergyLoss, precision, minStepSize);
  }
  
  // Kaption
  {
    Float_t as[] = { 1.00794,  12.0107,  14.010,   15.9994};
    Float_t zs[] = { 1.,        6.,       7.,       8.};
    Float_t ws[] = { 0.026362,  0.69113,  0.07327,  0.209235};
    density          = 1.42;
    maxBending       = 1;
    maxStepSize      = .001;
    precision        = .001;
    minStepSize      = .001;
    id               = kKaptonId;
    AliMixture(id, "Kaption$", as, zs, density, 4, ws);
    AliMedium(kKaptonId, "Kaption$", id,0,fieldType,maxField,maxBending,
	      maxStepSize,maxEnergyLoss,precision,minStepSize);
  }

  // Air
  {
    Float_t as[] = { 12.0107, 14.0067,   15.9994,  39.948 };
    Float_t zs[] = {  6.,      7.,       8.,       18. };
    Float_t ws[] = { 0.000124, 0.755267, 0.231781, 0.012827 }; 
    density      = .00120479;
    maxBending   = 1;
    maxStepSize  = .001;
    precision    = .001;
    minStepSize  = .001;
    id           = kAirId;
    AliMixture(id, "Air$", as, zs, density, 4, ws);
    AliMedium(kAirId, "Air$", id,0,fieldType,maxField,maxBending,
	      maxStepSize,maxEnergyLoss,precision,minStepSize);
  }
  
  // PCB
  {
    Float_t zs[] = { 14.,         20.,         13.,         12.,
		      5.,         22.,         11.,         19.,
		     26.,          9.,          8.,          6.,
		      7.,          1.};
    Float_t as[] = { 28.0855,     40.078,      26.981538,   24.305, 
		     10.811,      47.867,      22.98977,    39.0983,
		     55.845,      18.9984,     15.9994,     12.0107,
		     14.0067,      1.00794};
    Float_t ws[] = {  0.15144894,  0.08147477,  0.04128158,  0.00904554, 
		      0.01397570,  0.00287685,  0.00445114,  0.00498089,
		      0.00209828,  0.00420000,  0.36043788,  0.27529426,
		      0.01415852,  0.03427566};
    density      = 1.8;
    maxBending   = 1;
    maxStepSize  = .001;
    precision    = .001;
    minStepSize  = .001;
    id           = kPcbId;
    AliMixture(id, "PCB$", as, zs, density, 14, ws);
    AliMedium(kPcbId, "PCB$", id,0,fieldType,maxField,maxBending,
	      maxStepSize,maxEnergyLoss,precision,minStepSize);
  }
  
  // Stainless steel
  {
    Float_t as[] = { 55.847, 51.9961, 58.6934, 28.0855 };
    Float_t zs[] = { 26.,    24.,     28.,     14.     };
    Float_t ws[] = { .715,   .18,     .1,      .005    };
    density      = 7.88;
    id           = kSteelId;
    AliMixture(id, "Steel$", as, zs, density, 4, ws);
    AliMedium(kSteelId, "Steel$", id, 0, fieldType, maxField, maxBending, 
	      maxStepSize, maxEnergyLoss, precision, minStepSize);
  }
  // Plastic 
  {
    Float_t as[] = { 1.01, 12.01 };
    Float_t zs[] = { 1.,   6.    };
    Float_t ws[] = { 1.,   1.    };
    density      = 1.03;
    maxBending   = 10;
    maxStepSize  = .01;
    precision    = .003;
    minStepSize  = .003;
    id           = kPlasticId;
    AliMixture(id, "Plastic$", as, zs, density, -2, ws);
    AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
	      maxStepSize,maxEnergyLoss,precision,minStepSize);
  }

}

#if 0
//____________________________________________________________________
void  
AliFMD::SetTrackingParameters(Int_t imed, 
			      Float_t gamma,                 
			      Float_t electron, 
			      Float_t neutral_hadron, 
			      Float_t charged_hadron, 
			      Float_t muon,
			      Float_t electron_bremstrahlung, 
			      Float_t muon__bremstrahlung, 
			      Float_t electron_delta,
			      Float_t muon_delta,
			      Float_t muon_pair,
			      Int_t   annihilation, 
			      Int_t   bremstrahlung, 
			      Int_t   compton_scattering, 
			      Int_t   decay,
			      Int_t   delta_ray, 
			      Int_t   hadronic, 
			      Int_t   energy_loss, 
			      Int_t   multiple_scattering, 
			      Int_t   pair_production, 
			      Int_t   photon_production, 
			      Int_t   rayleigh_scattering)
{
  // Disabled by request of FCA, kept for reference only
  if (!TVirtualMC::GetMC()) return;
  TArrayI& idtmed = *(GetIdtmed());
  Int_t    iimed  = idtmed[imed];
  // TVirtualMC::GetMC()->Gstpar(iimed, "CUTGAM",	gamma);
  // TVirtualMC::GetMC()->Gstpar(iimed, "CUTELE",	electron);
  // TVirtualMC::GetMC()->Gstpar(iimed, "CUTNEU",	neutral_hadron);
  // TVirtualMC::GetMC()->Gstpar(iimed, "CUTHAD",	charged_hadron);
  // TVirtualMC::GetMC()->Gstpar(iimed, "CUTMUO",	muon);
  // TVirtualMC::GetMC()->Gstpar(iimed, "BCUTE",	electron_bremstrahlung);
  // TVirtualMC::GetMC()->Gstpar(iimed, "BCUTM",	muon__bremstrahlung);
  // TVirtualMC::GetMC()->Gstpar(iimed, "DCUTE",	electron_delta);
  // TVirtualMC::GetMC()->Gstpar(iimed, "DCUTM",	muon_delta);
  // TVirtualMC::GetMC()->Gstpar(iimed, "PPCUTM",	muon_pair);
  // TVirtualMC::GetMC()->Gstpar(iimed, "ANNI",	Float_t(annihilation));
  // TVirtualMC::GetMC()->Gstpar(iimed, "BREM",	Float_t(bremstrahlung));
  // TVirtualMC::GetMC()->Gstpar(iimed, "COMP",	Float_t(compton_scattering));
  // TVirtualMC::GetMC()->Gstpar(iimed, "DCAY",	Float_t(decay));
  // TVirtualMC::GetMC()->Gstpar(iimed, "DRAY",	Float_t(delta_ray));
  // TVirtualMC::GetMC()->Gstpar(iimed, "HADR",	Float_t(hadronic));
  // TVirtualMC::GetMC()->Gstpar(iimed, "LOSS",	Float_t(energy_loss));
  // TVirtualMC::GetMC()->Gstpar(iimed, "MULS",	Float_t(multiple_scattering));
  // TVirtualMC::GetMC()->Gstpar(iimed, "PAIR",	Float_t(pair_production));
  // TVirtualMC::GetMC()->Gstpar(iimed, "PHOT",	Float_t(photon_production));
  // TVirtualMC::GetMC()->Gstpar(iimed, "RAYL",	Float_t(rayleigh_scattering));
}
#endif

//____________________________________________________________________
void  
AliFMD::Init()
{
  // Initialize the detector 
  // 
  AliFMDDebug(1, ("Initialising FMD detector object"));
  TVirtualMC*      mc     = TVirtualMC::GetMC();
  AliFMDGeometry*  fmd    = AliFMDGeometry::Instance();
  TArrayI          actGeo = fmd->ActiveIds();
  bool             valid  = true;
  if (actGeo.fN <= 0) valid = false;
  else { 
    for (int i = 0; i < actGeo.fN; i++) {
      if (actGeo[i] < 0) { 
	valid = false;
	break;
      }
    }
  }
  if (!valid) { 
    AliFMDDebug(1, ("Extracting geometry info from loaded geometry"));
    fmd->ExtractGeomInfo();
    actGeo = fmd->ActiveIds();
  }
  TArrayI          actVmc(actGeo.fN);
  for (Int_t i = 0; i < actGeo.fN; i++) {
    if (actGeo[i] < 0) { 
      AliError(Form("Invalid id: %d", actGeo[i]));
      continue;
    }
    TGeoVolume *sens = gGeoManager->GetVolume(actGeo[i]);
    if (!sens) {
      AliError(Form("No TGeo volume for sensitive volume ID=%d",actGeo[i]));
      continue;
    }   
    actVmc[i] = mc->VolId(sens->GetName());
    AliFMDDebug(1, ("Active vol id # %d: %d changed to %d", 
		    i, actGeo[i], actVmc[i]));
  }
  fmd->SetActive(actVmc.fArray, actVmc.fN);
  // fmd->InitTransformations();
}

//____________________________________________________________________
void
AliFMD::FinishEvent()
{
  // Called at the end of the an event in simulations.  If the debug
  // level is high enough, then the `bad' hits are printed.
  // 
  if (AliLog::GetDebugLevel("FMD", "AliFMD") < 10) return;
  if (fBad && fBad->GetEntries() > 0) {
    AliWarning(Form("got %d 'bad' hits", fBad->GetEntries()));
    TIter next(fBad);
    AliFMDHit* hit;
    while ((hit = static_cast<AliFMDHit*>(next()))) hit->Print("D");
    fBad->Clear();
  }
}



//====================================================================
//
// Hit and Digit managment 
//
//____________________________________________________________________
void 
AliFMD::MakeBranch(Option_t * option)
{
  // Create Tree branches for the FMD.
  //
  // Options:
  //
  //    H          Make a branch of TClonesArray of AliFMDHit's
  //    D          Make a branch of TClonesArray of AliFMDDigit's
  //    S          Make a branch of TClonesArray of AliFMDSDigit's
  // 
  const Int_t kBufferSize = 16000;
  TString branchname(GetName());
  TString opt(option);
  
  if (opt.Contains("H", TString::kIgnoreCase)) {
    HitsArray();
    AliDetector::MakeBranch(option); 
  }
  if (opt.Contains("D", TString::kIgnoreCase)) { 
    DigitsArray();
    MakeBranchInTree(fLoader->TreeD(), branchname.Data(),
		     &fDigits, kBufferSize, 0);
  }
  if (opt.Contains("S", TString::kIgnoreCase)) { 
    SDigitsArray();
    MakeBranchInTree(fLoader->TreeS(), branchname.Data(),
		     &fSDigits, kBufferSize, 0);
  }
}

//____________________________________________________________________
void 
AliFMD::SetTreeAddress()
{
  // Set branch address for the Hits, Digits, and SDigits Tree.
  if (fLoader->TreeH()) HitsArray();
  AliDetector::SetTreeAddress();

  TTree *treeD = fLoader->TreeD();
  if (treeD) {
    DigitsArray();
    TBranch* branch = treeD->GetBranch ("FMD");
    if (branch) branch->SetAddress(&fDigits);
  }

  TTree *treeS = fLoader->TreeS();
  if (treeS) {
    SDigitsArray();
    TBranch* branch = treeS->GetBranch ("FMD");
    if (branch) branch->SetAddress(&fSDigits);
  }
}

//____________________________________________________________________
void 
AliFMD::SetHitsAddressBranch(TBranch *b)
{
  // Set the TClonesArray to read hits into. 
  b->SetAddress(&fHits);
}
//____________________________________________________________________
void 
AliFMD::SetSDigitsAddressBranch(TBranch *b)
{
  // Set the TClonesArray to read hits into. 
  b->SetAddress(&fSDigits);
}

//____________________________________________________________________
void 
AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits) 
{
  // Add a hit to the hits tree 
  // 
  // The information of the two arrays are decoded as 
  // 
  // Parameters
  //    track	 	     Track #
  //    ivol[0]  [UShort_t ] Detector # 
  //    ivol[1]	 [Char_t   ] Ring ID 
  //    ivol[2]	 [UShort_t ] Sector #
  //    ivol[3]	 [UShort_t ] Strip # 
  //    hits[0]	 [Float_t  ] Track's X-coordinate at hit 
  //    hits[1]	 [Float_t  ] Track's Y-coordinate at hit
  //    hits[3]  [Float_t  ] Track's Z-coordinate at hit
  //    hits[4]  [Float_t  ] X-component of track's momentum 	       	 
  //    hits[5]	 [Float_t  ] Y-component of track's momentum	       	 
  //    hits[6]	 [Float_t  ] Z-component of track's momentum	       	
  //    hits[7]	 [Float_t  ] Energy deposited by track		       	
  //    hits[8]	 [Int_t    ] Track's particle Id # 
  //    hits[9]	 [Float_t  ] Time when the track hit
  // 
  // 
  AddHitByFields(track, 
		 UShort_t(vol[0]),  // Detector # 
		 Char_t(vol[1]),    // Ring ID
		 UShort_t(vol[2]),  // Sector # 
		 UShort_t(vol[3]),  // Strip # 
		 hits[0],           // X
		 hits[1],           // Y
		 hits[2],           // Z
		 hits[3],           // Px
		 hits[4],           // Py
		 hits[5],           // Pz
		 hits[6],           // Energy loss 
		 Int_t(hits[7]),    // PDG 
		 hits[8]);          // Time
}

//____________________________________________________________________
AliFMDHit*
AliFMD::AddHitByFields(Int_t    track, 
		       UShort_t detector, 
		       Char_t   ring, 
		       UShort_t sector, 
		       UShort_t strip, 
		       Float_t  x, 
		       Float_t  y, 
		       Float_t  z,
		       Float_t  px, 
		       Float_t  py, 
		       Float_t  pz,
		       Float_t  edep,
		       Int_t    pdg,
		       Float_t  t, 
		       Float_t  l, 
		       Bool_t   stop)
{
  // Add a hit to the list
  //
  // Parameters:
  // 
  //    track	  Track #
  //    detector  Detector # (1, 2, or 3)                      
  //    ring	  Ring ID ('I' or 'O')
  //    sector	  Sector # (For inner/outer rings: 0-19/0-39)
  //    strip	  Strip # (For inner/outer rings: 0-511/0-255)
  //    x	  Track's X-coordinate at hit
  //    y	  Track's Y-coordinate at hit
  //    z	  Track's Z-coordinate at hit
  //    px	  X-component of track's momentum 
  //    py	  Y-component of track's momentum
  //    pz	  Z-component of track's momentum
  //    edep	  Energy deposited by track
  //    pdg	  Track's particle Id #
  //    t	  Time when the track hit 
  //    l         Track length through the material. 
  //    stop      Whether track was stopped or disappeared
  // 
  TClonesArray& a = *(HitsArray());
  // Search through the list of already registered hits, and see if we
  // find a hit with the same parameters.  If we do, then don't create
  // a new hit, but rather update the energy deposited in the hit.
  // This is done, so that a FLUKA based simulation will get the
  // number of hits right, not just the enerrgy deposition. 
  AliFMDHit* hit = 0;
  for (Int_t i = 0; i < fNhits; i++) {
    if (!a.At(i)) continue;
    hit = static_cast<AliFMDHit*>(a.At(i));
    if (hit->Detector() == detector 
	&& hit->Ring() == ring
	&& hit->Sector() == sector 
	&& hit->Strip() == strip
	&& hit->Track() == track) {
      AliFMDDebug(1, ("already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
		       " adding energy (%f) to that hit (%f) -> %f", 
		       detector, ring, sector, strip, track, edep, hit->Edep(),
		       hit->Edep() + edep));
      hit->SetEdep(hit->Edep() + edep);
      return hit;
    }
  }
  // If hit wasn't already registered, do so know. 
  hit = new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, 
				  strip, x, y, z, px, py, pz, edep, pdg, t, 
				  l, stop);
  // TVirtualMC::GetMC()->AddTrackReference(track, 12);
  fNhits++;
  
  //Reference track

  AliMC *mcApplication = (AliMC*)gAlice->GetMCApp();
  
  AliTrackReference* trackRef = 
    AddTrackReference(mcApplication->GetCurrentTrackNumber(), 
		      AliTrackReference::kFMD); 
  UInt_t stripId = AliFMDStripIndex::Pack(detector,ring,sector,strip);  
  UInt_t dedx    = AliFMDEncodedEdx::Encode(edep, l);
  
  trackRef->SetUserId((dedx << 19) | stripId);

  
  return hit;
}

//____________________________________________________________________
void 
AliFMD::AddDigit(Int_t* digits, Int_t*)
{
  // Add a digit to the Digit tree 
  // 
  // Paramters 
  //
  //    digits[0]  [UShort_t] Detector #
  //    digits[1]  [Char_t]   Ring ID
  //    digits[2]  [UShort_t] Sector #
  //    digits[3]  [UShort_t] Strip #
  //    digits[4]  [UShort_t] ADC Count 
  //    digits[5]  [Short_t]  ADC Count, -1 if not used
  //    digits[6]  [Short_t]  ADC Count, -1 if not used 
  // 
  AddDigitByFields(UShort_t(digits[0]),  // Detector #
		   Char_t(digits[1]),    // Ring ID
		   UShort_t(digits[2]),  // Sector #
		   UShort_t(digits[3]),  // Strip #
		   UShort_t(digits[4]),  // ADC Count1 
		   Short_t(digits[5]), 	 // ADC Count2 
		   Short_t(digits[6]),   // ADC Count3 
		   Short_t(digits[7])); 
}

//____________________________________________________________________
void 
AliFMD::AddDigitByFields(UShort_t       detector, 
			 Char_t         ring, 
			 UShort_t       sector, 
			 UShort_t       strip, 
			 UShort_t       count1, 
			 Short_t        count2,
			 Short_t        count3, 
			 Short_t        count4,
			 UShort_t	nrefs,
			 Int_t*		refs)
{
  // add a real digit - as coming from data
  // 
  // Parameters 
  //
  //    detector  Detector # (1, 2, or 3)                      
  //    ring	  Ring ID ('I' or 'O')
  //    sector	  Sector # (For inner/outer rings: 0-19/0-39)
  //    strip	  Strip # (For inner/outer rings: 0-511/0-255)
  //    count1    ADC count (a 10-bit word)
  //    count2    ADC count (a 10-bit word), or -1 if not used
  //    count3    ADC count (a 10-bit word), or -1 if not used
  TClonesArray& a = *(DigitsArray());
  
  AliFMDDebug(15, ("Adding digit # %5d/%5d for FMD%d%c[%2d,%3d]"
		   "=(%d,%d,%d,%d) with %d tracks",
		   fNdigits-1, a.GetEntriesFast(),
		   detector, ring, sector, strip, 
		   count1, count2, count3, count4, nrefs));
  new (a[fNdigits++]) 
    AliFMDDigit(detector, ring, sector, strip, 
		count1, count2, count3, count4, nrefs, refs);
  
}

//____________________________________________________________________
void 
AliFMD::AddSDigit(Int_t* digits)
{
  // Add a digit to the SDigit tree 
  // 
  // Paramters 
  //
  //    digits[0]  [UShort_t] Detector #
  //    digits[1]  [Char_t]   Ring ID
  //    digits[2]  [UShort_t] Sector #
  //    digits[3]  [UShort_t] Strip #
  //    digits[4]  [Float_t]  Total energy deposited 
  //    digits[5]  [UShort_t] ADC Count 
  //    digits[6]  [Short_t]  ADC Count, -1 if not used
  //    digits[7]  [Short_t]  ADC Count, -1 if not used 
  // 
  AddSDigitByFields(UShort_t(digits[0]),   // Detector #
		    Char_t(digits[1]),     // Ring ID
		    UShort_t(digits[2]),   // Sector #
		    UShort_t(digits[3]),   // Strip #
		    Float_t(digits[4]),    // Edep
		    UShort_t(digits[5]),   // ADC Count1 
		    Short_t(digits[6]),    // ADC Count2 
		    Short_t(digits[7]),    // ADC Count3 
		    Short_t(digits[8]),    // ADC Count4
		    UShort_t(digits[9]),   // N particles
		    UShort_t(digits[10])); // N primaries
}

//____________________________________________________________________
void 
AliFMD::AddSDigitByFields(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       ntot, 
			  UShort_t       nprim,
			  Int_t*	 refs)
{
  // add a summable digit
  // 
  // Parameters 
  //
  //    detector  Detector # (1, 2, or 3)                      
  //    ring	  Ring ID ('I' or 'O')
  //    sector	  Sector # (For inner/outer rings: 0-19/0-39)
  //    strip	  Strip # (For inner/outer rings: 0-511/0-255)
  //    edep      Total energy deposited
  //    count1    ADC count (a 10-bit word)
  //    count2    ADC count (a 10-bit word), or -1 if not used
  //    count3    ADC count (a 10-bit word), or -1 if not used
  //
  TClonesArray& a = *(SDigitsArray());
  // AliFMDDebug(0, ("Adding sdigit # %d", fNsdigits));
  
  AliFMDDebug(15, ("Adding sdigit # %5d/%5d for FMD%d%c[%2d,%3d]"
		   "=(%d,%d,%d,%d) with %d tracks %d primaries (%p)",
		   fNsdigits-1, a.GetEntriesFast(),
		   detector, ring, sector, strip, 
		   count1, count2, count3, count4, ntot, nprim, refs));
  new (a[fNsdigits++]) 
    AliFMDSDigit(detector, ring, sector, strip, edep, 
		 count1, count2, count3, count4, ntot, nprim, refs);
}

//____________________________________________________________________
void 
AliFMD::ResetSDigits()
{
  // Reset number of digits and the digits array for this detector. 
  //
  fNsdigits   = 0;
  if (fSDigits) fSDigits->Clear();
}


//____________________________________________________________________
TClonesArray*
AliFMD::HitsArray() 
{
  // Initialize hit array if not already, and return pointer to it. 
  if (!fHits) { 
    fHits = new TClonesArray("AliFMDHit", 1000);
    fNhits = 0;
    if (gAlice && gAlice->GetMCApp() && gAlice->GetMCApp()->GetHitLists()) 
      gAlice->GetMCApp()->AddHitList(fHits);
  }
  return fHits;
}

//____________________________________________________________________
TClonesArray*
AliFMD::DigitsArray() 
{
  // Initialize digit array if not already, and return pointer to it. 
  if (!fDigits) { 
    fDigits = new TClonesArray("AliFMDDigit", 1000);
    fNdigits = 0;
  }
  return fDigits;
}

//____________________________________________________________________
TClonesArray*
AliFMD::SDigitsArray() 
{
  // Initialize digit array if not already, and return pointer to it. 
  if (!fSDigits) { 
    fSDigits = new TClonesArray("AliFMDSDigit", 1000);
    fNsdigits = 0;
  }
  return fSDigits;
}

//====================================================================
//
// Digitization 
//
//____________________________________________________________________
void 
AliFMD::Hits2Digits() 
{
  // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
  // AliFMDDigitizer, and executing that code.
  // 
  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kDigits);
  digitizer.Init();
  digitizer.Digitize("");
}

//____________________________________________________________________
void 
AliFMD::Hits2SDigits() 
{
  // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
  // an AliFMDSDigitizer object, and executing it. 
  // 
  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kSDigits);
  digitizer.Init();
  digitizer.Digitize("");
}

  
//____________________________________________________________________
AliDigitizer* 
AliFMD::CreateDigitizer(AliDigitizationInput* digInput) const
{
  // Create a digitizer object 
  
  /* This is what we probably _should_ do */
  AliFMDBaseDigitizer* digitizer = 0;
  
#ifdef USE_SSDIGITIZER
  digitizer = new AliFMDSSDigitizer(digInput);
#else 
  /* This is what we actually do, and will work */
#if 0
  AliInfo("SDigit->Digit conversion not really supported, "
	  "doing Hit->Digit conversion instead");
#endif
  digitizer = new AliFMDDigitizer(digInput);
#endif
  return digitizer;
}

//====================================================================
//
// Raw data simulation 
//
//__________________________________________________________________
void 
AliFMD::Digits2Raw() 
{
  // Turn digits into raw data. 
  // 
  // This uses the class AliFMDRawWriter to do the job.   Please refer
  // to that class for more information. 
  AliFMDRawWriter writer(this);
  writer.Exec();
}

//====================================================================
//
// Raw data reading 
//
//__________________________________________________________________
Bool_t
AliFMD::Raw2SDigits(AliRawReader* reader) 
{
  // Turn digits into raw data. 
  // 
  // This uses the class AliFMDRawWriter to do the job.   Please refer
  // to that class for more information. 
  AliFMDParameters::Instance()->Init();
  MakeTree("S");
  MakeBranch("S");
  
  TClonesArray*       sdigits = SDigits();
  AliFMDReconstructor rec;
  
  // The two boolean arguments
  //   Make sdigits instead of digits 
  //   Subtract the pedestal off the signal
  rec.Digitize(reader, sdigits);
  // 
  // Bool_t ret = fmdReader.ReadAdcs(sdigits, kTRUE, kTRUE);
  // sdigits->ls();
  UShort_t ns = sdigits->GetEntriesFast();
  if (AliLog::GetDebugLevel("FMD", 0) > 5) {
    for (UShort_t i = 0; i < ns; i++) 
      sdigits->At(i)->Print("pl");
  } 
  AliFMDDebug(1, ("Got a total of %d SDigits", ns));

  fLoader->TreeS()->Fill();
  ResetSDigits();
  fLoader->WriteSDigits("OVERWRITE");

  return kTRUE;
}


//====================================================================
//
// Utility 
//
//__________________________________________________________________
void 
AliFMD::Browse(TBrowser* b) 
{
  // Browse this object. 
  //
  AliFMDDebug(30, ("\tBrowsing the FMD"));
  AliDetector::Browse(b);
  b->Add(AliFMDGeometry::Instance());
}

//____________________________________________________________________	
void
AliFMD::AddAlignableVolumes() const
{
  //
  // Create entries for alignable volumes associating the symbolic volume
  // name with the corresponding volume path. Needs to be syncronized with
  // eventual changes in the geometry.
  // 
  // This code was made by Raffaele Grosso <rgrosso@mail.cern.ch>.  I
  // (cholm) will probably want to change it.   For one, I think it
  // should be the job of the geometry manager to deal with this. 
  AliInfo("Add FMD alignable volumes");
  AliFMDGeometry::Instance()->SetAlignableVolumes();
#if 0  
  for(size_t f = 1; f <= 3; f++){ // Detector 1,2,3
    for(size_t tb =  0; tb <2 ; tb++){ // Top/Bottom 
      char     stb = tb == 0 ? 'T' : 'B';
      unsigned min = tb == 0 ? 0   : 5;

      TString halfVol(Form("/ALIC_1/F%dM%c_%d", f, stb, f));
      TString halfSym(halfVol);
      if(!gGeoManager->SetAlignableEntry(halfSym.Data(),halfVol.Data()))
	AliFatal(Form("Alignable entry %s not created. "
		      "Volume path %s not valid", 
		      halfSym.Data(),halfVol.Data()));
      for(size_t io = 0; io < 2; io++){ // inner, outer 
	if (f==1 && io==1) continue; // Only one ring in FMD1 
	if(tb == 1 && io==1) min=10;
	char     sio = (io == 0 ? 'I' : 'O');
	unsigned nio = (io == 0 ? 3   : 9);
	unsigned max = (io == 0 ? 5   : 10) + min;
	
	for(size_t i = min; i < max; i++) { // Modules
	  TString modVol(Form("%s/F%c%cV_7%d/F%cSE_%d", halfVol.Data(), 
			      sio, stb, nio, sio, i));
	  TString modSym(modVol);
	  if(!gGeoManager->SetAlignableEntry(modSym.Data(),modVol.Data()))
	    AliFatal(Form("Alignable entry %s not created. "
			  "Volume path %s not valid", 
			  modSym.Data(), modVol.Data()));
	}
      }
    }
  }
#endif
}
//___________________________________________________________________
//
// EOF
//
 AliFMD.cxx:1
 AliFMD.cxx:2
 AliFMD.cxx:3
 AliFMD.cxx:4
 AliFMD.cxx:5
 AliFMD.cxx:6
 AliFMD.cxx:7
 AliFMD.cxx:8
 AliFMD.cxx:9
 AliFMD.cxx:10
 AliFMD.cxx:11
 AliFMD.cxx:12
 AliFMD.cxx:13
 AliFMD.cxx:14
 AliFMD.cxx:15
 AliFMD.cxx:16
 AliFMD.cxx:17
 AliFMD.cxx:18
 AliFMD.cxx:19
 AliFMD.cxx:20
 AliFMD.cxx:21
 AliFMD.cxx:22
 AliFMD.cxx:23
 AliFMD.cxx:24
 AliFMD.cxx:25
 AliFMD.cxx:26
 AliFMD.cxx:27
 AliFMD.cxx:28
 AliFMD.cxx:29
 AliFMD.cxx:30
 AliFMD.cxx:31
 AliFMD.cxx:32
 AliFMD.cxx:33
 AliFMD.cxx:34
 AliFMD.cxx:35
 AliFMD.cxx:36
 AliFMD.cxx:37
 AliFMD.cxx:38
 AliFMD.cxx:39
 AliFMD.cxx:40
 AliFMD.cxx:41
 AliFMD.cxx:42
 AliFMD.cxx:43
 AliFMD.cxx:44
 AliFMD.cxx:45
 AliFMD.cxx:46
 AliFMD.cxx:47
 AliFMD.cxx:48
 AliFMD.cxx:49
 AliFMD.cxx:50
 AliFMD.cxx:51
 AliFMD.cxx:52
 AliFMD.cxx:53
 AliFMD.cxx:54
 AliFMD.cxx:55
 AliFMD.cxx:56
 AliFMD.cxx:57
 AliFMD.cxx:58
 AliFMD.cxx:59
 AliFMD.cxx:60
 AliFMD.cxx:61
 AliFMD.cxx:62
 AliFMD.cxx:63
 AliFMD.cxx:64
 AliFMD.cxx:65
 AliFMD.cxx:66
 AliFMD.cxx:67
 AliFMD.cxx:68
 AliFMD.cxx:69
 AliFMD.cxx:70
 AliFMD.cxx:71
 AliFMD.cxx:72
 AliFMD.cxx:73
 AliFMD.cxx:74
 AliFMD.cxx:75
 AliFMD.cxx:76
 AliFMD.cxx:77
 AliFMD.cxx:78
 AliFMD.cxx:79
 AliFMD.cxx:80
 AliFMD.cxx:81
 AliFMD.cxx:82
 AliFMD.cxx:83
 AliFMD.cxx:84
 AliFMD.cxx:85
 AliFMD.cxx:86
 AliFMD.cxx:87
 AliFMD.cxx:88
 AliFMD.cxx:89
 AliFMD.cxx:90
 AliFMD.cxx:91
 AliFMD.cxx:92
 AliFMD.cxx:93
 AliFMD.cxx:94
 AliFMD.cxx:95
 AliFMD.cxx:96
 AliFMD.cxx:97
 AliFMD.cxx:98
 AliFMD.cxx:99
 AliFMD.cxx:100
 AliFMD.cxx:101
 AliFMD.cxx:102
 AliFMD.cxx:103
 AliFMD.cxx:104
 AliFMD.cxx:105
 AliFMD.cxx:106
 AliFMD.cxx:107
 AliFMD.cxx:108
 AliFMD.cxx:109
 AliFMD.cxx:110
 AliFMD.cxx:111
 AliFMD.cxx:112
 AliFMD.cxx:113
 AliFMD.cxx:114
 AliFMD.cxx:115
 AliFMD.cxx:116
 AliFMD.cxx:117
 AliFMD.cxx:118
 AliFMD.cxx:119
 AliFMD.cxx:120
 AliFMD.cxx:121
 AliFMD.cxx:122
 AliFMD.cxx:123
 AliFMD.cxx:124
 AliFMD.cxx:125
 AliFMD.cxx:126
 AliFMD.cxx:127
 AliFMD.cxx:128
 AliFMD.cxx:129
 AliFMD.cxx:130
 AliFMD.cxx:131
 AliFMD.cxx:132
 AliFMD.cxx:133
 AliFMD.cxx:134
 AliFMD.cxx:135
 AliFMD.cxx:136
 AliFMD.cxx:137
 AliFMD.cxx:138
 AliFMD.cxx:139
 AliFMD.cxx:140
 AliFMD.cxx:141
 AliFMD.cxx:142
 AliFMD.cxx:143
 AliFMD.cxx:144
 AliFMD.cxx:145
 AliFMD.cxx:146
 AliFMD.cxx:147
 AliFMD.cxx:148
 AliFMD.cxx:149
 AliFMD.cxx:150
 AliFMD.cxx:151
 AliFMD.cxx:152
 AliFMD.cxx:153
 AliFMD.cxx:154
 AliFMD.cxx:155
 AliFMD.cxx:156
 AliFMD.cxx:157
 AliFMD.cxx:158
 AliFMD.cxx:159
 AliFMD.cxx:160
 AliFMD.cxx:161
 AliFMD.cxx:162
 AliFMD.cxx:163
 AliFMD.cxx:164
 AliFMD.cxx:165
 AliFMD.cxx:166
 AliFMD.cxx:167
 AliFMD.cxx:168
 AliFMD.cxx:169
 AliFMD.cxx:170
 AliFMD.cxx:171
 AliFMD.cxx:172
 AliFMD.cxx:173
 AliFMD.cxx:174
 AliFMD.cxx:175
 AliFMD.cxx:176
 AliFMD.cxx:177
 AliFMD.cxx:178
 AliFMD.cxx:179
 AliFMD.cxx:180
 AliFMD.cxx:181
 AliFMD.cxx:182
 AliFMD.cxx:183
 AliFMD.cxx:184
 AliFMD.cxx:185
 AliFMD.cxx:186
 AliFMD.cxx:187
 AliFMD.cxx:188
 AliFMD.cxx:189
 AliFMD.cxx:190
 AliFMD.cxx:191
 AliFMD.cxx:192
 AliFMD.cxx:193
 AliFMD.cxx:194
 AliFMD.cxx:195
 AliFMD.cxx:196
 AliFMD.cxx:197
 AliFMD.cxx:198
 AliFMD.cxx:199
 AliFMD.cxx:200
 AliFMD.cxx:201
 AliFMD.cxx:202
 AliFMD.cxx:203
 AliFMD.cxx:204
 AliFMD.cxx:205
 AliFMD.cxx:206
 AliFMD.cxx:207
 AliFMD.cxx:208
 AliFMD.cxx:209
 AliFMD.cxx:210
 AliFMD.cxx:211
 AliFMD.cxx:212
 AliFMD.cxx:213
 AliFMD.cxx:214
 AliFMD.cxx:215
 AliFMD.cxx:216
 AliFMD.cxx:217
 AliFMD.cxx:218
 AliFMD.cxx:219
 AliFMD.cxx:220
 AliFMD.cxx:221
 AliFMD.cxx:222
 AliFMD.cxx:223
 AliFMD.cxx:224
 AliFMD.cxx:225
 AliFMD.cxx:226
 AliFMD.cxx:227
 AliFMD.cxx:228
 AliFMD.cxx:229
 AliFMD.cxx:230
 AliFMD.cxx:231
 AliFMD.cxx:232
 AliFMD.cxx:233
 AliFMD.cxx:234
 AliFMD.cxx:235
 AliFMD.cxx:236
 AliFMD.cxx:237
 AliFMD.cxx:238
 AliFMD.cxx:239
 AliFMD.cxx:240
 AliFMD.cxx:241
 AliFMD.cxx:242
 AliFMD.cxx:243
 AliFMD.cxx:244
 AliFMD.cxx:245
 AliFMD.cxx:246
 AliFMD.cxx:247
 AliFMD.cxx:248
 AliFMD.cxx:249
 AliFMD.cxx:250
 AliFMD.cxx:251
 AliFMD.cxx:252
 AliFMD.cxx:253
 AliFMD.cxx:254
 AliFMD.cxx:255
 AliFMD.cxx:256
 AliFMD.cxx:257
 AliFMD.cxx:258
 AliFMD.cxx:259
 AliFMD.cxx:260
 AliFMD.cxx:261
 AliFMD.cxx:262
 AliFMD.cxx:263
 AliFMD.cxx:264
 AliFMD.cxx:265
 AliFMD.cxx:266
 AliFMD.cxx:267
 AliFMD.cxx:268
 AliFMD.cxx:269
 AliFMD.cxx:270
 AliFMD.cxx:271
 AliFMD.cxx:272
 AliFMD.cxx:273
 AliFMD.cxx:274
 AliFMD.cxx:275
 AliFMD.cxx:276
 AliFMD.cxx:277
 AliFMD.cxx:278
 AliFMD.cxx:279
 AliFMD.cxx:280
 AliFMD.cxx:281
 AliFMD.cxx:282
 AliFMD.cxx:283
 AliFMD.cxx:284
 AliFMD.cxx:285
 AliFMD.cxx:286
 AliFMD.cxx:287
 AliFMD.cxx:288
 AliFMD.cxx:289
 AliFMD.cxx:290
 AliFMD.cxx:291
 AliFMD.cxx:292
 AliFMD.cxx:293
 AliFMD.cxx:294
 AliFMD.cxx:295
 AliFMD.cxx:296
 AliFMD.cxx:297
 AliFMD.cxx:298
 AliFMD.cxx:299
 AliFMD.cxx:300
 AliFMD.cxx:301
 AliFMD.cxx:302
 AliFMD.cxx:303
 AliFMD.cxx:304
 AliFMD.cxx:305
 AliFMD.cxx:306
 AliFMD.cxx:307
 AliFMD.cxx:308
 AliFMD.cxx:309
 AliFMD.cxx:310
 AliFMD.cxx:311
 AliFMD.cxx:312
 AliFMD.cxx:313
 AliFMD.cxx:314
 AliFMD.cxx:315
 AliFMD.cxx:316
 AliFMD.cxx:317
 AliFMD.cxx:318
 AliFMD.cxx:319
 AliFMD.cxx:320
 AliFMD.cxx:321
 AliFMD.cxx:322
 AliFMD.cxx:323
 AliFMD.cxx:324
 AliFMD.cxx:325
 AliFMD.cxx:326
 AliFMD.cxx:327
 AliFMD.cxx:328
 AliFMD.cxx:329
 AliFMD.cxx:330
 AliFMD.cxx:331
 AliFMD.cxx:332
 AliFMD.cxx:333
 AliFMD.cxx:334
 AliFMD.cxx:335
 AliFMD.cxx:336
 AliFMD.cxx:337
 AliFMD.cxx:338
 AliFMD.cxx:339
 AliFMD.cxx:340
 AliFMD.cxx:341
 AliFMD.cxx:342
 AliFMD.cxx:343
 AliFMD.cxx:344
 AliFMD.cxx:345
 AliFMD.cxx:346
 AliFMD.cxx:347
 AliFMD.cxx:348
 AliFMD.cxx:349
 AliFMD.cxx:350
 AliFMD.cxx:351
 AliFMD.cxx:352
 AliFMD.cxx:353
 AliFMD.cxx:354
 AliFMD.cxx:355
 AliFMD.cxx:356
 AliFMD.cxx:357
 AliFMD.cxx:358
 AliFMD.cxx:359
 AliFMD.cxx:360
 AliFMD.cxx:361
 AliFMD.cxx:362
 AliFMD.cxx:363
 AliFMD.cxx:364
 AliFMD.cxx:365
 AliFMD.cxx:366
 AliFMD.cxx:367
 AliFMD.cxx:368
 AliFMD.cxx:369
 AliFMD.cxx:370
 AliFMD.cxx:371
 AliFMD.cxx:372
 AliFMD.cxx:373
 AliFMD.cxx:374
 AliFMD.cxx:375
 AliFMD.cxx:376
 AliFMD.cxx:377
 AliFMD.cxx:378
 AliFMD.cxx:379
 AliFMD.cxx:380
 AliFMD.cxx:381
 AliFMD.cxx:382
 AliFMD.cxx:383
 AliFMD.cxx:384
 AliFMD.cxx:385
 AliFMD.cxx:386
 AliFMD.cxx:387
 AliFMD.cxx:388
 AliFMD.cxx:389
 AliFMD.cxx:390
 AliFMD.cxx:391
 AliFMD.cxx:392
 AliFMD.cxx:393
 AliFMD.cxx:394
 AliFMD.cxx:395
 AliFMD.cxx:396
 AliFMD.cxx:397
 AliFMD.cxx:398
 AliFMD.cxx:399
 AliFMD.cxx:400
 AliFMD.cxx:401
 AliFMD.cxx:402
 AliFMD.cxx:403
 AliFMD.cxx:404
 AliFMD.cxx:405
 AliFMD.cxx:406
 AliFMD.cxx:407
 AliFMD.cxx:408
 AliFMD.cxx:409
 AliFMD.cxx:410
 AliFMD.cxx:411
 AliFMD.cxx:412
 AliFMD.cxx:413
 AliFMD.cxx:414
 AliFMD.cxx:415
 AliFMD.cxx:416
 AliFMD.cxx:417
 AliFMD.cxx:418
 AliFMD.cxx:419
 AliFMD.cxx:420
 AliFMD.cxx:421
 AliFMD.cxx:422
 AliFMD.cxx:423
 AliFMD.cxx:424
 AliFMD.cxx:425
 AliFMD.cxx:426
 AliFMD.cxx:427
 AliFMD.cxx:428
 AliFMD.cxx:429
 AliFMD.cxx:430
 AliFMD.cxx:431
 AliFMD.cxx:432
 AliFMD.cxx:433
 AliFMD.cxx:434
 AliFMD.cxx:435
 AliFMD.cxx:436
 AliFMD.cxx:437
 AliFMD.cxx:438
 AliFMD.cxx:439
 AliFMD.cxx:440
 AliFMD.cxx:441
 AliFMD.cxx:442
 AliFMD.cxx:443
 AliFMD.cxx:444
 AliFMD.cxx:445
 AliFMD.cxx:446
 AliFMD.cxx:447
 AliFMD.cxx:448
 AliFMD.cxx:449
 AliFMD.cxx:450
 AliFMD.cxx:451
 AliFMD.cxx:452
 AliFMD.cxx:453
 AliFMD.cxx:454
 AliFMD.cxx:455
 AliFMD.cxx:456
 AliFMD.cxx:457
 AliFMD.cxx:458
 AliFMD.cxx:459
 AliFMD.cxx:460
 AliFMD.cxx:461
 AliFMD.cxx:462
 AliFMD.cxx:463
 AliFMD.cxx:464
 AliFMD.cxx:465
 AliFMD.cxx:466
 AliFMD.cxx:467
 AliFMD.cxx:468
 AliFMD.cxx:469
 AliFMD.cxx:470
 AliFMD.cxx:471
 AliFMD.cxx:472
 AliFMD.cxx:473
 AliFMD.cxx:474
 AliFMD.cxx:475
 AliFMD.cxx:476
 AliFMD.cxx:477
 AliFMD.cxx:478
 AliFMD.cxx:479
 AliFMD.cxx:480
 AliFMD.cxx:481
 AliFMD.cxx:482
 AliFMD.cxx:483
 AliFMD.cxx:484
 AliFMD.cxx:485
 AliFMD.cxx:486
 AliFMD.cxx:487
 AliFMD.cxx:488
 AliFMD.cxx:489
 AliFMD.cxx:490
 AliFMD.cxx:491
 AliFMD.cxx:492
 AliFMD.cxx:493
 AliFMD.cxx:494
 AliFMD.cxx:495
 AliFMD.cxx:496
 AliFMD.cxx:497
 AliFMD.cxx:498
 AliFMD.cxx:499
 AliFMD.cxx:500
 AliFMD.cxx:501
 AliFMD.cxx:502
 AliFMD.cxx:503
 AliFMD.cxx:504
 AliFMD.cxx:505
 AliFMD.cxx:506
 AliFMD.cxx:507
 AliFMD.cxx:508
 AliFMD.cxx:509
 AliFMD.cxx:510
 AliFMD.cxx:511
 AliFMD.cxx:512
 AliFMD.cxx:513
 AliFMD.cxx:514
 AliFMD.cxx:515
 AliFMD.cxx:516
 AliFMD.cxx:517
 AliFMD.cxx:518
 AliFMD.cxx:519
 AliFMD.cxx:520
 AliFMD.cxx:521
 AliFMD.cxx:522
 AliFMD.cxx:523
 AliFMD.cxx:524
 AliFMD.cxx:525
 AliFMD.cxx:526
 AliFMD.cxx:527
 AliFMD.cxx:528
 AliFMD.cxx:529
 AliFMD.cxx:530
 AliFMD.cxx:531
 AliFMD.cxx:532
 AliFMD.cxx:533
 AliFMD.cxx:534
 AliFMD.cxx:535
 AliFMD.cxx:536
 AliFMD.cxx:537
 AliFMD.cxx:538
 AliFMD.cxx:539
 AliFMD.cxx:540
 AliFMD.cxx:541
 AliFMD.cxx:542
 AliFMD.cxx:543
 AliFMD.cxx:544
 AliFMD.cxx:545
 AliFMD.cxx:546
 AliFMD.cxx:547
 AliFMD.cxx:548
 AliFMD.cxx:549
 AliFMD.cxx:550
 AliFMD.cxx:551
 AliFMD.cxx:552
 AliFMD.cxx:553
 AliFMD.cxx:554
 AliFMD.cxx:555
 AliFMD.cxx:556
 AliFMD.cxx:557
 AliFMD.cxx:558
 AliFMD.cxx:559
 AliFMD.cxx:560
 AliFMD.cxx:561
 AliFMD.cxx:562
 AliFMD.cxx:563
 AliFMD.cxx:564
 AliFMD.cxx:565
 AliFMD.cxx:566
 AliFMD.cxx:567
 AliFMD.cxx:568
 AliFMD.cxx:569
 AliFMD.cxx:570
 AliFMD.cxx:571
 AliFMD.cxx:572
 AliFMD.cxx:573
 AliFMD.cxx:574
 AliFMD.cxx:575
 AliFMD.cxx:576
 AliFMD.cxx:577
 AliFMD.cxx:578
 AliFMD.cxx:579
 AliFMD.cxx:580
 AliFMD.cxx:581
 AliFMD.cxx:582
 AliFMD.cxx:583
 AliFMD.cxx:584
 AliFMD.cxx:585
 AliFMD.cxx:586
 AliFMD.cxx:587
 AliFMD.cxx:588
 AliFMD.cxx:589
 AliFMD.cxx:590
 AliFMD.cxx:591
 AliFMD.cxx:592
 AliFMD.cxx:593
 AliFMD.cxx:594
 AliFMD.cxx:595
 AliFMD.cxx:596
 AliFMD.cxx:597
 AliFMD.cxx:598
 AliFMD.cxx:599
 AliFMD.cxx:600
 AliFMD.cxx:601
 AliFMD.cxx:602
 AliFMD.cxx:603
 AliFMD.cxx:604
 AliFMD.cxx:605
 AliFMD.cxx:606
 AliFMD.cxx:607
 AliFMD.cxx:608
 AliFMD.cxx:609
 AliFMD.cxx:610
 AliFMD.cxx:611
 AliFMD.cxx:612
 AliFMD.cxx:613
 AliFMD.cxx:614
 AliFMD.cxx:615
 AliFMD.cxx:616
 AliFMD.cxx:617
 AliFMD.cxx:618
 AliFMD.cxx:619
 AliFMD.cxx:620
 AliFMD.cxx:621
 AliFMD.cxx:622
 AliFMD.cxx:623
 AliFMD.cxx:624
 AliFMD.cxx:625
 AliFMD.cxx:626
 AliFMD.cxx:627
 AliFMD.cxx:628
 AliFMD.cxx:629
 AliFMD.cxx:630
 AliFMD.cxx:631
 AliFMD.cxx:632
 AliFMD.cxx:633
 AliFMD.cxx:634
 AliFMD.cxx:635
 AliFMD.cxx:636
 AliFMD.cxx:637
 AliFMD.cxx:638
 AliFMD.cxx:639
 AliFMD.cxx:640
 AliFMD.cxx:641
 AliFMD.cxx:642
 AliFMD.cxx:643
 AliFMD.cxx:644
 AliFMD.cxx:645
 AliFMD.cxx:646
 AliFMD.cxx:647
 AliFMD.cxx:648
 AliFMD.cxx:649
 AliFMD.cxx:650
 AliFMD.cxx:651
 AliFMD.cxx:652
 AliFMD.cxx:653
 AliFMD.cxx:654
 AliFMD.cxx:655
 AliFMD.cxx:656
 AliFMD.cxx:657
 AliFMD.cxx:658
 AliFMD.cxx:659
 AliFMD.cxx:660
 AliFMD.cxx:661
 AliFMD.cxx:662
 AliFMD.cxx:663
 AliFMD.cxx:664
 AliFMD.cxx:665
 AliFMD.cxx:666
 AliFMD.cxx:667
 AliFMD.cxx:668
 AliFMD.cxx:669
 AliFMD.cxx:670
 AliFMD.cxx:671
 AliFMD.cxx:672
 AliFMD.cxx:673
 AliFMD.cxx:674
 AliFMD.cxx:675
 AliFMD.cxx:676
 AliFMD.cxx:677
 AliFMD.cxx:678
 AliFMD.cxx:679
 AliFMD.cxx:680
 AliFMD.cxx:681
 AliFMD.cxx:682
 AliFMD.cxx:683
 AliFMD.cxx:684
 AliFMD.cxx:685
 AliFMD.cxx:686
 AliFMD.cxx:687
 AliFMD.cxx:688
 AliFMD.cxx:689
 AliFMD.cxx:690
 AliFMD.cxx:691
 AliFMD.cxx:692
 AliFMD.cxx:693
 AliFMD.cxx:694
 AliFMD.cxx:695
 AliFMD.cxx:696
 AliFMD.cxx:697
 AliFMD.cxx:698
 AliFMD.cxx:699
 AliFMD.cxx:700
 AliFMD.cxx:701
 AliFMD.cxx:702
 AliFMD.cxx:703
 AliFMD.cxx:704
 AliFMD.cxx:705
 AliFMD.cxx:706
 AliFMD.cxx:707
 AliFMD.cxx:708
 AliFMD.cxx:709
 AliFMD.cxx:710
 AliFMD.cxx:711
 AliFMD.cxx:712
 AliFMD.cxx:713
 AliFMD.cxx:714
 AliFMD.cxx:715
 AliFMD.cxx:716
 AliFMD.cxx:717
 AliFMD.cxx:718
 AliFMD.cxx:719
 AliFMD.cxx:720
 AliFMD.cxx:721
 AliFMD.cxx:722
 AliFMD.cxx:723
 AliFMD.cxx:724
 AliFMD.cxx:725
 AliFMD.cxx:726
 AliFMD.cxx:727
 AliFMD.cxx:728
 AliFMD.cxx:729
 AliFMD.cxx:730
 AliFMD.cxx:731
 AliFMD.cxx:732
 AliFMD.cxx:733
 AliFMD.cxx:734
 AliFMD.cxx:735
 AliFMD.cxx:736
 AliFMD.cxx:737
 AliFMD.cxx:738
 AliFMD.cxx:739
 AliFMD.cxx:740
 AliFMD.cxx:741
 AliFMD.cxx:742
 AliFMD.cxx:743
 AliFMD.cxx:744
 AliFMD.cxx:745
 AliFMD.cxx:746
 AliFMD.cxx:747
 AliFMD.cxx:748
 AliFMD.cxx:749
 AliFMD.cxx:750
 AliFMD.cxx:751
 AliFMD.cxx:752
 AliFMD.cxx:753
 AliFMD.cxx:754
 AliFMD.cxx:755
 AliFMD.cxx:756
 AliFMD.cxx:757
 AliFMD.cxx:758
 AliFMD.cxx:759
 AliFMD.cxx:760
 AliFMD.cxx:761
 AliFMD.cxx:762
 AliFMD.cxx:763
 AliFMD.cxx:764
 AliFMD.cxx:765
 AliFMD.cxx:766
 AliFMD.cxx:767
 AliFMD.cxx:768
 AliFMD.cxx:769
 AliFMD.cxx:770
 AliFMD.cxx:771
 AliFMD.cxx:772
 AliFMD.cxx:773
 AliFMD.cxx:774
 AliFMD.cxx:775
 AliFMD.cxx:776
 AliFMD.cxx:777
 AliFMD.cxx:778
 AliFMD.cxx:779
 AliFMD.cxx:780
 AliFMD.cxx:781
 AliFMD.cxx:782
 AliFMD.cxx:783
 AliFMD.cxx:784
 AliFMD.cxx:785
 AliFMD.cxx:786
 AliFMD.cxx:787
 AliFMD.cxx:788
 AliFMD.cxx:789
 AliFMD.cxx:790
 AliFMD.cxx:791
 AliFMD.cxx:792
 AliFMD.cxx:793
 AliFMD.cxx:794
 AliFMD.cxx:795
 AliFMD.cxx:796
 AliFMD.cxx:797
 AliFMD.cxx:798
 AliFMD.cxx:799
 AliFMD.cxx:800
 AliFMD.cxx:801
 AliFMD.cxx:802
 AliFMD.cxx:803
 AliFMD.cxx:804
 AliFMD.cxx:805
 AliFMD.cxx:806
 AliFMD.cxx:807
 AliFMD.cxx:808
 AliFMD.cxx:809
 AliFMD.cxx:810
 AliFMD.cxx:811
 AliFMD.cxx:812
 AliFMD.cxx:813
 AliFMD.cxx:814
 AliFMD.cxx:815
 AliFMD.cxx:816
 AliFMD.cxx:817
 AliFMD.cxx:818
 AliFMD.cxx:819
 AliFMD.cxx:820
 AliFMD.cxx:821
 AliFMD.cxx:822
 AliFMD.cxx:823
 AliFMD.cxx:824
 AliFMD.cxx:825
 AliFMD.cxx:826
 AliFMD.cxx:827
 AliFMD.cxx:828
 AliFMD.cxx:829
 AliFMD.cxx:830
 AliFMD.cxx:831
 AliFMD.cxx:832
 AliFMD.cxx:833
 AliFMD.cxx:834
 AliFMD.cxx:835
 AliFMD.cxx:836
 AliFMD.cxx:837
 AliFMD.cxx:838
 AliFMD.cxx:839
 AliFMD.cxx:840
 AliFMD.cxx:841
 AliFMD.cxx:842
 AliFMD.cxx:843
 AliFMD.cxx:844
 AliFMD.cxx:845
 AliFMD.cxx:846
 AliFMD.cxx:847
 AliFMD.cxx:848
 AliFMD.cxx:849
 AliFMD.cxx:850
 AliFMD.cxx:851
 AliFMD.cxx:852
 AliFMD.cxx:853
 AliFMD.cxx:854
 AliFMD.cxx:855
 AliFMD.cxx:856
 AliFMD.cxx:857
 AliFMD.cxx:858
 AliFMD.cxx:859
 AliFMD.cxx:860
 AliFMD.cxx:861
 AliFMD.cxx:862
 AliFMD.cxx:863
 AliFMD.cxx:864
 AliFMD.cxx:865
 AliFMD.cxx:866
 AliFMD.cxx:867
 AliFMD.cxx:868
 AliFMD.cxx:869
 AliFMD.cxx:870
 AliFMD.cxx:871
 AliFMD.cxx:872
 AliFMD.cxx:873
 AliFMD.cxx:874
 AliFMD.cxx:875
 AliFMD.cxx:876
 AliFMD.cxx:877
 AliFMD.cxx:878
 AliFMD.cxx:879
 AliFMD.cxx:880
 AliFMD.cxx:881
 AliFMD.cxx:882
 AliFMD.cxx:883
 AliFMD.cxx:884
 AliFMD.cxx:885
 AliFMD.cxx:886
 AliFMD.cxx:887
 AliFMD.cxx:888
 AliFMD.cxx:889
 AliFMD.cxx:890
 AliFMD.cxx:891
 AliFMD.cxx:892
 AliFMD.cxx:893
 AliFMD.cxx:894
 AliFMD.cxx:895
 AliFMD.cxx:896
 AliFMD.cxx:897
 AliFMD.cxx:898
 AliFMD.cxx:899
 AliFMD.cxx:900
 AliFMD.cxx:901
 AliFMD.cxx:902
 AliFMD.cxx:903
 AliFMD.cxx:904
 AliFMD.cxx:905
 AliFMD.cxx:906
 AliFMD.cxx:907
 AliFMD.cxx:908
 AliFMD.cxx:909
 AliFMD.cxx:910
 AliFMD.cxx:911
 AliFMD.cxx:912
 AliFMD.cxx:913
 AliFMD.cxx:914
 AliFMD.cxx:915
 AliFMD.cxx:916
 AliFMD.cxx:917
 AliFMD.cxx:918
 AliFMD.cxx:919
 AliFMD.cxx:920
 AliFMD.cxx:921
 AliFMD.cxx:922
 AliFMD.cxx:923
 AliFMD.cxx:924
 AliFMD.cxx:925
 AliFMD.cxx:926
 AliFMD.cxx:927
 AliFMD.cxx:928
 AliFMD.cxx:929
 AliFMD.cxx:930
 AliFMD.cxx:931
 AliFMD.cxx:932
 AliFMD.cxx:933
 AliFMD.cxx:934
 AliFMD.cxx:935
 AliFMD.cxx:936
 AliFMD.cxx:937
 AliFMD.cxx:938
 AliFMD.cxx:939
 AliFMD.cxx:940
 AliFMD.cxx:941
 AliFMD.cxx:942
 AliFMD.cxx:943
 AliFMD.cxx:944
 AliFMD.cxx:945
 AliFMD.cxx:946
 AliFMD.cxx:947
 AliFMD.cxx:948
 AliFMD.cxx:949
 AliFMD.cxx:950
 AliFMD.cxx:951
 AliFMD.cxx:952
 AliFMD.cxx:953
 AliFMD.cxx:954
 AliFMD.cxx:955
 AliFMD.cxx:956
 AliFMD.cxx:957
 AliFMD.cxx:958
 AliFMD.cxx:959
 AliFMD.cxx:960
 AliFMD.cxx:961
 AliFMD.cxx:962
 AliFMD.cxx:963
 AliFMD.cxx:964
 AliFMD.cxx:965
 AliFMD.cxx:966
 AliFMD.cxx:967
 AliFMD.cxx:968
 AliFMD.cxx:969
 AliFMD.cxx:970
 AliFMD.cxx:971
 AliFMD.cxx:972
 AliFMD.cxx:973
 AliFMD.cxx:974
 AliFMD.cxx:975
 AliFMD.cxx:976
 AliFMD.cxx:977
 AliFMD.cxx:978
 AliFMD.cxx:979
 AliFMD.cxx:980
 AliFMD.cxx:981
 AliFMD.cxx:982
 AliFMD.cxx:983
 AliFMD.cxx:984
 AliFMD.cxx:985
 AliFMD.cxx:986
 AliFMD.cxx:987
 AliFMD.cxx:988
 AliFMD.cxx:989
 AliFMD.cxx:990
 AliFMD.cxx:991
 AliFMD.cxx:992
 AliFMD.cxx:993
 AliFMD.cxx:994
 AliFMD.cxx:995
 AliFMD.cxx:996
 AliFMD.cxx:997
 AliFMD.cxx:998
 AliFMD.cxx:999
 AliFMD.cxx:1000
 AliFMD.cxx:1001
 AliFMD.cxx:1002
 AliFMD.cxx:1003
 AliFMD.cxx:1004
 AliFMD.cxx:1005
 AliFMD.cxx:1006
 AliFMD.cxx:1007
 AliFMD.cxx:1008
 AliFMD.cxx:1009
 AliFMD.cxx:1010
 AliFMD.cxx:1011
 AliFMD.cxx:1012
 AliFMD.cxx:1013
 AliFMD.cxx:1014
 AliFMD.cxx:1015
 AliFMD.cxx:1016
 AliFMD.cxx:1017
 AliFMD.cxx:1018
 AliFMD.cxx:1019
 AliFMD.cxx:1020
 AliFMD.cxx:1021
 AliFMD.cxx:1022
 AliFMD.cxx:1023
 AliFMD.cxx:1024
 AliFMD.cxx:1025
 AliFMD.cxx:1026
 AliFMD.cxx:1027
 AliFMD.cxx:1028
 AliFMD.cxx:1029
 AliFMD.cxx:1030
 AliFMD.cxx:1031
 AliFMD.cxx:1032
 AliFMD.cxx:1033
 AliFMD.cxx:1034
 AliFMD.cxx:1035
 AliFMD.cxx:1036
 AliFMD.cxx:1037
 AliFMD.cxx:1038
 AliFMD.cxx:1039
 AliFMD.cxx:1040
 AliFMD.cxx:1041
 AliFMD.cxx:1042
 AliFMD.cxx:1043
 AliFMD.cxx:1044
 AliFMD.cxx:1045
 AliFMD.cxx:1046
 AliFMD.cxx:1047
 AliFMD.cxx:1048
 AliFMD.cxx:1049
 AliFMD.cxx:1050
 AliFMD.cxx:1051
 AliFMD.cxx:1052
 AliFMD.cxx:1053
 AliFMD.cxx:1054
 AliFMD.cxx:1055
 AliFMD.cxx:1056
 AliFMD.cxx:1057
 AliFMD.cxx:1058
 AliFMD.cxx:1059
 AliFMD.cxx:1060
 AliFMD.cxx:1061
 AliFMD.cxx:1062
 AliFMD.cxx:1063
 AliFMD.cxx:1064
 AliFMD.cxx:1065
 AliFMD.cxx:1066
 AliFMD.cxx:1067
 AliFMD.cxx:1068
 AliFMD.cxx:1069
 AliFMD.cxx:1070
 AliFMD.cxx:1071
 AliFMD.cxx:1072
 AliFMD.cxx:1073
 AliFMD.cxx:1074
 AliFMD.cxx:1075
 AliFMD.cxx:1076
 AliFMD.cxx:1077
 AliFMD.cxx:1078
 AliFMD.cxx:1079
 AliFMD.cxx:1080
 AliFMD.cxx:1081
 AliFMD.cxx:1082
 AliFMD.cxx:1083
 AliFMD.cxx:1084
 AliFMD.cxx:1085
 AliFMD.cxx:1086
 AliFMD.cxx:1087
 AliFMD.cxx:1088
 AliFMD.cxx:1089
 AliFMD.cxx:1090
 AliFMD.cxx:1091
 AliFMD.cxx:1092
 AliFMD.cxx:1093
 AliFMD.cxx:1094
 AliFMD.cxx:1095
 AliFMD.cxx:1096
 AliFMD.cxx:1097
 AliFMD.cxx:1098
 AliFMD.cxx:1099
 AliFMD.cxx:1100
 AliFMD.cxx:1101
 AliFMD.cxx:1102
 AliFMD.cxx:1103
 AliFMD.cxx:1104
 AliFMD.cxx:1105
 AliFMD.cxx:1106
 AliFMD.cxx:1107
 AliFMD.cxx:1108