Int_t AliUnfolding::fgSkipBinsBegin = 0;
Float_t AliUnfolding::fgMinuitStepSize = 0.1; // (usually not needed to be changed) step size in minimization
Float_t AliUnfolding::fgMinuitPrecision = 1e-6; // minuit precision
-Int_t AliUnfolding::fgMinuitMaxIterations = 1000000; // minuit maximum number of iterations\r
+Int_t AliUnfolding::fgMinuitMaxIterations = 1000000; // minuit maximum number of iterations
Double_t AliUnfolding::fgMinuitStrategy = 1.; // minuit strategy
Bool_t AliUnfolding::fgMinimumInitialValue = kFALSE; // set all initial values at least to the smallest value among the initial values
Float_t AliUnfolding::fgMinimumInitialValueFix = -1;
fgBayesianSmoothing = smoothing;
fgBayesianIterations = nIterations;
- Printf("AliUnfolding::SetBayesianParameters --> Parameters set to %d iterations with smoothing %f", fgBayesianIterations, fgBayesianSmoothing);\r
+ Printf("AliUnfolding::SetBayesianParameters --> Parameters set to %d iterations with smoothing %f", fgBayesianIterations, fgBayesianSmoothing);
}
//____________________________________________________________________
fgEntropyAPriori = new TVectorD(fgMaxParams);
if (!fgEfficiency)
fgEfficiency = new TVectorD(fgMaxParams);
- if (!fgUnfoldedAxis)
+ if (fgUnfoldedAxis)
+ {
delete fgUnfoldedAxis;
- fgUnfoldedAxis = new TAxis(*(correlation->GetXaxis()));
- if (!fgMeasuredAxis)
+ fgUnfoldedAxis = 0;
+ }
+ if (!fgUnfoldedAxis)
+ fgUnfoldedAxis = new TAxis(*(correlation->GetXaxis()));
+ if (fgMeasuredAxis)
+ {
delete fgMeasuredAxis;
- fgMeasuredAxis = new TAxis(*(correlation->GetYaxis()));
+ fgMeasuredAxis = 0;
+ }
+ if (!fgMeasuredAxis)
+ fgMeasuredAxis = new TAxis(*(correlation->GetYaxis()));
fgCorrelationMatrix->Zero();
fgCorrelationCovarianceMatrix->Zero();
Double_t* result = new Double_t[kMaxT];
Double_t* efficiency = new Double_t[kMaxT];
Double_t* binWidths = new Double_t[kMaxT];
- Double_t* normResponse = new Double_t[kMaxT]; \r
+ Double_t* normResponse = new Double_t[kMaxT];
Double_t** response = new Double_t*[kMaxT];
Double_t** inverseResponse = new Double_t*[kMaxT];
{
response[i] = new Double_t[kMaxM];
inverseResponse[i] = new Double_t[kMaxM];
- normResponse[i] = 0;\r
+ normResponse[i] = 0;
}
// for normalization
{
response[t][m] = correlation->GetBinContent(t+1, m+1);
inverseResponse[t][m] = 0;
- normResponse[t] += correlation->GetBinContent(t+1, m+1);\r
+ normResponse[t] += correlation->GetBinContent(t+1, m+1);
}
}
prior[t] = measuredCopy[t];
result[t] = 0;
binWidths[t] = aResult->GetXaxis()->GetBinWidth(t+1);
-\r
- for (Int_t m=0; m<kMaxM; m++) { // Normalise response matrix\r
- if (normResponse[t] != 0) \r
- response[t][m] /= normResponse[t];\r
- else\r
- Printf("AliUnfolding::UnfoldWithBayesian: Empty row,column in response matrix, for truth bin %d",t);\r
- }\r
+
+ for (Int_t m=0; m<kMaxM; m++) { // Normalise response matrix
+ if (normResponse[t] != 0)
+ response[t][m] /= normResponse[t];
+ else
+ Printf("AliUnfolding::UnfoldWithBayesian: Empty row,column in response matrix, for truth bin %d",t);
+ }
}
// pick prior distribution
{
Float_t norm = 0;
for (Int_t t = kStartBin; t<kMaxT; t++)
- norm += response[t][m] * prior[t] * efficiency[t];\r
+ norm += response[t][m] * prior[t] * efficiency[t];
// calc. chi2: (measured - response * prior) / error
if (measuredError[m] > 0)
if (norm > 0)
{
for (Int_t t = kStartBin; t<kMaxT; t++)
- inverseResponse[t][m] = response[t][m] * prior[t] * efficiency[t] / norm;\r
+ inverseResponse[t][m] = response[t][m] * prior[t] * efficiency[t] / norm;
}
else
{
delete[] result;
delete[] efficiency;
delete[] binWidths;
- delete[] normResponse;\r
+ delete[] normResponse;
for (Int_t i=0; i<kMaxT; i++)
{