// 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;
datasize = rawreaderdate->GetDataSize();
eqbelsize = rawreaderdate->GetEquipmentElementSize();
if ( datasize % eqbelsize ) {
- AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i",
+ 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 = %i, %i",
+ 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");
}
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];
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: %i, max number of channels: %i\n", eqn, strn);
+ TString str = TString::Format("Max number of equipment: %d, max number of channels: %ld\n", eqn, strn);
DumpInitData(str.Data());
return kTRUE;
}
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: ", filename, 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)));
//______________________________________________________________________________
-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 ((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 : [%i]:[%i]:[%i]\n",
+ AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n",
module->GetModuleId(), chipind, ev));
}
}
if (dafname) dadatafilename.Form("%s/", dafname);
dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId);
tmpfname = new Char_t[dadatafilename.Length()+1];
- dafname = strcpy(tmpfname, dadatafilename.Data());
+ 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()));
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;
}
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++) {
//___________________________________________________________________________________________
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;
modn = RetrieveModuleId(ddl, ad, adc);
if (modn < 0) return -1;
if (modn < fgkMinSSDModuleId) {
- AliWarning(Form("Module ddl/ad/adc: %i/%i/%i has number %i which is wrong for SSD module", ddl, ad, adc, strn, modn));
+ 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;
//______________________________________________________________________________
-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 : [%i]:[%i]:[%i]\n",
+ 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 : [%i]:[%i]:[%i]\n",
+ AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n",
module->GetModuleId(), chipind, ev));
continue;
}
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 : [%i]:[%i]:[%i]\n",
+ AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE 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));
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff