ROOT logo
/**************************************************************************
 * Copyright(c) 2007-2009, 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$ */

///////////////////////////////////////////////////////////////////////////////
///
/// This class provides ITS SSD data handling
/// used by DA. 
//  Author: Oleksandr Borysov
//  Date: 18/07/2008
///////////////////////////////////////////////////////////////////////////////

#include <cstring>
#include <fstream>
#include <new>
#include <Riostream.h> 
#include "AliITSHandleDaSSD.h"
//#include <math.h>
#include <limits.h>
#include "event.h"
#include "TFile.h"
#include "TString.h"
#include "TMath.h"
#include "AliLog.h"
#include "AliITSNoiseSSDv2.h"
#include "AliITSPedestalSSDv2.h"
#include "AliITSBadChannelsSSDv2.h"
#include "AliITSRawStreamSSD.h"
#include "AliRawReaderDate.h"
#include "AliITSRawStreamSSD.h"
#include "AliITSChannelDaSSD.h"


ClassImp(AliITSHandleDaSSD)

using namespace std;


const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698;       // Number of SSD modules in ITS
const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108;  // Number of SSD modules in DDL
const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12;  // Number of SSD modules in Slot
const Short_t  AliITSHandleDaSSD::fgkMinSSDModuleId = 500;            // Initial SSD modules number
const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDSlotsPerDDL = 9;      // Number of SSD slots per DDL
const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDDDLs = 16;            // Number of SSD modules in Slot
const Float_t  AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0;   // Defalt value for fPedestalThresholdFactor 
const Float_t  AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0;         // Defalt value for fCmThresholdFactor

const UInt_t   AliITSHandleDaSSD::fgkZsBitMask      = 0x0000003F;     // Bit mask for FEROM ZS
const UInt_t   AliITSHandleDaSSD::fgkOffSetBitMask  = 0x000003FF;     // Bit mask for FEROM Offset correction
const UInt_t   AliITSHandleDaSSD::fgkBadChannelMask = 0x00000001;     // Mask to suppress the channel from the bad channel list
const Int_t    AliITSHandleDaSSD::fgkAdcPerDBlock   = 6;              // FEROM configuration file constant

//______________________________________________________________________________
AliITSHandleDaSSD::AliITSHandleDaSSD() :
  fRawDataFileName(NULL),
  fNumberOfModules(0),
  fModules(NULL),
  fModIndProcessed(0),
  fModIndRead(0),
  fModIndex(NULL),
  fEqIndex(0),
  fNumberOfEvents(0),
  fBadChannelsList(NULL),
  fDDLModuleMap(NULL),
  fALaddersOff(0),
  fCLaddersOff(0),
  fLdcId(0),
  fRunId(0),
  fPedestalThresholdFactor(fgkPedestalThresholdFactor),
  fCmThresholdFactor(fgkCmThresholdFactor),
  fZsDefault(-1),
  fOffsetDefault(INT_MAX),
  fZsMinimum(2),
  fMergeBCLists(1),
  fZsFactor(3.0)
{
// Default constructor
}


//______________________________________________________________________________
AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
  fRawDataFileName(NULL),
  fNumberOfModules(0),
  fModules(NULL),
  fModIndProcessed(0),
  fModIndRead(0),
  fModIndex(NULL),
  fEqIndex(0),
  fNumberOfEvents(0),
  fBadChannelsList(NULL),
  fDDLModuleMap(NULL),
  fALaddersOff(0),
  fCLaddersOff(0),
  fLdcId(0),
  fRunId(0),
  fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
  fCmThresholdFactor(fgkCmThresholdFactor),
  fZsDefault(-1),
  fOffsetDefault(INT_MAX),
  fZsMinimum(2),
  fMergeBCLists(1),
  fZsFactor(3.0)
{
  if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
}


//______________________________________________________________________________
AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
  TObject(ssdadldc),
  fRawDataFileName(NULL),
  fNumberOfModules(ssdadldc.fNumberOfModules),
  fModules(NULL),
  fModIndProcessed(ssdadldc.fModIndProcessed),
  fModIndRead(ssdadldc.fModIndRead),
  fModIndex(NULL),
  fEqIndex(ssdadldc.fEqIndex),
  fNumberOfEvents(ssdadldc.fNumberOfEvents),
  fBadChannelsList(NULL),
  fDDLModuleMap(NULL),
  fALaddersOff(ssdadldc.fALaddersOff),
  fCLaddersOff(ssdadldc.fCLaddersOff),
  fLdcId(ssdadldc.fLdcId),
  fRunId(ssdadldc.fRunId),
  fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
  fCmThresholdFactor(ssdadldc.fCmThresholdFactor),
  fZsDefault(ssdadldc.fZsDefault),
  fOffsetDefault(ssdadldc.fOffsetDefault),
  fZsMinimum(ssdadldc.fZsMinimum),
  fMergeBCLists(ssdadldc.fMergeBCLists),
  fZsFactor(ssdadldc.fZsFactor)
{
  // copy constructor
  if (ssdadldc.fRawDataFileName) {
    fRawDataFileName = new (nothrow) Char_t[strlen(ssdadldc.fRawDataFileName)+1];
    if (fRawDataFileName) strncpy(fRawDataFileName, ssdadldc.fRawDataFileName, strlen(ssdadldc.fRawDataFileName)+1);
  } else fRawDataFileName = NULL;
  if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
    fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
    if (fModules) {
      for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
        if (ssdadldc.fModules[modind]) {
	  fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
	  if (!fModules[modind]) { 
	    AliError("AliITSHandleDaSSD: Error copy constructor");
            for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
	    delete [] fModules;
	    fModules = NULL;
	    break;
	  }
	} else fModules[modind] = NULL; 
      }	  
    } else {
      AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
      fNumberOfModules = 0;
      fModules = NULL;
    }
  }
  if (ssdadldc.fModIndex) {
    fModIndex = new (nothrow) Int_t [ssdadldc.fNumberOfModules];
    if (fModIndex) memcpy(fModIndex, ssdadldc.fModIndex, ssdadldc.fNumberOfModules*sizeof(Int_t));
  } else fModIndex = NULL;
  fBadChannelsList = new AliITSBadChannelsSSDv2(*ssdadldc.fBadChannelsList);
  if (ssdadldc.fDDLModuleMap) {
    fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl];
    if (fDDLModuleMap) memcpy(fDDLModuleMap, ssdadldc.fDDLModuleMap, fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl * sizeof(Int_t)); 
  } else fDDLModuleMap = NULL;

  //  if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by copy constructor, use other methods to init it!");
  //  if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by copy constructor, use other methods to init it!");
}

//______________________________________________________________________________
AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
{
// assignment operator
  if (this == &ssdadldc)  return *this;
  TObject::operator=(ssdadldc);
  if (fModules) {
    for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
    delete [] fModules; 
    fModules = NULL;
  }
  if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
  fNumberOfModules = ssdadldc.fNumberOfModules;
  if ((fNumberOfModules > 0) && (ssdadldc.fModules)) {
    fModules = new (nothrow) AliITSModuleDaSSD* [fNumberOfModules];
    if (fModules) {
      for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
        if (ssdadldc.fModules[modind]) {
	      fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
          if (!fModules[modind]) { 
	        AliError("AliITSHandleDaSSD: Error assignment operator");
            for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
            delete [] fModules;
            fModules = NULL;
            break;
          }
        } else fModules[modind] = NULL; 
      }	  
    } else {
      AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
      fNumberOfModules = 0;
      fModules = NULL;
    }
  }
  if(fRawDataFileName)delete[]fRawDataFileName;
  if (ssdadldc.fRawDataFileName) {
    fRawDataFileName = new (nothrow) Char_t[strlen(ssdadldc.fRawDataFileName)+1];
    if (fRawDataFileName) strncpy(fRawDataFileName, ssdadldc.fRawDataFileName, strlen(ssdadldc.fRawDataFileName)+1);
  } else fRawDataFileName = NULL;
  fModIndProcessed = ssdadldc.fModIndProcessed;
  fModIndRead = ssdadldc.fModIndRead;

  if (ssdadldc.fModIndex) {
    fModIndex = new (nothrow) Int_t [ssdadldc.fNumberOfModules];
    if (fModIndex) memcpy(fModIndex, ssdadldc.fModIndex, ssdadldc.fNumberOfModules*sizeof(Int_t));
  } else fModIndex = NULL;

  fEqIndex = ssdadldc.fEqIndex;
  fNumberOfEvents = ssdadldc.fNumberOfEvents;
  fLdcId = ssdadldc.fLdcId;
  fRunId = ssdadldc.fRunId;
  fPedestalThresholdFactor = ssdadldc.fPedestalThresholdFactor;
  fCmThresholdFactor = ssdadldc.fCmThresholdFactor;
  fZsDefault = ssdadldc.fZsDefault;
  fOffsetDefault = ssdadldc.fOffsetDefault;
  fZsMinimum = ssdadldc.fZsMinimum;
  fMergeBCLists = ssdadldc.fMergeBCLists;
  fZsFactor = ssdadldc.fZsFactor;
  fALaddersOff = ssdadldc.fALaddersOff;
  fCLaddersOff = ssdadldc.fCLaddersOff;
  if (fBadChannelsList) delete fBadChannelsList;
  fBadChannelsList = new AliITSBadChannelsSSDv2(*ssdadldc.fBadChannelsList);
  if (fDDLModuleMap) delete [] fDDLModuleMap; 
  if (ssdadldc.fDDLModuleMap) {
    fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl];
    if (fDDLModuleMap) memcpy(fDDLModuleMap, ssdadldc.fDDLModuleMap, fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl * sizeof(Int_t)); 
  } else fDDLModuleMap = NULL;

  //  if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by assignment operator, use other methods to init it!");
  //  if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by assignment operator, use other methods to init it!");
  return *this;
}


//______________________________________________________________________________
AliITSHandleDaSSD::~AliITSHandleDaSSD()
{
// Default destructor 
  delete []fRawDataFileName;
  if (fModules) 
  {
    for (Int_t i = 0; i < fNumberOfModules; i++)
    { 
      if (fModules[i]) delete fModules[i];
    }
    delete [] fModules;
  }
  if (fModIndex) delete [] fModIndex;
  if (fBadChannelsList)  delete fBadChannelsList;
  if (fDDLModuleMap) delete [] fDDLModuleMap;
}



//______________________________________________________________________________
void AliITSHandleDaSSD::Reset()
{
// Delete array of AliITSModuleDaSSD* objects. 
  if (fModules) {
    for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
    delete [] fModules;
    fModules = NULL;
  }
  if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
/*
  if (fBadChannelsList) {
    delete fBadChannelsList;
    fBadChannelsList = NULL; 
  }    
  if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL; }
*/
  fALaddersOff.Set(0);
  fCLaddersOff.Set(0);
  if(fRawDataFileName){
    delete []fRawDataFileName;
    fRawDataFileName = NULL;
  }
  fModIndProcessed = fModIndRead = 0;
  fNumberOfEvents = 0;
  fLdcId = fRunId = 0;
  fPedestalThresholdFactor = fgkPedestalThresholdFactor;
  fCmThresholdFactor = fgkCmThresholdFactor;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname)
{
// Read raw data file and set initial and configuration parameters
  Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
  Int_t  nofeqipmentev, nofeqipment = 0, eqn = 0; 
  AliRawReaderDate  *rawreaderdate = NULL;
  UChar_t *data = NULL;
  Long_t datasize = 0, eqbelsize = 1;

  rawreaderdate = new AliRawReaderDate(rdfname, 0);
  if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
    AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
    MakeZombie();
    return kFALSE;
  }
  if (rawreaderdate->NextEvent()) {
    fRunId = rawreaderdate->GetRunNumber(); 
    rawreaderdate->RewindEvents();
  } else { MakeZombie(); return kFALSE; }
  if (fModules) Reset();
  //rawreaderdate->SelectEvents(-1);
  rawreaderdate->Select("ITSSSD");  
  nofstrips = 0;
  while (rawreaderdate->NextEvent()) {
    if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
    nofstripsev = 0;
    nofeqipmentev = 0;
    while (rawreaderdate->ReadNextData(data)) {
      fLdcId = rawreaderdate->GetLDCId();
      nofeqipmentev += 1;
      datasize = rawreaderdate->GetDataSize();
      eqbelsize = rawreaderdate->GetEquipmentElementSize();
      if ( datasize % eqbelsize ) {
        AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %ld is not an integer of equipment data size %ld", 
	                            rdfname, datasize, eqbelsize));
        MakeZombie();
	    return kFALSE;
      }
      nofstripsev += (Int_t) (datasize / eqbelsize);
    }
    if (physeventind++) {
      if (nofstrips != nofstripsev) AliWarning(Form("AliITSHandleDaSSD: number of strips varies from event to event, ev = %ld, %ld", 
                                                     physeventind, nofstripsev));
      if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to event");
    }
    nofstrips = nofstripsev;
    nofeqipment = nofeqipmentev;
    if (strn < nofstrips)  strn = nofstrips;
    if (eqn < nofeqipment) eqn = nofeqipment;
  }
  delete rawreaderdate;
  if ((physeventind > 0) && (strn > 0))
  {
    fNumberOfEvents = physeventind;
    if(rdfname){
      delete []fRawDataFileName;
      fRawDataFileName = new Char_t[strlen(rdfname)+1];
      strncpy(fRawDataFileName,rdfname,strlen(rdfname)+1);
    }
    fEqIndex.Set(eqn);
    fEqIndex.Reset(-1);
    fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
    if (fModIndex) 
      for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1; 
    else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created", 
                                     rdfname, fgkNumberOfSSDModulesPerDdl * eqn));
    if (SetNumberOfModules(fgkNumberOfSSDModulesPerDdl * eqn)) {
      TString str = TString::Format("Max number of equipment: %d, max number of channels: %ld\n", eqn, strn);
      DumpInitData(str.Data());
      return kTRUE;
    }  
  }
  MakeZombie();
  return kFALSE;
}



//______________________________________________________________________________
AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
{
// Retrieve AliITSModuleDaSSD object from the array
   if (!fModules) return NULL;
   for (Int_t i = 0; i < fNumberOfModules; i++) {
     if (fModules[i]) {
       if (    (fModules[i]->GetDdlId() == ddlID)
            && (fModules[i]->GetAD() == ad)
            && (fModules[i]->GetADC() == adc))
	    return fModules[i];
     }	    
   }
   return NULL;
}


Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
{
// Retrieve the position of AliITSModuleDaSSD object in the array
   if (!fModules) return -1;
   for (Int_t i = 0; i < fNumberOfModules; i++) {
     if (fModules[i]) {
       if (    (fModules[i]->GetDdlId() == ddlID)
            && (fModules[i]->GetAD() == ad)
            && (fModules[i]->GetADC() == adc))
	    return i;
     }	    
   }
   return -1;
}



//______________________________________________________________________________
AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
{
// Retrieve AliITSChannalDaSSD object from the array
  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
    if (    (fModules[modind]->GetDdlId() == ddlID)
         && (fModules[modind]->GetAD() == ad)
         && (fModules[modind]->GetADC() == adc)  ) 
        {
       return fModules[modind]->GetStrip(stripID);
    }
  }
  AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
                ddlID, ad, adc, stripID));
  return NULL;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
{ 
// Assign array element with AliITSModuleDaSSD object
   if ((index < fNumberOfModules) && (index >= 0)) 
     { 
        if (fModules[index]) delete fModules[index];
	fModules[index] = module;
	return kTRUE;
      }
   else return kFALSE;   		       
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
{
// Allocates memory for AliITSModuleDaSSD objects
  if (numberofmodules > fgkNumberOfSSDModules)
    AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD", 
                     numberofmodules, fgkNumberOfSSDModules));
  if (fModules) {
    for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
    delete [] fModules; 
    fModules = NULL;
  }
  fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
  if (fModules) {
    fNumberOfModules = numberofmodules;
    memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
    return kTRUE;
  } else {
     AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
     fNumberOfModules = 0;
     fModules = NULL;
  }
  return kFALSE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename)
{
// Reads Static Bad Channels Map from the file
  TFile *bcfile;
  if (!filename) {
    AliWarning("No file name is specified for Static Bad Channels Map!");
    return kFALSE;
  } 
  bcfile = new TFile(filename, "READ");
  if (bcfile->IsZombie()) {
    AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename));
    return kFALSE;
  }
  bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList);
  if (!fBadChannelsList) {
    AliWarning("Error fBadChannelsList == NULL!");
    bcfile->Close();
    delete bcfile;
    return kFALSE;
  }
  bcfile->Close();
  delete bcfile;
  return kTRUE;
}



Bool_t AliITSHandleDaSSD::ReadDDLModuleMap(const Char_t *filename)
{
// Reads the SSD DDL Map from the file
  ifstream             ddlmfile;
  AliRawReaderDate    *rwr = NULL;
  AliITSRawStreamSSD  *rsm = NULL;
  void                *event = NULL;
  if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
  fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl];
  if (!fDDLModuleMap) {
    AliWarning("Error allocation memory for DDL Map!");
    return kFALSE;
  }    
  if (!filename) {
    AliWarning("No file name is specified for SSD DDL Map, using the one from AliITSRawStreamSSD!");
    rwr = new AliRawReaderDate(event);
    rsm = new AliITSRawStreamSSD(rwr);
    rsm->Setv11HybridDDLMapping();
    for (Int_t ddli = 0; ddli < fgkNumberOfSSDDDLs; ddli++)
      for (Int_t mi = 0; mi < fgkNumberOfSSDModulesPerDdl; mi++)
        fDDLModuleMap[(ddli * fgkNumberOfSSDModulesPerDdl + mi)] = rsm->GetModuleNumber(ddli, mi);
    if (rsm) delete rsm;
    if (rwr) delete rwr;	
    return kTRUE;
  } 
  ddlmfile.open(filename, ios::in);
  if (!ddlmfile.is_open()) {
    AliWarning(Form("Error reading file %s with SSD DDL Map!", filename));
    if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
    return kFALSE;
  }
  Int_t ind = 0;
  while((!ddlmfile.eof()) && (ind < (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))) {
    ddlmfile >> fDDLModuleMap[ind++];
    if (ddlmfile.fail()) AliError(Form("Error extracting number from the DDL map file %s, ind: %d ", filename, ind));
  }
  if (ind != (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))
    AliWarning(Form("Only %i (< %i) entries were read from DDL Map!", ind, (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl)));
  ddlmfile.close();
  return kTRUE;
}



//______________________________________________________________________________
Int_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
{
// Reads raw data from file
  if (!Init(fileName)){
    AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
    return kFALSE;
  }
  fNumberOfEvents = eventsnumber;
  return ReadModuleRawData (fNumberOfModules);  
}



//______________________________________________________________________________
Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
{
// Reads raw data from file
  AliRawReader        *rawreaderdate = NULL;
  AliITSRawStreamSSD  *stream = NULL;
  AliITSModuleDaSSD   *module;
  AliITSChannelDaSSD  *strip;
  Long_t            eventind = 0;
  Int_t             nofeqipment, eqind;
  Short_t           equipid, prequipid;
  Short_t           modind;
  if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
  if (!fModules) {
    AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
    return 0;
  }
  if (!fDDLModuleMap) if (!ReadDDLModuleMap()) AliWarning("DDL map is not defined, ModuleID will be set to 0!");
  stream = new AliITSRawStreamSSD(rawreaderdate);
  stream->Setv11HybridDDLMapping();
  //rawreaderdate->SelectEvents(-1);
  rawreaderdate->Select("ITSSSD");  
  modind = 0;
  nofeqipment = 0;
  while (rawreaderdate->NextEvent()) {
    if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
    prequipid = -1;
    eqind = -1;
    while (stream->Next()) {
      equipid = rawreaderdate->GetEquipmentId(); 
      if ((equipid != prequipid)) {
        if ((eqind = GetEqIndex(equipid)) < 0) { fEqIndex.AddAt(equipid, nofeqipment); eqind = nofeqipment++; }
        prequipid = equipid;
      }
      Int_t     equiptype  = rawreaderdate->GetEquipmentType();
      UChar_t   ddlID      = (UChar_t)rawreaderdate->GetDDLID();
      UChar_t   ad      = stream->GetAD();
      UChar_t   adc     = stream->GetADC();
      UShort_t  stripID = stream->GetSideFlag() ? AliITSChannelDaSSD::GetMaxStripIdConst() - stream->GetStrip() : stream->GetStrip();
      Short_t   signal  = stream->GetSignal();

      Int_t indpos = (eqind * fgkNumberOfSSDModulesPerDdl)
                   + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
      Int_t modpos = fModIndex[indpos];
      if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
      if ((modpos < 0) && (modind < modulesnumber)) {
        module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
        Int_t mddli;
        if (fDDLModuleMap) mddli = RetrieveModuleId(ddlID, ad, adc);
        else  mddli = 0;
        if (!module->SetModuleIdData (ddlID, ad, adc, mddli)) return 0;
        module->SetModuleRorcId (equipid, equiptype);
        modpos = fModIndRead + modind;
        modind += 1;
        fModules[modpos] = module;
        fModIndex[indpos] = modpos;
      } 
      if (stripID < AliITSModuleDaSSD::GetStripsPerModuleConst()) {
        if (!(strip = fModules[modpos]->GetStrip(stripID))) {
          strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
          fModules[modpos]->SetStrip(strip, stripID);
        }
        strip->SetSignal(eventind, signal);
	  } else  {
        if (!(fModules[modpos]->GetCMFerom())) {
          fModules[modpos]->AllocateCMFeromArray();
          fModules[modpos]->SetCMFeromEventsNumber(fNumberOfEvents);
		}
	    fModules[modpos]->SetCMFerom(signal, (stripID - AliITSModuleDaSSD::GetStripsPerModuleConst()), eventind);
	  }
    }
    if (++eventind > fNumberOfEvents) break;
  }
  delete stream;
  delete rawreaderdate;
  if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
  fModIndRead += modind;
  if (modind < modulesnumber) RelocateModules();
  return modind;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::RelocateModules()
{
// Relocate memory for AliITSModuleDaSSD object array
  Int_t         nm = 0;
  AliITSModuleDaSSD **marray = NULL;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++)
    if (fModules[modind]) nm += 1;
  if (nm == fNumberOfModules) return kTRUE;
  marray = new (nothrow) AliITSModuleDaSSD* [nm];
  if (!marray) {
    AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
    return kFALSE;
  }
  nm = 0;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++)  
    if (fModules[modind]) marray[nm++] = fModules[modind];
  delete [] fModules;
  fModules = marray;
  fNumberOfModules = fModIndRead = nm;
  return kTRUE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::AddFeromCm(const AliITSModuleDaSSD *const module)
{
// Restore the original signal value adding CM calculated and subtracted in ferom
  AliITSChannelDaSSD *strip;
  Short_t            *signal, *cmferom;

  if (!module) return kFALSE;
  if (!module->GetCMFerom()) return kTRUE;
  for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
    if (!(cmferom = module->GetCMFerom(chipind))) {
      AliWarning(Form("AliITSHandleDaSSD: There is no Ferom CM values for chip %i, module %i!", chipind, module->GetModuleId()));
      continue;
    }
    for (Int_t strind = (chipind * AliITSModuleDaSSD::GetStripsPerChip()); 
               strind < ((chipind + 1) * AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
      if (!(strip = module->GetStrip(strind))) continue;
      if (!(signal = strip->GetSignal())) continue;
//      if (strip->GetEventsNumber() != module->GetEventsNumber()) return kFALSE;
      Long_t ovev = 0;
      for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
        if (SignalOutOfRange(signal[ev]) || SignalOutOfRange(cmferom[ev])) ovev += 1;
        else {
          Short_t signal1 = signal[ev] + cmferom[ev];
          strip->SetSignal(ev, signal1);
	    }  
      }	
    } 
  }  
  return kTRUE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculatePedestal(const AliITSModuleDaSSD *const module)
{
// Calculates Pedestal
  AliITSChannelDaSSD *strip;
  Double_t            pedestal, noise;
  Short_t            *signal;
  Long_t              ovev, ev, n;
  if (!module) return kFALSE;
  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
    if (!(strip = module->GetStrip(strind))) continue;
    if (!(signal = strip->GetSignal())) {
      AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
                     module->GetModuleId(), strind));
      continue;	
    }
//************* pedestal first pass ****************
    pedestal = 0.0L;
    ovev = 0l;
    for (ev = 0; ev < strip->GetEventsNumber(); ev++)
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1) : signal[ev];
    if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetPedestal(static_cast<Float_t>(pedestal));	
//************* noise *******************************
    Double_t nsum = 0.0L;
    ovev = 0l;
    for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
    } 
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  TMath::Sqrt(nsum / (Double_t)(n));
    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetNoise(static_cast<Float_t>(noise));
//************* pedestal second pass ****************
    pedestal = 0.0L;
    ovev = 0l;
    for (ev = 0; ev < strip->GetEventsNumber(); ev++)
      if (   SignalOutOfRange(signal[ev]) 
          || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
      else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1) : signal[ev];
    if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetPedestal(static_cast<Float_t>(pedestal));	
    strip->SetOverflowNumber(ovev);	
  }
  return kTRUE;
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculateNoise(const AliITSModuleDaSSD *const module)
{
// Calculates Noise
  AliITSChannelDaSSD *strip;
  Short_t    *signal;
  Float_t     noise;
  Long_t      ovev, n;
  if (!module) return kFALSE;
  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
    if (!(strip = module->GetStrip(strind))) continue;
    if (!(signal = strip->GetSignal())) {
      strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
      AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
                     module->GetModuleId(), strind));
      continue;
    }
    Double_t nsum = 0.0L;
    ovev = 0l;
    for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
    } 
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  static_cast<Float_t>(TMath::Sqrt(nsum / (Float_t)(n)));
    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetNoise(noise);
  }
  return kTRUE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
{
// Calculates Noise with CM correction
  AliITSChannelDaSSD  *strip = NULL;
  Short_t     *signal;
  Float_t      noise;
  Long_t       ovev, n;
  if (!CalculateCM(module)) { 
    AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
    return kFALSE;
  }  
  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
    if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
    if (!(signal = strip->GetSignal())) {
      strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
      AliError(Form("AliITSHandleDaSSD: Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", 
                     module->GetModuleId(), strind));
      continue; //return kFALSE;
    }
    Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
    Double_t nsum = 0.0L;
    ovev = 0l;
    for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
    } 
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = static_cast<Float_t>(TMath::Sqrt(nsum / (Double_t)(n)));
    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetNoiseCM(noise);
  }
  return kTRUE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
{
// Calculates CM
  AliITSChannelDaSSD  *strip = NULL;
  Short_t             *signal;
  Long_t               ovstr, n;
  Int_t                stripind;
  module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
  for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
    stripind = chipind * module->GetStripsPerChip();
    module->GetCM()[chipind].Set(fNumberOfEvents);
    module->GetCM()[chipind].Reset(0.0f);
    for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
    // calculate firs approximation of CM.
      Double_t cm0 = 0.0L;
      ovstr = 0l;
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = module->GetStrip(strind))) continue; //return kFALSE; 
        if (!(signal = strip->GetSignal())) {
          AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", 
	                module->GetModuleId(), strind));
          return kFALSE;
        }
        if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
        else cm0 += (signal[ev] - strip->GetPedestal());
      }
      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
      else { module->SetCM(0.0f, chipind, ev); continue; }
    // calculate avarage (cm - (signal - pedestal)) over the chip
      Double_t cmsigma = 0.0L;
      ovstr = 0l;
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = module->GetStrip(strind))) continue;
        if (!(signal = strip->GetSignal())) {
          AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
	                 module->GetModuleId(), strind));
          return kFALSE;
        }
        if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
        else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
      }
      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = TMath::Sqrt(cmsigma / (Float_t)(n));
      else { module->SetCM(0.0f, chipind, ev); continue; }
   // calculate cm with threshold
      Double_t cmsum = 0.0L;
      ovstr = 0l;
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = module->GetStrip(strind))) continue;
        signal = strip->GetSignal();
        if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) 
	       || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
        else cmsum += (signal[ev] - strip->GetPedestal());
      }
      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
      else cmsum = 0.0L;
      if (!(module->SetCM(cmsum, chipind, ev))) 
        AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n",
	                   module->GetModuleId(), chipind, ev));
    } 
  }
  return kTRUE; 
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread, const Bool_t usewelford)
{
// Performs calculation of calibration parameters (pedestal, noise, ...) 
  Int_t nm = 0;
  if (nmread <= 0) return kFALSE;
  if (!fModules) return kFALSE;
  while ((nm = ReadModuleRawData(nmread)) > 0) {
    cout << "Processing next " << nm << " modules;" << endl;  
    for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
      if (!fModules[modind]) {
        AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
	               modind));
        return kFALSE;
      }
      AddFeromCm(fModules[modind]);
      if (usewelford) {
        CalculatePedNoiseW(fModules[modind]);
        CalculateNoiseCMW(fModules[modind]);
      } else {
        CalculatePedestal(fModules[modind]);
        CalculateNoise(fModules[modind]);
        CalculateNoiseCM(fModules[modind]);
      }
    }
    DeleteSignal();
    DeleteCM();
    DeleteCMFerom();
    fModIndProcessed = fModIndRead;
    cout << fModIndProcessed << " - done" << endl;
    if (nm < nmread ) break;
  }
  return kTRUE;  
}


//______________________________________________________________________________
Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
{
// Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
  if (!fDDLModuleMap) {
    AliError("Error DDLMap is not initialized, return 0!");
	return 0;
  }
  Int_t mddli = ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
  if ((ddlID < fgkNumberOfSSDDDLs) && (mddli < fgkNumberOfSSDModulesPerDdl)) {
    mddli = fDDLModuleMap[ddlID * fgkNumberOfSSDModulesPerDdl + mddli];
  }  
  else {
    AliWarning(Form("Module index  = %d or ddlID = %d is out of range 0 is rturned", ddlID, mddli));
    mddli = 0;
  }
  if (mddli > SHRT_MAX) return SHRT_MAX;
  else return (Short_t)mddli;
}



//______________________________________________________________________________
AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const
{
// Fill in the array for OCDB 
  AliITSNoiseSSDv2         *ldcn = NULL;
  AliITSModuleDaSSD      *module = NULL;
  AliITSChannelDaSSD     *strip = NULL; 
  if (!fModules) return NULL;
  ldcn = new AliITSNoiseSSDv2;
  if (!ldcn) {
    AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
    return NULL;
  }
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!(module = fModules[i])) continue;
    if (module->GetModuleId() < fgkMinSSDModuleId) continue;
    for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
      if (!(strip = module->GetStrip(strind))) continue;
      Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
      if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) 
        ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
      else
        ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
    }
  }
  return ldcn;
}


//______________________________________________________________________________
AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const
{
// Fill in the TObjArray with the list of bad channels 
  AliITSBadChannelsSSDv2   *ldcbc = NULL;
  AliITSModuleDaSSD      *module = NULL;
  AliITSChannelDaSSD     *strip = NULL; 
  if (!fModules) return NULL;
  ldcbc = new AliITSBadChannelsSSDv2;
  if (!ldcbc) {
    AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
    return NULL;
  }
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!(module = fModules[i])) continue;
    if (module->GetModuleId() < fgkMinSSDModuleId) continue;
    for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
      if (!(strip = module->GetStrip(strind))) continue;
      Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
      if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
        ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId()));
      else 
        ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), 
                                     EvaluateIfChannelIsBad(module, strip->GetStripId()));
    }
  }
  return ldcbc;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname)
{
// Save Calibration data locally
  AliITSBadChannelsSSDv2   *ldcbc = NULL;
  AliITSPedestalSSDv2      *ldcp = NULL;
  AliITSNoiseSSDv2         *ldcn = NULL;
  AliITSModuleDaSSD      *module = NULL;
  AliITSChannelDaSSD     *strip = NULL; 
  Char_t         *tmpfname;
  TString         dadatafilename("");
  if (!fModules) return kFALSE;
  ldcn = new AliITSNoiseSSDv2;
  ldcp = new AliITSPedestalSSDv2;
  ldcbc = new AliITSBadChannelsSSDv2;
  if ((!ldcn) || (!ldcp) || (!ldcp)) {
    AliError("Error allocation mamory for calibration objects, return kFALSE!");
    return kFALSE;
  }
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!(module = fModules[i])) continue;
    if (module->GetModuleId() < fgkMinSSDModuleId) continue;
    for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
      if (!(strip = module->GetStrip(strind))) continue;
      Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
      if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) {
        ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
        ldcp->AddPedestalP(modid, strip->GetStripId(), strip->GetPedestal());
        ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId()));
      } else {
        ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
        ldcp->AddPedestalN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetPedestal()); 
        ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), 
                                     EvaluateIfChannelIsBad(module, strip->GetStripId()));
      }
    }
  }
  if (dafname) dadatafilename.Form("%s/", dafname);
  dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId);
  tmpfname = new Char_t[dadatafilename.Length()+1];
  Int_t sz = dadatafilename.Sizeof();
  dafname = strncpy(tmpfname, dadatafilename.Data(),sz);
  TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
  if (fileRun->IsZombie()) {
    AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
    ldcn->Delete();
    delete fileRun;
    delete ldcn;
    delete ldcp;
    delete ldcbc;
    return kFALSE;
  }
  fileRun->WriteTObject(ldcn);
  fileRun->WriteTObject(ldcp);
  if (fBadChannelsList) 
    if (fMergeBCLists) {
      MergeBadChannels(ldcbc);
      fileRun->WriteTObject(ldcbc);
    } else fileRun->WriteTObject(fBadChannelsList);
  else fileRun->WriteTObject(ldcbc);
  fileRun->Close();
  delete fileRun;
  delete ldcn;
  delete ldcp;
  delete ldcbc;
  return kTRUE;
}


//______________________________________________________________________________
Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*&  bcl) const
{
// Merges the statick bad channels list with bad channels got upon calibration
  AliITSModuleDaSSD     *module = 0;
  Int_t                  nmpch = 0, nmnch = 0, ngpch = 0, ngnch = 0;
  if (!fBadChannelsList || !bcl) {
    AliWarning("Either fBadChannelsList == NULL or bad_channels_list == NULL, there is nothing to merge!");
	return -1;
  }
  for (Int_t modind = 0; modind < GetNumberOfModules(); modind++) {
    if (!(module = fModules[modind])) continue;
    if (module->GetModuleId() < fgkMinSSDModuleId) continue;
    Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
    for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) {
      if ( (!(fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask)) 
          && (bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) 
        ngpch++;
      if ( (!(fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask)) 
          && (bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) 
        ngnch++;
      if ( (!(bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask)) 
          && (fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) {
        bcl->AddBadChannelP(modid, strind, fBadChannelsList->GetBadChannelP(modid, strind));
        nmpch++;  
      }    
      if ( (!(bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask)) 
          && (fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) {
        bcl->AddBadChannelN(modid, strind, fBadChannelsList->GetBadChannelN(modid, strind));
        nmnch++;  
      }
    }	  
  }
  AliInfo(Form("Static bad, dynamic good: P%d,  N%d", nmpch, nmnch));
  AliInfo(Form("Static good, dynamic bad: P%d,  N%d", ngpch, ngnch));
  return (nmnch + nmpch);
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
{
// Dump calibration parameters
  AliITSModuleDaSSD    *mod;
  AliITSChannelDaSSD   *strip;
  if (!fModules) {
    cout << "SSDDALDC::DumpModInfo():  Error, no modules are allocated!" << endl;
    return kFALSE;
  }  
  cout << "Modules with MeanNoise > " << meannosethreshold << endl;
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!(mod = fModules[i])) continue;
    Double_t  maxnoise = 0.0L, meannoise = 0.0L, meanovf = 0.0L;
    Float_t   maxped = 0.0f;
    Int_t     maxstrind = 0, novfstr = 0, maxovf = 0; 
    for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
      if (!(strip = mod->GetStrip(strind))) {novfstr++;  continue; }
      if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++;  continue; }
      if (maxnoise < strip->GetNoiseCM()) { 
        maxnoise = strip->GetNoiseCM();
        maxstrind = strind;
      }	
      meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Double_t>(strind - novfstr + 1) 
                                    : strip->GetNoiseCM();
      if (TMath::Abs(maxped) < TMath::Abs(strip->GetPedestal())) maxped = strip->GetPedestal();
      meanovf = (strind - novfstr) ? meanovf + (strip->GetOverflowNumber() - meanovf) / static_cast<Double_t>(strind - novfstr + 1) 
                                    : strip->GetOverflowNumber();
      if (strip->GetOverflowNumber() > maxovf) maxovf = strip->GetOverflowNumber();
    } 
    if (meannoise > meannosethreshold)
      cout << "Mod: " << i << ";  DDl: " << (int)mod->GetDdlId() << ";  AD: " << (int)mod->GetAD()  
                           << ";  ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped
			   << ";  MeanNoise = " << meannoise << "; MaxNoise = " << maxnoise << "; MaxNoiseStrip = " << maxstrind 
			   << ";  NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
	if (maxovf > 10) cout << "Max number of events with overflow :  " << maxovf << ";  mean : " << meanovf << endl;
  }
  return kTRUE;
}



//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
{
// Print Module calibration data whether in file or in cout
   AliITSChannelDaSSD  *strip;
   ofstream             datafile;
   ostream             *outputfile;
   if (!fname) { outputfile = &cout; }
   else {
     datafile.open(fname, ios::out);
     if  (datafile.fail()) return kFALSE;
     outputfile = dynamic_cast<ostream*>(&datafile); 
   }
   *outputfile  << "DDL = " << (int)ddlID << ";  AD = " << (int)ad << ";  ADC = " << (int)adc << endl;
   for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
     if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) {
       *outputfile << "Str = " << strind << ";  ped = " << strip->GetPedestal() 
                   << ";  noise = " << strip->GetNoiseCM() << endl;
     }
     else continue;
   }
  if (datafile.is_open()) datafile.close(); 
  return kTRUE;
}



//______________________________________________________________________________
void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
{
// Print general information retrieved from raw data file
  cout << "Raw data file: " << fRawDataFileName << endl
       << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
       << "Number of physics events: " << fNumberOfEvents << endl
       << str;
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
{
// Used to allocate simulated modules to test the performance  
  AliITSModuleDaSSD *module;
  UChar_t      ad, adc, ddlID;
  ad = adc = ddlID = 0;
  if (!(fModules[copymodind])) return kFALSE;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
    if (!fModules[modind]) {
      module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
      if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
      else if (adc == 5) adc = 8;
      else if (adc == 13) {
        adc = 0;
        if (ad < 8) ad += 1;
        else {
          ad = 0;
          ddlID +=1;
        }
      }
      if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
      fModules[modind] = module;
      for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
        AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
	if(!cstrip)return kFALSE;
        Long_t      eventsnumber = cstrip->GetEventsNumber();
        AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
        for (Long_t evind = 0; evind < eventsnumber; evind++) {
          Short_t sign = cstrip->GetSignal(evind);
          if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
        }
	module->SetStrip(strip, strind);
      }
    }
    else {
      ddlID = fModules[modind]->GetDdlId();
      ad    = fModules[modind]->GetAD();
      adc   = fModules[modind]->GetADC();
    }
  }
  for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);  
  return kTRUE;
}


    
//___________________________________________________________________________________________
Bool_t AliITSHandleDaSSD::AdDataPresent(const Int_t ddl, const Int_t ad) const
{
// Check if there are calibration data for given ddl and slot
  for (Int_t modind = 0; modind < fNumberOfModules; modind++)
    if ((GetModule(modind)->GetAD() == ad) && (GetModule(modind)->GetDdlId() == ddl)) return kTRUE;
  return kFALSE;
}

   

//___________________________________________________________________________________________
Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const
{
// Saves calibration files for selected equipment (DDL)
  fstream    feefile;
  Int_t      zsml, offsetml;
  ULong_t    zsth, offset, zsoffset;
  if (!fname) {
    AliError("File name must be specified!");
    return kFALSE;   
  }
  if (!AdDataPresent(ddl, ad)) {
    AliError(Form("Error SaveEqSlotCalibrationData(ddl = %i, ad = %i) no data present", ddl, ad)); 
    return kFALSE;
  }
  feefile.open(fname, ios::out);
  if (!feefile.is_open()) {
	AliError(Form("Can not open the file %s for output!", fname)); 
    return kFALSE;
  }
  for (zsml = 0; fgkZsBitMask >> zsml; zsml++) ;
  for (offsetml = 0; fgkOffSetBitMask >> offsetml; offsetml++) ;
  for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
    for (Int_t adcb = 0; adcb < fgkAdcPerDBlock; adcb++) {
      zsoffset = 0x0;
      for (Int_t j = 0; j < 2; j++) {
        Int_t adc = adcb + j * 8;
        zsth = ZsThreshold(ddl, ad, adc, strind);
        offset = OffsetValue(ddl, ad, adc, strind);
        zsoffset = zsoffset | (((zsth << offsetml) | offset) << ((j == 0) ? (offsetml + zsml) : 0));
      }
      feefile << "0x" << ConvBase(static_cast<unsigned long>(zsoffset), 16) << endl;
    }
  }
  feefile.close();
  return kTRUE;
}


//______________________________________________________________________________
Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
{
// Check if the channel is bad
  AliITSModuleDaSSD     *module = NULL;
  Int_t                  modn = -1;
  if (fBadChannelsList && fDDLModuleMap) {
    modn = RetrieveModuleId(ddl, ad, adc);
    if (modn < 0) return -1;
    if (modn < fgkMinSSDModuleId) {
      AliWarning(Form("Module ddl/ad/adc: %d/%d/%d has number %d which is wrong for SSD module %d", ddl, ad, adc, strn, modn));
	  return -1;
    }
    Short_t modid = modn - fgkMinSSDModuleId;
    if (strn < AliITSModuleDaSSD::GetPNStripsPerModule()) 
      return (fBadChannelsList->GetBadChannelP(modid, strn)  & fgkBadChannelMask);
    else return (fBadChannelsList->GetBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strn)) & fgkBadChannelMask);
  } else {
    AliError("Error ether bad channels list or DDLMap is not initialized or both, EvaluateIfChannelIsBad(module, strip) is used!");
    if ((module = GetModule(ddl, ad, adc))) {
      return (EvaluateIfChannelIsBad(module, strn) & fgkBadChannelMask);
    } else {
      AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
      return 0ul;
    }  
	return 0;
  }
}



//______________________________________________________________________________
Int_t AliITSHandleDaSSD::LadderIsOff(const UChar_t ddl, const UChar_t ad, const UChar_t adc) const
{
//Checks if the module with given ddl, ad, adc is on the ladder which is in the list of ladders which are off
  const Int_t nm5 =  500;
  const Int_t nm6 =  1248;
  const Int_t nml5a = 12;
  const Int_t nml5c = 10;
  const Int_t nml6a = 12;
  const Int_t nml6c = 13;
  Int_t               modn, ladder, layer, side;
  AliITSModuleDaSSD  *module;
  if (!(module = GetModule(ddl, ad, adc))) return 0;
  if ((modn = module->GetModuleId()) <= 0)  modn = RetrieveModuleId(ddl, ad, adc);
  if (modn <= 0) return 0;
  layer = modn >= nm6 ? 1 : 0;     // 6 : 5
  ladder = (modn - (layer ? nm6 : nm5)) / (layer ? (nml6a + nml6c) : (nml5a + nml5c));
  if ( ((modn - (layer ? nm6 : nm5)) % (layer ? (nml6a + nml6c) : (nml5a + nml5c))) < (layer ? nml6a : nml5a))
    side = 0;      // A
  else side = 1;   // C
  ladder += (layer ? 600 : 500);
  layer += 5;
  if (side)
    if (fCLaddersOff.GetSize()) {
      for(Int_t i = 0; i < fCLaddersOff.GetSize(); i++) 
        if (fCLaddersOff.At(i) == ladder) return fCLaddersOff.At(i);
      return 0;
    } else return 0;
  else
    if (fALaddersOff.GetSize()) {
      for(Int_t i = 0; i < fALaddersOff.GetSize(); i++) 
        if (fALaddersOff.At(i) == ladder) return fALaddersOff.At(i);
      return 0;
    } else return 0;
  return 0;  
}


        
//______________________________________________________________________________
ULong_t AliITSHandleDaSSD::OffsetValue(const AliITSChannelDaSSD *strip, 
                                       const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
{
// Calculate the offset value to be upload to FEROM	
  Int_t  pedint;
  if (fOffsetDefault < INT_MAX) pedint = fOffsetDefault;
  else pedint = TMath::Nint(strip->GetPedestal());
  if (pedint > static_cast<Int_t>((fgkOffSetBitMask >> 1))) {
    if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn)))) 
      AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i  can not be represented with mask 0x%s, Offset = %i",
                   pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), (fgkOffSetBitMask >> 1)));
    return (fgkOffSetBitMask >> 1);
  }  
  if ((-pedint) > static_cast<Int_t>(((fgkOffSetBitMask + 1) >> 1))) {
    if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn)))) 
      AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i  can not be represented with mask 0x%s, Offset = %i", 
               pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), 
               ((fgkOffSetBitMask & (~fgkOffSetBitMask >> 1)) - fgkOffSetBitMask - 1)));
    return fgkOffSetBitMask & (~fgkOffSetBitMask >> 1);
  }
  return fgkOffSetBitMask & (pedint >= 0 ? pedint : pedint + fgkOffSetBitMask + 1);
}



//______________________________________________________________________________
ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
{
// Calculate the offset value to be upload to FEROM	
  AliITSChannelDaSSD    *strip = NULL;
  AliITSModuleDaSSD     *module = NULL;
  if ((module = GetModule(ddl, ad, adc))) {
    if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
    else {
      AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
      return 0ul;
    }
  } else {
    AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
    return 0ul;
  }  
}



//______________________________________________________________________________
ULong_t AliITSHandleDaSSD::ZsThreshold(const AliITSChannelDaSSD *strip) const
{ 
// Calculate the value of zero suppression threshold to be upload to FEROM
  ULong_t zs;
  if (fZsDefault < 0) {
    zs = TMath::Nint(fZsFactor * strip->GetNoiseCM());
    if (zs < static_cast<ULong_t>(fZsMinimum)) zs = static_cast<ULong_t>(fZsMinimum);
  }
  else zs = fZsDefault;
  return (zs < fgkZsBitMask) ? (zs & fgkZsBitMask) : fgkZsBitMask;
}


//______________________________________________________________________________
ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
{
// Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
  AliITSChannelDaSSD    *strip = NULL;
  AliITSModuleDaSSD     *module = NULL;
  if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
  if (LadderIsOff(ddl, ad, adc)) return fgkZsBitMask;
  if (fZsDefault > 0) if (static_cast<ULong_t>(fZsDefault) >= fgkZsBitMask) return fgkZsBitMask;
  if ((module = GetModule(ddl, ad, adc))) {
	if (fMergeBCLists) if (EvaluateIfChannelIsBad(module, strn)) return fgkZsBitMask;
    if ((strip = module->GetStrip(strn)))  return ZsThreshold(strip);
    else {
      AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
      return 0ul;
    }
  } else {
    AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
    return 0ul;
  }
}

            
//______________________________________________________________________________
string AliITSHandleDaSSD::ConvBase(const unsigned long value, const long base) const
{
// Converts the unsigned long number into that in another base 
  string digits = "0123456789ABCDEF";
  string result;
  unsigned long v = value;
  if((base < 2) || (base > 16)) {
    result = "Error: base out of range.";
  }
  else {
    int i = 0;
    do {
      result = digits[v % base] + result;
      v /= base;
      i++;
    }
    while((v) || (i<8));
  }
  return result;
}



//______________________________________________________________________________
Int_t AliITSHandleDaSSD::CheckOffChips() const
{
// Check if the chip, module are off
  AliITSChannelDaSSD *strip;
  Int_t       offthreshold;
  Int_t       strnd, chipnd, modnd, stroff, chipoff, modoff;
  offthreshold = TMath::Nint(fZsMinimum/fZsFactor);
  modnd = modoff = 0;
  for (Int_t mi = 0; mi < fNumberOfModules; mi++) {
    if (!fModules[mi]) { modnd++; continue; }
    if (fModules[mi]->GetModuleId() < 0) continue;
    if (LadderIsOff(fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()) ) continue;
    chipoff = chipnd = 0;
    for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
      strnd = stroff = 0;
      Int_t stripind = chipind * AliITSModuleDaSSD::GetStripsPerChip();
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = fModules[mi]->GetStrip(strind))) { strnd++;  continue; }
        if (strip->GetNoiseCM() < offthreshold ) stroff++;
      }
      if (strnd == AliITSModuleDaSSD::GetStripsPerChip()) chipnd++;
      else if (stroff == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
      else if ((stroff + strnd) == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
    }
    if ((!chipoff) && (!chipnd)) continue;
    if (chipnd == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
      AliInfo(Form("Module: (ddl/ad/adc) %i/%i/%i seems to be off and it is not on the ladders which are off!", 
               fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
      modnd++;
    }
    if (chipoff == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
      AliInfo(Form("Module (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!", 
               fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
      modoff++;
    }
    else if ((chipoff + chipnd) == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
      AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!", 
               fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
      modoff++;
    }
    else if (chipoff) {
      AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i has %i chips which are off!", 
               fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC(), chipoff));
      modoff++;
    }
  }
  return (modoff + modnd);
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculatePedNoiseW(const AliITSModuleDaSSD *const module)
{
// Calculates Pedestal and Noise using Welford algorithm
  AliITSChannelDaSSD *strip;
  Double_t            pedestal, noise, p0, s0;
  Short_t            *signal;
  Int_t               ovev, n;
  if (!module) return kFALSE;
  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
    if (!(strip = module->GetStrip(strind))) continue;
    if (!(signal = strip->GetSignal())) {
      AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
                     module->GetModuleId(), strind));
      continue;	
    }
//************* pedestal and noise first pass ****************
    pedestal = p0 = noise = 0.0L;
    ovev = 0;
    for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else 
        if (!(ev - ovev)) {
          pedestal = p0 = signal[ev];
          noise = 0.0L;
        } else {
          p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
          s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
          pedestal = p0;
          noise = s0;
        }
    }
    if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetPedestal(static_cast<Float_t>(pedestal));
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) 
      strip->SetNoise( static_cast<Float_t>(TMath::Sqrt(noise / static_cast<Double_t>(n))) );
    else {
      strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
      continue;
    }
//************* Second pass excluds event with |p - s|>f*noise *****************
    pedestal = p0 = noise = 0.0L;
    ovev = 0;
    for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (   SignalOutOfRange(signal[ev]) 
          || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
      else
        if (!(ev - ovev)) {
          pedestal = p0 = signal[ev];
          noise = 0.0L;
        } else {
          p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
          s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
          pedestal = p0;
          noise = s0;
        }
    }      
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = TMath::Sqrt(noise / static_cast<Double_t>(n));
    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetNoise(static_cast<Float_t>(noise));
    if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetPedestal(static_cast<Float_t>(pedestal));
    strip->SetOverflowNumber(ovev);	
  }
  return kTRUE;
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculateCMW(AliITSModuleDaSSD *const module)
{
// Calculates CM using Welford algorithm
  AliITSChannelDaSSD  *strip = NULL;
  Short_t             *signal;
  Int_t                ovstr, n;
  Int_t                stripind;
  Double_t             cm0, cm1, cmsigma, cms1;
  module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
  for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
    stripind = chipind * module->GetStripsPerChip();
    module->GetCM()[chipind].Set(fNumberOfEvents);
    module->GetCM()[chipind].Reset(0.0f);
    for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
    // calculate firs approximation of CM and SigmaCM.
      cm0 = cm1 = cmsigma = 0.0L;
      ovstr = 0;
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; } //return kFALSE; 
        if (!(signal = strip->GetSignal())) { ovstr += 1; continue; }  //return kFALSE; 
        if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
        else {
          if (!(strind - stripind - ovstr)) {
          cm0 = cm1 = signal[ev] - strip->GetPedestal();
          cmsigma = 0.0L;
        } else {
          cm1 = cm0 + (signal[ev] - strip->GetPedestal() - cm0) / static_cast<Double_t>(strind - stripind - ovstr + 1);
          cms1 = cmsigma + (signal[ev] - strip->GetPedestal() - cm0) * (signal[ev] - strip->GetPedestal() - cm1);
          cm0 = cm1;
          cmsigma = cms1;
        } }
      }
      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr - 1) > 0) cmsigma = TMath::Sqrt(cmsigma / static_cast<Double_t>(n));
      else {
        AliWarning(Form("AliITSHandleDaSSD: Too little number of strips have a signal for module:chip:event : [%d]:[%d]:[%ld]\n",
                   module->GetModuleId(), chipind, ev));
        if (!(module->SetCM(0.0f, chipind, ev))) 
          AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n",
                   module->GetModuleId(), chipind, ev));
        continue;
      }
   // calculate cm with threshold
      Double_t cmsum = 0.0L;
      ovstr = 0;
      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
        if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; }
        if (!(signal = strip->GetSignal())) { ovstr += 1; continue; }
        if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) 
	       || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
        else cmsum += (signal[ev] - strip->GetPedestal());
      }
      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Double_t)(n);
      else cmsum = 0.0L;
      if (!(module->SetCM(static_cast<Float_t>(cmsum), chipind, ev))) 
        AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n",
                 module->GetModuleId(), chipind, ev));
    } 
  }
  return kTRUE; 
}


//______________________________________________________________________________
Bool_t AliITSHandleDaSSD::CalculateNoiseCMW(AliITSModuleDaSSD *const module)
{
// Calculates Noise with CM correction
  AliITSChannelDaSSD  *strip = NULL;
  Short_t     *signal;
  Int_t        ovev, n;
  if (!CalculateCMW(module)) { 
    AliError("Error: AliITSHandleDaSSD::CalculateCMW() returned kFALSE");
    return kFALSE;
  }  
  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
    if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
    if (!(signal = strip->GetSignal())) {
      strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
      AliError(Form("AliITSHandleDaSSD: Error CalculateNoiseCMW(): there are no events data for module[%i] strip[%i]->GetSignal()", 
                     module->GetModuleId(), strind));
      continue; //return kFALSE;
    }
//** To get exactly the same set of events as for pedestal and noise calculation **
    Double_t pedestal, noise, p0, s0;
    pedestal = p0 = noise = 0.0L;
    ovev = 0;
    for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (SignalOutOfRange(signal[ev])) ovev += 1;
      else 
        if (!(ev - ovev)) {
          pedestal = p0 = signal[ev];
          noise = 0.0L;
        } else {
          p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
          s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
          pedestal = p0;
          noise = s0;
        }
    }
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = TMath::Sqrt(noise / static_cast<Double_t>(n));
    else  {
	  strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
	  continue;
    }
//** Calculation of CM corrected noise **
    Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
    Double_t nsum = 0.0L;
    ovev = 0;
    for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
      if (   SignalOutOfRange(signal[ev])
          || TMath::Abs(signal[ev] - pedestal) > (fPedestalThresholdFactor * noise)) ovev += 1;
      else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
    } 
    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  TMath::Sqrt(nsum / static_cast<Double_t>(n));
    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
    strip->SetNoiseCM(static_cast<Float_t>(noise));
  }
  return kTRUE;
}



//______________________________________________________________________________
UChar_t AliITSHandleDaSSD::EvaluateIfChannelIsBad(const AliITSModuleDaSSD *const module, const Int_t stripn) const
{
//Applies the bad channel creteria and set the appropriate flags for returned value
  AliITSChannelDaSSD  *strip = 0;
  UInt_t               bcflags = 0;
  if (fZsDefault >= 0) { if (static_cast<ULong_t>(fZsDefault) >= fgkZsBitMask) bcflags |= 3; }
  else if (static_cast<ULong_t>(fZsMinimum) >= fgkZsBitMask) bcflags |= 3;
  if (LadderIsOff(module->GetDdlId(), module->GetAD(), module->GetADC()) )  bcflags |= 3;
  
  if (!(strip = module->GetStrip(stripn))) bcflags |= 3;
  else {
    if (strip->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags |= 8;
    if (static_cast<ULong_t>(TMath::Nint(fZsFactor * strip->GetNoiseCM())) >= fgkZsBitMask) bcflags |= 8;
    if (strip->GetNoiseCM() < 1) bcflags |= 16;
    if (strip->GetPedestal() > ((fgkOffSetBitMask >> 1) - 1))  bcflags |= 4;
    else if ((-(strip->GetPedestal())) > (fgkOffSetBitMask >> 1))  bcflags |= 4;
    if (bcflags) bcflags |= 3;
  }
  return bcflags;
}

 AliITSHandleDaSSD.cxx:1
 AliITSHandleDaSSD.cxx:2
 AliITSHandleDaSSD.cxx:3
 AliITSHandleDaSSD.cxx:4
 AliITSHandleDaSSD.cxx:5
 AliITSHandleDaSSD.cxx:6
 AliITSHandleDaSSD.cxx:7
 AliITSHandleDaSSD.cxx:8
 AliITSHandleDaSSD.cxx:9
 AliITSHandleDaSSD.cxx:10
 AliITSHandleDaSSD.cxx:11
 AliITSHandleDaSSD.cxx:12
 AliITSHandleDaSSD.cxx:13
 AliITSHandleDaSSD.cxx:14
 AliITSHandleDaSSD.cxx:15
 AliITSHandleDaSSD.cxx:16
 AliITSHandleDaSSD.cxx:17
 AliITSHandleDaSSD.cxx:18
 AliITSHandleDaSSD.cxx:19
 AliITSHandleDaSSD.cxx:20
 AliITSHandleDaSSD.cxx:21
 AliITSHandleDaSSD.cxx:22
 AliITSHandleDaSSD.cxx:23
 AliITSHandleDaSSD.cxx:24
 AliITSHandleDaSSD.cxx:25
 AliITSHandleDaSSD.cxx:26
 AliITSHandleDaSSD.cxx:27
 AliITSHandleDaSSD.cxx:28
 AliITSHandleDaSSD.cxx:29
 AliITSHandleDaSSD.cxx:30
 AliITSHandleDaSSD.cxx:31
 AliITSHandleDaSSD.cxx:32
 AliITSHandleDaSSD.cxx:33
 AliITSHandleDaSSD.cxx:34
 AliITSHandleDaSSD.cxx:35
 AliITSHandleDaSSD.cxx:36
 AliITSHandleDaSSD.cxx:37
 AliITSHandleDaSSD.cxx:38
 AliITSHandleDaSSD.cxx:39
 AliITSHandleDaSSD.cxx:40
 AliITSHandleDaSSD.cxx:41
 AliITSHandleDaSSD.cxx:42
 AliITSHandleDaSSD.cxx:43
 AliITSHandleDaSSD.cxx:44
 AliITSHandleDaSSD.cxx:45
 AliITSHandleDaSSD.cxx:46
 AliITSHandleDaSSD.cxx:47
 AliITSHandleDaSSD.cxx:48
 AliITSHandleDaSSD.cxx:49
 AliITSHandleDaSSD.cxx:50
 AliITSHandleDaSSD.cxx:51
 AliITSHandleDaSSD.cxx:52
 AliITSHandleDaSSD.cxx:53
 AliITSHandleDaSSD.cxx:54
 AliITSHandleDaSSD.cxx:55
 AliITSHandleDaSSD.cxx:56
 AliITSHandleDaSSD.cxx:57
 AliITSHandleDaSSD.cxx:58
 AliITSHandleDaSSD.cxx:59
 AliITSHandleDaSSD.cxx:60
 AliITSHandleDaSSD.cxx:61
 AliITSHandleDaSSD.cxx:62
 AliITSHandleDaSSD.cxx:63
 AliITSHandleDaSSD.cxx:64
 AliITSHandleDaSSD.cxx:65
 AliITSHandleDaSSD.cxx:66
 AliITSHandleDaSSD.cxx:67
 AliITSHandleDaSSD.cxx:68
 AliITSHandleDaSSD.cxx:69
 AliITSHandleDaSSD.cxx:70
 AliITSHandleDaSSD.cxx:71
 AliITSHandleDaSSD.cxx:72
 AliITSHandleDaSSD.cxx:73
 AliITSHandleDaSSD.cxx:74
 AliITSHandleDaSSD.cxx:75
 AliITSHandleDaSSD.cxx:76
 AliITSHandleDaSSD.cxx:77
 AliITSHandleDaSSD.cxx:78
 AliITSHandleDaSSD.cxx:79
 AliITSHandleDaSSD.cxx:80
 AliITSHandleDaSSD.cxx:81
 AliITSHandleDaSSD.cxx:82
 AliITSHandleDaSSD.cxx:83
 AliITSHandleDaSSD.cxx:84
 AliITSHandleDaSSD.cxx:85
 AliITSHandleDaSSD.cxx:86
 AliITSHandleDaSSD.cxx:87
 AliITSHandleDaSSD.cxx:88
 AliITSHandleDaSSD.cxx:89
 AliITSHandleDaSSD.cxx:90
 AliITSHandleDaSSD.cxx:91
 AliITSHandleDaSSD.cxx:92
 AliITSHandleDaSSD.cxx:93
 AliITSHandleDaSSD.cxx:94
 AliITSHandleDaSSD.cxx:95
 AliITSHandleDaSSD.cxx:96
 AliITSHandleDaSSD.cxx:97
 AliITSHandleDaSSD.cxx:98
 AliITSHandleDaSSD.cxx:99
 AliITSHandleDaSSD.cxx:100
 AliITSHandleDaSSD.cxx:101
 AliITSHandleDaSSD.cxx:102
 AliITSHandleDaSSD.cxx:103
 AliITSHandleDaSSD.cxx:104
 AliITSHandleDaSSD.cxx:105
 AliITSHandleDaSSD.cxx:106
 AliITSHandleDaSSD.cxx:107
 AliITSHandleDaSSD.cxx:108
 AliITSHandleDaSSD.cxx:109
 AliITSHandleDaSSD.cxx:110
 AliITSHandleDaSSD.cxx:111
 AliITSHandleDaSSD.cxx:112
 AliITSHandleDaSSD.cxx:113
 AliITSHandleDaSSD.cxx:114
 AliITSHandleDaSSD.cxx:115
 AliITSHandleDaSSD.cxx:116
 AliITSHandleDaSSD.cxx:117
 AliITSHandleDaSSD.cxx:118
 AliITSHandleDaSSD.cxx:119
 AliITSHandleDaSSD.cxx:120
 AliITSHandleDaSSD.cxx:121
 AliITSHandleDaSSD.cxx:122
 AliITSHandleDaSSD.cxx:123
 AliITSHandleDaSSD.cxx:124
 AliITSHandleDaSSD.cxx:125
 AliITSHandleDaSSD.cxx:126
 AliITSHandleDaSSD.cxx:127
 AliITSHandleDaSSD.cxx:128
 AliITSHandleDaSSD.cxx:129
 AliITSHandleDaSSD.cxx:130
 AliITSHandleDaSSD.cxx:131
 AliITSHandleDaSSD.cxx:132
 AliITSHandleDaSSD.cxx:133
 AliITSHandleDaSSD.cxx:134
 AliITSHandleDaSSD.cxx:135
 AliITSHandleDaSSD.cxx:136
 AliITSHandleDaSSD.cxx:137
 AliITSHandleDaSSD.cxx:138
 AliITSHandleDaSSD.cxx:139
 AliITSHandleDaSSD.cxx:140
 AliITSHandleDaSSD.cxx:141
 AliITSHandleDaSSD.cxx:142
 AliITSHandleDaSSD.cxx:143
 AliITSHandleDaSSD.cxx:144
 AliITSHandleDaSSD.cxx:145
 AliITSHandleDaSSD.cxx:146
 AliITSHandleDaSSD.cxx:147
 AliITSHandleDaSSD.cxx:148
 AliITSHandleDaSSD.cxx:149
 AliITSHandleDaSSD.cxx:150
 AliITSHandleDaSSD.cxx:151
 AliITSHandleDaSSD.cxx:152
 AliITSHandleDaSSD.cxx:153
 AliITSHandleDaSSD.cxx:154
 AliITSHandleDaSSD.cxx:155
 AliITSHandleDaSSD.cxx:156
 AliITSHandleDaSSD.cxx:157
 AliITSHandleDaSSD.cxx:158
 AliITSHandleDaSSD.cxx:159
 AliITSHandleDaSSD.cxx:160
 AliITSHandleDaSSD.cxx:161
 AliITSHandleDaSSD.cxx:162
 AliITSHandleDaSSD.cxx:163
 AliITSHandleDaSSD.cxx:164
 AliITSHandleDaSSD.cxx:165
 AliITSHandleDaSSD.cxx:166
 AliITSHandleDaSSD.cxx:167
 AliITSHandleDaSSD.cxx:168
 AliITSHandleDaSSD.cxx:169
 AliITSHandleDaSSD.cxx:170
 AliITSHandleDaSSD.cxx:171
 AliITSHandleDaSSD.cxx:172
 AliITSHandleDaSSD.cxx:173
 AliITSHandleDaSSD.cxx:174
 AliITSHandleDaSSD.cxx:175
 AliITSHandleDaSSD.cxx:176
 AliITSHandleDaSSD.cxx:177
 AliITSHandleDaSSD.cxx:178
 AliITSHandleDaSSD.cxx:179
 AliITSHandleDaSSD.cxx:180
 AliITSHandleDaSSD.cxx:181
 AliITSHandleDaSSD.cxx:182
 AliITSHandleDaSSD.cxx:183
 AliITSHandleDaSSD.cxx:184
 AliITSHandleDaSSD.cxx:185
 AliITSHandleDaSSD.cxx:186
 AliITSHandleDaSSD.cxx:187
 AliITSHandleDaSSD.cxx:188
 AliITSHandleDaSSD.cxx:189
 AliITSHandleDaSSD.cxx:190
 AliITSHandleDaSSD.cxx:191
 AliITSHandleDaSSD.cxx:192
 AliITSHandleDaSSD.cxx:193
 AliITSHandleDaSSD.cxx:194
 AliITSHandleDaSSD.cxx:195
 AliITSHandleDaSSD.cxx:196
 AliITSHandleDaSSD.cxx:197
 AliITSHandleDaSSD.cxx:198
 AliITSHandleDaSSD.cxx:199
 AliITSHandleDaSSD.cxx:200
 AliITSHandleDaSSD.cxx:201
 AliITSHandleDaSSD.cxx:202
 AliITSHandleDaSSD.cxx:203
 AliITSHandleDaSSD.cxx:204
 AliITSHandleDaSSD.cxx:205
 AliITSHandleDaSSD.cxx:206
 AliITSHandleDaSSD.cxx:207
 AliITSHandleDaSSD.cxx:208
 AliITSHandleDaSSD.cxx:209
 AliITSHandleDaSSD.cxx:210
 AliITSHandleDaSSD.cxx:211
 AliITSHandleDaSSD.cxx:212
 AliITSHandleDaSSD.cxx:213
 AliITSHandleDaSSD.cxx:214
 AliITSHandleDaSSD.cxx:215
 AliITSHandleDaSSD.cxx:216
 AliITSHandleDaSSD.cxx:217
 AliITSHandleDaSSD.cxx:218
 AliITSHandleDaSSD.cxx:219
 AliITSHandleDaSSD.cxx:220
 AliITSHandleDaSSD.cxx:221
 AliITSHandleDaSSD.cxx:222
 AliITSHandleDaSSD.cxx:223
 AliITSHandleDaSSD.cxx:224
 AliITSHandleDaSSD.cxx:225
 AliITSHandleDaSSD.cxx:226
 AliITSHandleDaSSD.cxx:227
 AliITSHandleDaSSD.cxx:228
 AliITSHandleDaSSD.cxx:229
 AliITSHandleDaSSD.cxx:230
 AliITSHandleDaSSD.cxx:231
 AliITSHandleDaSSD.cxx:232
 AliITSHandleDaSSD.cxx:233
 AliITSHandleDaSSD.cxx:234
 AliITSHandleDaSSD.cxx:235
 AliITSHandleDaSSD.cxx:236
 AliITSHandleDaSSD.cxx:237
 AliITSHandleDaSSD.cxx:238
 AliITSHandleDaSSD.cxx:239
 AliITSHandleDaSSD.cxx:240
 AliITSHandleDaSSD.cxx:241
 AliITSHandleDaSSD.cxx:242
 AliITSHandleDaSSD.cxx:243
 AliITSHandleDaSSD.cxx:244
 AliITSHandleDaSSD.cxx:245
 AliITSHandleDaSSD.cxx:246
 AliITSHandleDaSSD.cxx:247
 AliITSHandleDaSSD.cxx:248
 AliITSHandleDaSSD.cxx:249
 AliITSHandleDaSSD.cxx:250
 AliITSHandleDaSSD.cxx:251
 AliITSHandleDaSSD.cxx:252
 AliITSHandleDaSSD.cxx:253
 AliITSHandleDaSSD.cxx:254
 AliITSHandleDaSSD.cxx:255
 AliITSHandleDaSSD.cxx:256
 AliITSHandleDaSSD.cxx:257
 AliITSHandleDaSSD.cxx:258
 AliITSHandleDaSSD.cxx:259
 AliITSHandleDaSSD.cxx:260
 AliITSHandleDaSSD.cxx:261
 AliITSHandleDaSSD.cxx:262
 AliITSHandleDaSSD.cxx:263
 AliITSHandleDaSSD.cxx:264
 AliITSHandleDaSSD.cxx:265
 AliITSHandleDaSSD.cxx:266
 AliITSHandleDaSSD.cxx:267
 AliITSHandleDaSSD.cxx:268
 AliITSHandleDaSSD.cxx:269
 AliITSHandleDaSSD.cxx:270
 AliITSHandleDaSSD.cxx:271
 AliITSHandleDaSSD.cxx:272
 AliITSHandleDaSSD.cxx:273
 AliITSHandleDaSSD.cxx:274
 AliITSHandleDaSSD.cxx:275
 AliITSHandleDaSSD.cxx:276
 AliITSHandleDaSSD.cxx:277
 AliITSHandleDaSSD.cxx:278
 AliITSHandleDaSSD.cxx:279
 AliITSHandleDaSSD.cxx:280
 AliITSHandleDaSSD.cxx:281
 AliITSHandleDaSSD.cxx:282
 AliITSHandleDaSSD.cxx:283
 AliITSHandleDaSSD.cxx:284
 AliITSHandleDaSSD.cxx:285
 AliITSHandleDaSSD.cxx:286
 AliITSHandleDaSSD.cxx:287
 AliITSHandleDaSSD.cxx:288
 AliITSHandleDaSSD.cxx:289
 AliITSHandleDaSSD.cxx:290
 AliITSHandleDaSSD.cxx:291
 AliITSHandleDaSSD.cxx:292
 AliITSHandleDaSSD.cxx:293
 AliITSHandleDaSSD.cxx:294
 AliITSHandleDaSSD.cxx:295
 AliITSHandleDaSSD.cxx:296
 AliITSHandleDaSSD.cxx:297
 AliITSHandleDaSSD.cxx:298
 AliITSHandleDaSSD.cxx:299
 AliITSHandleDaSSD.cxx:300
 AliITSHandleDaSSD.cxx:301
 AliITSHandleDaSSD.cxx:302
 AliITSHandleDaSSD.cxx:303
 AliITSHandleDaSSD.cxx:304
 AliITSHandleDaSSD.cxx:305
 AliITSHandleDaSSD.cxx:306
 AliITSHandleDaSSD.cxx:307
 AliITSHandleDaSSD.cxx:308
 AliITSHandleDaSSD.cxx:309
 AliITSHandleDaSSD.cxx:310
 AliITSHandleDaSSD.cxx:311
 AliITSHandleDaSSD.cxx:312
 AliITSHandleDaSSD.cxx:313
 AliITSHandleDaSSD.cxx:314
 AliITSHandleDaSSD.cxx:315
 AliITSHandleDaSSD.cxx:316
 AliITSHandleDaSSD.cxx:317
 AliITSHandleDaSSD.cxx:318
 AliITSHandleDaSSD.cxx:319
 AliITSHandleDaSSD.cxx:320
 AliITSHandleDaSSD.cxx:321
 AliITSHandleDaSSD.cxx:322
 AliITSHandleDaSSD.cxx:323
 AliITSHandleDaSSD.cxx:324
 AliITSHandleDaSSD.cxx:325
 AliITSHandleDaSSD.cxx:326
 AliITSHandleDaSSD.cxx:327
 AliITSHandleDaSSD.cxx:328
 AliITSHandleDaSSD.cxx:329
 AliITSHandleDaSSD.cxx:330
 AliITSHandleDaSSD.cxx:331
 AliITSHandleDaSSD.cxx:332
 AliITSHandleDaSSD.cxx:333
 AliITSHandleDaSSD.cxx:334
 AliITSHandleDaSSD.cxx:335
 AliITSHandleDaSSD.cxx:336
 AliITSHandleDaSSD.cxx:337
 AliITSHandleDaSSD.cxx:338
 AliITSHandleDaSSD.cxx:339
 AliITSHandleDaSSD.cxx:340
 AliITSHandleDaSSD.cxx:341
 AliITSHandleDaSSD.cxx:342
 AliITSHandleDaSSD.cxx:343
 AliITSHandleDaSSD.cxx:344
 AliITSHandleDaSSD.cxx:345
 AliITSHandleDaSSD.cxx:346
 AliITSHandleDaSSD.cxx:347
 AliITSHandleDaSSD.cxx:348
 AliITSHandleDaSSD.cxx:349
 AliITSHandleDaSSD.cxx:350
 AliITSHandleDaSSD.cxx:351
 AliITSHandleDaSSD.cxx:352
 AliITSHandleDaSSD.cxx:353
 AliITSHandleDaSSD.cxx:354
 AliITSHandleDaSSD.cxx:355
 AliITSHandleDaSSD.cxx:356
 AliITSHandleDaSSD.cxx:357
 AliITSHandleDaSSD.cxx:358
 AliITSHandleDaSSD.cxx:359
 AliITSHandleDaSSD.cxx:360
 AliITSHandleDaSSD.cxx:361
 AliITSHandleDaSSD.cxx:362
 AliITSHandleDaSSD.cxx:363
 AliITSHandleDaSSD.cxx:364
 AliITSHandleDaSSD.cxx:365
 AliITSHandleDaSSD.cxx:366
 AliITSHandleDaSSD.cxx:367
 AliITSHandleDaSSD.cxx:368
 AliITSHandleDaSSD.cxx:369
 AliITSHandleDaSSD.cxx:370
 AliITSHandleDaSSD.cxx:371
 AliITSHandleDaSSD.cxx:372
 AliITSHandleDaSSD.cxx:373
 AliITSHandleDaSSD.cxx:374
 AliITSHandleDaSSD.cxx:375
 AliITSHandleDaSSD.cxx:376
 AliITSHandleDaSSD.cxx:377
 AliITSHandleDaSSD.cxx:378
 AliITSHandleDaSSD.cxx:379
 AliITSHandleDaSSD.cxx:380
 AliITSHandleDaSSD.cxx:381
 AliITSHandleDaSSD.cxx:382
 AliITSHandleDaSSD.cxx:383
 AliITSHandleDaSSD.cxx:384
 AliITSHandleDaSSD.cxx:385
 AliITSHandleDaSSD.cxx:386
 AliITSHandleDaSSD.cxx:387
 AliITSHandleDaSSD.cxx:388
 AliITSHandleDaSSD.cxx:389
 AliITSHandleDaSSD.cxx:390
 AliITSHandleDaSSD.cxx:391
 AliITSHandleDaSSD.cxx:392
 AliITSHandleDaSSD.cxx:393
 AliITSHandleDaSSD.cxx:394
 AliITSHandleDaSSD.cxx:395
 AliITSHandleDaSSD.cxx:396
 AliITSHandleDaSSD.cxx:397
 AliITSHandleDaSSD.cxx:398
 AliITSHandleDaSSD.cxx:399
 AliITSHandleDaSSD.cxx:400
 AliITSHandleDaSSD.cxx:401
 AliITSHandleDaSSD.cxx:402
 AliITSHandleDaSSD.cxx:403
 AliITSHandleDaSSD.cxx:404
 AliITSHandleDaSSD.cxx:405
 AliITSHandleDaSSD.cxx:406
 AliITSHandleDaSSD.cxx:407
 AliITSHandleDaSSD.cxx:408
 AliITSHandleDaSSD.cxx:409
 AliITSHandleDaSSD.cxx:410
 AliITSHandleDaSSD.cxx:411
 AliITSHandleDaSSD.cxx:412
 AliITSHandleDaSSD.cxx:413
 AliITSHandleDaSSD.cxx:414
 AliITSHandleDaSSD.cxx:415
 AliITSHandleDaSSD.cxx:416
 AliITSHandleDaSSD.cxx:417
 AliITSHandleDaSSD.cxx:418
 AliITSHandleDaSSD.cxx:419
 AliITSHandleDaSSD.cxx:420
 AliITSHandleDaSSD.cxx:421
 AliITSHandleDaSSD.cxx:422
 AliITSHandleDaSSD.cxx:423
 AliITSHandleDaSSD.cxx:424
 AliITSHandleDaSSD.cxx:425
 AliITSHandleDaSSD.cxx:426
 AliITSHandleDaSSD.cxx:427
 AliITSHandleDaSSD.cxx:428
 AliITSHandleDaSSD.cxx:429
 AliITSHandleDaSSD.cxx:430
 AliITSHandleDaSSD.cxx:431
 AliITSHandleDaSSD.cxx:432
 AliITSHandleDaSSD.cxx:433
 AliITSHandleDaSSD.cxx:434
 AliITSHandleDaSSD.cxx:435
 AliITSHandleDaSSD.cxx:436
 AliITSHandleDaSSD.cxx:437
 AliITSHandleDaSSD.cxx:438
 AliITSHandleDaSSD.cxx:439
 AliITSHandleDaSSD.cxx:440
 AliITSHandleDaSSD.cxx:441
 AliITSHandleDaSSD.cxx:442
 AliITSHandleDaSSD.cxx:443
 AliITSHandleDaSSD.cxx:444
 AliITSHandleDaSSD.cxx:445
 AliITSHandleDaSSD.cxx:446
 AliITSHandleDaSSD.cxx:447
 AliITSHandleDaSSD.cxx:448
 AliITSHandleDaSSD.cxx:449
 AliITSHandleDaSSD.cxx:450
 AliITSHandleDaSSD.cxx:451
 AliITSHandleDaSSD.cxx:452
 AliITSHandleDaSSD.cxx:453
 AliITSHandleDaSSD.cxx:454
 AliITSHandleDaSSD.cxx:455
 AliITSHandleDaSSD.cxx:456
 AliITSHandleDaSSD.cxx:457
 AliITSHandleDaSSD.cxx:458
 AliITSHandleDaSSD.cxx:459
 AliITSHandleDaSSD.cxx:460
 AliITSHandleDaSSD.cxx:461
 AliITSHandleDaSSD.cxx:462
 AliITSHandleDaSSD.cxx:463
 AliITSHandleDaSSD.cxx:464
 AliITSHandleDaSSD.cxx:465
 AliITSHandleDaSSD.cxx:466
 AliITSHandleDaSSD.cxx:467
 AliITSHandleDaSSD.cxx:468
 AliITSHandleDaSSD.cxx:469
 AliITSHandleDaSSD.cxx:470
 AliITSHandleDaSSD.cxx:471
 AliITSHandleDaSSD.cxx:472
 AliITSHandleDaSSD.cxx:473
 AliITSHandleDaSSD.cxx:474
 AliITSHandleDaSSD.cxx:475
 AliITSHandleDaSSD.cxx:476
 AliITSHandleDaSSD.cxx:477
 AliITSHandleDaSSD.cxx:478
 AliITSHandleDaSSD.cxx:479
 AliITSHandleDaSSD.cxx:480
 AliITSHandleDaSSD.cxx:481
 AliITSHandleDaSSD.cxx:482
 AliITSHandleDaSSD.cxx:483
 AliITSHandleDaSSD.cxx:484
 AliITSHandleDaSSD.cxx:485
 AliITSHandleDaSSD.cxx:486
 AliITSHandleDaSSD.cxx:487
 AliITSHandleDaSSD.cxx:488
 AliITSHandleDaSSD.cxx:489
 AliITSHandleDaSSD.cxx:490
 AliITSHandleDaSSD.cxx:491
 AliITSHandleDaSSD.cxx:492
 AliITSHandleDaSSD.cxx:493
 AliITSHandleDaSSD.cxx:494
 AliITSHandleDaSSD.cxx:495
 AliITSHandleDaSSD.cxx:496
 AliITSHandleDaSSD.cxx:497
 AliITSHandleDaSSD.cxx:498
 AliITSHandleDaSSD.cxx:499
 AliITSHandleDaSSD.cxx:500
 AliITSHandleDaSSD.cxx:501
 AliITSHandleDaSSD.cxx:502
 AliITSHandleDaSSD.cxx:503
 AliITSHandleDaSSD.cxx:504
 AliITSHandleDaSSD.cxx:505
 AliITSHandleDaSSD.cxx:506
 AliITSHandleDaSSD.cxx:507
 AliITSHandleDaSSD.cxx:508
 AliITSHandleDaSSD.cxx:509
 AliITSHandleDaSSD.cxx:510
 AliITSHandleDaSSD.cxx:511
 AliITSHandleDaSSD.cxx:512
 AliITSHandleDaSSD.cxx:513
 AliITSHandleDaSSD.cxx:514
 AliITSHandleDaSSD.cxx:515
 AliITSHandleDaSSD.cxx:516
 AliITSHandleDaSSD.cxx:517
 AliITSHandleDaSSD.cxx:518
 AliITSHandleDaSSD.cxx:519
 AliITSHandleDaSSD.cxx:520
 AliITSHandleDaSSD.cxx:521
 AliITSHandleDaSSD.cxx:522
 AliITSHandleDaSSD.cxx:523
 AliITSHandleDaSSD.cxx:524
 AliITSHandleDaSSD.cxx:525
 AliITSHandleDaSSD.cxx:526
 AliITSHandleDaSSD.cxx:527
 AliITSHandleDaSSD.cxx:528
 AliITSHandleDaSSD.cxx:529
 AliITSHandleDaSSD.cxx:530
 AliITSHandleDaSSD.cxx:531
 AliITSHandleDaSSD.cxx:532
 AliITSHandleDaSSD.cxx:533
 AliITSHandleDaSSD.cxx:534
 AliITSHandleDaSSD.cxx:535
 AliITSHandleDaSSD.cxx:536
 AliITSHandleDaSSD.cxx:537
 AliITSHandleDaSSD.cxx:538
 AliITSHandleDaSSD.cxx:539
 AliITSHandleDaSSD.cxx:540
 AliITSHandleDaSSD.cxx:541
 AliITSHandleDaSSD.cxx:542
 AliITSHandleDaSSD.cxx:543
 AliITSHandleDaSSD.cxx:544
 AliITSHandleDaSSD.cxx:545
 AliITSHandleDaSSD.cxx:546
 AliITSHandleDaSSD.cxx:547
 AliITSHandleDaSSD.cxx:548
 AliITSHandleDaSSD.cxx:549
 AliITSHandleDaSSD.cxx:550
 AliITSHandleDaSSD.cxx:551
 AliITSHandleDaSSD.cxx:552
 AliITSHandleDaSSD.cxx:553
 AliITSHandleDaSSD.cxx:554
 AliITSHandleDaSSD.cxx:555
 AliITSHandleDaSSD.cxx:556
 AliITSHandleDaSSD.cxx:557
 AliITSHandleDaSSD.cxx:558
 AliITSHandleDaSSD.cxx:559
 AliITSHandleDaSSD.cxx:560
 AliITSHandleDaSSD.cxx:561
 AliITSHandleDaSSD.cxx:562
 AliITSHandleDaSSD.cxx:563
 AliITSHandleDaSSD.cxx:564
 AliITSHandleDaSSD.cxx:565
 AliITSHandleDaSSD.cxx:566
 AliITSHandleDaSSD.cxx:567
 AliITSHandleDaSSD.cxx:568
 AliITSHandleDaSSD.cxx:569
 AliITSHandleDaSSD.cxx:570
 AliITSHandleDaSSD.cxx:571
 AliITSHandleDaSSD.cxx:572
 AliITSHandleDaSSD.cxx:573
 AliITSHandleDaSSD.cxx:574
 AliITSHandleDaSSD.cxx:575
 AliITSHandleDaSSD.cxx:576
 AliITSHandleDaSSD.cxx:577
 AliITSHandleDaSSD.cxx:578
 AliITSHandleDaSSD.cxx:579
 AliITSHandleDaSSD.cxx:580
 AliITSHandleDaSSD.cxx:581
 AliITSHandleDaSSD.cxx:582
 AliITSHandleDaSSD.cxx:583
 AliITSHandleDaSSD.cxx:584
 AliITSHandleDaSSD.cxx:585
 AliITSHandleDaSSD.cxx:586
 AliITSHandleDaSSD.cxx:587
 AliITSHandleDaSSD.cxx:588
 AliITSHandleDaSSD.cxx:589
 AliITSHandleDaSSD.cxx:590
 AliITSHandleDaSSD.cxx:591
 AliITSHandleDaSSD.cxx:592
 AliITSHandleDaSSD.cxx:593
 AliITSHandleDaSSD.cxx:594
 AliITSHandleDaSSD.cxx:595
 AliITSHandleDaSSD.cxx:596
 AliITSHandleDaSSD.cxx:597
 AliITSHandleDaSSD.cxx:598
 AliITSHandleDaSSD.cxx:599
 AliITSHandleDaSSD.cxx:600
 AliITSHandleDaSSD.cxx:601
 AliITSHandleDaSSD.cxx:602
 AliITSHandleDaSSD.cxx:603
 AliITSHandleDaSSD.cxx:604
 AliITSHandleDaSSD.cxx:605
 AliITSHandleDaSSD.cxx:606
 AliITSHandleDaSSD.cxx:607
 AliITSHandleDaSSD.cxx:608
 AliITSHandleDaSSD.cxx:609
 AliITSHandleDaSSD.cxx:610
 AliITSHandleDaSSD.cxx:611
 AliITSHandleDaSSD.cxx:612
 AliITSHandleDaSSD.cxx:613
 AliITSHandleDaSSD.cxx:614
 AliITSHandleDaSSD.cxx:615
 AliITSHandleDaSSD.cxx:616
 AliITSHandleDaSSD.cxx:617
 AliITSHandleDaSSD.cxx:618
 AliITSHandleDaSSD.cxx:619
 AliITSHandleDaSSD.cxx:620
 AliITSHandleDaSSD.cxx:621
 AliITSHandleDaSSD.cxx:622
 AliITSHandleDaSSD.cxx:623
 AliITSHandleDaSSD.cxx:624
 AliITSHandleDaSSD.cxx:625
 AliITSHandleDaSSD.cxx:626
 AliITSHandleDaSSD.cxx:627
 AliITSHandleDaSSD.cxx:628
 AliITSHandleDaSSD.cxx:629
 AliITSHandleDaSSD.cxx:630
 AliITSHandleDaSSD.cxx:631
 AliITSHandleDaSSD.cxx:632
 AliITSHandleDaSSD.cxx:633
 AliITSHandleDaSSD.cxx:634
 AliITSHandleDaSSD.cxx:635
 AliITSHandleDaSSD.cxx:636
 AliITSHandleDaSSD.cxx:637
 AliITSHandleDaSSD.cxx:638
 AliITSHandleDaSSD.cxx:639
 AliITSHandleDaSSD.cxx:640
 AliITSHandleDaSSD.cxx:641
 AliITSHandleDaSSD.cxx:642
 AliITSHandleDaSSD.cxx:643
 AliITSHandleDaSSD.cxx:644
 AliITSHandleDaSSD.cxx:645
 AliITSHandleDaSSD.cxx:646
 AliITSHandleDaSSD.cxx:647
 AliITSHandleDaSSD.cxx:648
 AliITSHandleDaSSD.cxx:649
 AliITSHandleDaSSD.cxx:650
 AliITSHandleDaSSD.cxx:651
 AliITSHandleDaSSD.cxx:652
 AliITSHandleDaSSD.cxx:653
 AliITSHandleDaSSD.cxx:654
 AliITSHandleDaSSD.cxx:655
 AliITSHandleDaSSD.cxx:656
 AliITSHandleDaSSD.cxx:657
 AliITSHandleDaSSD.cxx:658
 AliITSHandleDaSSD.cxx:659
 AliITSHandleDaSSD.cxx:660
 AliITSHandleDaSSD.cxx:661
 AliITSHandleDaSSD.cxx:662
 AliITSHandleDaSSD.cxx:663
 AliITSHandleDaSSD.cxx:664
 AliITSHandleDaSSD.cxx:665
 AliITSHandleDaSSD.cxx:666
 AliITSHandleDaSSD.cxx:667
 AliITSHandleDaSSD.cxx:668
 AliITSHandleDaSSD.cxx:669
 AliITSHandleDaSSD.cxx:670
 AliITSHandleDaSSD.cxx:671
 AliITSHandleDaSSD.cxx:672
 AliITSHandleDaSSD.cxx:673
 AliITSHandleDaSSD.cxx:674
 AliITSHandleDaSSD.cxx:675
 AliITSHandleDaSSD.cxx:676
 AliITSHandleDaSSD.cxx:677
 AliITSHandleDaSSD.cxx:678
 AliITSHandleDaSSD.cxx:679
 AliITSHandleDaSSD.cxx:680
 AliITSHandleDaSSD.cxx:681
 AliITSHandleDaSSD.cxx:682
 AliITSHandleDaSSD.cxx:683
 AliITSHandleDaSSD.cxx:684
 AliITSHandleDaSSD.cxx:685
 AliITSHandleDaSSD.cxx:686
 AliITSHandleDaSSD.cxx:687
 AliITSHandleDaSSD.cxx:688
 AliITSHandleDaSSD.cxx:689
 AliITSHandleDaSSD.cxx:690
 AliITSHandleDaSSD.cxx:691
 AliITSHandleDaSSD.cxx:692
 AliITSHandleDaSSD.cxx:693
 AliITSHandleDaSSD.cxx:694
 AliITSHandleDaSSD.cxx:695
 AliITSHandleDaSSD.cxx:696
 AliITSHandleDaSSD.cxx:697
 AliITSHandleDaSSD.cxx:698
 AliITSHandleDaSSD.cxx:699
 AliITSHandleDaSSD.cxx:700
 AliITSHandleDaSSD.cxx:701
 AliITSHandleDaSSD.cxx:702
 AliITSHandleDaSSD.cxx:703
 AliITSHandleDaSSD.cxx:704
 AliITSHandleDaSSD.cxx:705
 AliITSHandleDaSSD.cxx:706
 AliITSHandleDaSSD.cxx:707
 AliITSHandleDaSSD.cxx:708
 AliITSHandleDaSSD.cxx:709
 AliITSHandleDaSSD.cxx:710
 AliITSHandleDaSSD.cxx:711
 AliITSHandleDaSSD.cxx:712
 AliITSHandleDaSSD.cxx:713
 AliITSHandleDaSSD.cxx:714
 AliITSHandleDaSSD.cxx:715
 AliITSHandleDaSSD.cxx:716
 AliITSHandleDaSSD.cxx:717
 AliITSHandleDaSSD.cxx:718
 AliITSHandleDaSSD.cxx:719
 AliITSHandleDaSSD.cxx:720
 AliITSHandleDaSSD.cxx:721
 AliITSHandleDaSSD.cxx:722
 AliITSHandleDaSSD.cxx:723
 AliITSHandleDaSSD.cxx:724
 AliITSHandleDaSSD.cxx:725
 AliITSHandleDaSSD.cxx:726
 AliITSHandleDaSSD.cxx:727
 AliITSHandleDaSSD.cxx:728
 AliITSHandleDaSSD.cxx:729
 AliITSHandleDaSSD.cxx:730
 AliITSHandleDaSSD.cxx:731
 AliITSHandleDaSSD.cxx:732
 AliITSHandleDaSSD.cxx:733
 AliITSHandleDaSSD.cxx:734
 AliITSHandleDaSSD.cxx:735
 AliITSHandleDaSSD.cxx:736
 AliITSHandleDaSSD.cxx:737
 AliITSHandleDaSSD.cxx:738
 AliITSHandleDaSSD.cxx:739
 AliITSHandleDaSSD.cxx:740
 AliITSHandleDaSSD.cxx:741
 AliITSHandleDaSSD.cxx:742
 AliITSHandleDaSSD.cxx:743
 AliITSHandleDaSSD.cxx:744
 AliITSHandleDaSSD.cxx:745
 AliITSHandleDaSSD.cxx:746
 AliITSHandleDaSSD.cxx:747
 AliITSHandleDaSSD.cxx:748
 AliITSHandleDaSSD.cxx:749
 AliITSHandleDaSSD.cxx:750
 AliITSHandleDaSSD.cxx:751
 AliITSHandleDaSSD.cxx:752
 AliITSHandleDaSSD.cxx:753
 AliITSHandleDaSSD.cxx:754
 AliITSHandleDaSSD.cxx:755
 AliITSHandleDaSSD.cxx:756
 AliITSHandleDaSSD.cxx:757
 AliITSHandleDaSSD.cxx:758
 AliITSHandleDaSSD.cxx:759
 AliITSHandleDaSSD.cxx:760
 AliITSHandleDaSSD.cxx:761
 AliITSHandleDaSSD.cxx:762
 AliITSHandleDaSSD.cxx:763
 AliITSHandleDaSSD.cxx:764
 AliITSHandleDaSSD.cxx:765
 AliITSHandleDaSSD.cxx:766
 AliITSHandleDaSSD.cxx:767
 AliITSHandleDaSSD.cxx:768
 AliITSHandleDaSSD.cxx:769
 AliITSHandleDaSSD.cxx:770
 AliITSHandleDaSSD.cxx:771
 AliITSHandleDaSSD.cxx:772
 AliITSHandleDaSSD.cxx:773
 AliITSHandleDaSSD.cxx:774
 AliITSHandleDaSSD.cxx:775
 AliITSHandleDaSSD.cxx:776
 AliITSHandleDaSSD.cxx:777
 AliITSHandleDaSSD.cxx:778
 AliITSHandleDaSSD.cxx:779
 AliITSHandleDaSSD.cxx:780
 AliITSHandleDaSSD.cxx:781
 AliITSHandleDaSSD.cxx:782
 AliITSHandleDaSSD.cxx:783
 AliITSHandleDaSSD.cxx:784
 AliITSHandleDaSSD.cxx:785
 AliITSHandleDaSSD.cxx:786
 AliITSHandleDaSSD.cxx:787
 AliITSHandleDaSSD.cxx:788
 AliITSHandleDaSSD.cxx:789
 AliITSHandleDaSSD.cxx:790
 AliITSHandleDaSSD.cxx:791
 AliITSHandleDaSSD.cxx:792
 AliITSHandleDaSSD.cxx:793
 AliITSHandleDaSSD.cxx:794
 AliITSHandleDaSSD.cxx:795
 AliITSHandleDaSSD.cxx:796
 AliITSHandleDaSSD.cxx:797
 AliITSHandleDaSSD.cxx:798
 AliITSHandleDaSSD.cxx:799
 AliITSHandleDaSSD.cxx:800
 AliITSHandleDaSSD.cxx:801
 AliITSHandleDaSSD.cxx:802
 AliITSHandleDaSSD.cxx:803
 AliITSHandleDaSSD.cxx:804
 AliITSHandleDaSSD.cxx:805
 AliITSHandleDaSSD.cxx:806
 AliITSHandleDaSSD.cxx:807
 AliITSHandleDaSSD.cxx:808
 AliITSHandleDaSSD.cxx:809
 AliITSHandleDaSSD.cxx:810
 AliITSHandleDaSSD.cxx:811
 AliITSHandleDaSSD.cxx:812
 AliITSHandleDaSSD.cxx:813
 AliITSHandleDaSSD.cxx:814
 AliITSHandleDaSSD.cxx:815
 AliITSHandleDaSSD.cxx:816
 AliITSHandleDaSSD.cxx:817
 AliITSHandleDaSSD.cxx:818
 AliITSHandleDaSSD.cxx:819
 AliITSHandleDaSSD.cxx:820
 AliITSHandleDaSSD.cxx:821
 AliITSHandleDaSSD.cxx:822
 AliITSHandleDaSSD.cxx:823
 AliITSHandleDaSSD.cxx:824
 AliITSHandleDaSSD.cxx:825
 AliITSHandleDaSSD.cxx:826
 AliITSHandleDaSSD.cxx:827
 AliITSHandleDaSSD.cxx:828
 AliITSHandleDaSSD.cxx:829
 AliITSHandleDaSSD.cxx:830
 AliITSHandleDaSSD.cxx:831
 AliITSHandleDaSSD.cxx:832
 AliITSHandleDaSSD.cxx:833
 AliITSHandleDaSSD.cxx:834
 AliITSHandleDaSSD.cxx:835
 AliITSHandleDaSSD.cxx:836
 AliITSHandleDaSSD.cxx:837
 AliITSHandleDaSSD.cxx:838
 AliITSHandleDaSSD.cxx:839
 AliITSHandleDaSSD.cxx:840
 AliITSHandleDaSSD.cxx:841
 AliITSHandleDaSSD.cxx:842
 AliITSHandleDaSSD.cxx:843
 AliITSHandleDaSSD.cxx:844
 AliITSHandleDaSSD.cxx:845
 AliITSHandleDaSSD.cxx:846
 AliITSHandleDaSSD.cxx:847
 AliITSHandleDaSSD.cxx:848
 AliITSHandleDaSSD.cxx:849
 AliITSHandleDaSSD.cxx:850
 AliITSHandleDaSSD.cxx:851
 AliITSHandleDaSSD.cxx:852
 AliITSHandleDaSSD.cxx:853
 AliITSHandleDaSSD.cxx:854
 AliITSHandleDaSSD.cxx:855
 AliITSHandleDaSSD.cxx:856
 AliITSHandleDaSSD.cxx:857
 AliITSHandleDaSSD.cxx:858
 AliITSHandleDaSSD.cxx:859
 AliITSHandleDaSSD.cxx:860
 AliITSHandleDaSSD.cxx:861
 AliITSHandleDaSSD.cxx:862
 AliITSHandleDaSSD.cxx:863
 AliITSHandleDaSSD.cxx:864
 AliITSHandleDaSSD.cxx:865
 AliITSHandleDaSSD.cxx:866
 AliITSHandleDaSSD.cxx:867
 AliITSHandleDaSSD.cxx:868
 AliITSHandleDaSSD.cxx:869
 AliITSHandleDaSSD.cxx:870
 AliITSHandleDaSSD.cxx:871
 AliITSHandleDaSSD.cxx:872
 AliITSHandleDaSSD.cxx:873
 AliITSHandleDaSSD.cxx:874
 AliITSHandleDaSSD.cxx:875
 AliITSHandleDaSSD.cxx:876
 AliITSHandleDaSSD.cxx:877
 AliITSHandleDaSSD.cxx:878
 AliITSHandleDaSSD.cxx:879
 AliITSHandleDaSSD.cxx:880
 AliITSHandleDaSSD.cxx:881
 AliITSHandleDaSSD.cxx:882
 AliITSHandleDaSSD.cxx:883
 AliITSHandleDaSSD.cxx:884
 AliITSHandleDaSSD.cxx:885
 AliITSHandleDaSSD.cxx:886
 AliITSHandleDaSSD.cxx:887
 AliITSHandleDaSSD.cxx:888
 AliITSHandleDaSSD.cxx:889
 AliITSHandleDaSSD.cxx:890
 AliITSHandleDaSSD.cxx:891
 AliITSHandleDaSSD.cxx:892
 AliITSHandleDaSSD.cxx:893
 AliITSHandleDaSSD.cxx:894
 AliITSHandleDaSSD.cxx:895
 AliITSHandleDaSSD.cxx:896
 AliITSHandleDaSSD.cxx:897
 AliITSHandleDaSSD.cxx:898
 AliITSHandleDaSSD.cxx:899
 AliITSHandleDaSSD.cxx:900
 AliITSHandleDaSSD.cxx:901
 AliITSHandleDaSSD.cxx:902
 AliITSHandleDaSSD.cxx:903
 AliITSHandleDaSSD.cxx:904
 AliITSHandleDaSSD.cxx:905
 AliITSHandleDaSSD.cxx:906
 AliITSHandleDaSSD.cxx:907
 AliITSHandleDaSSD.cxx:908
 AliITSHandleDaSSD.cxx:909
 AliITSHandleDaSSD.cxx:910
 AliITSHandleDaSSD.cxx:911
 AliITSHandleDaSSD.cxx:912
 AliITSHandleDaSSD.cxx:913
 AliITSHandleDaSSD.cxx:914
 AliITSHandleDaSSD.cxx:915
 AliITSHandleDaSSD.cxx:916
 AliITSHandleDaSSD.cxx:917
 AliITSHandleDaSSD.cxx:918
 AliITSHandleDaSSD.cxx:919
 AliITSHandleDaSSD.cxx:920
 AliITSHandleDaSSD.cxx:921
 AliITSHandleDaSSD.cxx:922
 AliITSHandleDaSSD.cxx:923
 AliITSHandleDaSSD.cxx:924
 AliITSHandleDaSSD.cxx:925
 AliITSHandleDaSSD.cxx:926
 AliITSHandleDaSSD.cxx:927
 AliITSHandleDaSSD.cxx:928
 AliITSHandleDaSSD.cxx:929
 AliITSHandleDaSSD.cxx:930
 AliITSHandleDaSSD.cxx:931
 AliITSHandleDaSSD.cxx:932
 AliITSHandleDaSSD.cxx:933
 AliITSHandleDaSSD.cxx:934
 AliITSHandleDaSSD.cxx:935
 AliITSHandleDaSSD.cxx:936
 AliITSHandleDaSSD.cxx:937
 AliITSHandleDaSSD.cxx:938
 AliITSHandleDaSSD.cxx:939
 AliITSHandleDaSSD.cxx:940
 AliITSHandleDaSSD.cxx:941
 AliITSHandleDaSSD.cxx:942
 AliITSHandleDaSSD.cxx:943
 AliITSHandleDaSSD.cxx:944
 AliITSHandleDaSSD.cxx:945
 AliITSHandleDaSSD.cxx:946
 AliITSHandleDaSSD.cxx:947
 AliITSHandleDaSSD.cxx:948
 AliITSHandleDaSSD.cxx:949
 AliITSHandleDaSSD.cxx:950
 AliITSHandleDaSSD.cxx:951
 AliITSHandleDaSSD.cxx:952
 AliITSHandleDaSSD.cxx:953
 AliITSHandleDaSSD.cxx:954
 AliITSHandleDaSSD.cxx:955
 AliITSHandleDaSSD.cxx:956
 AliITSHandleDaSSD.cxx:957
 AliITSHandleDaSSD.cxx:958
 AliITSHandleDaSSD.cxx:959
 AliITSHandleDaSSD.cxx:960
 AliITSHandleDaSSD.cxx:961
 AliITSHandleDaSSD.cxx:962
 AliITSHandleDaSSD.cxx:963
 AliITSHandleDaSSD.cxx:964
 AliITSHandleDaSSD.cxx:965
 AliITSHandleDaSSD.cxx:966
 AliITSHandleDaSSD.cxx:967
 AliITSHandleDaSSD.cxx:968
 AliITSHandleDaSSD.cxx:969
 AliITSHandleDaSSD.cxx:970
 AliITSHandleDaSSD.cxx:971
 AliITSHandleDaSSD.cxx:972
 AliITSHandleDaSSD.cxx:973
 AliITSHandleDaSSD.cxx:974
 AliITSHandleDaSSD.cxx:975
 AliITSHandleDaSSD.cxx:976
 AliITSHandleDaSSD.cxx:977
 AliITSHandleDaSSD.cxx:978
 AliITSHandleDaSSD.cxx:979
 AliITSHandleDaSSD.cxx:980
 AliITSHandleDaSSD.cxx:981
 AliITSHandleDaSSD.cxx:982
 AliITSHandleDaSSD.cxx:983
 AliITSHandleDaSSD.cxx:984
 AliITSHandleDaSSD.cxx:985
 AliITSHandleDaSSD.cxx:986
 AliITSHandleDaSSD.cxx:987
 AliITSHandleDaSSD.cxx:988
 AliITSHandleDaSSD.cxx:989
 AliITSHandleDaSSD.cxx:990
 AliITSHandleDaSSD.cxx:991
 AliITSHandleDaSSD.cxx:992
 AliITSHandleDaSSD.cxx:993
 AliITSHandleDaSSD.cxx:994
 AliITSHandleDaSSD.cxx:995
 AliITSHandleDaSSD.cxx:996
 AliITSHandleDaSSD.cxx:997
 AliITSHandleDaSSD.cxx:998
 AliITSHandleDaSSD.cxx:999
 AliITSHandleDaSSD.cxx:1000
 AliITSHandleDaSSD.cxx:1001
 AliITSHandleDaSSD.cxx:1002
 AliITSHandleDaSSD.cxx:1003
 AliITSHandleDaSSD.cxx:1004
 AliITSHandleDaSSD.cxx:1005
 AliITSHandleDaSSD.cxx:1006
 AliITSHandleDaSSD.cxx:1007
 AliITSHandleDaSSD.cxx:1008
 AliITSHandleDaSSD.cxx:1009
 AliITSHandleDaSSD.cxx:1010
 AliITSHandleDaSSD.cxx:1011
 AliITSHandleDaSSD.cxx:1012
 AliITSHandleDaSSD.cxx:1013
 AliITSHandleDaSSD.cxx:1014
 AliITSHandleDaSSD.cxx:1015
 AliITSHandleDaSSD.cxx:1016
 AliITSHandleDaSSD.cxx:1017
 AliITSHandleDaSSD.cxx:1018
 AliITSHandleDaSSD.cxx:1019
 AliITSHandleDaSSD.cxx:1020
 AliITSHandleDaSSD.cxx:1021
 AliITSHandleDaSSD.cxx:1022
 AliITSHandleDaSSD.cxx:1023
 AliITSHandleDaSSD.cxx:1024
 AliITSHandleDaSSD.cxx:1025
 AliITSHandleDaSSD.cxx:1026
 AliITSHandleDaSSD.cxx:1027
 AliITSHandleDaSSD.cxx:1028
 AliITSHandleDaSSD.cxx:1029
 AliITSHandleDaSSD.cxx:1030
 AliITSHandleDaSSD.cxx:1031
 AliITSHandleDaSSD.cxx:1032
 AliITSHandleDaSSD.cxx:1033
 AliITSHandleDaSSD.cxx:1034
 AliITSHandleDaSSD.cxx:1035
 AliITSHandleDaSSD.cxx:1036
 AliITSHandleDaSSD.cxx:1037
 AliITSHandleDaSSD.cxx:1038
 AliITSHandleDaSSD.cxx:1039
 AliITSHandleDaSSD.cxx:1040
 AliITSHandleDaSSD.cxx:1041
 AliITSHandleDaSSD.cxx:1042
 AliITSHandleDaSSD.cxx:1043
 AliITSHandleDaSSD.cxx:1044
 AliITSHandleDaSSD.cxx:1045
 AliITSHandleDaSSD.cxx:1046
 AliITSHandleDaSSD.cxx:1047
 AliITSHandleDaSSD.cxx:1048
 AliITSHandleDaSSD.cxx:1049
 AliITSHandleDaSSD.cxx:1050
 AliITSHandleDaSSD.cxx:1051
 AliITSHandleDaSSD.cxx:1052
 AliITSHandleDaSSD.cxx:1053
 AliITSHandleDaSSD.cxx:1054
 AliITSHandleDaSSD.cxx:1055
 AliITSHandleDaSSD.cxx:1056
 AliITSHandleDaSSD.cxx:1057
 AliITSHandleDaSSD.cxx:1058
 AliITSHandleDaSSD.cxx:1059
 AliITSHandleDaSSD.cxx:1060
 AliITSHandleDaSSD.cxx:1061
 AliITSHandleDaSSD.cxx:1062
 AliITSHandleDaSSD.cxx:1063
 AliITSHandleDaSSD.cxx:1064
 AliITSHandleDaSSD.cxx:1065
 AliITSHandleDaSSD.cxx:1066
 AliITSHandleDaSSD.cxx:1067
 AliITSHandleDaSSD.cxx:1068
 AliITSHandleDaSSD.cxx:1069
 AliITSHandleDaSSD.cxx:1070
 AliITSHandleDaSSD.cxx:1071
 AliITSHandleDaSSD.cxx:1072
 AliITSHandleDaSSD.cxx:1073
 AliITSHandleDaSSD.cxx:1074
 AliITSHandleDaSSD.cxx:1075
 AliITSHandleDaSSD.cxx:1076
 AliITSHandleDaSSD.cxx:1077
 AliITSHandleDaSSD.cxx:1078
 AliITSHandleDaSSD.cxx:1079
 AliITSHandleDaSSD.cxx:1080
 AliITSHandleDaSSD.cxx:1081
 AliITSHandleDaSSD.cxx:1082
 AliITSHandleDaSSD.cxx:1083
 AliITSHandleDaSSD.cxx:1084
 AliITSHandleDaSSD.cxx:1085
 AliITSHandleDaSSD.cxx:1086
 AliITSHandleDaSSD.cxx:1087
 AliITSHandleDaSSD.cxx:1088
 AliITSHandleDaSSD.cxx:1089
 AliITSHandleDaSSD.cxx:1090
 AliITSHandleDaSSD.cxx:1091
 AliITSHandleDaSSD.cxx:1092
 AliITSHandleDaSSD.cxx:1093
 AliITSHandleDaSSD.cxx:1094
 AliITSHandleDaSSD.cxx:1095
 AliITSHandleDaSSD.cxx:1096
 AliITSHandleDaSSD.cxx:1097
 AliITSHandleDaSSD.cxx:1098
 AliITSHandleDaSSD.cxx:1099
 AliITSHandleDaSSD.cxx:1100
 AliITSHandleDaSSD.cxx:1101
 AliITSHandleDaSSD.cxx:1102
 AliITSHandleDaSSD.cxx:1103
 AliITSHandleDaSSD.cxx:1104
 AliITSHandleDaSSD.cxx:1105
 AliITSHandleDaSSD.cxx:1106
 AliITSHandleDaSSD.cxx:1107
 AliITSHandleDaSSD.cxx:1108
 AliITSHandleDaSSD.cxx:1109
 AliITSHandleDaSSD.cxx:1110
 AliITSHandleDaSSD.cxx:1111
 AliITSHandleDaSSD.cxx:1112
 AliITSHandleDaSSD.cxx:1113
 AliITSHandleDaSSD.cxx:1114
 AliITSHandleDaSSD.cxx:1115
 AliITSHandleDaSSD.cxx:1116
 AliITSHandleDaSSD.cxx:1117
 AliITSHandleDaSSD.cxx:1118
 AliITSHandleDaSSD.cxx:1119
 AliITSHandleDaSSD.cxx:1120
 AliITSHandleDaSSD.cxx:1121
 AliITSHandleDaSSD.cxx:1122
 AliITSHandleDaSSD.cxx:1123
 AliITSHandleDaSSD.cxx:1124
 AliITSHandleDaSSD.cxx:1125
 AliITSHandleDaSSD.cxx:1126
 AliITSHandleDaSSD.cxx:1127
 AliITSHandleDaSSD.cxx:1128
 AliITSHandleDaSSD.cxx:1129
 AliITSHandleDaSSD.cxx:1130
 AliITSHandleDaSSD.cxx:1131
 AliITSHandleDaSSD.cxx:1132
 AliITSHandleDaSSD.cxx:1133
 AliITSHandleDaSSD.cxx:1134
 AliITSHandleDaSSD.cxx:1135
 AliITSHandleDaSSD.cxx:1136
 AliITSHandleDaSSD.cxx:1137
 AliITSHandleDaSSD.cxx:1138
 AliITSHandleDaSSD.cxx:1139
 AliITSHandleDaSSD.cxx:1140
 AliITSHandleDaSSD.cxx:1141
 AliITSHandleDaSSD.cxx:1142
 AliITSHandleDaSSD.cxx:1143
 AliITSHandleDaSSD.cxx:1144
 AliITSHandleDaSSD.cxx:1145
 AliITSHandleDaSSD.cxx:1146
 AliITSHandleDaSSD.cxx:1147
 AliITSHandleDaSSD.cxx:1148
 AliITSHandleDaSSD.cxx:1149
 AliITSHandleDaSSD.cxx:1150
 AliITSHandleDaSSD.cxx:1151
 AliITSHandleDaSSD.cxx:1152
 AliITSHandleDaSSD.cxx:1153
 AliITSHandleDaSSD.cxx:1154
 AliITSHandleDaSSD.cxx:1155
 AliITSHandleDaSSD.cxx:1156
 AliITSHandleDaSSD.cxx:1157
 AliITSHandleDaSSD.cxx:1158
 AliITSHandleDaSSD.cxx:1159
 AliITSHandleDaSSD.cxx:1160
 AliITSHandleDaSSD.cxx:1161
 AliITSHandleDaSSD.cxx:1162
 AliITSHandleDaSSD.cxx:1163
 AliITSHandleDaSSD.cxx:1164
 AliITSHandleDaSSD.cxx:1165
 AliITSHandleDaSSD.cxx:1166
 AliITSHandleDaSSD.cxx:1167
 AliITSHandleDaSSD.cxx:1168
 AliITSHandleDaSSD.cxx:1169
 AliITSHandleDaSSD.cxx:1170
 AliITSHandleDaSSD.cxx:1171
 AliITSHandleDaSSD.cxx:1172
 AliITSHandleDaSSD.cxx:1173
 AliITSHandleDaSSD.cxx:1174
 AliITSHandleDaSSD.cxx:1175
 AliITSHandleDaSSD.cxx:1176
 AliITSHandleDaSSD.cxx:1177
 AliITSHandleDaSSD.cxx:1178
 AliITSHandleDaSSD.cxx:1179
 AliITSHandleDaSSD.cxx:1180
 AliITSHandleDaSSD.cxx:1181
 AliITSHandleDaSSD.cxx:1182
 AliITSHandleDaSSD.cxx:1183
 AliITSHandleDaSSD.cxx:1184
 AliITSHandleDaSSD.cxx:1185
 AliITSHandleDaSSD.cxx:1186
 AliITSHandleDaSSD.cxx:1187
 AliITSHandleDaSSD.cxx:1188
 AliITSHandleDaSSD.cxx:1189
 AliITSHandleDaSSD.cxx:1190
 AliITSHandleDaSSD.cxx:1191
 AliITSHandleDaSSD.cxx:1192
 AliITSHandleDaSSD.cxx:1193
 AliITSHandleDaSSD.cxx:1194
 AliITSHandleDaSSD.cxx:1195
 AliITSHandleDaSSD.cxx:1196
 AliITSHandleDaSSD.cxx:1197
 AliITSHandleDaSSD.cxx:1198
 AliITSHandleDaSSD.cxx:1199
 AliITSHandleDaSSD.cxx:1200
 AliITSHandleDaSSD.cxx:1201
 AliITSHandleDaSSD.cxx:1202
 AliITSHandleDaSSD.cxx:1203
 AliITSHandleDaSSD.cxx:1204
 AliITSHandleDaSSD.cxx:1205
 AliITSHandleDaSSD.cxx:1206
 AliITSHandleDaSSD.cxx:1207
 AliITSHandleDaSSD.cxx:1208
 AliITSHandleDaSSD.cxx:1209
 AliITSHandleDaSSD.cxx:1210
 AliITSHandleDaSSD.cxx:1211
 AliITSHandleDaSSD.cxx:1212
 AliITSHandleDaSSD.cxx:1213
 AliITSHandleDaSSD.cxx:1214
 AliITSHandleDaSSD.cxx:1215
 AliITSHandleDaSSD.cxx:1216
 AliITSHandleDaSSD.cxx:1217
 AliITSHandleDaSSD.cxx:1218
 AliITSHandleDaSSD.cxx:1219
 AliITSHandleDaSSD.cxx:1220
 AliITSHandleDaSSD.cxx:1221
 AliITSHandleDaSSD.cxx:1222
 AliITSHandleDaSSD.cxx:1223
 AliITSHandleDaSSD.cxx:1224
 AliITSHandleDaSSD.cxx:1225
 AliITSHandleDaSSD.cxx:1226
 AliITSHandleDaSSD.cxx:1227
 AliITSHandleDaSSD.cxx:1228
 AliITSHandleDaSSD.cxx:1229
 AliITSHandleDaSSD.cxx:1230
 AliITSHandleDaSSD.cxx:1231
 AliITSHandleDaSSD.cxx:1232
 AliITSHandleDaSSD.cxx:1233
 AliITSHandleDaSSD.cxx:1234
 AliITSHandleDaSSD.cxx:1235
 AliITSHandleDaSSD.cxx:1236
 AliITSHandleDaSSD.cxx:1237
 AliITSHandleDaSSD.cxx:1238
 AliITSHandleDaSSD.cxx:1239
 AliITSHandleDaSSD.cxx:1240
 AliITSHandleDaSSD.cxx:1241
 AliITSHandleDaSSD.cxx:1242
 AliITSHandleDaSSD.cxx:1243
 AliITSHandleDaSSD.cxx:1244
 AliITSHandleDaSSD.cxx:1245
 AliITSHandleDaSSD.cxx:1246
 AliITSHandleDaSSD.cxx:1247
 AliITSHandleDaSSD.cxx:1248
 AliITSHandleDaSSD.cxx:1249
 AliITSHandleDaSSD.cxx:1250
 AliITSHandleDaSSD.cxx:1251
 AliITSHandleDaSSD.cxx:1252
 AliITSHandleDaSSD.cxx:1253
 AliITSHandleDaSSD.cxx:1254
 AliITSHandleDaSSD.cxx:1255
 AliITSHandleDaSSD.cxx:1256
 AliITSHandleDaSSD.cxx:1257
 AliITSHandleDaSSD.cxx:1258
 AliITSHandleDaSSD.cxx:1259
 AliITSHandleDaSSD.cxx:1260
 AliITSHandleDaSSD.cxx:1261
 AliITSHandleDaSSD.cxx:1262
 AliITSHandleDaSSD.cxx:1263
 AliITSHandleDaSSD.cxx:1264
 AliITSHandleDaSSD.cxx:1265
 AliITSHandleDaSSD.cxx:1266
 AliITSHandleDaSSD.cxx:1267
 AliITSHandleDaSSD.cxx:1268
 AliITSHandleDaSSD.cxx:1269
 AliITSHandleDaSSD.cxx:1270
 AliITSHandleDaSSD.cxx:1271
 AliITSHandleDaSSD.cxx:1272
 AliITSHandleDaSSD.cxx:1273
 AliITSHandleDaSSD.cxx:1274
 AliITSHandleDaSSD.cxx:1275
 AliITSHandleDaSSD.cxx:1276
 AliITSHandleDaSSD.cxx:1277
 AliITSHandleDaSSD.cxx:1278
 AliITSHandleDaSSD.cxx:1279
 AliITSHandleDaSSD.cxx:1280
 AliITSHandleDaSSD.cxx:1281
 AliITSHandleDaSSD.cxx:1282
 AliITSHandleDaSSD.cxx:1283
 AliITSHandleDaSSD.cxx:1284
 AliITSHandleDaSSD.cxx:1285
 AliITSHandleDaSSD.cxx:1286
 AliITSHandleDaSSD.cxx:1287
 AliITSHandleDaSSD.cxx:1288
 AliITSHandleDaSSD.cxx:1289
 AliITSHandleDaSSD.cxx:1290
 AliITSHandleDaSSD.cxx:1291
 AliITSHandleDaSSD.cxx:1292
 AliITSHandleDaSSD.cxx:1293
 AliITSHandleDaSSD.cxx:1294
 AliITSHandleDaSSD.cxx:1295
 AliITSHandleDaSSD.cxx:1296
 AliITSHandleDaSSD.cxx:1297
 AliITSHandleDaSSD.cxx:1298
 AliITSHandleDaSSD.cxx:1299
 AliITSHandleDaSSD.cxx:1300
 AliITSHandleDaSSD.cxx:1301
 AliITSHandleDaSSD.cxx:1302
 AliITSHandleDaSSD.cxx:1303
 AliITSHandleDaSSD.cxx:1304
 AliITSHandleDaSSD.cxx:1305
 AliITSHandleDaSSD.cxx:1306
 AliITSHandleDaSSD.cxx:1307
 AliITSHandleDaSSD.cxx:1308
 AliITSHandleDaSSD.cxx:1309
 AliITSHandleDaSSD.cxx:1310
 AliITSHandleDaSSD.cxx:1311
 AliITSHandleDaSSD.cxx:1312
 AliITSHandleDaSSD.cxx:1313
 AliITSHandleDaSSD.cxx:1314
 AliITSHandleDaSSD.cxx:1315
 AliITSHandleDaSSD.cxx:1316
 AliITSHandleDaSSD.cxx:1317
 AliITSHandleDaSSD.cxx:1318
 AliITSHandleDaSSD.cxx:1319
 AliITSHandleDaSSD.cxx:1320
 AliITSHandleDaSSD.cxx:1321
 AliITSHandleDaSSD.cxx:1322
 AliITSHandleDaSSD.cxx:1323
 AliITSHandleDaSSD.cxx:1324
 AliITSHandleDaSSD.cxx:1325
 AliITSHandleDaSSD.cxx:1326
 AliITSHandleDaSSD.cxx:1327
 AliITSHandleDaSSD.cxx:1328
 AliITSHandleDaSSD.cxx:1329
 AliITSHandleDaSSD.cxx:1330
 AliITSHandleDaSSD.cxx:1331
 AliITSHandleDaSSD.cxx:1332
 AliITSHandleDaSSD.cxx:1333
 AliITSHandleDaSSD.cxx:1334
 AliITSHandleDaSSD.cxx:1335
 AliITSHandleDaSSD.cxx:1336
 AliITSHandleDaSSD.cxx:1337
 AliITSHandleDaSSD.cxx:1338
 AliITSHandleDaSSD.cxx:1339
 AliITSHandleDaSSD.cxx:1340
 AliITSHandleDaSSD.cxx:1341
 AliITSHandleDaSSD.cxx:1342
 AliITSHandleDaSSD.cxx:1343
 AliITSHandleDaSSD.cxx:1344
 AliITSHandleDaSSD.cxx:1345
 AliITSHandleDaSSD.cxx:1346
 AliITSHandleDaSSD.cxx:1347
 AliITSHandleDaSSD.cxx:1348
 AliITSHandleDaSSD.cxx:1349
 AliITSHandleDaSSD.cxx:1350
 AliITSHandleDaSSD.cxx:1351
 AliITSHandleDaSSD.cxx:1352
 AliITSHandleDaSSD.cxx:1353
 AliITSHandleDaSSD.cxx:1354
 AliITSHandleDaSSD.cxx:1355
 AliITSHandleDaSSD.cxx:1356
 AliITSHandleDaSSD.cxx:1357
 AliITSHandleDaSSD.cxx:1358
 AliITSHandleDaSSD.cxx:1359
 AliITSHandleDaSSD.cxx:1360
 AliITSHandleDaSSD.cxx:1361
 AliITSHandleDaSSD.cxx:1362
 AliITSHandleDaSSD.cxx:1363
 AliITSHandleDaSSD.cxx:1364
 AliITSHandleDaSSD.cxx:1365
 AliITSHandleDaSSD.cxx:1366
 AliITSHandleDaSSD.cxx:1367
 AliITSHandleDaSSD.cxx:1368
 AliITSHandleDaSSD.cxx:1369
 AliITSHandleDaSSD.cxx:1370
 AliITSHandleDaSSD.cxx:1371
 AliITSHandleDaSSD.cxx:1372
 AliITSHandleDaSSD.cxx:1373
 AliITSHandleDaSSD.cxx:1374
 AliITSHandleDaSSD.cxx:1375
 AliITSHandleDaSSD.cxx:1376
 AliITSHandleDaSSD.cxx:1377
 AliITSHandleDaSSD.cxx:1378
 AliITSHandleDaSSD.cxx:1379
 AliITSHandleDaSSD.cxx:1380
 AliITSHandleDaSSD.cxx:1381
 AliITSHandleDaSSD.cxx:1382
 AliITSHandleDaSSD.cxx:1383
 AliITSHandleDaSSD.cxx:1384
 AliITSHandleDaSSD.cxx:1385
 AliITSHandleDaSSD.cxx:1386
 AliITSHandleDaSSD.cxx:1387
 AliITSHandleDaSSD.cxx:1388
 AliITSHandleDaSSD.cxx:1389
 AliITSHandleDaSSD.cxx:1390
 AliITSHandleDaSSD.cxx:1391
 AliITSHandleDaSSD.cxx:1392
 AliITSHandleDaSSD.cxx:1393
 AliITSHandleDaSSD.cxx:1394
 AliITSHandleDaSSD.cxx:1395
 AliITSHandleDaSSD.cxx:1396
 AliITSHandleDaSSD.cxx:1397
 AliITSHandleDaSSD.cxx:1398
 AliITSHandleDaSSD.cxx:1399
 AliITSHandleDaSSD.cxx:1400
 AliITSHandleDaSSD.cxx:1401
 AliITSHandleDaSSD.cxx:1402
 AliITSHandleDaSSD.cxx:1403
 AliITSHandleDaSSD.cxx:1404
 AliITSHandleDaSSD.cxx:1405
 AliITSHandleDaSSD.cxx:1406
 AliITSHandleDaSSD.cxx:1407
 AliITSHandleDaSSD.cxx:1408
 AliITSHandleDaSSD.cxx:1409
 AliITSHandleDaSSD.cxx:1410
 AliITSHandleDaSSD.cxx:1411
 AliITSHandleDaSSD.cxx:1412
 AliITSHandleDaSSD.cxx:1413
 AliITSHandleDaSSD.cxx:1414
 AliITSHandleDaSSD.cxx:1415
 AliITSHandleDaSSD.cxx:1416
 AliITSHandleDaSSD.cxx:1417
 AliITSHandleDaSSD.cxx:1418
 AliITSHandleDaSSD.cxx:1419
 AliITSHandleDaSSD.cxx:1420
 AliITSHandleDaSSD.cxx:1421
 AliITSHandleDaSSD.cxx:1422
 AliITSHandleDaSSD.cxx:1423
 AliITSHandleDaSSD.cxx:1424
 AliITSHandleDaSSD.cxx:1425
 AliITSHandleDaSSD.cxx:1426
 AliITSHandleDaSSD.cxx:1427
 AliITSHandleDaSSD.cxx:1428
 AliITSHandleDaSSD.cxx:1429
 AliITSHandleDaSSD.cxx:1430
 AliITSHandleDaSSD.cxx:1431
 AliITSHandleDaSSD.cxx:1432
 AliITSHandleDaSSD.cxx:1433
 AliITSHandleDaSSD.cxx:1434
 AliITSHandleDaSSD.cxx:1435
 AliITSHandleDaSSD.cxx:1436
 AliITSHandleDaSSD.cxx:1437
 AliITSHandleDaSSD.cxx:1438
 AliITSHandleDaSSD.cxx:1439
 AliITSHandleDaSSD.cxx:1440
 AliITSHandleDaSSD.cxx:1441
 AliITSHandleDaSSD.cxx:1442
 AliITSHandleDaSSD.cxx:1443
 AliITSHandleDaSSD.cxx:1444
 AliITSHandleDaSSD.cxx:1445
 AliITSHandleDaSSD.cxx:1446
 AliITSHandleDaSSD.cxx:1447
 AliITSHandleDaSSD.cxx:1448
 AliITSHandleDaSSD.cxx:1449
 AliITSHandleDaSSD.cxx:1450
 AliITSHandleDaSSD.cxx:1451
 AliITSHandleDaSSD.cxx:1452
 AliITSHandleDaSSD.cxx:1453
 AliITSHandleDaSSD.cxx:1454
 AliITSHandleDaSSD.cxx:1455
 AliITSHandleDaSSD.cxx:1456
 AliITSHandleDaSSD.cxx:1457
 AliITSHandleDaSSD.cxx:1458
 AliITSHandleDaSSD.cxx:1459
 AliITSHandleDaSSD.cxx:1460
 AliITSHandleDaSSD.cxx:1461
 AliITSHandleDaSSD.cxx:1462
 AliITSHandleDaSSD.cxx:1463
 AliITSHandleDaSSD.cxx:1464
 AliITSHandleDaSSD.cxx:1465
 AliITSHandleDaSSD.cxx:1466
 AliITSHandleDaSSD.cxx:1467
 AliITSHandleDaSSD.cxx:1468
 AliITSHandleDaSSD.cxx:1469
 AliITSHandleDaSSD.cxx:1470
 AliITSHandleDaSSD.cxx:1471
 AliITSHandleDaSSD.cxx:1472
 AliITSHandleDaSSD.cxx:1473
 AliITSHandleDaSSD.cxx:1474
 AliITSHandleDaSSD.cxx:1475
 AliITSHandleDaSSD.cxx:1476
 AliITSHandleDaSSD.cxx:1477
 AliITSHandleDaSSD.cxx:1478
 AliITSHandleDaSSD.cxx:1479
 AliITSHandleDaSSD.cxx:1480
 AliITSHandleDaSSD.cxx:1481
 AliITSHandleDaSSD.cxx:1482
 AliITSHandleDaSSD.cxx:1483
 AliITSHandleDaSSD.cxx:1484
 AliITSHandleDaSSD.cxx:1485
 AliITSHandleDaSSD.cxx:1486
 AliITSHandleDaSSD.cxx:1487
 AliITSHandleDaSSD.cxx:1488
 AliITSHandleDaSSD.cxx:1489
 AliITSHandleDaSSD.cxx:1490
 AliITSHandleDaSSD.cxx:1491
 AliITSHandleDaSSD.cxx:1492
 AliITSHandleDaSSD.cxx:1493
 AliITSHandleDaSSD.cxx:1494
 AliITSHandleDaSSD.cxx:1495
 AliITSHandleDaSSD.cxx:1496
 AliITSHandleDaSSD.cxx:1497
 AliITSHandleDaSSD.cxx:1498
 AliITSHandleDaSSD.cxx:1499
 AliITSHandleDaSSD.cxx:1500
 AliITSHandleDaSSD.cxx:1501
 AliITSHandleDaSSD.cxx:1502
 AliITSHandleDaSSD.cxx:1503
 AliITSHandleDaSSD.cxx:1504
 AliITSHandleDaSSD.cxx:1505
 AliITSHandleDaSSD.cxx:1506
 AliITSHandleDaSSD.cxx:1507
 AliITSHandleDaSSD.cxx:1508
 AliITSHandleDaSSD.cxx:1509
 AliITSHandleDaSSD.cxx:1510
 AliITSHandleDaSSD.cxx:1511
 AliITSHandleDaSSD.cxx:1512
 AliITSHandleDaSSD.cxx:1513
 AliITSHandleDaSSD.cxx:1514
 AliITSHandleDaSSD.cxx:1515
 AliITSHandleDaSSD.cxx:1516
 AliITSHandleDaSSD.cxx:1517
 AliITSHandleDaSSD.cxx:1518
 AliITSHandleDaSSD.cxx:1519
 AliITSHandleDaSSD.cxx:1520
 AliITSHandleDaSSD.cxx:1521
 AliITSHandleDaSSD.cxx:1522
 AliITSHandleDaSSD.cxx:1523
 AliITSHandleDaSSD.cxx:1524
 AliITSHandleDaSSD.cxx:1525
 AliITSHandleDaSSD.cxx:1526
 AliITSHandleDaSSD.cxx:1527
 AliITSHandleDaSSD.cxx:1528
 AliITSHandleDaSSD.cxx:1529
 AliITSHandleDaSSD.cxx:1530
 AliITSHandleDaSSD.cxx:1531
 AliITSHandleDaSSD.cxx:1532
 AliITSHandleDaSSD.cxx:1533
 AliITSHandleDaSSD.cxx:1534
 AliITSHandleDaSSD.cxx:1535
 AliITSHandleDaSSD.cxx:1536
 AliITSHandleDaSSD.cxx:1537
 AliITSHandleDaSSD.cxx:1538
 AliITSHandleDaSSD.cxx:1539
 AliITSHandleDaSSD.cxx:1540
 AliITSHandleDaSSD.cxx:1541
 AliITSHandleDaSSD.cxx:1542
 AliITSHandleDaSSD.cxx:1543
 AliITSHandleDaSSD.cxx:1544
 AliITSHandleDaSSD.cxx:1545
 AliITSHandleDaSSD.cxx:1546
 AliITSHandleDaSSD.cxx:1547
 AliITSHandleDaSSD.cxx:1548
 AliITSHandleDaSSD.cxx:1549
 AliITSHandleDaSSD.cxx:1550
 AliITSHandleDaSSD.cxx:1551
 AliITSHandleDaSSD.cxx:1552
 AliITSHandleDaSSD.cxx:1553
 AliITSHandleDaSSD.cxx:1554
 AliITSHandleDaSSD.cxx:1555
 AliITSHandleDaSSD.cxx:1556
 AliITSHandleDaSSD.cxx:1557
 AliITSHandleDaSSD.cxx:1558
 AliITSHandleDaSSD.cxx:1559
 AliITSHandleDaSSD.cxx:1560
 AliITSHandleDaSSD.cxx:1561
 AliITSHandleDaSSD.cxx:1562
 AliITSHandleDaSSD.cxx:1563
 AliITSHandleDaSSD.cxx:1564
 AliITSHandleDaSSD.cxx:1565
 AliITSHandleDaSSD.cxx:1566
 AliITSHandleDaSSD.cxx:1567
 AliITSHandleDaSSD.cxx:1568
 AliITSHandleDaSSD.cxx:1569
 AliITSHandleDaSSD.cxx:1570
 AliITSHandleDaSSD.cxx:1571
 AliITSHandleDaSSD.cxx:1572
 AliITSHandleDaSSD.cxx:1573
 AliITSHandleDaSSD.cxx:1574
 AliITSHandleDaSSD.cxx:1575
 AliITSHandleDaSSD.cxx:1576
 AliITSHandleDaSSD.cxx:1577
 AliITSHandleDaSSD.cxx:1578
 AliITSHandleDaSSD.cxx:1579
 AliITSHandleDaSSD.cxx:1580
 AliITSHandleDaSSD.cxx:1581
 AliITSHandleDaSSD.cxx:1582
 AliITSHandleDaSSD.cxx:1583
 AliITSHandleDaSSD.cxx:1584
 AliITSHandleDaSSD.cxx:1585
 AliITSHandleDaSSD.cxx:1586
 AliITSHandleDaSSD.cxx:1587
 AliITSHandleDaSSD.cxx:1588
 AliITSHandleDaSSD.cxx:1589
 AliITSHandleDaSSD.cxx:1590
 AliITSHandleDaSSD.cxx:1591
 AliITSHandleDaSSD.cxx:1592
 AliITSHandleDaSSD.cxx:1593
 AliITSHandleDaSSD.cxx:1594
 AliITSHandleDaSSD.cxx:1595
 AliITSHandleDaSSD.cxx:1596
 AliITSHandleDaSSD.cxx:1597
 AliITSHandleDaSSD.cxx:1598
 AliITSHandleDaSSD.cxx:1599
 AliITSHandleDaSSD.cxx:1600
 AliITSHandleDaSSD.cxx:1601
 AliITSHandleDaSSD.cxx:1602
 AliITSHandleDaSSD.cxx:1603
 AliITSHandleDaSSD.cxx:1604
 AliITSHandleDaSSD.cxx:1605
 AliITSHandleDaSSD.cxx:1606
 AliITSHandleDaSSD.cxx:1607
 AliITSHandleDaSSD.cxx:1608
 AliITSHandleDaSSD.cxx:1609
 AliITSHandleDaSSD.cxx:1610
 AliITSHandleDaSSD.cxx:1611
 AliITSHandleDaSSD.cxx:1612
 AliITSHandleDaSSD.cxx:1613
 AliITSHandleDaSSD.cxx:1614
 AliITSHandleDaSSD.cxx:1615
 AliITSHandleDaSSD.cxx:1616
 AliITSHandleDaSSD.cxx:1617
 AliITSHandleDaSSD.cxx:1618
 AliITSHandleDaSSD.cxx:1619
 AliITSHandleDaSSD.cxx:1620
 AliITSHandleDaSSD.cxx:1621
 AliITSHandleDaSSD.cxx:1622
 AliITSHandleDaSSD.cxx:1623
 AliITSHandleDaSSD.cxx:1624
 AliITSHandleDaSSD.cxx:1625
 AliITSHandleDaSSD.cxx:1626
 AliITSHandleDaSSD.cxx:1627
 AliITSHandleDaSSD.cxx:1628
 AliITSHandleDaSSD.cxx:1629
 AliITSHandleDaSSD.cxx:1630
 AliITSHandleDaSSD.cxx:1631
 AliITSHandleDaSSD.cxx:1632
 AliITSHandleDaSSD.cxx:1633
 AliITSHandleDaSSD.cxx:1634
 AliITSHandleDaSSD.cxx:1635
 AliITSHandleDaSSD.cxx:1636
 AliITSHandleDaSSD.cxx:1637
 AliITSHandleDaSSD.cxx:1638
 AliITSHandleDaSSD.cxx:1639
 AliITSHandleDaSSD.cxx:1640
 AliITSHandleDaSSD.cxx:1641
 AliITSHandleDaSSD.cxx:1642
 AliITSHandleDaSSD.cxx:1643
 AliITSHandleDaSSD.cxx:1644
 AliITSHandleDaSSD.cxx:1645
 AliITSHandleDaSSD.cxx:1646
 AliITSHandleDaSSD.cxx:1647
 AliITSHandleDaSSD.cxx:1648
 AliITSHandleDaSSD.cxx:1649
 AliITSHandleDaSSD.cxx:1650
 AliITSHandleDaSSD.cxx:1651
 AliITSHandleDaSSD.cxx:1652
 AliITSHandleDaSSD.cxx:1653
 AliITSHandleDaSSD.cxx:1654
 AliITSHandleDaSSD.cxx:1655
 AliITSHandleDaSSD.cxx:1656
 AliITSHandleDaSSD.cxx:1657
 AliITSHandleDaSSD.cxx:1658
 AliITSHandleDaSSD.cxx:1659
 AliITSHandleDaSSD.cxx:1660
 AliITSHandleDaSSD.cxx:1661
 AliITSHandleDaSSD.cxx:1662
 AliITSHandleDaSSD.cxx:1663
 AliITSHandleDaSSD.cxx:1664
 AliITSHandleDaSSD.cxx:1665
 AliITSHandleDaSSD.cxx:1666
 AliITSHandleDaSSD.cxx:1667
 AliITSHandleDaSSD.cxx:1668
 AliITSHandleDaSSD.cxx:1669
 AliITSHandleDaSSD.cxx:1670
 AliITSHandleDaSSD.cxx:1671
 AliITSHandleDaSSD.cxx:1672
 AliITSHandleDaSSD.cxx:1673
 AliITSHandleDaSSD.cxx:1674
 AliITSHandleDaSSD.cxx:1675
 AliITSHandleDaSSD.cxx:1676
 AliITSHandleDaSSD.cxx:1677
 AliITSHandleDaSSD.cxx:1678
 AliITSHandleDaSSD.cxx:1679
 AliITSHandleDaSSD.cxx:1680
 AliITSHandleDaSSD.cxx:1681
 AliITSHandleDaSSD.cxx:1682
 AliITSHandleDaSSD.cxx:1683
 AliITSHandleDaSSD.cxx:1684
 AliITSHandleDaSSD.cxx:1685
 AliITSHandleDaSSD.cxx:1686
 AliITSHandleDaSSD.cxx:1687
 AliITSHandleDaSSD.cxx:1688
 AliITSHandleDaSSD.cxx:1689
 AliITSHandleDaSSD.cxx:1690
 AliITSHandleDaSSD.cxx:1691
 AliITSHandleDaSSD.cxx:1692
 AliITSHandleDaSSD.cxx:1693
 AliITSHandleDaSSD.cxx:1694
 AliITSHandleDaSSD.cxx:1695
 AliITSHandleDaSSD.cxx:1696
 AliITSHandleDaSSD.cxx:1697
 AliITSHandleDaSSD.cxx:1698
 AliITSHandleDaSSD.cxx:1699
 AliITSHandleDaSSD.cxx:1700
 AliITSHandleDaSSD.cxx:1701
 AliITSHandleDaSSD.cxx:1702
 AliITSHandleDaSSD.cxx:1703
 AliITSHandleDaSSD.cxx:1704
 AliITSHandleDaSSD.cxx:1705
 AliITSHandleDaSSD.cxx:1706
 AliITSHandleDaSSD.cxx:1707
 AliITSHandleDaSSD.cxx:1708
 AliITSHandleDaSSD.cxx:1709
 AliITSHandleDaSSD.cxx:1710
 AliITSHandleDaSSD.cxx:1711
 AliITSHandleDaSSD.cxx:1712
 AliITSHandleDaSSD.cxx:1713
 AliITSHandleDaSSD.cxx:1714
 AliITSHandleDaSSD.cxx:1715
 AliITSHandleDaSSD.cxx:1716
 AliITSHandleDaSSD.cxx:1717
 AliITSHandleDaSSD.cxx:1718
 AliITSHandleDaSSD.cxx:1719
 AliITSHandleDaSSD.cxx:1720
 AliITSHandleDaSSD.cxx:1721
 AliITSHandleDaSSD.cxx:1722
 AliITSHandleDaSSD.cxx:1723
 AliITSHandleDaSSD.cxx:1724
 AliITSHandleDaSSD.cxx:1725
 AliITSHandleDaSSD.cxx:1726
 AliITSHandleDaSSD.cxx:1727
 AliITSHandleDaSSD.cxx:1728
 AliITSHandleDaSSD.cxx:1729
 AliITSHandleDaSSD.cxx:1730
 AliITSHandleDaSSD.cxx:1731
 AliITSHandleDaSSD.cxx:1732
 AliITSHandleDaSSD.cxx:1733
 AliITSHandleDaSSD.cxx:1734
 AliITSHandleDaSSD.cxx:1735
 AliITSHandleDaSSD.cxx:1736
 AliITSHandleDaSSD.cxx:1737
 AliITSHandleDaSSD.cxx:1738
 AliITSHandleDaSSD.cxx:1739
 AliITSHandleDaSSD.cxx:1740