merged = MergeOutput(outputFile, fGridOutputDir, fMaxMergeFiles);
if (!merged) {
Error("MergeOutputs", "Terminate() will NOT be executed");
- return kFALSE;
+ delete list;
+ return kFALSE;
}
TFile *fileOpened = (TFile*)gROOT->GetListOfFiles()->FindObject(outputFile);
if (fileOpened) fileOpened->Close();
}
+ delete list;
return kTRUE;
}
TIter next(arr);
TObject *obj;
while ((obj=next())) mgr->LoadBranch(obj->GetName());
+ delete arr;
}
TObjString * syst = (TObjString*) tokens->At(4);
stat->String().ReplaceAll("+-","");
if(syst) syst->String().ReplaceAll("+-","");
- if (!binMin->String().Atof()) continue; // skip headers
+ if (!binMin->String().Atof()) {delete tokens; continue;} // skip headers
Float_t binCenter = (binMax->String().Atof() + binMin->String().Atof())/2;
Float_t binWidth = (binMax->String().Atof() - binMin->String().Atof())/2;
cout << line.Data() << endl;//<< " " << binMin->String().Atof() <<" " << binCenter << " " << binWidth << endl;
syst->String().Atof(),
syst->String().Atof());
ipoints++;
+ delete tokens;
}
infile.close();
TString stringevlist = oevlist->GetName();
TObjArray *evlist = stringevlist.Tokenize(",");
for (Int_t n = 0; n < evlist->GetEntries(); n++) xmlevlist->Enter(atol(((TObjString *) evlist->At(n))->GetName()));
+ delete evlist;
}
attributes->Add(new TObjString("evlist"), xmlevlist);
}
AliLog::SetClassDebugLevel(strr.Data(), fLogType);
AliDebug(AliLog::kDebug + 5, Form("Setting Debug level %d to %s ...", (Int_t)fLogType - AliLog::kDebug, strr.Data()));
}
+ delete array;
AliDebug(AliLog::kDebug + 10, "->");
}
}
fPComboBoxTrigger->Select(0, kTRUE); //set default no filtering and emit
fPComboBoxTrigger->SetEnabled(kTRUE);
+ delete activetrgarr;
}
else
{
if(((TObjString*)(*so)[0])->GetString().CompareTo("TRD") != 0){
AliError(Form("Filename %s do not fulfill AliRoot naming conventions.", filename));
+ delete so;
return kFALSE;
}
if(gSystem->AccessPathName(Form("%s/%s", dir, filename))){
AliError(Form("Missing file %s/%s", dir, filename));
+ delete so;
return kFALSE;
}
if(((TObjString*)(*so)[1])->GetString().CompareTo("Hits") == 0){
}
} else {
AliError("Filename didn't fulfill naming conventions. No data will be loaded.");
+ delete so;
return kFALSE;
}
-
+ delete so;
SetDataLinked();
return kTRUE;
}
ETrees type = ParseLoad(os->GetName());
AddLoad(type);
}
+ delete ll;
}
TString name(static_cast<TObjString*>(a->At(0))->String());
- if ( name.Contains("sw") || name.Contains("SUMMARY") ) continue;
+ if ( name.Contains("sw") || name.Contains("SUMMARY") ) {delete a; continue;}
Int_t index = hvNamer.DCSIndexFromDCSAlias(name.Data());
if (!de)
{
AliErrorGeneral("AliMUONCDB::CheckHV",Form("Could not get detElemId from dcsAlias %s",name.Data()));
+ delete a;
continue;
}
emax = static_cast<TObjString*>(a->At(7))->String();
}
+ delete a;
+
AliRawReader* rawReader = 0x0;
if ( filename.Contains(TRegexp("^alien")) )
runNumber = s.Atoi();
AliDebugClass(1,Form("runNumber is %d",runNumber));
}
+ delete a;
}
if ( sline.Contains("DAC values") )
{
if ( ! AliMpDEManager::IsValidDetElemId(idDE, false) ) {
AliErrorStream() << "DetElemId "<< idDE << " not valid." << endl;
- return false;
+ delete stringList;
+ return false;
}
TString busPatch = ((TObjString*)stringList->At(1))->GetString();
if ( iDDL < 0 || iDDL >= fgkNofDDLs ) {
AliErrorStream() << "DDL id "<< iDDL << " outside limits." << endl;
- return false;
+ delete stringList;
+ return false;
}
AliDebugStream(3)
AliMpBusPatch* busPatch = GetBusPatch(busPatchID);
if ( ! busPatch ) {
AliErrorStream() << "Bus patch " << busPatchID << " does not exist." << endl;
- return kFALSE;
+ delete stringList;
+ return kFALSE;
}
if ( sKey == GetRevertKeyword() ) {
}
else {
AliErrorStream() << "Unrecognized key." << endl;
- return kFALSE;
+ delete stringList;
+ return kFALSE;
}
}
}
m->Add(b->At(0),b->At(1));
}
}
+ delete a;
return m;
}
{
AliErrorClass(Form("Cannot read pcbType=%s",pcbName.Data()));
delete slat;
+ delete tokens;
return 0;
}
}
b->Add(folder);
delete tokIter;
+ delete tokens;
}
delete mapIter;
}
const Int_t md = ((TObjString*)tks->At(0))->GetString().Atoi();
const Int_t X = ((TObjString*)tks->At(1))->GetString().Atoi();
const Int_t Z = ((TObjString*)tks->At(2))->GetString().Atoi();
-
+ delete tks;
if(badMap) {
if(badMap->IsBadChannel(5-md,Z+1,X+1)) {
AliInfo(Form("Cell mod=%d col=%d row=%d is bad. Histogram %s rejected.",
TClonesArray *arrin = dynamic_cast<TClonesArray*>(objsin->FindObject(cname));
if (!arrin) {
AliFatal(Form("Can not find input clusters with name %s", cname.Data()));
- return;
+ delete namearr;
+ return;
}
TClonesArray *arrout = dynamic_cast<TClonesArray*>(objsout->FindObject(cname));
if (!arrout) {
Int_t w = ((TObjString *) cols->At(icol))->String().Length();
if (w>col_widths[icol]) col_widths[icol] = w;
}
-
+ delete cols;
}
return col_widths;
}
printf ("\n");
+ delete cols;
}
delete [] colWidths;
} // loop on track sources
} // loop on steps
+ delete centralityClasses;
//////////////////////
// Event statistics //
action = static_cast<TObjString*>(a->At(1))->String();
action.ToUpper();
}
-
+
+ delete a;
+
Int_t nslashes = identifier.CountChar('/');
TH1* h(0x0);
}
l->Draw();
+ delete triggers;
}
//_____________________________________________________________________________
total,totalExpected,totalExpected ? total*100.0/totalExpected : 0.0) << std::endl;
AliLog::SetGlobalLogLevel(oldLevel);
+ delete triggers;
+ delete runs;
}
//_____________________________________________________________________________
(*out) << sep << "0" << sep << "0" << sep << "0" << sep << "0" << sep << std::endl; // LHC per fill, LHC integrated, lumi tot muon , efficiency
}
}
-
+ //
+ delete triggerArray;
}
//______________________________________________________________________________
++color;
++marker;
}
+ delete a;
return 0x0;
}
-
+ delete a;
+
std::vector<int> vx;
std::vector<int> vex;
std::vector<double> vy;
hist->Copy(*((TH1D*)hi));
hi->SetName(lastnam);
delete hist;
+ delete ar;
return hi;
}
//=============================================================================
if(fCFVarBins[ivar][0]!='\0') {
TObjArray* arr = fCFVarBins[ivar].Tokenize(",");
fCFVarsNbins[ivar] = arr->GetEntries()-1;
+ delete arr;
}
}
fCFVarsNbins[fCFNVars] = AliPID::kSPECIES;
}
fCfContainer->SetBinLimits(ivar, binLims);
}
+ delete arr;
}
fCfContainer->SetVarTitle(ivar, AliDielectronVarManager::GetValueName(fCFVarsEnabled[ivar]));
}
TString title = ((TObjArray*)fArrPairType->At(0))->First()->GetTitle();
TObjArray* binvars = title.Tokenize(":");
AliInfo(Form(" Number of variables: %d",binvars->GetEntriesFast()));
+ delete binvars;
TObjArray* binvars2 = title.Tokenize(":#");
for(Int_t ivar=0; ivar<binvars2->GetEntriesFast(); ivar++) {
if(ivar%3) continue;
AliInfo(Form(" variable %.0f: %s",((Double_t)ivar)/3+1,binvars2->At(ivar)->GetName()));
}
+ delete binvars2;
}
TObjArray* arr = name.Tokenize("_");
Bool_t isBplus = kTRUE;
if(name.Contains("BMINUS")) isBplus = kFALSE;
- TString centMinStr = arr->At(2)->GetName(); TString centMaxStr = arr->At(3)->GetName();
+ TString centMinStr = arr->At(2)->GetName();
+ TString centMaxStr = arr->At(3)->GetName();
+ delete arr;
if(isBplus) {
fgTRDpidEffCentRanges[idxp][2] = centMinStr.Atof();
fgTRDpidEffCentRanges[idxp][3] = centMaxStr.Atof();
for(Int_t istep = 0; istep < ctemp->GetNStep(); istep++)
cmerged->SetGrid(cstep++, new AliCFGridSparse(*ctemp->GetGrid(istep)));
}
+ delete containers;
return cmerged;
}
AliWarningGeneral("MakeTriggerMask",
Form("Unknown trigger %s", s.Data()));
}
- parts->Delete();
+ delete parts;
return trgMask;
}
TString twhat(what);
twhat.ToUpper();
TObjString* opt;
- TIter next(twhat.Tokenize(" ,|"));
+ TObjArray* token = twhat.Tokenize(" ,|");
+ TIter next(token);
while ((opt = static_cast<TObjString*>(next()))) {
TString s(opt->GetString());
if (s.IsNull()) continue;
if (add) scheme |= bit;
else scheme ^= bit;
}
+ delete token;
return scheme;
}
//________________________________________________________________________
// cout << "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++triggers fired: " << triggerClasses.Data() << endl;
TObjArray* triggers = triggerClasses.Tokenize(" ");
TObjArray* userTriggers = fUserEnabledTriggers.Tokenize(";");
- if(triggers->GetEntries()<1) return;
+ if(triggers->GetEntries()<1) {delete triggers; delete userTriggers; return;}
Bool_t hasGoodTriggers = kFALSE;
Int_t triggerIndices[kNMaxAssignedTriggers] = {0};
Int_t nTrigFired=0;
// Int_t nTRDtracks = fESD->GetNumberOfTrdTracks();
// Int_t nGlobalTracks = fESD->GetNumberOfTracks();
//cout << "TRD/All tracks: " << nTRDtracks << "/" << nGlobalTracks << endl;
+ //
+ delete triggers;
+ delete userTriggers;
+ //
for(Int_t i=0; i<nTrigFired; ++i)
((TH1F*)fHistos->At(kTriggerDefs))->Fill(triggerIndices[i]);
// Assign an index into the trigger histogram and the CF container for this trigger
GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
}
+ delete arr;
}
}
// Add background triggers from PhysicsSelection
// Assign an index into the trigger histogram and the CF container for this trigger
GetTriggerIndex(arr2->At(jt)->GetName(), kTRUE);
}
+ delete arr;
}
}
for(Int_t it=0; it<arr->GetEntries(); ++it) {
GetTriggerIndex(arr->At(it)->GetName(), kTRUE);
}
+ delete arr;
}
TObjArray* arr = fExpertCFVarBins[ivar].Tokenize(";");
nBins[nVars] = arr->GetEntries()-1;
if(nBins[nVars]>0) nVars++;
+ delete arr;
}
}
if(nVars<1) return 0x0;
}
cf->SetBinLimits(iUsedVar++, binLims);
}
+ delete arr;
}
cf->SetVarTitle(iUsedVar, varNames[ivar]);
}
}
else {
AliErrorClass(Form("Invalid syntax: %s",fileURI.Data()));
- fields->Delete();
+ delete fields;
return NULL;
}
}
if (!rawReader->IsRawReaderValid()) {
AliErrorClass(Form("Raw-reader is invalid - check the input URI (%s)",fileURI.Data()));
delete rawReader;
- fields->Delete();
delete fields;
return NULL;
}
rawReader->SelectEvents(eventType,triggerMask,triggerExpr.Data());
}
- fields->Delete();
delete fields;
return rawReader;
TObjArray *tokens = line.Tokenize(" \t");
TString system = ((TObjString *)tokens->At(0))->String();
TString password = ((TObjString *)tokens->At(1))->String();
+ delete tokens;
if (system.Contains("DAQ_LB")){
fDAQlbPass=password;
nPwd++;
AliDebug(3,Form("%i fake line(s) found in file %s", nPwdFake, fPasswdFilePath.Data()));
continue;
}
- delete tokens;
}
inputfile->close();
for(int ip=0; ip<fNPoints; ip++) fData[idim][ip] = (Float_t)v[ip];
}
Build();
+ delete vars;
}
//_________________________________________________________________
TObjArray* valTokens = strVal.Tokenize(":");
drawStr = valTokens->At(0)->GetName();
ferr = valTokens->At(1)->GetName();
+ delete valTokens;
}
fitter->ClearPoints();
Int_t entries = tree->Draw(drawStr.Data(), cutStr.Data(), "goff", stop-start, start);
- if (entries == -1) return new TString("An ERROR has occured during fitting!");
+ if (entries == -1) {
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
Double_t **values = new Double_t*[dim+1] ;
for (Int_t i=0; i<dim+1; i++) values[i]=NULL;
//
entries = tree->Draw(ferr.Data(), cutStr.Data(), "goff", stop-start, start);
if (entries == -1) {
+ delete formulaTokens;
delete []values;
return new TString("An ERROR has occured during fitting!");
}
TObjArray* valTokens = strVal.Tokenize(":");
drawStr = valTokens->At(0)->GetName();
ferr = valTokens->At(1)->GetName();
+ delete valTokens;
}
fitter->ClearPoints();
Int_t entries = tree->Draw(drawStr.Data(), cutStr.Data(), "goff", stop-start, start);
- if (entries == -1) return new TString("An ERROR has occured during fitting!");
+ if (entries == -1) {
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
Double_t **values = new Double_t*[dim+1] ;
for (Int_t i=0; i<dim+1; i++) values[i]=NULL;
//
entries = tree->Draw(ferr.Data(), cutStr.Data(), "goff", stop-start, start);
if (entries == -1) {
+ delete formulaTokens;
delete [] values;
return new TString("An ERROR has occured during fitting!");
}
if (entries != centries) {
delete []errors;
delete []values;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
values[i] = new Double_t[entries];
if (strVal.Contains(":")){
TObjArray* valTokens = strVal.Tokenize(":");
drawStr = valTokens->At(0)->GetName();
- ferr = valTokens->At(1)->GetName();
+ ferr = valTokens->At(1)->GetName();
+ delete valTokens;
}
fitter->ClearPoints();
Int_t entries = tree->Draw(drawStr.Data(), cutStr.Data(), "goff", stop-start, start);
- if (entries == -1) return new TString("An ERROR has occured during fitting!");
+ if (entries == -1) {
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
Double_t **values = new Double_t*[dim+1] ;
for (Int_t i=0; i<dim+1; i++) values[i]=NULL;
//
entries = tree->Draw(ferr.Data(), cutStr.Data(), "goff", stop-start, start);
if (entries == -1) {
delete []values;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
Double_t *errors = new Double_t[entries];
if (entries != centries) {
delete []errors;
delete []values;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
values[i] = new Double_t[entries];
}
if (isOK) index=i;
}
+ delete arrFit;
+ delete arrSub;
return index;
}
}
}
result+="-0.)";
+ delete array0;
+ delete array1;
return result;
}
for (Int_t i=0; i<=array0->GetEntries(); i++){
param(i)=paramM(i,0);
}
+ delete array0;
+ delete array1;
}
TString TStatToolkit::MakeFitString(const TString &input, const TVectorD ¶m, const TMatrixD & covar, Bool_t verbose){
if (verbose) printf("%f\t%f\t%s\n", param[i+1], TMath::Sqrt(covar(i+1,i+1)),str.Data());
}
result+="-0.)";
+ delete array0;
return result;
}
Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
if (entries == -1) {
delete fitter;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
Double_t **values = new Double_t*[dim+1] ;
if (entries != centries) {
delete fitter;
delete [] values;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
values[i] = new Double_t[entries];
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+ //
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
if (dangerousToDraw) {
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+ //
if (plotMean) {
cutHistoMean = SigmaCut(htemp, mean, sigma, sigmaMax, sigmaStep, pm);
if (cutHistoMean) {
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
activeDet.Append( " " );
activeDet.Append( ((TObjString*)det->At(k))->String() );
}
+ delete det;
}
return activeDet;
}
// Read inputs
if (ntokens != 5) {
AliError(Form("Invalid trigger input syntax (%s)!",strLine.Data()));
+ delete tokens;
return kFALSE;
}
AddInput(((TObjString*)tokens->At(0))->String(),
// Read interaction
if (ntokens != 2) {
AliError(Form("Invalid trigger interaction syntax (%s)!",strLine.Data()));
+ delete tokens;
return kFALSE;
}
AddInteraction(((TObjString*)tokens->At(0))->String(),
}
else {
AliError(Form("Invalid trigger descriptor syntax (%s)!",strLine.Data()));
+ delete tokens;
return kFALSE;
}
}
if (((TObjString*)tokens->At(0))->String().BeginsWith("l0f")) {
// function
if(!AddFunction(((TObjString*)tokens->At(0))->String(),
- strLine.ReplaceAll(((TObjString*)tokens->At(0))->String(),""))) return kFALSE;
+ strLine.ReplaceAll(((TObjString*)tokens->At(0))->String(),""))) {
+ delete tokens;
+ return kFALSE;
+ }
}
else {
if(!AddDescriptor(((TObjString*)tokens->At(0))->String(),
- strLine.ReplaceAll(((TObjString*)tokens->At(0))->String(),""))) return kFALSE;
+ strLine.ReplaceAll(((TObjString*)tokens->At(0))->String(),""))) {
+ delete tokens;
+ return kFALSE;
+ }
}
break;
case 4:
{
if (ntokens < 2) {
AliError(Form("Invalid trigger cluster syntax (%s)!",strLine.Data()));
- return kFALSE;
+ delete tokens;
+ return kFALSE;
}
if (((TObjString*)tokens->At(1))->String().Atoi() <= 0) {
AliError(Form("Invalid trigger cluster syntax (%s)!",strLine.Data()));
case 6:
if (ntokens > 2) {
AliError(Form("Invalid trigger bcmasks syntax (%s)!",strLine.Data()));
+ delete tokens;
return kFALSE;
}
if (((TObjString*)tokens->At(0))->String().CompareTo("NONE") == 0)
{
- if(!AddMask(new AliTriggerBCMask(((TObjString*)tokens->At(0))->String()))) return kFALSE;
+ if(!AddMask(new AliTriggerBCMask(((TObjString*)tokens->At(0))->String()))) {
+ delete tokens;
+ return kFALSE;
+ }
}
else {
- if(!AddMask(((TObjString*)tokens->At(0))->String(),((TObjString*)tokens->At(1))->String())) return kFALSE;
+ if(!AddMask(((TObjString*)tokens->At(0))->String(),((TObjString*)tokens->At(1))->String())) {
+ delete tokens;
+ return kFALSE;
+ }
}
break;
case 7:
{
if ((ntokens !=8) && (ntokens != 10) && (ntokens != 11)) {
AliError(Form("Invalid trigger class syntax (%s)!",strLine.Data()));
+ delete tokens;
return kFALSE;
}
AliTriggerClass *trclass=0;
((TObjString*)tokens->At(4))->String(),
((TObjString*)tokens->At(6))->String().Atoi(),(Bool_t)(((TObjString*)tokens->At(7))->String().Atoi()),
(((TObjString*)tokens->At(8))->String().Atoi()),(((TObjString*)tokens->At(9))->String().Atoi()));
- if(!trclass->SetMasks(this,((TObjString*)tokens->At(5))->String())) return kFALSE;
- }
+ if(!trclass->SetMasks(this,((TObjString*)tokens->At(5))->String())) {
+ delete tokens;
+ return kFALSE;
+ }
+ }
AddClass(trclass);
}
default:
TObjArray* arr = strLine.Tokenize(' ');
if(arr->GetEntries() != 2){
Printf("The line:\n%s\nunexpectedly contains %d tokens, instead of two.",strLine.Data(),arr->GetEntries());
+ delete arr;
return 0;
}
TObjString *osTC = (TObjString*) arr->At(0);
//
AliDebug(3,Form("Number of tokens = %d",ntokens));
if (ntokens == 2 && !(((TObjString*)tokens->At(0))->String()).CompareTo("LHC_ENTRIES")){
- lhcEntries = (((TObjString*)tokens->At(1))->String()).Atoi();
- AliInfo(Form("LHC entries = %d",lhcEntries));
- AliDebug(3,Form("LHC entries = %d",lhcEntries));
- continue;
+ lhcEntries = (((TObjString*)tokens->At(1))->String()).Atoi();
+ AliInfo(Form("LHC entries = %d",lhcEntries));
+ AliDebug(3,Form("LHC entries = %d",lhcEntries));
+ delete tokens;
+ continue;
}
if (ntokens == 1 && !(((TObjString*)tokens->At(0))->String()).CompareTo("END_OF_DATA")){
AliDebug(2,"End of file reached");
TObjArray *dets = fgkValidDetectors.Tokenize(',');
TObject *found = dets->FindObject(detector);
- dets->Delete();
- dets = 0;
+ delete dets;
if (!found) return kFALSE;
else return kTRUE;
TObjArray *dets = fgkGRPDetectors.Tokenize(',');
if (dets->FindObject(detector)) folderName = "GRP";
- dets->Delete();
- dets = 0;
+ delete dets;
dets = fgkMUONDetectors.Tokenize(',');
if (dets->FindObject(detector)) folderName = "MUON";
- dets->Delete();
-
-
-
- dets = 0;
-
+ delete dets;
+
return folderName;
}
TObjArray *dets = fgkValidDetectors.Tokenize(',');
for (int i = 0; i < dets->GetEntries(); ++i)
Printf("%s", ((TObjString *) dets->At(i))->GetString().Data());
- dets->Delete();
- dets = 0;
+ delete dets;
+
Printf("Some reports are stored in more general folders.\n"
"These reports can be opened using either name, the original or the\n"
"folder name. Example: 'SPACEFRAME' or 'GRP' are both valid when\n"
dets = fgkMUONDetectors.Tokenize(',');
for (int i = 0; i < dets->GetEntries(); ++i)
Printf("%s", ((TObjString *) dets->At(i))->GetString().Data());
- dets->Delete();
- dets = 0;
+ delete dets;
Printf("Detectors stored in 'GRP' folder:");
dets = fgkGRPDetectors.Tokenize(',');
for (int i = 0; i < dets->GetEntries(); ++i)
Printf("%s", ((TObjString *) dets->At(i))->GetString().Data());
- dets->Delete();
- dets = 0;
+ delete dets;
return;
}
lines->Add(oneLineObj);
}
- linesRaw->Delete();
delete linesRaw;
linesRaw = NULL;
colLine = nextLine.Tokenize(',');
if (colLine->GetEntries() != fNrColumns) {
AliError("Survey text file sintax error! (Declared number of Columns doesn't match number of column names)");
- colLine->Delete();
+ delete colLine;
lines->Delete();
delete lines; lines = NULL;
return kFALSE;
if (dataLine->GetEntries() != fNrColumns) {
// The number of columns doesn't match the number specified in the header
AliError("Survey text file sintax error! (Number of entries in line is different from number of Columns)");
- dataLine->Delete();
+ delete dataLine;
lines->Delete();
delete lines; lines = NULL;
return kFALSE;
if (ntokens != 1) {
AliErrorClass( Form( "Error reading version number from (%s), line :%s\n",
filename.Data() , strLine.Data() ) );
+ delete tokens;
return NULL;
}
// cout << "Version "<< ((TObjString*)tokens->At(0))->String().Atoi() << endl;
AliErrorClass( Form( "Error reading scalers from (%s): line (%s)",
filename.Data(), strLine1.Data() ));
delete rec;
+ delete tokens1;
return rScaler;
}
*/
}
}
-
+ delete tokens;
}
//-------------------------------------------------------------------------------------------------
if (!ostr) {
AliError("problems while getting run number from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str = ostr->GetString();
if (!str.BeginsWith("run:")) {
AliError("problems while getting run number from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str.Remove(0, 5);
if (runNb <= 0) {
AliError(Form("bad run number: %d", runNb));
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
AliInfo(Form("got run number: %d", runNb));
if (!ostr) {
AliError("problems while getting start timestamp from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str = ostr->GetString();
if (!str.BeginsWith("startTimestamp:")) {
AliError("problems while getting start timestamp from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str.Remove(0, 16);
if (startTimestamp <= 0) {
AliError(Form("bad start timestamp: %d", startTimestamp));
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
TTimeStamp ts = startTimestamp;
if (!ostr) {
AliError("problems while getting BPTX from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str = ostr->GetString();
if (!str.BeginsWith("BPTX:")) {
AliError("problems while getting BPTX from histogram title");
fStatus = kDataError;
+ delete strarr;
return kFALSE;
}
str.Remove(0, 6);
Bool_t useBPTX = atoi(str.Data());
AliInfo(Form("got BPTX: %d", useBPTX));
+ delete strarr;
+
/*** CALIBRATION STAGE ***/
/* get fit function */
type=optString.Atoi();
}
}
+ delete arr;
if ( type==4 ){
// only for the new algorithm
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
if (dangerousToDraw) {
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
if (plotMean) {
cutHistoMean = AliTPCCalibViewer::SigmaCut(htemp, mean, sigma, sigmaMax, sigmaStep, pm);
if (cutHistoMean) {
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
+ delete sigmasTokens;
if (plotMean) {
for (Int_t i = 0; i < entries; i++) {
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
TH1F *integralHistoMean = 0;
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
fitter->ClearPoints();
Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
- if (entries == -1) return new TString("An ERROR has occured during fitting!");
+ if (entries == -1) {
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
Double_t **values = new Double_t*[dim+1] ;
for (Int_t i = 0; i < dim + 1; i++){
if (entries != centries) {
delete [] values;
+ delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
values[i] = new Double_t[entries];
}
delete fIn;
}
+ delete arrFileLine;
}
fAlignTree->SetAlias("err","rms");
TString *strDeltaITS = TStatToolkit::FitPlaneConstrain(fAlignTree,"mean:err", fstringFast.Data(),cutFit, chi2,npoints,param,covar,-1,0, npointsMax, 1);
- strDeltaITS->Tokenize("++")->Print();
+ TObjArray* tokArr = strDeltaITS->Tokenize("++");
+ tokArr->Print();
+ delete tokArr;
fAlignTree->SetAlias("fitYFast",strDeltaITS->Data());
//
TVectorD paramC= param;
TObjArray *stokens = objName.Tokenize("_ROC");
TString rocNumber("");
if (stokens->GetEntriesFast()>1) rocNumber = ((TObjString*)stokens->At(1))->GetString();
+ delete stokens;
Int_t iroc = -1;
if (rocNumber.IsAlnum()) iroc = rocNumber.Atoi();
TObjString *sObjType = (TObjString*)(arrNextCol->At(0));
TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
-
+ delete arrNextCol;
+
if ( !sObjType || ! sObjFileName ) continue;
TString sType(sObjType->GetString());
TString sFileName(sObjFileName->GetString());
}
delete fIn;
}
+ delete arrFileLine;
}
Int_t AliTPCcalibDB::InitDeadMap() {
runs[naccept]=irunN;
naccept++;
}}
+ delete arr;
fRuns.Set(naccept);
fRunsStart.Set(fRuns.fN);
fRunsStop.Set(fRuns.fN);
TString * strFitG=0;
TString * strFitLX=0;
//
+ TObjArray* tokArr = 0;
strFitG = TStatToolkit::FitPlane(chain,"deltaT", fstringG.Data(),"sideA"+cutAll, chi2,npoints,vecG[0],covar,-1,0, 10000000, kFALSE);
chain->SetAlias("tfitGA",strFitG->Data());
- strFitG->Tokenize("++")->Print();
+ tokArr = strFitG->Tokenize("++");
+ tokArr->Print();
+ delete tokArr;
printf("chi2=%f\n",TMath::Sqrt(chi2/npoints));
//
strFitG = TStatToolkit::FitPlane(chain,"deltaT", fstringG.Data(),"sideC"+cutAll, chi2,npoints,vecG[1],covar,-1,0, 10000000, kFALSE);
chain->SetAlias("tfitGC",strFitG->Data());
- strFitG->Tokenize("++")->Print();
+ tokArr = strFitG->Tokenize("++");
+ tokArr->Print();
+ delete tokArr;
printf("chi2=%f\n",TMath::Sqrt(chi2/npoints));
//
AliTPCCalPad *padFitG =AliTPCCalPad::CreateCalPadFit("1++gy/500.++gx/500.++0+++0++0++0++0",vecG[0],vecG[1]);
for (Int_t i=0; i<array0->GetEntries(); i++){
param(i)=paramM(i,0);
}
+ delete array0;
+ delete array1;
}
}
}
result+="-0.)";
+ delete array0;
+ delete array1;
return result;
}
counter++;
}
finput.close();
+ delete array;
return kTRUE;
}
Bool_t result = TFile::Cp(infile,outfile);
succes &= result;
}
+ delete array;
return succes;
}
TFile * f = TFile::Open(description->At(4)->GetName());
if (!f){
printf("Fatal: Invalid description: fileName %s\n", description->At(4)->GetName());
+ delete arrayInput;
return;
}
arrayFile->AddAt(f,itree);
TTree * tree = (TTree*)f->Get(description->At(3)->GetName());
if (!tree){
printf("Fatal: Invalid description. Tree name\t%s\n", description->At(3)->GetName());
+ delete arrayInput;
return;
}
tree->SetCacheSize(400000000);
}}
//
+ delete arrayInput;
// 2. Make the run list
//
//
AliWarning(Form("Unknown option flag %s.", sopt.Data()));
}
+ delete opar;
}
//_____________________________________________________________________________
TObjArray *tokens = string.Tokenize(" ");
if (tokens->GetEntriesFast() < 7) {
AliWarning(Form("Invalid input in line %i, too few parameters", lineno));
+ delete tokens;
continue;
}
- if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event)
+ if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event) {
+ delete tokens;
continue;
-
+ }
iEvent = ((TObjString*) tokens->At(0))->GetString().Atoi();
iSec = ((TObjString*) tokens->At(1))->GetString().Atoi();
iStack = ((TObjString*) tokens->At(2))->GetString().Atoi();
if (fTMU)
fTMU->AddTracklet(trkl, iLink);
}
+ //
+ delete tokens;
}
if (fTMU && evcnt < noev) {
else if(name.Contains("DelayHit")) SetTimeOffset(0.01*(Float_t)val,iBoard,(iChannel-1));
else if(name.Contains("DiscriThr")) SetDiscriThr(((Float_t)val-2040.)/112.,iBoard,(iChannel-1));
else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));
+ //
+ delete nameSplit;
}
//________________________________________________________________
else if(name.Contains("PedCutOdd")) SetPedestalCut((UShort_t) val, 1, iBoard, iChannel-1);\r
else if(name.Contains("PedCutEven")) SetPedestalCut((UShort_t) val, 0, iBoard, iChannel-1);\r
else AliError(Form("No Setter found for FEE parameter : %s",name.Data()));\r
+ //\r
+ delete nameSplit;\r
}\r
//________________________________________________________________\r
void AliVZEROTriggerData::SetPedestalCut(UShort_t val,Int_t integrator, Int_t board, Int_t channel)\r