[u/mrichter/AliRoot.git] / ITS / AliITSHandleDaSSD.cxx


#include <iostream> 
#include "AliITSHandleDaSSD.h"


ClassImp(AliITSHandleDaSSD)

using namespace std;


AliITSHandleDaSSD::AliITSHandleDaSSD() :
  fNumberOfModules(0),
  fModules(NULL),
  fLdcId(0),
  fRunId(0)
{
}


AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
  fNumberOfModules(0),
  fModules(NULL),
  fLdcId(0),
  fRunId(0)
{
  if (numberofmodules > fgkNumberOfSSDModules) 
      cout << "ALICE ITS SSD contains " <<  fgkNumberOfSSDModules << "modules!"<< endl;
  try
  {
     fModules = new AliITSModuleDaSSD* [numberofmodules];
     fNumberOfModules = numberofmodules;
     for (Int_t i = 0; i < numberofmodules; i++) fModules[i] = NULL;
  }
  catch (bad_alloc&) 
  {
     Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD objects!", numberofmodules);
     fNumberOfModules = 0;
     fModules = NULL;
  }  
}


AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
  TObject(ssdadldc),
  fNumberOfModules(ssdadldc.fNumberOfModules),
  fModules(ssdadldc.fModules),
  fLdcId(ssdadldc.fLdcId),
  fRunId(ssdadldc.fRunId)
{
  // copy constructor

  Fatal("AliITSHandleDaSSD", "copy constructor not implemented");
}


AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
{
// assignment operator

  Fatal("operator =", "assignment operator not implemented");
  return *this;
}


AliITSHandleDaSSD::~AliITSHandleDaSSD()
{ 
  if (fModules) 
  {
    for (Int_t i = 0; i < fNumberOfModules; i++)
    { 
      if (fModules[i]) delete fModules[i];
    }
    delete [] fModules;
  }
}


AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
{
   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;
}


/*************************** Used for test only ******************************/

AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
{
  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);
    }
  }
  Error("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)
{ 
   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)
{
  if (numberofmodules > fgkNumberOfSSDModules) 
      Warning("AliITSHandleDaSSD", "The number of modules you use exceeds the maximum %i for ALICE ITS SSD", fgkNumberOfSSDModules);
  try
  {
     fModules = new AliITSModuleDaSSD* [numberofmodules];
     fNumberOfModules = numberofmodules;
     for (Int_t i = 0; i < fNumberOfModules; i++) fModules[i] = NULL;
     return kTRUE;
  }
  catch (bad_alloc&) 
  {
     Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModuleDaSSD objects!", numberofmodules);
     fNumberOfModules = 0;
     fModules = NULL;
  }  
  return kFALSE;
}


Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
{
  AliRawReaderDate    *rawreaderdate = new AliRawReaderDate(fileName, 0);
  AliITSModuleDaSSD   *module;
  AliITSChannelDaSSD  *strip;
  Long_t            datasize, eventind = 0;
  Int_t             nofstrips, eqbelsize;
  UShort_t          modind;
  long32           *data;
  if (!fModules) {
    Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: no structure was allocated for data");
    return kFALSE;
  }
  rawreaderdate->SelectEvents(PHYSICS_EVENT);
  while (rawreaderdate->NextEvent()) {
    fLdcId = rawreaderdate->GetLDCId();
    fRunId = rawreaderdate->GetRunNumber(); 
    modind = 0;
    while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
      Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
      Int_t     equiptype  = rawreaderdate->GetEquipmentType();            //
      UChar_t   ddlID      = (UChar_t)rawreaderdate->GetDDLID();           // GetDDLID(); index of DDL, ITS SSD: 33-48
      datasize = rawreaderdate->GetDataSize();
      eqbelsize = rawreaderdate->GetEquipmentElementSize();
      if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
        Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", datasize,
               eqbelsize);
        return kFALSE;
      }
      nofstrips = (Int_t) (datasize / eqbelsize);		 
      for (Int_t strind = 0; strind < nofstrips; strind++) {
        UChar_t   ad      = (UChar_t) (data[strind] >> 28) & 0x0000000F;  // index of AD module     0-9
        UChar_t   adc     = (UChar_t) (data[strind] >> 24) & 0x0000000F;  // index of ADC module    0-5, 8-13
        UShort_t  stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF;  // strip number           0-1535
        Short_t   signal  = (Short_t)(data[strind] & 0x00000FFF);
                  signal  = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst()) 
		                                                               : signal;
        if (!(module = GetModule(ddlID, ad, adc))) {
          module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
	  if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
          module->SetModuleRorcId (equipid, equiptype);
	  fModules[modind++] = module;
        }
        if (!(strip = module->GetStrip(stripID))) {
          strip = new AliITSChannelDaSSD(stripID, eventsnumber);
          module->SetStrip(strip, stripID);
        }
        strip->SetSignal(eventind, signal);
     }
     if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
   }
   if (++eventind > eventsnumber) break;
  }
  delete rawreaderdate;
  return RelocateModules();
}


Bool_t AliITSHandleDaSSD::RelocateModules()
{  
  Int_t         nm = 0;
  AliITSModuleDaSSD **marray;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++)
    if (fModules[modind]) nm += 1;
  if (nm == fNumberOfModules) return kTRUE;
  try {
    marray = new AliITSModuleDaSSD* [nm];
  }
  catch (bad_alloc&) {
    Error("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 = nm;
  return kTRUE;
}


Bool_t AliITSHandleDaSSD::CalculatePedestal()
{
  Float_t     pedestal;
  Short_t    *signal;
  AliITSChannelDaSSD *strip;
  Long_t      ovev, ev;
  if (!fModules) return kFALSE;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
    if (!fModules[modind]) {
      Error("AliITSHandleDaSSD", "Error CalculatePedestal(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
      return kFALSE;
    }
    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
      if (!(signal = strip->GetSignal())) {
        Error("AliITSHandleDaSSD", "Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
        return kFALSE;
      }
      pedestal = 0.0f;
      ovev = 0l;
      for (ev = 0; ev < strip->GetEventsNumber(); ev++)
        if (SignalOutOfRange(signal[ev])) ovev += 1;
//	else pedestal += signal[ev];
	else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
	if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
//      if ((Long_t n = strip->GetEventsNumber() - ovev)) pedestal /= static_cast<Float_t>(n);
//      else return kFALSE;
      strip->SetPedestal(pedestal);	
    }
  }
  return kTRUE;
}


Bool_t AliITSHandleDaSSD::CalculateNoise()
{
  AliITSChannelDaSSD *strip;
  Short_t    *signal;
  Float_t     noise;
  Long_t      ovev, n;
  if (!fModules) return kFALSE;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
    if (!fModules[modind]) {
      Error("AliITSHandleDaSSD", "Error CalculateNoise(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
      return kFALSE;
    }
    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
      if (!(signal = strip->GetSignal())) {
        Error("AliITSHandleDaSSD", "Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
        return kFALSE;
      }
      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);
//	else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal()), 2) - nsum) / static_cast<Double_t>(ev - ovev)
//	                          : pow((signal[ev] - strip->GetPedestal()), 2);
      } 
//      noise =  sqrt(nsum);
      if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
      else  noise = AliITSChannelDaSSD::GetUndefinedValue();
      strip->SetNoise(noise);
    }
  }
  return kTRUE;
}


Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
{
  AliITSChannelDaSSD *strip = NULL;
  Short_t    *signal;
  Long_t      ovstr, evn, n;
  if ((stripind + AliITSModuleDaSSD::GetStripsPerChip()) > fModules[modind]->GetNumberOfStrips()) return kFALSE;
  if (!(strip = fModules[modind]->GetStrip(stripind))) return kFALSE;
  evn = fModules[modind]->GetStrip(stripind)->GetEventsNumber();
  for (Long_t ev = 0; ev < evn; ev++) {
    Double_t cmsum = 0.0L;
    ovstr = 0l;
    for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
      if (!(signal = strip->GetSignal())) {
        Error("AliITSHandleDaSSD", "Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
        return kFALSE;
      }
      if (SignalOutOfRange(signal[ev])) ovstr += 1;
      else cmsum += (signal[ev] - strip->GetPedestal());
    }
    if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm[ev] = cmsum / (Float_t)(n);
    else cm[ev] = 0.0;
  } 
  return kTRUE; 
}


Bool_t  AliITSHandleDaSSD::CalculateNoiseCM()
{
  Short_t     *signal;
  AliITSChannelDaSSD  *strip = NULL;
  Float_t      noise, *cm = NULL;
  Long_t       ovev, n;
  if (!fModules) return kFALSE;
  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
    if (!fModules[modind]) {
      Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD", modind);
      return kFALSE;
    }
    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
      if (!(signal = strip->GetSignal())) {
        Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
        return kFALSE;
      }
      if (!(strind % AliITSModuleDaSSD::GetStripsPerChip())) {
        if (!cm) {
          try { 
	    cm = new Float_t [strip->GetEventsNumber()];  }
          catch (bad_alloc&) {
            Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
            return kFALSE; 
          }  
        }
// calculate cm;
        if (!CalculateCM(modind, strind, cm)) return kFALSE;
      }
// calculate noise;	
      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() - cm[ev]), 2);
//	else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2) - nsum) / static_cast<Double_t>(ev - ovev)
//	                          : pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
      } 
//      noise =  sqrt(nsum);
      if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
      else  noise = AliITSChannelDaSSD::GetUndefinedValue();
      strip->SetNoise(noise);
      }
    }
  if (cm) delete [] cm;
  return kTRUE;
}


TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
{ 
  TObjArray *ldcc;
  if (!fModules) return NULL;
  ldcc = new TObjArray(fNumberOfModules, 0);
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!fModules[i]) {
      delete ldcc;
      return NULL;
    }
    ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
  }
  ldcc->Compress();
  return ldcc;
}


Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
{
  ostringstream   dadatafilename;
  TObjArray      *ldcc;
  if (!fModules) return kFALSE;
  ldcc = new TObjArray(fNumberOfModules, 0);
  for (Int_t i = 0; i < fNumberOfModules; i++) {
    if (!fModules[i]) {
      delete ldcc;
      return kFALSE;
    }
    ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
  }
  ldcc->Compress();
  dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
  dafname = dadatafilename.str();
  TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
  if (fileRun->IsZombie()) {
    Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
    ldcc->Delete();
    delete fileRun;
    return kFALSE;
  }
  fileRun->WriteTObject(ldcc);
  fileRun->Close();
  ldcc->Delete();
  delete fileRun;
  return kTRUE;
}
Commit	Line	Data
f67db810	1
	2	#include <iostream>
	3	#include "AliITSHandleDaSSD.h"
	4
	5
	6	ClassImp(AliITSHandleDaSSD)
	7
	8	using namespace std;
	9
	10
	11	AliITSHandleDaSSD::AliITSHandleDaSSD() :
	12	fNumberOfModules(0),
	13	fModules(NULL),
	14	fLdcId(0),
	15	fRunId(0)
	16	{
	17	}
	18
	19
	20	AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
	21	fNumberOfModules(0),
	22	fModules(NULL),
	23	fLdcId(0),
	24	fRunId(0)
	25	{
	26	if (numberofmodules > fgkNumberOfSSDModules)
	27	cout << "ALICE ITS SSD contains " << fgkNumberOfSSDModules << "modules!"<< endl;
	28	try
	29	{
	30	fModules = new AliITSModuleDaSSD* [numberofmodules];
	31	fNumberOfModules = numberofmodules;
	32	for (Int_t i = 0; i < numberofmodules; i++) fModules[i] = NULL;
	33	}
	34	catch (bad_alloc&)
	35	{
	36	Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD objects!", numberofmodules);
	37	fNumberOfModules = 0;
	38	fModules = NULL;
	39	}
	40	}
	41
	42
	43	AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
	44	TObject(ssdadldc),
	45	fNumberOfModules(ssdadldc.fNumberOfModules),
	46	fModules(ssdadldc.fModules),
	47	fLdcId(ssdadldc.fLdcId),
	48	fRunId(ssdadldc.fRunId)
	49	{
	50	// copy constructor
	51
	52	Fatal("AliITSHandleDaSSD", "copy constructor not implemented");
	53	}
	54
	55
	56	AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
	57	{
	58	// assignment operator
	59
	60	Fatal("operator =", "assignment operator not implemented");
	61	return *this;
	62	}
	63
	64
65	AliITSHandleDaSSD::~AliITSHandleDaSSD()
66	{
67	if (fModules)
68	{
69	for (Int_t i = 0; i < fNumberOfModules; i++)
70	{
71	if (fModules[i]) delete fModules[i];
72	}
73	delete [] fModules;
74	}
75	}
76
77
78
79	AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
80	{
81	if (!fModules) return NULL;
82	for (Int_t i = 0; i < fNumberOfModules; i++) {
83	if (fModules[i]) {
84	if ( (fModules[i]->GetDdlId() == ddlID)
85	&& (fModules[i]->GetAD() == ad)
86	&& (fModules[i]->GetADC() == adc))
87	return fModules[i];
88	}
89	}
90	return NULL;
91	}
92
93
94
95	/************************* Used for test only ****************************/
96
97	AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
98	{
99	for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
100	if ( (fModules[modind]->GetDdlId() == ddlID)
101	&& (fModules[modind]->GetAD() == ad)
102	&& (fModules[modind]->GetADC() == adc) )
103	{
104	return fModules[modind]->GetStrip(stripID);
105	}
106	}
107	Error("AliITSHandleDaSSD", "Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!", ddlID, ad, adc, stripID);
108	return NULL;
109	}
110
111
112
113	Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
114	{
115	if ((index < fNumberOfModules) && (index >= 0))
116	{
117	if (fModules[index]) delete fModules[index];
118	fModules[index] = module;
119	return kTRUE;
120	}
121	else return kFALSE;
122	}
123
124
125	Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
126	{
127	if (numberofmodules > fgkNumberOfSSDModules)
128	Warning("AliITSHandleDaSSD", "The number of modules you use exceeds the maximum %i for ALICE ITS SSD", fgkNumberOfSSDModules);
129	try
130	{
131	fModules = new AliITSModuleDaSSD* [numberofmodules];
132	fNumberOfModules = numberofmodules;
133	for (Int_t i = 0; i < fNumberOfModules; i++) fModules[i] = NULL;
134	return kTRUE;
135	}
136	catch (bad_alloc&)
137	{
138	Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModuleDaSSD objects!", numberofmodules);
139	fNumberOfModules = 0;
140	fModules = NULL;
141	}
142	return kFALSE;
143	}
144
145
146	Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
147	{
148	AliRawReaderDate *rawreaderdate = new AliRawReaderDate(fileName, 0);
149	AliITSModuleDaSSD *module;
150	AliITSChannelDaSSD *strip;
151	Long_t datasize, eventind = 0;
152	Int_t nofstrips, eqbelsize;
153	UShort_t modind;
154	long32 *data;
155	if (!fModules) {
156	Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: no structure was allocated for data");
157	return kFALSE;
158	}
159	rawreaderdate->SelectEvents(PHYSICS_EVENT);
160	while (rawreaderdate->NextEvent()) {
161	fLdcId = rawreaderdate->GetLDCId();
162	fRunId = rawreaderdate->GetRunNumber();
163	modind = 0;
164	while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
165	Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc
166	Int_t equiptype = rawreaderdate->GetEquipmentType(); //
167	UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48
168	datasize = rawreaderdate->GetDataSize();
169	eqbelsize = rawreaderdate->GetEquipmentElementSize();
170	if ( (datasize % eqbelsize) \|\| (eqbelsize != sizeof(long32)) ) {
171	Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", datasize,
172	eqbelsize);
173	return kFALSE;
174	}
175	nofstrips = (Int_t) (datasize / eqbelsize);
176	for (Int_t strind = 0; strind < nofstrips; strind++) {
177	UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9
178	UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13
179	UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535
180	Short_t signal = (Short_t)(data[strind] & 0x00000FFF);
181	signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
182	: signal;
183	if (!(module = GetModule(ddlID, ad, adc))) {
184	module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
185	if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
186	module->SetModuleRorcId (equipid, equiptype);
187	fModules[modind++] = module;
188	}
189	if (!(strip = module->GetStrip(stripID))) {
190	strip = new AliITSChannelDaSSD(stripID, eventsnumber);
191	module->SetStrip(strip, stripID);
192	}
193	strip->SetSignal(eventind, signal);
194	}
195	if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
196	}
197	if (++eventind > eventsnumber) break;
198	}
199	delete rawreaderdate;
200	return RelocateModules();
201	}
202
203
204	Bool_t AliITSHandleDaSSD::RelocateModules()
205	{
206	Int_t nm = 0;
207	AliITSModuleDaSSD **marray;
208	for (Int_t modind = 0; modind < fNumberOfModules; modind++)
209	if (fModules[modind]) nm += 1;
210	if (nm == fNumberOfModules) return kTRUE;
211	try {
212	marray = new AliITSModuleDaSSD* [nm];
213	}
214	catch (bad_alloc&) {
215	Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD objects!", nm);
216	return kFALSE;
217	}
218	nm = 0;
219	for (Int_t modind = 0; modind < fNumberOfModules; modind++)
220	if (fModules[modind]) marray[nm++] = fModules[modind];
221	delete [] fModules;
222	fModules = marray;
223	fNumberOfModules = nm;
224	return kTRUE;
225	}
226
227
228	Bool_t AliITSHandleDaSSD::CalculatePedestal()
229	{
230	Float_t pedestal;
231	Short_t *signal;
232	AliITSChannelDaSSD *strip;
233	Long_t ovev, ev;
234	if (!fModules) return kFALSE;
235	for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
236	if (!fModules[modind]) {
237	Error("AliITSHandleDaSSD", "Error CalculatePedestal(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
238	return kFALSE;
239	}
240	for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
241	if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
242	if (!(signal = strip->GetSignal())) {
243	Error("AliITSHandleDaSSD", "Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
244	return kFALSE;
245	}
246	pedestal = 0.0f;
247	ovev = 0l;
248	for (ev = 0; ev < strip->GetEventsNumber(); ev++)
249	if (SignalOutOfRange(signal[ev])) ovev += 1;
250	// else pedestal += signal[ev];
251	else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
252	if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
253	// if ((Long_t n = strip->GetEventsNumber() - ovev)) pedestal /= static_cast<Float_t>(n);
254	// else return kFALSE;
255	strip->SetPedestal(pedestal);
256	}
257	}
258	return kTRUE;
259	}
260
261
262
263	Bool_t AliITSHandleDaSSD::CalculateNoise()
264	{
265	AliITSChannelDaSSD *strip;
266	Short_t *signal;
267	Float_t noise;
268	Long_t ovev, n;
269	if (!fModules) return kFALSE;
270	for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
271	if (!fModules[modind]) {
272	Error("AliITSHandleDaSSD", "Error CalculateNoise(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
273	return kFALSE;
274	}
275	for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
276	if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
277	if (!(signal = strip->GetSignal())) {
278	Error("AliITSHandleDaSSD", "Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
279	return kFALSE;
280	}
281	Double_t nsum = 0.0L;
282	ovev = 0l;
283	for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
284	if (SignalOutOfRange(signal[ev])) ovev += 1;
285	else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
286	// else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal()), 2) - nsum) / static_cast<Double_t>(ev - ovev)
287	// : pow((signal[ev] - strip->GetPedestal()), 2);
288	}
289	// noise = sqrt(nsum);
290	if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
291	else noise = AliITSChannelDaSSD::GetUndefinedValue();
292	strip->SetNoise(noise);
293	}
294	}
295	return kTRUE;
296	}
297
298
299
300	Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
301	{
302	AliITSChannelDaSSD *strip = NULL;
303	Short_t *signal;
304	Long_t ovstr, evn, n;
305	if ((stripind + AliITSModuleDaSSD::GetStripsPerChip()) > fModules[modind]->GetNumberOfStrips()) return kFALSE;
306	if (!(strip = fModules[modind]->GetStrip(stripind))) return kFALSE;
307	evn = fModules[modind]->GetStrip(stripind)->GetEventsNumber();
308	for (Long_t ev = 0; ev < evn; ev++) {
309	Double_t cmsum = 0.0L;
310	ovstr = 0l;
311	for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
312	if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
313	if (!(signal = strip->GetSignal())) {
314	Error("AliITSHandleDaSSD", "Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
315	return kFALSE;
316	}
317	if (SignalOutOfRange(signal[ev])) ovstr += 1;
318	else cmsum += (signal[ev] - strip->GetPedestal());
319	}
320	if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm[ev] = cmsum / (Float_t)(n);
321	else cm[ev] = 0.0;
322	}
323	return kTRUE;
324	}
325
326
327
328	Bool_t AliITSHandleDaSSD::CalculateNoiseCM()
329	{
330	Short_t *signal;
331	AliITSChannelDaSSD *strip = NULL;
332	Float_t noise, *cm = NULL;
333	Long_t ovev, n;
334	if (!fModules) return kFALSE;
335	for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
336	if (!fModules[modind]) {
337	Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD", modind);
338	return kFALSE;
339	}
340	for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
341	if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
342	if (!(signal = strip->GetSignal())) {
343	Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
344	return kFALSE;
345	}
346	if (!(strind % AliITSModuleDaSSD::GetStripsPerChip())) {
347	if (!cm) {
348	try {
349	cm = new Float_t [strip->GetEventsNumber()]; }
350	catch (bad_alloc&) {
351	Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
352	return kFALSE;
353	}
354	}
355	// calculate cm;
356	if (!CalculateCM(modind, strind, cm)) return kFALSE;
357	}
358	// calculate noise;
359	Double_t nsum = 0.0L;
360	ovev = 0l;
361	for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
362	if (SignalOutOfRange(signal[ev])) ovev += 1;
363	else nsum += pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
364	// else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2) - nsum) / static_cast<Double_t>(ev - ovev)
365	// : pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
366	}
367	// noise = sqrt(nsum);
368	if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
369	else noise = AliITSChannelDaSSD::GetUndefinedValue();
370	strip->SetNoise(noise);
371	}
372	}
373	if (cm) delete [] cm;
374	return kTRUE;
375	}
376
377
378
379	TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
380	{
381	TObjArray *ldcc;
382	if (!fModules) return NULL;
383	ldcc = new TObjArray(fNumberOfModules, 0);
384	for (Int_t i = 0; i < fNumberOfModules; i++) {
385	if (!fModules[i]) {
386	delete ldcc;
387	return NULL;
388	}
389	ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
390	}
391	ldcc->Compress();
392	return ldcc;
393	}
394
395
396	Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
397	{
398	ostringstream dadatafilename;
399	TObjArray *ldcc;
400	if (!fModules) return kFALSE;
401	ldcc = new TObjArray(fNumberOfModules, 0);
402	for (Int_t i = 0; i < fNumberOfModules; i++) {
403	if (!fModules[i]) {
404	delete ldcc;
405	return kFALSE;
406	}
407	ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
408	}
409	ldcc->Compress();
410	dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
411	dafname = dadatafilename.str();
412	TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
413	if (fileRun->IsZombie()) {
414	Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
415	ldcc->Delete();
416	delete fileRun;
417	return kFALSE;
418	}
419	fileRun->WriteTObject(ldcc);
420	fileRun->Close();
421	ldcc->Delete();
422	delete fileRun;
423	return kTRUE;
424	}