// Date: 18/07/2008
///////////////////////////////////////////////////////////////////////////////
-#include <string>
+#include <cstring>
#include <fstream>
#include <new>
#include <Riostream.h>
#include "AliITSHandleDaSSD.h"
-#include <math.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"
//______________________________________________________________________________
AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
TObject(ssdadldc),
- fRawDataFileName(ssdadldc.fRawDataFileName),
+ fRawDataFileName(NULL),
fNumberOfModules(ssdadldc.fNumberOfModules),
fModules(NULL),
fModIndProcessed(ssdadldc.fModIndProcessed),
fModIndRead(ssdadldc.fModIndRead),
fModIndex(NULL),
- fEqIndex(0),
+ fEqIndex(ssdadldc.fEqIndex),
fNumberOfEvents(ssdadldc.fNumberOfEvents),
fBadChannelsList(NULL),
fDDLModuleMap(NULL),
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) {
fModules = 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!");
+ 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)
{
fModules = NULL;
}
if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
- if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
- fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
+ fNumberOfModules = ssdadldc.fNumberOfModules;
+ if ((fNumberOfModules > 0) && (ssdadldc.fModules)) {
+ fModules = new (nothrow) AliITSModuleDaSSD* [fNumberOfModules];
if (fModules) {
- for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
+ for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
if (ssdadldc.fModules[modind]) {
fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
if (!fModules[modind]) {
fModules = NULL;
}
}
- fRawDataFileName = NULL;
- fModIndProcessed = 0;
- fModIndRead = 0;
- fModIndex = 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;
fZsFactor = ssdadldc.fZsFactor;
fALaddersOff = ssdadldc.fALaddersOff;
fCLaddersOff = ssdadldc.fCLaddersOff;
- fBadChannelsList = NULL;
- fDDLModuleMap = NULL;
- fModIndex = 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!");
+ 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++)
*/
fALaddersOff.Set(0);
fCLaddersOff.Set(0);
- fRawDataFileName = NULL;
+ if(fRawDataFileName){
+ delete []fRawDataFileName;
+ fRawDataFileName = NULL;
+ }
fModIndProcessed = fModIndRead = 0;
fNumberOfEvents = 0;
fLdcId = fRunId = 0;
if ((physeventind > 0) && (strn > 0))
{
fNumberOfEvents = physeventind;
- fRawDataFileName = rdfname;
+ 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];
//______________________________________________________________________________
-Bool_t AliITSHandleDaSSD::AddFeromCm(AliITSModuleDaSSD *const module)
-// Restore the original signal value adding CM calculated and subtracted in ferom
+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;
//______________________________________________________________________________
-Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
+Bool_t AliITSHandleDaSSD::CalculatePedestal(const AliITSModuleDaSSD *const module)
{
// Calculates Pedestal
AliITSChannelDaSSD *strip;
if (SignalOutOfRange(signal[ev])) ovev += 1;
else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
}
- if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Double_t)(n));
+ 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 ****************
//______________________________________________________________________________
-Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
+Bool_t AliITSHandleDaSSD::CalculateNoise(const AliITSModuleDaSSD *const module)
{
// Calculates Noise
AliITSChannelDaSSD *strip;
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>(sqrt(nsum / (Float_t)(n)));
+ 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);
}
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>(sqrt(nsum / (Double_t)(n)));
+ 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);
}
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 = sqrt(cmsigma / (Float_t)(n));
+ 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;
if (meannoise > meannosethreshold)
cout << "Mod: " << i << "; DDl: " << (int)mod->GetDdlId() << "; AD: " << (int)mod->GetAD()
<< "; ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped
- << "; MeanNoise = " << meannoise
+ << "; 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;
}
//___________________________________________________________________________________________
Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const
-// Saves calibration files for selected equipment (DDL)
{
+// Saves calibration files for selected equipment (DDL)
fstream feefile;
Int_t zsml, offsetml;
ULong_t zsth, offset, zsoffset;
//______________________________________________________________________________
-ULong_t AliITSHandleDaSSD::ZsThreshold(AliITSChannelDaSSD *strip) const
+ULong_t AliITSHandleDaSSD::ZsThreshold(const AliITSChannelDaSSD *strip) const
{
// Calculate the value of zero suppression threshold to be upload to FEROM
ULong_t zs;
//______________________________________________________________________________
-Bool_t AliITSHandleDaSSD::CalculatePedNoiseW(AliITSModuleDaSSD *const module)
+Bool_t AliITSHandleDaSSD::CalculatePedNoiseW(const AliITSModuleDaSSD *const module)
{
// Calculates Pedestal and Noise using Welford algorithm
AliITSChannelDaSSD *strip;
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>(sqrt(noise / static_cast<Double_t>(n))) );
+ strip->SetNoise( static_cast<Float_t>(TMath::Sqrt(noise / static_cast<Double_t>(n))) );
else {
strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
continue;
noise = s0;
}
}
- if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast<Double_t>(n));
+ 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();
cmsigma = cms1;
} }
}
- if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr - 1) > 0) cmsigma = sqrt(cmsigma / static_cast<Double_t>(n));
+ 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));
noise = s0;
}
}
- if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast<Double_t>(n));
+ if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = TMath::Sqrt(noise / static_cast<Double_t>(n));
else {
strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
continue;
|| 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 = sqrt(nsum / static_cast<Double_t>(n));
+ 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));
}