def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
simulation.setSampleBuilder(MySampleBuilder())
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*radius", 8. * nm,
ba.AttLimits.limited(4., 12.))
fit_suite.addFitParameter("*lattice_constant", 8. * nm,
ba.AttLimits.limited(4., 12.))
print(fit_suite.treeToString())
print(fit_suite.parametersToString())
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
Setup simulation and fit
"""
sample = get_sample()
# sample.printParameters()
simulation = get_simulation()
simulation.setSample(sample)
real_data = load_exp_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
# choose the minimizer (optional)
# or set fit strategies (optional)
fit_suite.initPrint(10)
# setting fitting parameters with starting values
# set and attach observer
draw_observer = DrawObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# print results
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
return fit_suite
def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
sample = get_sample()
simulation.setSample(sample)
# the core method of this example which adds masks to the simulation
add_mask_to_simulation(simulation)
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*/Cylinder/Radius", 6. * nm).setLimited(4., 8.)
fit_suite.addFitParameter("*/Cylinder/Height", 9. * nm).setLimited(8., 12.)
# running fit
fit_suite.runFit()
print("Fitting completed.")
fit_suite.printResults()
print("chi2:", fit_suite.getChi2())
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
main function to run fitting
"""
incident_alpha_angles = [0.1*deg, 0.4*deg]
fit_suite = ba.FitSuite()
sample = get_sample()
for alpha in incident_alpha_angles:
real_data = create_real_data(incident_alpha=alpha)
simulation = get_simulation(incident_alpha=alpha)
simulation.setSample(sample)
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = DrawObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*/HemiEllipsoid/RadiusX", 4.*nm).setLimited(2., 10.)
fit_suite.addFitParameter("*/HemiEllipsoid/RadiusY", 6.*nm).setFixed()
fit_suite.addFitParameter("*/HemiEllipsoid/Height", 4.*nm).setLimited(2., 10.)
print(fit_suite.treeToString())
print(fit_suite.parametersToString())
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
simulation = create_simulation()
sample_builder = MySampleBuilder()
simulation.setSampleBuilder(sample_builder)
real_data = load_exp_data()
fit_suite = ba.FitSuite()
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
fit_suite.initPrint(10)
fit_suite.addSimulationAndRealData(simulation, real_data)
print("1.8")
# setting fitting parameters with starting values
fit_suite.addFitParameter("*radius", 5.0 * ba.nm,
ba.AttLimits.limited(4.0, 6.0), 0.1 * ba.nm)
fit_suite.addFitParameter("*sigma", 0.55, ba.AttLimits.limited(0.2, 0.8),
0.01 * ba.nm)
fit_suite.addFitParameter("*distance", 27. * ba.nm,
ba.AttLimits.limited(20, 70), 0.1 * ba.nm)
# set fit strategies
# strategy1 = ba.AdjustMinimizerStrategy("Genetic")
# fit_suite.addFitStrategy(strategy1)
# Second fit strategy will use another algorithm.
# It will use best parameters found from previous minimization round.
# strategy2 = ba.AdjustMinimizerStrategy("Minuit2", "Migrad")
# fit_suite.addFitStrategy(strategy2)
# running fit
fit_suite.runFit()
plt.show()
def run_fitting():
"""
run fitting
"""
sample = get_sample()
simulation = get_simulation()
simulation.setSample(sample)
real_data = ba.IntensityDataIOFactory.readIntensityData(
'refdata_fitcylinderprisms.int.gz')
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*Cylinder/Height",
4. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Cylinder/Radius",
6. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/Height", 4. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/BaseEdge",
12. * nm).setLowerLimited(0.01)
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for par in fit_suite.fitParameters():
print(par.name(), par.value(), par.error())
def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
sample = get_sample()
simulation.setSample(sample)
real_data = create_real_data()
fit_suite = ba.FitSuite()
#fit_suite.setMinimizer("GSLLMA")
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
fit_suite.addFitParameter("*/FullSphere/Radius", 8. * nm,
ba.AttLimits.limited(4., 12.))
fit_suite.addFitParameter("*HexagonalLattice/LatticeLength", 8. * nm,
ba.AttLimits.limited(4., 12.))
print(fit_suite.treeToString())
print(fit_suite.parametersToString())
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def test_FitParameterSetIterator(self):
"""
Testing of python iterator over defined fit parameters.
"""
fitSuite = ba.FitSuite()
names = ["par0", "par1", "par2"]
values = [1.0, 2.0, 3.0]
for name, value in zip(names, values):
fitSuite.addFitParameter(name, value)
nn = 0
for par in fitSuite.fitParameters():
self.assertTrue(par.name() == names[nn])
self.assertTrue(par.value() == values[nn])
nn = nn+1
self.assertTrue(nn == 3)
def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
sample = get_sample()
simulation.setSample(sample)
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# setting fitting parameters with starting values
# Here we select starting values being quite far from true values
# to puzzle our minimizer's as much as possible
fit_suite.addFitParameter("*Height", 1.*nm).setLimited(0.01, 30.)\
.setStep(0.05*nm)
fit_suite.addFitParameter("*Radius", 20.*nm).setLimited(0.01, 30.)\
.setStep(0.05*nm)
# Now we create first fig strategy which will run first minimization round
# using the Genetic minimizer.
# The Genetic minimizer is able to explore large parameter space
# without being trapped by some local minima.
strategy1 = ba.AdjustMinimizerStrategy("Genetic", "",
"MaxIterations=2;RandomSeed=1")
fit_suite.addFitStrategy(strategy1)
# Second fit strategy will use another minimizer.
# It starts from best parameters found in previous minimization
# and then continues until fit converges.
strategy2 = ba.AdjustMinimizerStrategy("Minuit2", "Migrad")
fit_suite.addFitStrategy(strategy2)
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
main function to run fitting
"""
ax_values, real_data = create_real_data()
axis = make_axis(ax_values)
simulation = get_simulation(axis)
sample = get_sample()
simulation.setSample(sample)
print(simulation.treeToString())
print(simulation.parametersToString())
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10,
SimulationType='Specular')
fit_suite.attachObserver(draw_observer)
fitPar = ba.FitParameter(5. * ba.nm,
ba.AttLimits.limited(1. * ba.nm, 7. * ba.nm))
fitPar.setName("thickness")
for odd in [1, 3, 5, 7,
9]: # adding patterns for all odd layers' thicknesses
fitPar.addPattern("*" + str(odd) + "/Thickness*")
fit_suite.addFitParameter(fitPar)
strategy1 = ba.AdjustMinimizerStrategy("Minuit2", "Migrad",
"Strategy=2;Tolerance=1e-5")
fit_suite.addFitStrategy(strategy1)
# prints defined fit parameters and their relation to instrument parameters
print(fit_suite.setupToString())
# running fit
print("Starting the fitting")
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
Setup simulation and fit
"""
sample = get_sample()
# sample.printParameters()
simulation = get_simulation()
simulation.setSample(sample)
real_data = load_exp_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
# choose the minimizer
# fit_suite.setMinimizer("Minuit2", "Migrad") # ba.Default
# fit_suite.setMinimizer("Minuit2", "Fumili")
# or set fit strategies
# strategy1 = ba.AdjustMinimizerStrategy("Genetic")
# fit_suite.addFitStrategy(strategy1)
# strategy2 = ba.AdjustMinimizerStrategy("Minuit2", "Migrad")
# fit_suite.addFitStrategy(strategy2)
fit_suite.initPrint(10)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*Box/Height", 18.*nm).setLimited(5.0, 30.0)
# fit_suite.addFitParameter("*Box/Width", 18. * nm).setLimited(5.0, 30.0)
# fit_suite.addFitParameter("*Box/Length", 18. * nm).setLimited(5.0, 30.0)
# fit_suite.addFitParameter("*LatticeLength*", 40. * nm).setLimited(30.0, 60.0)
draw_observer = DrawObserver(draw_every_nth=10)
# draw_observer = ba.DefaultFitObserver(draw_every_nth=10) # alternatively
fit_suite.attachObserver(draw_observer)
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
return fit_suite
def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
sample = get_sample()
simulation.setSample(sample)
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
chiModule = ba.ChiSquaredModule()
chiModule.setIntensityNormalizer(ba.IntensityScaleAndShiftNormalizer())
fit_suite.setChiSquaredModule(chiModule)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# print all defined parameters for sample and simulation
print(fit_suite.parametersToString())
# setting fitting parameters with starting values
fit_suite.addFitParameter("*/Cylinder/Radius", 6. * nm,
ba.AttLimits.limited(4., 8.))
fit_suite.addFitParameter("*/Cylinder/Height", 9. * nm,
ba.AttLimits.limited(8., 12.))
fit_suite.addFitParameter("*/Normalizer/scale", 1.5,
ba.AttLimits.limited(1.0, 3.0))
fit_suite.addFitParameter("*/Normalizer/shift", 50.,
ba.AttLimits.limited(1, 500.))
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
main function to run fitting
"""
simulation = get_simulation()
sample = get_sample()
simulation.setSample(sample)
print(simulation.treeToString())
print(simulation.parametersToString())
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
# this fit parameter fits 4 sample parameter with one value
fit_suite.addFitParameter("*Lattice/LatticeLength*", 9.*nm).\
setLimited(6., 10.).addPattern("*Cylinder/Radius").\
addPattern("*Cylinder/Height").setName("custom_length")
# alternatively, following syntax is possible
# fitPar = ba.FitParameter(10.*nm, ba.AttLimits.limited(4., 12.))
# fitPar.setName("custom_length")
# fitPar.addPattern("*Lattice/LatticeLength*")
# fitPar.addPattern("*Cylinder/Radius").addPattern("*Cylinder/Height")
# fit_suite.addFitParameter(fitPar)
# prints defined fit parameters and their relation to instrument parameters
print(fit_suite.setupToString())
# running fit
print("Starting the fitting")
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
run fitting
"""
sample = get_sample()
simulation = get_simulation()
simulation.setSample(sample)
real_data = ba.IntensityDataIOFactory.readIntensityData(
'refdata_fitcylinderprisms.int.gz')
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
# setting fitting parameters with starting values and limits
fit_suite.addFitParameter("*Cylinder/Height",
4. * nm).setLowerLimited(0.01).setStep(0.02)
fit_suite.addFitParameter("*Cylinder/Radius", 6. * nm).setLimited(3.0, 8.0)
fit_suite.addFitParameter("*Prism3/Height", 4. * nm).setUpperLimited(10.0)
fit_suite.addFitParameter("*Prism3/BaseEdge", 5. * nm).setFixed()
# > Changing minimization algorithm
# catalogue = ba.MinimizerCatalogue()
# print(catalogue.toString())
# fit_suite.setMinimizer("Minuit2", "Migrad") # ba.Default
# fit_suite.setMinimizer("Minuit2", "Fumili")
# fit_suite.setMinimizer("Minuit2", "Fumili", "MaxFunctionCalls=20")
# fit_suite.setMinimizer("GSLLMA")
# > Drawing fit progress evey 10'th iteration
# draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
# fit_suite.attachObserver(draw_observer)
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for par in fit_suite.fitParameters():
print(par.name(), par.value(), par.error())
def test_addFitParameter(self):
fitSuite = ba.FitSuite()
fitSuite.addFitParameter("pattern0", 1.0)
fitSuite.addFitParameter("pattern1", 2.0, ba.AttLimits.limited(10.0, 20.0), 0.02)
fitSuite.addFitParameter("pattern2", 3.0).setLowerLimited(30.0).setStep(0.03)
fitSuite.addFitParameter("pattern3", 4.0).setStep(0.04).setUpperLimited(40.0)
fitSuite.addFitParameter("pattern4", 5.0).setFixed()
par = fitSuite.fitParameters()[0]
self.assertEqual(par.name(), "par0")
self.assertEqual(par.value(), 1.0)
self.assertEqual(par.step(), 0.01) # default step is 1% in FitSuite
self.assertTrue(par.limits().isLimitless())
par = fitSuite.fitParameters()[1]
self.assertEqual(par.name(), "par1")
self.assertEqual(par.value(), 2.0)
self.assertEqual(par.step(), 0.02)
self.assertTrue(par.limits().isLimited())
self.assertEqual(par.limits().lowerLimit(), 10.0)
self.assertEqual(par.limits().upperLimit(), 20.0)
par = fitSuite.fitParameters()[2]
self.assertEqual(par.name(), "par2")
self.assertEqual(par.value(), 3.0)
self.assertEqual(par.step(), 0.03)
self.assertTrue(par.limits().isLowerLimited())
self.assertEqual(par.limits().lowerLimit(), 30.0)
par = fitSuite.fitParameters()[3]
self.assertEqual(par.name(), "par3")
self.assertEqual(par.value(), 4.0)
self.assertEqual(par.step(), 0.04)
self.assertTrue(par.limits().isUpperLimited())
self.assertEqual(par.limits().upperLimit(), 40.0)
par = fitSuite.fitParameters()[4]
self.assertEqual(par.name(), "par4")
self.assertEqual(par.value(), 5.0)
self.assertTrue(par.limits().isFixed())
def run_fitting():
"""
Setup simulation and fit
"""
sample = get_sample()
simulation = get_simulation()
simulation.setSample(sample)
real_data = create_real_data()
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
# fit_suite.setMinimizer("Minuit2", "Migrad") # ba.Default
# fit_suite.setMinimizer("Minuit2", "Fumili")
# fit_suite.setMinimizer("GSLLMA")
fit_suite.initPrint(10)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*Cylinder/Height",
4. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Cylinder/Radius",
6. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/Height", 4. * nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/BaseEdge",
12. * nm).setLowerLimited(0.01)
draw_observer = ba.DefaultFitObserver(draw_every_nth=10)
fit_suite.attachObserver(draw_observer)
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
return fit_suite
def run_fitting():
"""
main function to run fitting
"""
real_data = create_real_data()
sample = get_sample()
simulation = get_simulation()
simulation.setSample(sample)
# At this point we mask all the detector and then unmask two areas
# corresponding to the vertical and horizontal lines. This will make
# simulation/fitting to be performed along slices only.
simulation.maskAll()
simulation.addMask(ba.HorizontalLine(alpha_slice_value * deg), False)
simulation.addMask(ba.VerticalLine(phi_slice_value * deg), False)
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(5)
draw_observer = DrawObserver(draw_every_nth=5)
fit_suite.attachObserver(draw_observer)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*/Cylinder/Radius", 6. * nm).setLimited(4., 8.)
fit_suite.addFitParameter("*/Cylinder/Height", 9. * nm).setLimited(8., 12.)
# running fit
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for fitPar in fit_suite.fitParameters():
print(fitPar.name(), fitPar.value(), fitPar.error())
def run_fitting():
"""
run fitting
"""
# prints info about available minimizers
print(ba.MinimizerFactory().catalogueToString())
# prints detailed info about available minimizers and their options
print(ba.MinimizerFactory().catalogueDetailsToString())
sample = get_sample()
simulation = get_simulation()
simulation.setSample(sample)
real_data = ba.IntensityDataIOFactory.readIntensityData(
'refdata_fitcylinderprisms.int.gz')
fit_suite = ba.FitSuite()
fit_suite.addSimulationAndRealData(simulation, real_data)
fit_suite.initPrint(10)
# setting fitting parameters with starting values
fit_suite.addFitParameter("*Cylinder/Height", 4.*nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Cylinder/Radius", 6.*nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/Height", 4.*nm).setLowerLimited(0.01)
fit_suite.addFitParameter("*Prism3/BaseEdge", 12.*nm).setLowerLimited(0.01)
# Uncomment one of the line below to adjust minimizer settings
# setting Minuit2 minimizer with Migrad algorithm, limiting number of iterations
# Minimization will try to respect MaxFunctionCalls value
# fit_suite.setMinimizer("Minuit2", "Migrad", "MaxFunctionCalls=100")
# Setting two options at once.
# Strategy=2 promises more accurate fit.
# fit_suite.setMinimizer("Minuit2", "Simplex", "MaxFunctionCalls=100;Strategy=2")
# setting Minuit2 minimizer with Fumili algorithm
# fit_suite.setMinimizer("Minuit2", "Fumili")
# Setting Levenberg-Marquardt algorithm
# fit_suite.setMinimizer("GSLLMA")
# Setting Genetic algorithm.It requires all parameters
# to be limited, so we recreate parameters with min and max defined
# fit_suite.fitParameters().clear()
# fit_suite.addFitParameter("*Cylinder/Height", 4.*nm).setLimited(3.0, 8.0)
# fit_suite.addFitParameter("*Cylinder/Radius", 6.*nm).setLimited(3.0, 8.0)
# fit_suite.addFitParameter("*Prism3/Height", 4.*nm).setLimited(3.0, 8.0)
# fit_suite.addFitParameter("*Prism3/BaseEdge", 4.*nm).setLimited(3.0, 8.0)
# fit_suite.setMinimizer("Genetic", "Default",
# "MaxIterations=2;PopSize=200;RandomSeed=1")
# running fit with default minimizer
fit_suite.runFit()
print("Fitting completed.")
print("chi2:", fit_suite.getChi2())
for par in fit_suite.fitParameters():
print(par.name(), par.value(), par.error())
