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: AliITSU.cxx $ */


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//      An overview of the basic philosophy of the ITS code development      //
// and analysis is show in the figure below.                                 //
//Begin_Html                                                                 //
/*                                               
<img src="picts/ITS/ITS_Analysis_schema.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>Roberto Barbera is in charge of the ITS Offline code (1999).
<a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
</font>
<pre>
*/
//End_Html
//
//  AliITSU. Inner Traking System base class.
//  This class contains the base procedures for the Inner Tracking System
//
//Begin_Html
/*
<img src="picts/ITS/AliITS_Class_Diagram.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>This show the class diagram of the different elements that are part of
the AliITS class.
</font>
<pre>
*/
//End_Html
//
// Version: 0
// Written by Rene Brun, Federico Carminati, and Roberto Barbera
//
// Version: 1
// Modified and documented by Bjorn S. Nilsen
// July 11 1999
//
// Version: 2
// Modified and documented by A. Bologna
// October 18 1999
//
// AliITSU is the general base class for the ITS. Also see AliDetector for
// futher information.
//
///////////////////////////////////////////////////////////////////////////////

#include <stdlib.h>
#include <TClonesArray.h>
#include <TFile.h>
#include <TParticle.h>
#include <TString.h>
#include <TTree.h>
#include <TVirtualMC.h>
#include <TMath.h>
#include "AliDetector.h"
#include "AliITSU.h"
#include "AliITSLoader.h"
#include "AliITSULoader.h"
#include "AliITSUHit.h"
#include "AliITSUSDigit.h"
#include "AliITSUSimulation.h"
#include "AliITSUSimulationPix.h"
#include "AliITSsimulationFastPoints.h"
#include "AliMC.h"
#include "AliITSUDigitizer.h"
#include "AliITSRecPoint.h"
#include "AliRawReader.h"
#include "AliRun.h"
#include "AliLog.h"
#include "AliITSdigit.h"
#include "AliITSUChip.h"
#include "AliITSUDigitPix.h"
#include "AliITSsegmentation.h"
#include "AliITSUSegmentationPix.h"
#include "AliITSUSimuParam.h"
#include "AliITSFOSignalsSPD.h"
#include "AliITSUParamList.h"
#include "AliCDBManager.h" // tmp! Later the simuparam should be loaded centrally
#include "AliCDBEntry.h"

using namespace TMath;

ClassImp(AliITSU)

//______________________________________________________________________
AliITSU::AliITSU() : 
AliDetector()
  ,fEuclidOut(0)
  ,fNLayers(0)
  ,fIdSens(0)
  ,fLayerName(0)
  ,fTiming(kFALSE)
  ,fGeomTGeo(0)
  ,fSimuParam(0)
  ,fModA(0)
  ,fpSDigits(0)
  ,fSDigits(0)
  ,fDetHits(0)
  ,fChipHits(0)
  ,fDetDigits(0)
  ,fSensMap(0)
  ,fSimModelLr(0)
  ,fSegModelLr(0)
  ,fResponseLr(0)
  ,fCalibration(0)
  ,fRunNumber(0)
  ,fSimInitDone(kFALSE)
{
  // Default initializer for ITS  
}

//______________________________________________________________________
AliITSU::AliITSU(const Char_t *title, Int_t nlay) :
  AliDetector("ITS",title)
  ,fEuclidOut(0)
  ,fNLayers(nlay)
  ,fIdSens(0)
  ,fLayerName(0)
  ,fTiming(kFALSE)
  ,fGeomTGeo(0)
  ,fSimuParam(0)
  ,fModA(0)
  ,fpSDigits(0)
  ,fSDigits(0)
  ,fDetHits(0)
  ,fChipHits(0)
  ,fDetDigits(0)
  ,fSensMap(0)
  ,fSimModelLr(0)
  ,fSegModelLr(0)
  ,fResponseLr(0)
  ,fCalibration(0)
  ,fRunNumber(0)
  ,fSimInitDone(kFALSE)
{
  //     The standard Constructor for the ITS class. 
  AliMC* mc = gAlice->GetMCApp();
  if( mc && mc->GetHitLists() ) {
    fHits = new TClonesArray("AliITSUHit",100); // from AliDetector
    mc->AddHitList(fHits);  
  }
}


//______________________________________________________________________
AliITSU::~AliITSU()
{
  // Default destructor for ITS.
  //  
  delete fHits;
  //  delete fSimuParam; // provided by the CDBManager
  delete fSensMap;
  if (fSimModelLr) {
    for (int i=fNLayers;i--;) { // different layers may use the same simulation model
      for (int j=i;j--;) if (fSimModelLr[j]==fSimModelLr[i]) fSimModelLr[j] = 0;
      delete fSimModelLr[i];
    }
    delete[] fSimModelLr;
  }
  if (fSegModelLr) {
    for (int i=fNLayers;i--;) { // different layers may use the same simulation model     
      for (int j=i;j--;) if (fSegModelLr[j]==fSegModelLr[i]) fSegModelLr[j] = 0;
      delete fSegModelLr[i];
    }
    delete[] fSegModelLr;
  }
  //
  delete[] fResponseLr; // note: the response data is owned by the CDBManager, we don't delete them
  //
  delete[] fLayerName;  // Array of TStrings
  delete[] fIdSens;
  //
  int nmod = fGeomTGeo ? fGeomTGeo->GetNChips() : 0;
  if (fChipHits) fChipHits->Delete();
  delete fChipHits;
  if(fModA){
    for(Int_t j=0; j<nmod; j++){
      fModA[j]->Delete();
      delete fModA[j];
    }
    delete[] fModA;
  }
  if (fpSDigits) { fpSDigits->Delete(); delete fpSDigits; }
  if (fSDigits)  { fSDigits->Delete(); delete fSDigits; }
  delete fGeomTGeo;
  //
}

//______________________________________________________________________
AliDigitizer* AliITSU::CreateDigitizer(AliDigitizationInput* manager) const
{
  // Creates the AliITSDigitizer in a standard way for use via AliChip.
  // This function can not be included in the .h file because of problems
  // with the order of inclusion (recursive).
  // Inputs:
  //    AliDigitizationInput *manager  The Manger class for Digitization
  // Output:
  //    none.
  // Return:
  //    A new AliITSRunDigitizer (cast as a AliDigitizer).
  //
  return new AliITSUDigitizer(manager);
}

//______________________________________________________________________
void AliITSU::Init() 
{
  // Initializer ITS after it has been built
  //     This routine initializes the AliITS class. It is intended to be
  // called from the Init function in AliITSv?. Besides displaying a banner
  // indicating that it has been called it initializes the array fIdSens
  // and sets the default segmentation, response, digit and raw cluster
  // classes therefore it should be called after a call to CreateGeometry.
  //
  if (!fIdSens) fIdSens = new Int_t[fNLayers];
  for(int i=0;i<fNLayers;i++) fIdSens[i] = TVirtualMC::GetMC() ? TVirtualMC::GetMC()->VolId(fLayerName[i]) : 0;
  fGeomTGeo     = new AliITSUGeomTGeo(kTRUE);
  InitSimulation();
  //
}

//______________________________________________________________________
void AliITSU::MakeBranch(Option_t* option)
{
  // Creates Tree branches for the ITS.
  // Inputs:
  //      Option_t *option    String of Tree types S,D, and/or R.
  //      const char *file    String of the file name where these branches
  //                          are to be stored. If blank then these branches
  //                          are written to the same tree as the Hits were
  //                          read from.
  // Outputs:
  //      none.
  // Return:
  //      none.
  
  Bool_t cH = (strstr(option,"H")!=0);
  Bool_t cS = (strstr(option,"S")!=0);
  Bool_t cD = (strstr(option,"D")!=0);
  
  if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
  AliDetector::MakeBranch(option);
  
  if(cS) MakeBranchS(0);
  if(cD) MakeBranchD(0);
  // 
}

//___________________________________________________________________
void AliITSU::MakeBranchS(const char* fl) 
{
  // Creates Tree Branch for the ITS summable digits.
  // Inputs:
  //      cont char *fl  File name where SDigits branch is to be written
  //                     to. If blank it write the SDigits to the same
  //                     file in which the Hits were found.
  //  
  Int_t buffersize = 4000;
  char branchname[31];
  //
  // only one branch for SDigits.
  snprintf(branchname,30,"%s",GetName());
  if(fLoader->TreeS()) MakeBranchInTree(fLoader->TreeS(),branchname,&fSDigits,buffersize,fl);
  //
}

//______________________________________________________________________
void AliITSU::MakeBranchD(const char* file)
{
  //Make branch for digits
  MakeBranchInTreeD(fLoader->TreeD(),file);
}

//___________________________________________________________________
void AliITSU:: MakeBranchInTreeD(TTree* treeD, const char* file)
{
  // Creates Tree branches for the ITS.
  //
  if (!treeD) {AliFatal("No tree provided");}
  Int_t buffersize = 4000;
  if (!fDetDigits) InitArrays();
  //
  for (Int_t i=0;i<kNChipTypes;i++) {
    ResetDigits(i);
    TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
    AliDetector::MakeBranchInTree(treeD,Form("%sDigits%s",GetName(),fGeomTGeo->GetChipTypeName(i)),
				  &darr,buffersize,file);
  }
  //
}

//______________________________________________________________________
void AliITSU::InitArrays()
{
  // initialize arrays
  //
  if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
  //  
  fDetDigits = new TObjArray(kNChipTypes);
  for (Int_t i=0;i<kNChipTypes;i++) fDetDigits->AddAt(new TClonesArray(GetDigitClassName(i),100),i);
  //
  fSDigits = new TClonesArray("AliITSUSDigit",100);
  //
  fDetHits = new TClonesArray("AliITSUHit",100);
  //
  fChipHits = new TObjArray(fGeomTGeo->GetNChips());
  for (int i=0;i<fGeomTGeo->GetNChips();i++) fChipHits->AddLast( new AliITSUChip(i,fGeomTGeo) );
  //
}

//______________________________________________________________________
void AliITSU::SetTreeAddress()
{
  // Set branch address for the Trees.
  TTree *treeS = fLoader->TreeS();
  if (treeS) {
    TBranch* br = treeS->GetBranch(GetName());
    if (br) br->SetAddress(&fSDigits);
  }
  //
  TTree *treeD = fLoader->TreeD();
  if (treeD) {
    if (!fDetDigits) InitArrays();
    for (int i=0;i<kNChipTypes;i++) {
      TString brname = Form("%sDigits%s",GetName(),GetChipTypeName(i));
      TBranch* br = treeD->GetBranch(brname.Data());
      if (!br) continue;
      TClonesArray* darr = (TClonesArray*)fDetDigits->At(i);
      br->SetAddress(&darr);
    }
  }
  if (fLoader->TreeH() && (fHits == 0x0)) fHits = new TClonesArray("AliITSUHit", 1560);
  AliDetector::SetTreeAddress();
  //
}

//______________________________________________________________________
void AliITSU::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{
  // Add an ITS hit
  //     The function to add information to the AliITSUHit class. See the
  // AliITSUHit class for a full description. This function allocates the
  // necessary new space for the hit information and passes the variable
  // track, and the pointers *vol and *hits to the AliITSUHit constructor
  // function.
  // Inputs:
  //      Int_t   track   Track number which produced this hit.
  //      Int_t   *vol    Array of Integer Hit information. See AliITSUHit.h
  //      Float_t *hits   Array of Floating Hit information.  see AliITSUHit.h
  TClonesArray &lhits = *fHits;
  new(lhits[fNhits++]) AliITSUHit(fIshunt,track,vol,hits);
  //
}

//______________________________________________________________________
void AliITSU::FillChips(Int_t bgrev, Option_t *option, const char *filename) 
{
  // fill the chips with the sorted by chip hits; add hits from
  // background if option=Add.
  //
  static TTree *trH1=0;                 //Tree with background hits
  static Bool_t first=kTRUE;
  static TFile *file = 0;
  const char *addBgr = strstr(option,"Add");
  //
  if (addBgr ) {
    if(first) {
      file = new TFile(filename);    
      first=kFALSE;
    }
    file->cd();
    file->ls();
    // Get Hits Tree header from file
    if (trH1) {delete trH1; trH1=0;}
    //
    char treeName[21];
    snprintf(treeName,20,"TreeH%d",bgrev);
    trH1 = (TTree*)gDirectory->Get(treeName);
    if (!trH1) Error("FillChips","cannot find Hits Tree for event:%d",bgrev);
    // Set branch addresses
  } // end if addBgr
  
  FillChips(fLoader->TreeH(),0); // fill from this file's tree.
  //
  if (addBgr ) {
    FillChips(trH1,10000000); // Default mask 10M.
    TTree *fAli=fLoader->GetRunLoader()->TreeK();
    TFile *fileAli=0;
    if (fAli) {
      fileAli = fAli->GetCurrentFile();
      fileAli->cd();
    }
  } // end if add
  //  
}

//______________________________________________________________________
void AliITSU::FillChips(TTree *treeH, Int_t /*mask*/)
{
  // fill the chips with the sorted by chip hits; 
  // can be called many times to do a merging
  // Inputs:
  //      TTree *treeH  The tree containing the hits to be copied into
  //                    the chips.
  //      Int_t mask    The track number mask to indecate which file
  //                    this hits came from.
  //  
  if (treeH == 0x0) { AliError("Tree H  is NULL"); return; }
  //
  Int_t lay,sta,ssta,mod,chip,index;
  AliITSUHit *itsHit=0;
  char branchname[21];
  snprintf(branchname,20,"%s",GetName());
  TBranch *branch = treeH->GetBranch(branchname);
  if (!branch) {Error("FillChips","%s branch in TreeH not found",branchname); return;} // end if !branch
  //
  branch->SetAddress(&fHits);
  Int_t nTracks =(Int_t) treeH->GetEntries();
  Int_t iPrimTrack,h;
  for (iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++) {
    ResetHits();
    Int_t nBytes = treeH->GetEvent(iPrimTrack);
    if (nBytes <= 0) continue;
    Int_t nHits = fHits->GetEntriesFast();
    for (h=0; h<nHits; h++){
      itsHit = (AliITSUHit *)fHits->UncheckedAt(h);
      itsHit->GetChipID(lay,sta,ssta,mod,chip);
      index = fGeomTGeo->GetChipIndex(lay,sta,ssta,mod,chip); // !!! AliITSHit counts indices from 1!
      itsHit = new( (*fDetHits)[fDetHits->GetEntriesFast()] ) AliITSUHit(*itsHit);
      itsHit->SetUniqueID(h);
      GetChip(index)->AddHit(itsHit);
      // do we need to add a mask?
      // itsHit->SetTrack(itsHit->GetTrack()+mask);
    } // end loop over hits 
  } // end loop over tracks
}

//______________________________________________________________________
void AliITSU::ClearChips()
{
  // clear accumulated hits
  if (!fChipHits || !fDetHits) AliFatal("Hits accumulation arrays are not defined");
  for (int i=fGeomTGeo->GetNChips();i--;) GetChip(i)->Clear();
  fDetHits->Clear();
}

//______________________________________________________________________
void AliITSU::Hits2SDigits()
{
  // Standard Hits to summable Digits function.
  if (!IsSimInitDone()) InitSimulation();
  fLoader->LoadHits("read");
  fLoader->LoadSDigits("recreate");
  AliRunLoader* rl = fLoader->GetRunLoader(); 
  //
  for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
    rl->GetEvent(iEvent);
    if (!fLoader->TreeS()) fLoader->MakeTree("S");
    MakeBranch("S");
    SetTreeAddress();
    Hits2SDigits(iEvent,0," "," ");
  } // end for iEvent
    //
  fLoader->UnloadHits();
  fLoader->UnloadSDigits();
  // 
}

//______________________________________________________________________
void AliITSU::Hits2SDigits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
{
  // Keep galice.root for signal and name differently the file for 
  // background when add! otherwise the track info for signal will be lost !
  // Inputs:
  //      Int_t evnt       Event to be processed.
  //      Int_t bgrev      Background Hit tree number.
  //      Int_t nchips   Not used.
  //      Option_t *option String indicating if merging hits or not. To
  //                       merge hits set equal to "Add". Otherwise no
  //                       background hits are considered.
  //      Test_t *filename File name containing the background hits..
  //
  if (!IsSimInitDone()) InitSimulation();
  FillChips(bgrev,option,filename);
  //
  Int_t nchips = fGeomTGeo->GetNChips();
  int prevLr = -1;
  float roPhase=0; // synchronysation type between layers/chips
  Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
  //
  for(int chip=0;chip<nchips;chip++) {
    int lr = fGeomTGeo->GetLayer(chip);
    AliITSUSimulation* sim = GetSimulationModel(lr);
    sim->InitSimulationChip(GetChip(chip),evNumber/*,gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
    //
    if (prevLr!=lr) { // new layer started)
      roPhase = fSimuParam->GetLrROCycleShift(lr);
      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GetReadOutCycleLength(); // chips synchronized within layer with this offset
      else                randomyzeChips = kTRUE;                     // chips have random offset
    }
    if (randomyzeChips) sim->GenerateReadOutCycleOffset();
    else                  sim->SetReadOutCycleOffset(roPhase);
    //
    sim->SDigitiseChip();
    fLoader->TreeS()->Fill();      // fills all branches - wasted disk space
    ResetSDigits();
    prevLr = lr;
  } 
  //
  ClearChips();
  //
  fLoader->TreeS()->GetEntries();
  fLoader->TreeS()->AutoSave();
  fLoader->WriteSDigits("OVERWRITE");
  fLoader->TreeS()->Reset();
}

//______________________________________________________________________
void AliITSU::Hits2Digits()
{
  // Standard Hits to Digits function.
  if (!IsSimInitDone()) InitSimulation();
  fLoader->LoadHits("read");
  fLoader->LoadDigits("recreate");
  AliRunLoader* rl = fLoader->GetRunLoader(); 
  //
  for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
    rl->GetEvent(iEvent);
    if (!fLoader->TreeD()) fLoader->MakeTree("D");
    MakeBranch("D");
    SetTreeAddress();
    Hits2Digits(iEvent,0," "," ");
  } // end for iEvent
    //
  fLoader->UnloadHits();
  fLoader->UnloadSDigits();
  // 
}

//______________________________________________________________________
void AliITSU::Hits2Digits(Int_t evNumber,Int_t bgrev,Option_t *option,const char *filename)
{
  //   Keep galice.root for signal and name differently the file for 
  // background when add! otherwise the track info for signal will be lost !
  // Inputs:
  //      Int_t evnt       Event to be processed.
  //      Int_t bgrev      Background Hit tree number.
  //      Option_t *option String indicating if merging hits or not. To
  //                       merge hits set equal to "Add". Otherwise no
  //                       background hits are considered.
  //      Test_t *filename File name containing the background hits..
  // Outputs:
  //  
  if (!IsSimInitDone()) InitSimulation();
  FillChips(bgrev,option,filename);
  // 
  Int_t nchips = fGeomTGeo->GetNChips();
  int prevLr = -1;
  float roPhase=0; // synchronysation type between layers/chips
  Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
  //
  for (Int_t chip=0;chip<nchips;chip++) {
    int lr = fGeomTGeo->GetLayer(chip);
    AliITSUSimulation* sim = GetSimulationModel(lr);
    //
    sim->InitSimulationChip(GetChip(chip),evNumber/*gAlice->GetEvNumber()*/,GetSegmentation(lr),GetResponseParam(lr));
    if (prevLr!=lr) { // new layer started)
      roPhase = fSimuParam->GetLrROCycleShift(lr);
      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // chips synchronized within layer with this offset
      else                randomyzeChips = kTRUE;                     // chips have random offset
    }
    if (randomyzeChips) sim->GenerateReadOutCycleOffset();
    else                  sim->SetReadOutCycleOffset(roPhase);
    sim->DigitiseChip();
    // fills all branches - wasted disk space
    fLoader->TreeD()->Fill(); 
    ResetDigits();
    prevLr = lr;
  } // end for chip
  //
  ClearChips();
  //
  //    WriteFOSignals(); // Add Fast-OR signals to event (only one object per event)
  fLoader->TreeD()->GetEntries();
  fLoader->TreeD()->AutoSave();
  fLoader->TreeD()->Reset(); 
  //
}

//_____________________________________________________________________
void AliITSU::Hits2FastRecPoints(Int_t bgrev,Option_t *opt,const char *flnm)
{
  // keep galice.root for signal and name differently the file for 
  // background when add! otherwise the track info for signal will be lost !
  // Inputs:
  //      Int_t evnt       Event to be processed.
  //      Int_t bgrev      Background Hit tree number.
  //      Option_t *opt    Option passed to FillChips. See FillChips.
  //      Test_t *flnm     File name containing the background hits..
  // Outputs:
  //      none.
  // Return:
  //      none.
  if (!IsSimInitDone()) InitSimulation();
  AliITSULoader *pITSloader = (AliITSULoader*)fLoader;
  Int_t nchips = fGeomTGeo->GetNChips();
  FillChips(bgrev,opt,flnm);
  //
  TTree *lTR = pITSloader->TreeR();
  if(!lTR) {
    pITSloader->MakeTree("R");
    lTR = pITSloader->TreeR();
  }
  //
  TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
  TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
  branch->SetAddress(&ptarray);
  for (int chip=0;chip<nchips;chip++){
    int id = fGeomTGeo->GetChipChipTypeID(chip);
    AliITSUSimulation* sim = GetSimulationModel(id);
    if (!sim) AliFatal(Form("The sim.class for chip %d of ChipTypeID %d is missing",chip,id));
    sim->CreateFastRecPoints( GetChip(chip) ,chip,gRandom,ptarray);
    lTR->Fill();
    ptarray->Clear();
  } // end for chip
  //
  ClearChips();
  fLoader->WriteRecPoints("OVERWRITE");
  delete ptarray;
}

//_____________________________________________________________________
Int_t AliITSU::Hits2Clusters(TTree */*hTree*/, TTree */*cTree*/)
{
  /* RS: TODO
  // This function creates ITS clusters
  if (!IsSimInitDone()) InitSimulation();
  Int_t mmax = 0;
  FillChips(hTree,0);
  //
  TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
  TBranch *branch=cTree->GetBranch("ITSRecPoints");
  if (!branch) cTree->Branch("ITSRecPoints",&points);
  else branch->SetAddress(&points);
  //
  AliITSsimulationFastPoints sim;
  Int_t ncl=0;
  for (Int_t m=0; m<mmax; m++) {
    sim.CreateFastRecPoints(GetChip(m),m,gRandom,points);      
    ncl+=points->GetEntriesFast();
    cTree->Fill();
    points->Clear();
  }
  //
  ClearChips();
  //
  AliDebug(1,Form("Number of found fast clusters : %d",ncl));
  //cTree->Write();
  delete points;
  */
  return 0;
}

//_____________________________________________________________________
void AliITSU::CheckLabels(Int_t lab[3]) const //RSDONE
{
  // Tries to find mother's labels
  //
  if(lab[0]<0 && lab[1]<0 && lab[2]<0) return; // In case of no labels just exit
  //
  Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
  for (Int_t i=0;i<3;i++){
    Int_t label = lab[i];
    if (label>=0 && label<ntracks) {
      TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
      if (part->P() < 0.005) {
	Int_t m=part->GetFirstMother();
	if (m<0) continue;
	if (part->GetStatusCode()>0) continue;
	lab[i]=m;       
      }
    }    
  }
  //
}

//______________________________________________________________________
void AliITSU::ResetDigits() //RSDONE?
{
  // Reset number of digits and the digits array for the ITS detector.
  if (fDetDigits) for (int i=kNChipTypes;i--;) ResetDigits(i);
  //
}

//______________________________________________________________________
void AliITSU::ResetDigits(Int_t branch)
{
  // Reset number of digits and the digits array for this branch.
  if (fDetDigits) ((TClonesArray*)fDetDigits->At(branch))->Clear();
  //
}

//______________________________________________________________________
void AliITSU::AddSumDigit(AliITSUSDigit &sdig)
{
  // Adds the chip summable digits to the summable digits tree.
  new( (*fSDigits)[fSDigits->GetEntriesFast()]) AliITSUSDigit(sdig);
  //  
}

//______________________________________________________________________
void AliITSU::AddSimDigit(Int_t branch, AliITSdigit *d)
{
  //    Add a simulated digit.
  // Inputs:
  //      Int_t id        Detector type number.
  //      AliITSdigit *d  Digit to be added to the Digits Tree. See 
  //                      AliITSdigit.h
  TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
  int nd = ldigits.GetEntriesFast();
  switch(branch){
  case AliITSUGeomTGeo::kChipTypePix:
    new(ldigits[nd]) AliITSUDigitPix(*((AliITSUDigitPix*)d));
    break;
  default:
    AliFatal(Form("Unknown digits branch %d",branch));
  }
}

//______________________________________________________________________
void AliITSU::AddSimDigit(Int_t branch,Float_t /*phys*/,Int_t *digits,Int_t *tracks,
			  Int_t *hits,Float_t */*charges*/, Int_t /*sigexpanded*/)
{
  // Add a simulated digit to the list.
  // Inputs:
  //      Int_t id        Detector type number.
  //      Float_t phys    Physics indicator. See AliITSdigits.h
  //      Int_t *digits   Integer array containing the digits info. See 
  //                      AliITSdigit.h
  //      Int_t *tracks   Integer array [AliITSdigitS?D::GetNTracks()] 
  //                      containing the track numbers that contributed to
  //                      this digit.
  //      Int_t *hits     Integer array [AliITSdigitS?D::GetNTracks()]
  //                      containing the hit numbers, from AliITSchip, that
  //                      contributed to this digit.
  //      Float_t *charge Floating point array of the signals contributed
  //                      to this digit by each track.
  TClonesArray &ldigits = *((TClonesArray*)fDetDigits->At(branch));
  int nd = ldigits.GetEntriesFast();
  switch(branch){
  case AliITSUGeomTGeo::kChipTypePix:
    new(ldigits[nd]) AliITSUDigitPix(digits,tracks,hits);
    break;
  default:
    AliFatal(Form("Unknown digits branch %d",branch));
  }  
  //
}

//______________________________________________________________________
void AliITSU::Digits2Raw()
{
  AliError("Not ready");
}

//______________________________________________________________________
AliLoader* AliITSU::MakeLoader(const char* topfoldername)
{ 
  //builds ITSgetter (AliLoader type)
  //if detector wants to use castomized getter, it must overload this method
  
  AliDebug(1,Form("Creating AliITSULoader. Top folder is %s.",topfoldername));
  fLoader = new AliITSULoader(GetName(),topfoldername);
  return fLoader;
}

//______________________________________________________________________
Bool_t AliITSU::Raw2SDigits(AliRawReader* /*rawReader*/)
{
  AliError("Not ready");
  return kFALSE;
}

//______________________________________________________________________
/*
AliTriggerDetector* AliITSU::CreateTriggerDetector() const 
{
  // create an AliITSTrigger object (and set trigger conditions as input)
  return new AliITSTrigger(fChipTypeSim->GetTriggerConditions());
}
*/

//______________________________________________________________________
void AliITSU::WriteFOSignals()
{
  // This method write FO signals in Digits tree both in Hits2Digits
  // or SDigits2Digits
  AliError("Not ready");
  //  fChipTypeSim->ProcessNoiseForFastOr();
}

//_______________________________________________________________________
void AliITSU::SDigits2Digits()
{
  // Standard Summable digits to Digits function.
  //
  if (!IsSimInitDone()) InitSimulation();
  TTree* trees = fLoader->TreeS();
  if( !(trees && fSDigits) ) AliFatal("Error: No trees or SDigits.");
  TBranch* brchSDigits = trees->GetBranch(GetName());
  //
  int nchips = fGeomTGeo->GetNChips();
  int prevLr = -1;
  float roPhase=0; // synchronysation type between layers/chips
  Bool_t randomyzeChips = kFALSE; // do we need to randomize layers
  //
  for (int chip=0;chip<nchips;chip++) {
    int lr = fGeomTGeo->GetLayer(chip);
    AliITSUSimulation* sim = GetSimulationModel(lr);
    sim->InitSimulationChip(GetChip(chip),gAlice->GetEvNumber(),GetSegmentation(lr),GetResponseParam(lr));
    //
    if (prevLr!=lr) { // new layer started)
      roPhase = fSimuParam->GetLrROCycleShift(lr);
      if (Abs(roPhase)<1.) roPhase = roPhase*sim->GenerateReadOutCycleOffset(); // chips synchronized within layer with this offset
      else                randomyzeChips = kTRUE;                     // chips have random offset
    }
    if (randomyzeChips) sim->GenerateReadOutCycleOffset();
    else                  sim->SetReadOutCycleOffset(roPhase);
    //
    fSDigits->Clear();
    brchSDigits->GetEvent(chip);
    sim->AddSDigitsToChip(fSDigits,0);
    sim->FinishSDigitiseChip();
    fLoader->TreeD()->Fill();
    ResetDigits();
    prevLr = lr;
  }
  //  WriteFOSignals(); 
  fLoader->TreeD()->GetEntries();
  fLoader->TreeD()->AutoSave();
  fLoader->TreeD()->Reset();
}

//_______________________________________________________________________
void AliITSU::InitSimulation()
{
  // Initialize arrays, segmentations ets, needed for simulation
  // Equivalent of old AliITSChipTypeSim construction
  //
  if (fSimInitDone) {AliInfo("Already done"); return;}
  //
  AliCDBEntry* cdbEnt = AliCDBManager::Instance()->Get("ITS/Calib/SimuParam"); // tmp: load it centrally
  if (!cdbEnt) {AliFatal("Failed to find ITS/Calib/SimuParam on CDB"); exit(1);}
  fSimuParam    = (AliITSUSimuParam*)cdbEnt->GetObject();
  //
  fSensMap      = new AliITSUSensMap("AliITSUSDigit",0,0);
  fSimModelLr   = new AliITSUSimulation*[fNLayers];
  fSegModelLr   = new AliITSsegmentation*[fNLayers];
  fResponseLr   = new AliITSUParamList*[fNLayers];
  //
  TObjArray arrSeg;
  AliITSUSegmentationPix::LoadSegmentations(&arrSeg, AliITSUGeomTGeo::GetITSsegmentationFileName());
  //
  // add known simulation types used in the setup
  for (int i=fNLayers;i--;) {
    fSimModelLr[i] = 0;
    fSegModelLr[i] = 0;
    fResponseLr[i] = 0;
    int dType = fGeomTGeo->GetLayerChipTypeID(i);           // fine detector type: class + segmentation
    int sType = dType/AliITSUGeomTGeo::kMaxSegmPerChipType; // detector simulation class
    //
    // check if the simulation of this sType was already created for preceeding layers
    AliITSUSimulation* simUpg = 0;
    for (int j=fNLayers-1;j>i;j--) {
      simUpg = GetSimulationModel(j);
      if (simUpg && int(simUpg->GetUniqueID())==sType) break;
      else simUpg = 0;
    }
    //
    if (!simUpg) { // need to create simulation for detector class sType
      switch (sType) 
	{
	case AliITSUGeomTGeo::kChipTypePix : 
	  simUpg = new AliITSUSimulationPix(fSimuParam,fSensMap); 
	  break;
	default: AliFatal(Form("No %d detector type is defined",sType));
	}
    }
    fSimModelLr[i] = simUpg;
    //
    // add segmentations used in the setup
    if (!(fSegModelLr[i]=(AliITSsegmentation*)arrSeg[dType])) {AliFatal(Form("Segmentation for ChipType#%d is not found",dType)); exit(1);}
    //
    // add response function for the detectors of this layer
    if ( !(fResponseLr[i]=(AliITSUParamList*)fSimuParam->FindRespFunParams(dType)) ) {AliFatal(Form("Response for ChipType#%d is not found in SimuParams",dType)); exit(1);}
  }
  // delete non needed segmentations
  for (int i=fNLayers;i--;) arrSeg.Remove(fSegModelLr[i]);
  arrSeg.Delete();
  //
  InitArrays();
  //
  fSimInitDone = kTRUE;
  //
}
 AliITSU.cxx:1
 AliITSU.cxx:2
 AliITSU.cxx:3
 AliITSU.cxx:4
 AliITSU.cxx:5
 AliITSU.cxx:6
 AliITSU.cxx:7
 AliITSU.cxx:8
 AliITSU.cxx:9
 AliITSU.cxx:10
 AliITSU.cxx:11
 AliITSU.cxx:12
 AliITSU.cxx:13
 AliITSU.cxx:14
 AliITSU.cxx:15
 AliITSU.cxx:16
 AliITSU.cxx:17
 AliITSU.cxx:18
 AliITSU.cxx:19
 AliITSU.cxx:20
 AliITSU.cxx:21
 AliITSU.cxx:22
 AliITSU.cxx:23
 AliITSU.cxx:24
 AliITSU.cxx:25
 AliITSU.cxx:26
 AliITSU.cxx:27
 AliITSU.cxx:28
 AliITSU.cxx:29
 AliITSU.cxx:30
 AliITSU.cxx:31
 AliITSU.cxx:32
 AliITSU.cxx:33
 AliITSU.cxx:34
 AliITSU.cxx:35
 AliITSU.cxx:36
 AliITSU.cxx:37
 AliITSU.cxx:38
 AliITSU.cxx:39
 AliITSU.cxx:40
 AliITSU.cxx:41
 AliITSU.cxx:42
 AliITSU.cxx:43
 AliITSU.cxx:44
 AliITSU.cxx:45
 AliITSU.cxx:46
 AliITSU.cxx:47
 AliITSU.cxx:48
 AliITSU.cxx:49
 AliITSU.cxx:50
 AliITSU.cxx:51
 AliITSU.cxx:52
 AliITSU.cxx:53
 AliITSU.cxx:54
 AliITSU.cxx:55
 AliITSU.cxx:56
 AliITSU.cxx:57
 AliITSU.cxx:58
 AliITSU.cxx:59
 AliITSU.cxx:60
 AliITSU.cxx:61
 AliITSU.cxx:62
 AliITSU.cxx:63
 AliITSU.cxx:64
 AliITSU.cxx:65
 AliITSU.cxx:66
 AliITSU.cxx:67
 AliITSU.cxx:68
 AliITSU.cxx:69
 AliITSU.cxx:70
 AliITSU.cxx:71
 AliITSU.cxx:72
 AliITSU.cxx:73
 AliITSU.cxx:74
 AliITSU.cxx:75
 AliITSU.cxx:76
 AliITSU.cxx:77
 AliITSU.cxx:78
 AliITSU.cxx:79
 AliITSU.cxx:80
 AliITSU.cxx:81
 AliITSU.cxx:82
 AliITSU.cxx:83
 AliITSU.cxx:84
 AliITSU.cxx:85
 AliITSU.cxx:86
 AliITSU.cxx:87
 AliITSU.cxx:88
 AliITSU.cxx:89
 AliITSU.cxx:90
 AliITSU.cxx:91
 AliITSU.cxx:92
 AliITSU.cxx:93
 AliITSU.cxx:94
 AliITSU.cxx:95
 AliITSU.cxx:96
 AliITSU.cxx:97
 AliITSU.cxx:98
 AliITSU.cxx:99
 AliITSU.cxx:100
 AliITSU.cxx:101
 AliITSU.cxx:102
 AliITSU.cxx:103
 AliITSU.cxx:104
 AliITSU.cxx:105
 AliITSU.cxx:106
 AliITSU.cxx:107
 AliITSU.cxx:108
 AliITSU.cxx:109
 AliITSU.cxx:110
 AliITSU.cxx:111
 AliITSU.cxx:112
 AliITSU.cxx:113
 AliITSU.cxx:114
 AliITSU.cxx:115
 AliITSU.cxx:116
 AliITSU.cxx:117
 AliITSU.cxx:118
 AliITSU.cxx:119
 AliITSU.cxx:120
 AliITSU.cxx:121
 AliITSU.cxx:122
 AliITSU.cxx:123
 AliITSU.cxx:124
 AliITSU.cxx:125
 AliITSU.cxx:126
 AliITSU.cxx:127
 AliITSU.cxx:128
 AliITSU.cxx:129
 AliITSU.cxx:130
 AliITSU.cxx:131
 AliITSU.cxx:132
 AliITSU.cxx:133
 AliITSU.cxx:134
 AliITSU.cxx:135
 AliITSU.cxx:136
 AliITSU.cxx:137
 AliITSU.cxx:138
 AliITSU.cxx:139
 AliITSU.cxx:140
 AliITSU.cxx:141
 AliITSU.cxx:142
 AliITSU.cxx:143
 AliITSU.cxx:144
 AliITSU.cxx:145
 AliITSU.cxx:146
 AliITSU.cxx:147
 AliITSU.cxx:148
 AliITSU.cxx:149
 AliITSU.cxx:150
 AliITSU.cxx:151
 AliITSU.cxx:152
 AliITSU.cxx:153
 AliITSU.cxx:154
 AliITSU.cxx:155
 AliITSU.cxx:156
 AliITSU.cxx:157
 AliITSU.cxx:158
 AliITSU.cxx:159
 AliITSU.cxx:160
 AliITSU.cxx:161
 AliITSU.cxx:162
 AliITSU.cxx:163
 AliITSU.cxx:164
 AliITSU.cxx:165
 AliITSU.cxx:166
 AliITSU.cxx:167
 AliITSU.cxx:168
 AliITSU.cxx:169
 AliITSU.cxx:170
 AliITSU.cxx:171
 AliITSU.cxx:172
 AliITSU.cxx:173
 AliITSU.cxx:174
 AliITSU.cxx:175
 AliITSU.cxx:176
 AliITSU.cxx:177
 AliITSU.cxx:178
 AliITSU.cxx:179
 AliITSU.cxx:180
 AliITSU.cxx:181
 AliITSU.cxx:182
 AliITSU.cxx:183
 AliITSU.cxx:184
 AliITSU.cxx:185
 AliITSU.cxx:186
 AliITSU.cxx:187
 AliITSU.cxx:188
 AliITSU.cxx:189
 AliITSU.cxx:190
 AliITSU.cxx:191
 AliITSU.cxx:192
 AliITSU.cxx:193
 AliITSU.cxx:194
 AliITSU.cxx:195
 AliITSU.cxx:196
 AliITSU.cxx:197
 AliITSU.cxx:198
 AliITSU.cxx:199
 AliITSU.cxx:200
 AliITSU.cxx:201
 AliITSU.cxx:202
 AliITSU.cxx:203
 AliITSU.cxx:204
 AliITSU.cxx:205
 AliITSU.cxx:206
 AliITSU.cxx:207
 AliITSU.cxx:208
 AliITSU.cxx:209
 AliITSU.cxx:210
 AliITSU.cxx:211
 AliITSU.cxx:212
 AliITSU.cxx:213
 AliITSU.cxx:214
 AliITSU.cxx:215
 AliITSU.cxx:216
 AliITSU.cxx:217
 AliITSU.cxx:218
 AliITSU.cxx:219
 AliITSU.cxx:220
 AliITSU.cxx:221
 AliITSU.cxx:222
 AliITSU.cxx:223
 AliITSU.cxx:224
 AliITSU.cxx:225
 AliITSU.cxx:226
 AliITSU.cxx:227
 AliITSU.cxx:228
 AliITSU.cxx:229
 AliITSU.cxx:230
 AliITSU.cxx:231
 AliITSU.cxx:232
 AliITSU.cxx:233
 AliITSU.cxx:234
 AliITSU.cxx:235
 AliITSU.cxx:236
 AliITSU.cxx:237
 AliITSU.cxx:238
 AliITSU.cxx:239
 AliITSU.cxx:240
 AliITSU.cxx:241
 AliITSU.cxx:242
 AliITSU.cxx:243
 AliITSU.cxx:244
 AliITSU.cxx:245
 AliITSU.cxx:246
 AliITSU.cxx:247
 AliITSU.cxx:248
 AliITSU.cxx:249
 AliITSU.cxx:250
 AliITSU.cxx:251
 AliITSU.cxx:252
 AliITSU.cxx:253
 AliITSU.cxx:254
 AliITSU.cxx:255
 AliITSU.cxx:256
 AliITSU.cxx:257
 AliITSU.cxx:258
 AliITSU.cxx:259
 AliITSU.cxx:260
 AliITSU.cxx:261
 AliITSU.cxx:262
 AliITSU.cxx:263
 AliITSU.cxx:264
 AliITSU.cxx:265
 AliITSU.cxx:266
 AliITSU.cxx:267
 AliITSU.cxx:268
 AliITSU.cxx:269
 AliITSU.cxx:270
 AliITSU.cxx:271
 AliITSU.cxx:272
 AliITSU.cxx:273
 AliITSU.cxx:274
 AliITSU.cxx:275
 AliITSU.cxx:276
 AliITSU.cxx:277
 AliITSU.cxx:278
 AliITSU.cxx:279
 AliITSU.cxx:280
 AliITSU.cxx:281
 AliITSU.cxx:282
 AliITSU.cxx:283
 AliITSU.cxx:284
 AliITSU.cxx:285
 AliITSU.cxx:286
 AliITSU.cxx:287
 AliITSU.cxx:288
 AliITSU.cxx:289
 AliITSU.cxx:290
 AliITSU.cxx:291
 AliITSU.cxx:292
 AliITSU.cxx:293
 AliITSU.cxx:294
 AliITSU.cxx:295
 AliITSU.cxx:296
 AliITSU.cxx:297
 AliITSU.cxx:298
 AliITSU.cxx:299
 AliITSU.cxx:300
 AliITSU.cxx:301
 AliITSU.cxx:302
 AliITSU.cxx:303
 AliITSU.cxx:304
 AliITSU.cxx:305
 AliITSU.cxx:306
 AliITSU.cxx:307
 AliITSU.cxx:308
 AliITSU.cxx:309
 AliITSU.cxx:310
 AliITSU.cxx:311
 AliITSU.cxx:312
 AliITSU.cxx:313
 AliITSU.cxx:314
 AliITSU.cxx:315
 AliITSU.cxx:316
 AliITSU.cxx:317
 AliITSU.cxx:318
 AliITSU.cxx:319
 AliITSU.cxx:320
 AliITSU.cxx:321
 AliITSU.cxx:322
 AliITSU.cxx:323
 AliITSU.cxx:324
 AliITSU.cxx:325
 AliITSU.cxx:326
 AliITSU.cxx:327
 AliITSU.cxx:328
 AliITSU.cxx:329
 AliITSU.cxx:330
 AliITSU.cxx:331
 AliITSU.cxx:332
 AliITSU.cxx:333
 AliITSU.cxx:334
 AliITSU.cxx:335
 AliITSU.cxx:336
 AliITSU.cxx:337
 AliITSU.cxx:338
 AliITSU.cxx:339
 AliITSU.cxx:340
 AliITSU.cxx:341
 AliITSU.cxx:342
 AliITSU.cxx:343
 AliITSU.cxx:344
 AliITSU.cxx:345
 AliITSU.cxx:346
 AliITSU.cxx:347
 AliITSU.cxx:348
 AliITSU.cxx:349
 AliITSU.cxx:350
 AliITSU.cxx:351
 AliITSU.cxx:352
 AliITSU.cxx:353
 AliITSU.cxx:354
 AliITSU.cxx:355
 AliITSU.cxx:356
 AliITSU.cxx:357
 AliITSU.cxx:358
 AliITSU.cxx:359
 AliITSU.cxx:360
 AliITSU.cxx:361
 AliITSU.cxx:362
 AliITSU.cxx:363
 AliITSU.cxx:364
 AliITSU.cxx:365
 AliITSU.cxx:366
 AliITSU.cxx:367
 AliITSU.cxx:368
 AliITSU.cxx:369
 AliITSU.cxx:370
 AliITSU.cxx:371
 AliITSU.cxx:372
 AliITSU.cxx:373
 AliITSU.cxx:374
 AliITSU.cxx:375
 AliITSU.cxx:376
 AliITSU.cxx:377
 AliITSU.cxx:378
 AliITSU.cxx:379
 AliITSU.cxx:380
 AliITSU.cxx:381
 AliITSU.cxx:382
 AliITSU.cxx:383
 AliITSU.cxx:384
 AliITSU.cxx:385
 AliITSU.cxx:386
 AliITSU.cxx:387
 AliITSU.cxx:388
 AliITSU.cxx:389
 AliITSU.cxx:390
 AliITSU.cxx:391
 AliITSU.cxx:392
 AliITSU.cxx:393
 AliITSU.cxx:394
 AliITSU.cxx:395
 AliITSU.cxx:396
 AliITSU.cxx:397
 AliITSU.cxx:398
 AliITSU.cxx:399
 AliITSU.cxx:400
 AliITSU.cxx:401
 AliITSU.cxx:402
 AliITSU.cxx:403
 AliITSU.cxx:404
 AliITSU.cxx:405
 AliITSU.cxx:406
 AliITSU.cxx:407
 AliITSU.cxx:408
 AliITSU.cxx:409
 AliITSU.cxx:410
 AliITSU.cxx:411
 AliITSU.cxx:412
 AliITSU.cxx:413
 AliITSU.cxx:414
 AliITSU.cxx:415
 AliITSU.cxx:416
 AliITSU.cxx:417
 AliITSU.cxx:418
 AliITSU.cxx:419
 AliITSU.cxx:420
 AliITSU.cxx:421
 AliITSU.cxx:422
 AliITSU.cxx:423
 AliITSU.cxx:424
 AliITSU.cxx:425
 AliITSU.cxx:426
 AliITSU.cxx:427
 AliITSU.cxx:428
 AliITSU.cxx:429
 AliITSU.cxx:430
 AliITSU.cxx:431
 AliITSU.cxx:432
 AliITSU.cxx:433
 AliITSU.cxx:434
 AliITSU.cxx:435
 AliITSU.cxx:436
 AliITSU.cxx:437
 AliITSU.cxx:438
 AliITSU.cxx:439
 AliITSU.cxx:440
 AliITSU.cxx:441
 AliITSU.cxx:442
 AliITSU.cxx:443
 AliITSU.cxx:444
 AliITSU.cxx:445
 AliITSU.cxx:446
 AliITSU.cxx:447
 AliITSU.cxx:448
 AliITSU.cxx:449
 AliITSU.cxx:450
 AliITSU.cxx:451
 AliITSU.cxx:452
 AliITSU.cxx:453
 AliITSU.cxx:454
 AliITSU.cxx:455
 AliITSU.cxx:456
 AliITSU.cxx:457
 AliITSU.cxx:458
 AliITSU.cxx:459
 AliITSU.cxx:460
 AliITSU.cxx:461
 AliITSU.cxx:462
 AliITSU.cxx:463
 AliITSU.cxx:464
 AliITSU.cxx:465
 AliITSU.cxx:466
 AliITSU.cxx:467
 AliITSU.cxx:468
 AliITSU.cxx:469
 AliITSU.cxx:470
 AliITSU.cxx:471
 AliITSU.cxx:472
 AliITSU.cxx:473
 AliITSU.cxx:474
 AliITSU.cxx:475
 AliITSU.cxx:476
 AliITSU.cxx:477
 AliITSU.cxx:478
 AliITSU.cxx:479
 AliITSU.cxx:480
 AliITSU.cxx:481
 AliITSU.cxx:482
 AliITSU.cxx:483
 AliITSU.cxx:484
 AliITSU.cxx:485
 AliITSU.cxx:486
 AliITSU.cxx:487
 AliITSU.cxx:488
 AliITSU.cxx:489
 AliITSU.cxx:490
 AliITSU.cxx:491
 AliITSU.cxx:492
 AliITSU.cxx:493
 AliITSU.cxx:494
 AliITSU.cxx:495
 AliITSU.cxx:496
 AliITSU.cxx:497
 AliITSU.cxx:498
 AliITSU.cxx:499
 AliITSU.cxx:500
 AliITSU.cxx:501
 AliITSU.cxx:502
 AliITSU.cxx:503
 AliITSU.cxx:504
 AliITSU.cxx:505
 AliITSU.cxx:506
 AliITSU.cxx:507
 AliITSU.cxx:508
 AliITSU.cxx:509
 AliITSU.cxx:510
 AliITSU.cxx:511
 AliITSU.cxx:512
 AliITSU.cxx:513
 AliITSU.cxx:514
 AliITSU.cxx:515
 AliITSU.cxx:516
 AliITSU.cxx:517
 AliITSU.cxx:518
 AliITSU.cxx:519
 AliITSU.cxx:520
 AliITSU.cxx:521
 AliITSU.cxx:522
 AliITSU.cxx:523
 AliITSU.cxx:524
 AliITSU.cxx:525
 AliITSU.cxx:526
 AliITSU.cxx:527
 AliITSU.cxx:528
 AliITSU.cxx:529
 AliITSU.cxx:530
 AliITSU.cxx:531
 AliITSU.cxx:532
 AliITSU.cxx:533
 AliITSU.cxx:534
 AliITSU.cxx:535
 AliITSU.cxx:536
 AliITSU.cxx:537
 AliITSU.cxx:538
 AliITSU.cxx:539
 AliITSU.cxx:540
 AliITSU.cxx:541
 AliITSU.cxx:542
 AliITSU.cxx:543
 AliITSU.cxx:544
 AliITSU.cxx:545
 AliITSU.cxx:546
 AliITSU.cxx:547
 AliITSU.cxx:548
 AliITSU.cxx:549
 AliITSU.cxx:550
 AliITSU.cxx:551
 AliITSU.cxx:552
 AliITSU.cxx:553
 AliITSU.cxx:554
 AliITSU.cxx:555
 AliITSU.cxx:556
 AliITSU.cxx:557
 AliITSU.cxx:558
 AliITSU.cxx:559
 AliITSU.cxx:560
 AliITSU.cxx:561
 AliITSU.cxx:562
 AliITSU.cxx:563
 AliITSU.cxx:564
 AliITSU.cxx:565
 AliITSU.cxx:566
 AliITSU.cxx:567
 AliITSU.cxx:568
 AliITSU.cxx:569
 AliITSU.cxx:570
 AliITSU.cxx:571
 AliITSU.cxx:572
 AliITSU.cxx:573
 AliITSU.cxx:574
 AliITSU.cxx:575
 AliITSU.cxx:576
 AliITSU.cxx:577
 AliITSU.cxx:578
 AliITSU.cxx:579
 AliITSU.cxx:580
 AliITSU.cxx:581
 AliITSU.cxx:582
 AliITSU.cxx:583
 AliITSU.cxx:584
 AliITSU.cxx:585
 AliITSU.cxx:586
 AliITSU.cxx:587
 AliITSU.cxx:588
 AliITSU.cxx:589
 AliITSU.cxx:590
 AliITSU.cxx:591
 AliITSU.cxx:592
 AliITSU.cxx:593
 AliITSU.cxx:594
 AliITSU.cxx:595
 AliITSU.cxx:596
 AliITSU.cxx:597
 AliITSU.cxx:598
 AliITSU.cxx:599
 AliITSU.cxx:600
 AliITSU.cxx:601
 AliITSU.cxx:602
 AliITSU.cxx:603
 AliITSU.cxx:604
 AliITSU.cxx:605
 AliITSU.cxx:606
 AliITSU.cxx:607
 AliITSU.cxx:608
 AliITSU.cxx:609
 AliITSU.cxx:610
 AliITSU.cxx:611
 AliITSU.cxx:612
 AliITSU.cxx:613
 AliITSU.cxx:614
 AliITSU.cxx:615
 AliITSU.cxx:616
 AliITSU.cxx:617
 AliITSU.cxx:618
 AliITSU.cxx:619
 AliITSU.cxx:620
 AliITSU.cxx:621
 AliITSU.cxx:622
 AliITSU.cxx:623
 AliITSU.cxx:624
 AliITSU.cxx:625
 AliITSU.cxx:626
 AliITSU.cxx:627
 AliITSU.cxx:628
 AliITSU.cxx:629
 AliITSU.cxx:630
 AliITSU.cxx:631
 AliITSU.cxx:632
 AliITSU.cxx:633
 AliITSU.cxx:634
 AliITSU.cxx:635
 AliITSU.cxx:636
 AliITSU.cxx:637
 AliITSU.cxx:638
 AliITSU.cxx:639
 AliITSU.cxx:640
 AliITSU.cxx:641
 AliITSU.cxx:642
 AliITSU.cxx:643
 AliITSU.cxx:644
 AliITSU.cxx:645
 AliITSU.cxx:646
 AliITSU.cxx:647
 AliITSU.cxx:648
 AliITSU.cxx:649
 AliITSU.cxx:650
 AliITSU.cxx:651
 AliITSU.cxx:652
 AliITSU.cxx:653
 AliITSU.cxx:654
 AliITSU.cxx:655
 AliITSU.cxx:656
 AliITSU.cxx:657
 AliITSU.cxx:658
 AliITSU.cxx:659
 AliITSU.cxx:660
 AliITSU.cxx:661
 AliITSU.cxx:662
 AliITSU.cxx:663
 AliITSU.cxx:664
 AliITSU.cxx:665
 AliITSU.cxx:666
 AliITSU.cxx:667
 AliITSU.cxx:668
 AliITSU.cxx:669
 AliITSU.cxx:670
 AliITSU.cxx:671
 AliITSU.cxx:672
 AliITSU.cxx:673
 AliITSU.cxx:674
 AliITSU.cxx:675
 AliITSU.cxx:676
 AliITSU.cxx:677
 AliITSU.cxx:678
 AliITSU.cxx:679
 AliITSU.cxx:680
 AliITSU.cxx:681
 AliITSU.cxx:682
 AliITSU.cxx:683
 AliITSU.cxx:684
 AliITSU.cxx:685
 AliITSU.cxx:686
 AliITSU.cxx:687
 AliITSU.cxx:688
 AliITSU.cxx:689
 AliITSU.cxx:690
 AliITSU.cxx:691
 AliITSU.cxx:692
 AliITSU.cxx:693
 AliITSU.cxx:694
 AliITSU.cxx:695
 AliITSU.cxx:696
 AliITSU.cxx:697
 AliITSU.cxx:698
 AliITSU.cxx:699
 AliITSU.cxx:700
 AliITSU.cxx:701
 AliITSU.cxx:702
 AliITSU.cxx:703
 AliITSU.cxx:704
 AliITSU.cxx:705
 AliITSU.cxx:706
 AliITSU.cxx:707
 AliITSU.cxx:708
 AliITSU.cxx:709
 AliITSU.cxx:710
 AliITSU.cxx:711
 AliITSU.cxx:712
 AliITSU.cxx:713
 AliITSU.cxx:714
 AliITSU.cxx:715
 AliITSU.cxx:716
 AliITSU.cxx:717
 AliITSU.cxx:718
 AliITSU.cxx:719
 AliITSU.cxx:720
 AliITSU.cxx:721
 AliITSU.cxx:722
 AliITSU.cxx:723
 AliITSU.cxx:724
 AliITSU.cxx:725
 AliITSU.cxx:726
 AliITSU.cxx:727
 AliITSU.cxx:728
 AliITSU.cxx:729
 AliITSU.cxx:730
 AliITSU.cxx:731
 AliITSU.cxx:732
 AliITSU.cxx:733
 AliITSU.cxx:734
 AliITSU.cxx:735
 AliITSU.cxx:736
 AliITSU.cxx:737
 AliITSU.cxx:738
 AliITSU.cxx:739
 AliITSU.cxx:740
 AliITSU.cxx:741
 AliITSU.cxx:742
 AliITSU.cxx:743
 AliITSU.cxx:744
 AliITSU.cxx:745
 AliITSU.cxx:746
 AliITSU.cxx:747
 AliITSU.cxx:748
 AliITSU.cxx:749
 AliITSU.cxx:750
 AliITSU.cxx:751
 AliITSU.cxx:752
 AliITSU.cxx:753
 AliITSU.cxx:754
 AliITSU.cxx:755
 AliITSU.cxx:756
 AliITSU.cxx:757
 AliITSU.cxx:758
 AliITSU.cxx:759
 AliITSU.cxx:760
 AliITSU.cxx:761
 AliITSU.cxx:762
 AliITSU.cxx:763
 AliITSU.cxx:764
 AliITSU.cxx:765
 AliITSU.cxx:766
 AliITSU.cxx:767
 AliITSU.cxx:768
 AliITSU.cxx:769
 AliITSU.cxx:770
 AliITSU.cxx:771
 AliITSU.cxx:772
 AliITSU.cxx:773
 AliITSU.cxx:774
 AliITSU.cxx:775
 AliITSU.cxx:776
 AliITSU.cxx:777
 AliITSU.cxx:778
 AliITSU.cxx:779
 AliITSU.cxx:780
 AliITSU.cxx:781
 AliITSU.cxx:782
 AliITSU.cxx:783
 AliITSU.cxx:784
 AliITSU.cxx:785
 AliITSU.cxx:786
 AliITSU.cxx:787
 AliITSU.cxx:788
 AliITSU.cxx:789
 AliITSU.cxx:790
 AliITSU.cxx:791
 AliITSU.cxx:792
 AliITSU.cxx:793
 AliITSU.cxx:794
 AliITSU.cxx:795
 AliITSU.cxx:796
 AliITSU.cxx:797
 AliITSU.cxx:798
 AliITSU.cxx:799
 AliITSU.cxx:800
 AliITSU.cxx:801
 AliITSU.cxx:802
 AliITSU.cxx:803
 AliITSU.cxx:804
 AliITSU.cxx:805
 AliITSU.cxx:806
 AliITSU.cxx:807
 AliITSU.cxx:808
 AliITSU.cxx:809
 AliITSU.cxx:810
 AliITSU.cxx:811
 AliITSU.cxx:812
 AliITSU.cxx:813
 AliITSU.cxx:814
 AliITSU.cxx:815
 AliITSU.cxx:816
 AliITSU.cxx:817
 AliITSU.cxx:818
 AliITSU.cxx:819
 AliITSU.cxx:820
 AliITSU.cxx:821
 AliITSU.cxx:822
 AliITSU.cxx:823
 AliITSU.cxx:824
 AliITSU.cxx:825
 AliITSU.cxx:826
 AliITSU.cxx:827
 AliITSU.cxx:828
 AliITSU.cxx:829
 AliITSU.cxx:830
 AliITSU.cxx:831
 AliITSU.cxx:832
 AliITSU.cxx:833
 AliITSU.cxx:834
 AliITSU.cxx:835
 AliITSU.cxx:836
 AliITSU.cxx:837
 AliITSU.cxx:838
 AliITSU.cxx:839
 AliITSU.cxx:840
 AliITSU.cxx:841
 AliITSU.cxx:842
 AliITSU.cxx:843
 AliITSU.cxx:844
 AliITSU.cxx:845
 AliITSU.cxx:846
 AliITSU.cxx:847
 AliITSU.cxx:848
 AliITSU.cxx:849
 AliITSU.cxx:850
 AliITSU.cxx:851
 AliITSU.cxx:852
 AliITSU.cxx:853
 AliITSU.cxx:854
 AliITSU.cxx:855
 AliITSU.cxx:856
 AliITSU.cxx:857
 AliITSU.cxx:858
 AliITSU.cxx:859
 AliITSU.cxx:860
 AliITSU.cxx:861
 AliITSU.cxx:862
 AliITSU.cxx:863
 AliITSU.cxx:864
 AliITSU.cxx:865
 AliITSU.cxx:866
 AliITSU.cxx:867
 AliITSU.cxx:868
 AliITSU.cxx:869
 AliITSU.cxx:870
 AliITSU.cxx:871
 AliITSU.cxx:872
 AliITSU.cxx:873
 AliITSU.cxx:874
 AliITSU.cxx:875
 AliITSU.cxx:876
 AliITSU.cxx:877
 AliITSU.cxx:878
 AliITSU.cxx:879
 AliITSU.cxx:880
 AliITSU.cxx:881
 AliITSU.cxx:882
 AliITSU.cxx:883
 AliITSU.cxx:884
 AliITSU.cxx:885
 AliITSU.cxx:886
 AliITSU.cxx:887
 AliITSU.cxx:888
 AliITSU.cxx:889
 AliITSU.cxx:890
 AliITSU.cxx:891
 AliITSU.cxx:892
 AliITSU.cxx:893
 AliITSU.cxx:894
 AliITSU.cxx:895
 AliITSU.cxx:896
 AliITSU.cxx:897
 AliITSU.cxx:898
 AliITSU.cxx:899
 AliITSU.cxx:900
 AliITSU.cxx:901
 AliITSU.cxx:902
 AliITSU.cxx:903
 AliITSU.cxx:904
 AliITSU.cxx:905
 AliITSU.cxx:906
 AliITSU.cxx:907
 AliITSU.cxx:908
 AliITSU.cxx:909
 AliITSU.cxx:910
 AliITSU.cxx:911
 AliITSU.cxx:912
 AliITSU.cxx:913
 AliITSU.cxx:914
 AliITSU.cxx:915
 AliITSU.cxx:916
 AliITSU.cxx:917
 AliITSU.cxx:918
 AliITSU.cxx:919
 AliITSU.cxx:920
 AliITSU.cxx:921
 AliITSU.cxx:922
 AliITSU.cxx:923
 AliITSU.cxx:924
 AliITSU.cxx:925
 AliITSU.cxx:926
 AliITSU.cxx:927
 AliITSU.cxx:928
 AliITSU.cxx:929