Fitting the data

The Fit class takes the data and model expression to be fit, and uses the optimiser to minimise the chosen statistic. The basic approach is to:

  • create a Fit object;

  • call its fit() method one or more times, potentially varying the method attribute to change the optimiser;

  • inspect the FitResults object returned by fit() to extract information about the fit;

  • review the fit quality, perhaps re-fitting with a different set of parameters or using a different optimiser;

  • once the “best-fit” solution has been found, calculate error estimates by calling the est_errors() method, which returns a ErrorEstResults object detailing the results;

  • visualize the parameter errors with classes such as IntervalProjection and RegionProjection.

The following discussion uses a one-dimensional data set with gaussian errors (it was simulated with gaussian noise with \(\sigma = 5\)):

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from import Data1D
>>> d = Data1D('fit example', [-13, -5, -3, 2, 7, 12],
...            [102.3, 16.7, -0.6, -6.7, -9.9, 33.2],
...            np.ones(6) * 5)

It is going to be fit with the expression:

\[y = c_0 + c_1 x + c_2 x^2\]

which is represented by the Polynom1D model:

>>> from sherpa.models.basic import Polynom1D
>>> mdl = Polynom1D()

To start with, just the \(c_0\) and \(c_2\) terms are used in the fit:

>>> mdl.c2.thaw()
>>> print(mdl)
   Param        Type          Value          Min          Max      Units
   -----        ----          -----          ---          ---      -----
   polynom1d.c0 thawed            1 -3.40282e+38  3.40282e+38
   polynom1d.c1 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c2 thawed            0 -3.40282e+38  3.40282e+38
   polynom1d.c3 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c4 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c5 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c6 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c7 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c8 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.offset frozen            0 -3.40282e+38  3.40282e+38

Creating a fit object

A Fit object requires both a data set and a model object, and will use the Chi2Gehrels statistic with the LevMar optimiser unless explicitly over-riden with the stat and method parameters (when creating the object) or the stat and method attributes (once the object has been created).

>>> from import Fit
>>> f = Fit(d, mdl)
>>> print(f)
data      = fit example
model     = polynom1d
stat      = Chi2Gehrels
method    = LevMar
estmethod = Covariance
>>> print(
name      = fit example
x         = [-13, -5, -3, 2, 7, 12]
y         = [102.3, 16.7, -0.6, -6.7, -9.9, 33.2]
staterror = Float64[6]
syserror  = None
>>> print(f.model)
   Param        Type          Value          Min          Max      Units
   -----        ----          -----          ---          ---      -----
   polynom1d.c0 thawed            1 -3.40282e+38  3.40282e+38
   polynom1d.c1 thawed            0 -3.40282e+38  3.40282e+38
   polynom1d.c2 thawed            0 -3.40282e+38  3.40282e+38
   polynom1d.c3 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c4 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c5 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c6 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c7 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.c8 frozen            0 -3.40282e+38  3.40282e+38
   polynom1d.offset frozen            0 -3.40282e+38  3.40282e+38

The fit object stores references to objects, such as the model, which means that the fit object reflects the current state, and not just the values when it was created or used. For example, in the following the model is changed directly, and the value stored in the fit object is also changed:

>>> f.model.c2.val
>>> mdl.c2 = 1
>>> f.model.c2.val

Using the optimiser and statistic

With a Fit object can calculate the statistic value for the current data and model (calc_stat()), summarise how well the current model represents the data (calc_stat_info()), calculate the per-bin chi-squared value (for chi-square statistics; calc_stat_chisqr()), fit the model to the data (fit() and simulfit()), and calculate the parameter errors (est_errors()).

>>> print("Starting statistic: {:.3f}".format(f.calc_stat()))
Starting statistic: 840.251
>>> sinfo1 = f.calc_stat_info()
>>> print(sinfo1)
name      =
ids       = None
bkg_ids   = None
statname  = chi2
statval   = 840.2511999999999
numpoints = 6
dof       = 4
qval      = 1.4661616529226985e-180
rstat     = 210.06279999999998

The fields in the StatInfoResults depend on the choice of statistic; in particular, rstat and qval are set to None if the statistic is not based on chi-square. The current data set has a reduced statistic of \(\sim 200\) which indicates that the fit is not very good (if the error bars in the dataset are correct then a good fit is indicated by a reduced statistic \(\simeq 1\) for chi-square based statistics).

As with the model and statistic, if the data object is changed then the results of calculations made on the fit object can be changed. As shown below, when one data point is removed, the calculated statistics are changed (such as the numpoints value).

>>> d.ignore(0, 5)
>>> sinfo2 = f.calc_stat_info()
>>> d.notice()
>>> sinfo1.numpoints
>>> sinfo2.numpoints


The objects returned by the fit methods, such as StatInfoResults and FitResults, do not contain references to any of the input objects. This means that the values stored in these objects are not changed when the input values change.

The fit() method uses the optimiser to vary the thawed parameter values in the model in an attempt to minimize the statistic value. The method returns a FitResults object which contains information on the fit, such as whether it succeeded (found a minimum, succeeded), the start and end statistic value (istatval and statval), and the best-fit parameter values (parnames and parvals).

>>> res =
>>> if res.succeeded: print("Fit succeeded")
Fit succeeded

The return value has a format() method which provides a summary of the fit:

>>> print(res.format())
Method                = levmar
Statistic             = chi2
Initial fit statistic = 840.251
Final fit statistic   = 96.8191 at function evaluation 6
Data points           = 6
Degrees of freedom    = 4
Probability [Q-value] = 4.67533e-20
Reduced statistic     = 24.2048
Change in statistic   = 743.432
   polynom1d.c0   -11.0742     +/- 2.91223
   polynom1d.c2   0.503612     +/- 0.0311568

The information is also available directly as fields of the FitResults object:

>>> print(res)
datasets       = None
itermethodname = none
methodname     = levmar
statname       = chi2
succeeded      = True
parnames       = ('polynom1d.c0', 'polynom1d.c2')
parvals        = (-11.074165156709268, 0.5036124773506225)
statval        = 96.8190901009578
istatval       = 840.2511999999999
dstatval       = 743.4321098990422
numpoints      = 6
dof            = 4
qval           = 4.675333207707564e-20
rstat          = 24.20477252523945
message        = successful termination
nfev           = 6

The reduced chi square fit is now lower, \(\sim 25\), but still not close to 1.

Visualizing the fit

The DataPlot, ModelPlot, and FitPlot classes can be used to see how well the model represents the data.

>>> from sherpa.plot import DataPlot, ModelPlot
>>> dplot = DataPlot()
>>> dplot.prepare(
>>> mplot = ModelPlot()
>>> mplot.prepare(, f.model)
>>> dplot.plot()
>>> mplot.overplot()

As can be seen, the model isn’t able to fully describe the data. One check to make here is to change the optimiser in case the fit is stuck in a local minimum. The default optimiser is LevMar:

>>> original_method = f.method

This can be changed to NelderMead and the data re-fit.

>>> from sherpa.optmethods import NelderMead
>>> f.method = NelderMead()
>>> resn =

In this case the statistic value has not changed, as shown by dstatval being zero:

>>> print("Change in statistic: {}".format(resn.dstatval))
Change in statistic: 0.0


An alternative approach is to create a new Fit object, with the new method, and use that instead of changing the method attribute. For instance:

>>> fit2 = Fit(d, mdl, method=NelderMead())

Adjusting the model

This suggests that the problem is not that a local minimum has been found, but that the model is not expressive enough to represent the data. One possible approach is to change the set of points used for the comparison, either by removing data points - perhaps because they are not well calibrated or there are known to be issues - or adding extra ones (by removing a previously-applied filter). The approach taken here is to change the model being fit; in this case by allowing the linear term (\(c_1\)) of the polynomial to be fit, but a new model could have been tried.

>>> mdl.c1.thaw()

For the remainder of the analysis the original (Levenberg-Marquardt) optimiser will be used:

>>> f.method = original_method

With \(c_1\) allowed to vary, the fit finds a much better solution, with a reduced chi square value of \(\simeq 1.3\):

>>> res2 =
>>> print(res2.format())
Method                = levmar
Statistic             = chi2
Initial fit statistic = 96.8191
Final fit statistic   = 4.01682 at function evaluation 8
Data points           = 6
Degrees of freedom    = 3
Probability [Q-value] = 0.259653
Reduced statistic     = 1.33894
Change in statistic   = 92.8023
   polynom1d.c0   -9.38489     +/- 2.91751
   polynom1d.c1   -2.41692     +/- 0.250889
   polynom1d.c2   0.478273     +/- 0.0312677

The previous plot objects can be used, but the model plot has to be updated to reflect the new model values. Three new plot styles are used: FitPlot shows both the data and model values, DelchiPlot to show the residuals, and SplitPlot to control the layout of the plots:

>>> from sherpa.plot import DelchiPlot, FitPlot, SplitPlot
>>> fplot = FitPlot()
>>> rplot = DelchiPlot()
>>> splot = SplitPlot()
>>> mplot.prepare(, f.model)
>>> fplot.prepare(dplot, mplot)
>>> splot.addplot(fplot)
>>> rplot.prepare(, f.model, f.stat)
>>> splot.addplot(rplot)

The residuals plot shows, on the ordinate, \(\sigma = (d - m) / e\) where \(d\), \(m\), and \(e\) are the data, model, and error value for each bin respectively.

The use of this style of plot - where there’s the data and fit in the top and a related plot (normally some form of residual about the fit) in the bottom - is common enough that Sherpa provides a specialization of SplitPlot called JointPlot for this case. In the following example the plots from above are re-used, as no settings have changed, so there is no need to call the prepare method of the component plots:

>>> from sherpa.plot import JointPlot
>>> jplot = JointPlot()
>>> jplot.plottop(fplot)
>>> jplot.plotbot(rplot)

The two major changes to the SplitPlot output are that the top plot is now taller, and the gap between the plots has been reduced by removing the axis labelling from the first plot and the title of the second plot (the X axes of the two plots are also tied together, but that’s not obvious from this example).

Refit from a different location

It may be useful to repeat the fit starting the model off at different parameter locations to check that the fit solution is robust. This can be done manually, or the reset() method used to change the parameters back to the last values they were explicitly set to:

>>> mdl.reset()

Rather than print out all the components, most of which are fixed at 0, the first three can be looped over using the model’s pars attribute:

>>> [(, p.val, p.frozen) for p in[:3]]
[('c0', 1.0, False), ('c1', 0.0, False), ('c2', 1.0, False)]

There are many ways to choose the starting location; in this case the value of 10 is picked, as it is “far away” from the original values, but hopefully not so far away that the optimiser will not be able to find the best-fit location.

>>> for p in[:3]:
...     p.val = 10


Since the parameter object - an instance of the Parameter class - is being accessed directly here, the value is changed via the val attribute, since it does not contain the same overloaded accessor functionality that allows the setting of the parameter directly from the model. The fields of the parameter object are:

>>> print([1])
val         = 10.0
min         = -3.4028234663852886e+38
max         = 3.4028234663852886e+38
units       =
frozen      = False
link        = None
default_val = 10.0
default_min = -3.4028234663852886e+38
default_max = 3.4028234663852886e+38

How did the optimiser vary the parameters?

It can be instructive to see the “search path” taken by the optimiser; that is, how the parameter values are changed per iteration. The fit() method will write these results to a file if the outfile parameter is set (clobber is set here to make sure that any existing file is overwritten):

>>> res3 ='fitpath.txt', clobber=True)
>>> print(res3.format())
Method                = levmar
Statistic             = chi2
Initial fit statistic = 196017
Final fit statistic   = 4.01682 at function evaluation 8
Data points           = 6
Degrees of freedom    = 3
Probability [Q-value] = 0.259653
Reduced statistic     = 1.33894
Change in statistic   = 196013
   polynom1d.c0   -9.38489     +/- 2.91751
   polynom1d.c1   -2.41692     +/- 0.250889
   polynom1d.c2   0.478273     +/- 0.0312677

The output file is a simple ASCII file where the columns give the function evaluation number, the statistic, and the parameter values:

# nfev statistic polynom1d.c0 polynom1d.c1 polynom1d.c2
0.000000e+00 1.960165e+05 1.000000e+01 1.000000e+01 1.000000e+01
1.000000e+00 1.960165e+05 1.000000e+01 1.000000e+01 1.000000e+01
2.000000e+00 1.960176e+05 1.000345e+01 1.000000e+01 1.000000e+01
3.000000e+00 1.960172e+05 1.000000e+01 1.000345e+01 1.000000e+01
4.000000e+00 1.961557e+05 1.000000e+01 1.000000e+01 1.000345e+01
5.000000e+00 4.016822e+00 -9.384890e+00 -2.416915e+00 4.782733e-01
6.000000e+00 4.016824e+00 -9.381649e+00 -2.416915e+00 4.782733e-01
7.000000e+00 4.016833e+00 -9.384890e+00 -2.416081e+00 4.782733e-01
8.000000e+00 4.016879e+00 -9.384890e+00 -2.416915e+00 4.784385e-01
9.000000e+00 4.016822e+00 -9.384890e+00 -2.416915e+00 4.782733e-01

As can be seen, a solution is found quickly in this situation. Is it the same as the previous attempt? Although the final statistic values are not the same, they are very close:

>>> res3.statval == res2.statval
>>> res3.statval - res2.statval

as are the parameter values:

>>> res2.parvals
(-9.384889507344186, -2.416915493735619, 0.4782733426100644)
>>> res3.parvals
(-9.384889507268973, -2.4169154937357664, 0.47827334260997567)
>>> for p2, p3 in zip(res2.parvals, res3.parvals):
...     print("{:+.2e}".format(p3 - p2))

The fact that the parameter values are very similar is good evidence for having found the “best fit” location, although this data set was designed to be easy to fit. Real-world examples often require more in-depth analysis.

Comparing models

Sherpa contains the calc_mlr() and calc_ftest() routines which can be used to compare the model fits (using the change in the number of degrees of freedom and chi-square statistic) to see if freeing up \(c_1\) is statistically meaningful.

>>> from sherpa.utils import calc_mlr
>>> calc_mlr(res.dof - res2.dof, res.statval - res2.statval)

This provides evidence that the three-term model (with \(c_1\) free) is a statistically better fit, but the results of these routines should be reviewed carefully to be sure that they are valid; a suggested reference is Protassov et al. 2002, Astrophysical Journal, 571, 545.

Estimating errors


Should I add a paragraph mentioning it can be a good idea to rerun to make sure any changes haven’t messsed up the location?

There are two methods available to estimate errors from the fit object: Covariance and Confidence. The method to use can be set when creating the fit object - using the estmethod parameter - or after the object has been created, by changing the estmethod attribute. The default method is covariance

>>> print(

which can be significantly faster faster, but less robust, than the confidence technique shown below.

The est_errors() method is used to calculate the errors on the parameters and returns a ErrorEstResults object:

>>> coverrs = f.est_errors()
>>> print(coverrs.format())
Confidence Method     = covariance
Iterative Fit Method  = None
Fitting Method        = levmar
Statistic             = chi2gehrels
covariance 1-sigma (68.2689%) bounds:
   Param            Best-Fit  Lower Bound  Upper Bound
   -----            --------  -----------  -----------
   polynom1d.c0     -9.38489     -2.91751      2.91751
   polynom1d.c1     -2.41692    -0.250889     0.250889
   polynom1d.c2     0.478273   -0.0312677    0.0312677

The EstErrResults object can also be displayed directly (in a similar manner to the FitResults object returned by fit):

>>> print(coverrs)
datasets    = None
methodname  = covariance
iterfitname = none
fitname     = levmar
statname    = chi2gehrels
sigma       = 1
percent     = 68.2689492137
parnames    = ('polynom1d.c0', 'polynom1d.c1', 'polynom1d.c2')
parvals     = (-9.384889507268973, -2.4169154937357664, 0.47827334260997567)
parmins     = (-2.917507940156572, -0.2508893171295504, -0.031267664298717336)
parmaxes    = (2.917507940156572, 0.2508893171295504, 0.031267664298717336)
nfits       = 0

The default is to calculate the one-sigma (68.3%) limits for each thawed parameter. The error range can be changed with the sigma attribute of the error estimator, and the set of parameters used in the analysis can be changed with the parlist attribute of the est_errors() call.


The error estimate should only be run when at a “good” fit. The assumption is that the search statistic is chi-square distributed so the change in statistic as a statistic varies can be related to a confidence bound. One requirement is that - for chi-square statistics - is that the reduced statistic value is small enough. See the max_rstat field of the EstMethod object.

Give the error if this does not happen (e.g. if c1 has not been fit)?

Changing the error bounds

The default is to calculate one-sigma errors, since:

>>> f.estmethod.sigma

This can be changed, e.g. to calculate 90% errors which are approximately \(\sigma = 1.6\):

>>> f.estmethod.sigma = 1.6
>>> coverrs90 = f.est_errors()
>>> print(coverrs90.format())
Confidence Method     = covariance
Iterative Fit Method  = None
Fitting Method        = levmar
Statistic             = chi2gehrels
covariance 1.6-sigma (89.0401%) bounds:
   Param            Best-Fit  Lower Bound  Upper Bound
   -----            --------  -----------  -----------
   polynom1d.c0     -9.38489     -4.66801      4.66801
   polynom1d.c1     -2.41692    -0.401423     0.401423
   polynom1d.c2     0.478273   -0.0500283    0.0500283


As can be seen, 1.6 sigma isn’t quite 90%

>>> coverrs90.percent

Accessing the covariance matrix

The errors created by Covariance provides access to the covariance matrix via the extra_output attribute:

>>> print(coverrs.extra_output)
[[  8.51185258e+00  -4.39950074e-02  -6.51777887e-02]
 [ -4.39950074e-02   6.29454494e-02   6.59925111e-04]
 [ -6.51777887e-02   6.59925111e-04   9.77666831e-04]]

The order of these rows and columns matches that of the parnames field:

>>> print([p.split('.')[1] for p in coverrs.parnames])
['c0', 'c1', 'c2']

Changing the estimator

The Confidence method takes each thawed parameter and varies it until it finds the point where the statistic has increased enough (the value is determined by the sigma parameter and assumes the statistic is chi-squared distributed). This is repeated separately for the upper and lower bounds for each parameter. Since this can take time for complicated fits, the default behavior is to display a message when each limit is found (the order these messages are displayed can change from run to run):

>>> from sherpa.estmethods import Confidence
>>> f.estmethod = Confidence()
>>> conferrs = f.est_errors()
polynom1d.c0 lower bound:    -2.91751
polynom1d.c1 lower bound:    -0.250889
polynom1d.c0 upper bound:    2.91751
polynom1d.c2 lower bound:    -0.0312677
polynom1d.c1 upper bound:    0.250889
polynom1d.c2 upper bound:    0.0312677

As with the covariance run, the return value is a ErrorEstResults object:

>>> print(conferrs.format())
Confidence Method     = confidence
Iterative Fit Method  = None
Fitting Method        = levmar
Statistic             = chi2gehrels
confidence 1-sigma (68.2689%) bounds:
   Param            Best-Fit  Lower Bound  Upper Bound
   -----            --------  -----------  -----------
   polynom1d.c0     -9.38489     -2.91751      2.91751
   polynom1d.c1     -2.41692    -0.250889     0.250889
   polynom1d.c2     0.478273   -0.0312677    0.0312677

Unlike the covariance errors, these are not guaranteed to be symmetrical (although in this example they are).

Using multiple cores

The example data and model used here does not require many iterations to fit and calculate errors. However, for real-world situations the error analysis can often take significantly-longer than the fit. When using the Confidence technique, the default is to use all available CPU cores on the machine (the error range for each parameter can be thought of as a separate task, and the Python multiprocessing module is used to evaluate these tasks). This is why the order of the screen output from the est_errors() call can vary.

The parallel attribute of the error estimator controls whether the calculation should be run in parallel (True) or not, and the numcores attribute determines how many CPU cores are used (the default is to use all available cores).

>>> f.estmethod.parallel

The Covariance technique does not provide a parallel option.

Using a subset of parameters

To save time, the error calculation can be restricted to a subset of parameters by setting the parlist parameter of the est_errors() call. As an example, the errors on just \(c_1\) can be evaluated with the following:

>>> c1errs = f.est_errors(parlist=(mdl.c1, ))
polynom1d.c1 lower bound:    -0.250889
polynom1d.c1 upper bound:    0.250889
>>> print(c1errs)
datasets    = None
methodname  = confidence
iterfitname = none
fitname     = levmar
statname    = chi2gehrels
sigma       = 1
percent     = 68.26894921370858
parnames    = ('polynom1d.c1',)
parvals     = (-2.4169154937357664,)
parmins     = (-0.25088931712955054,)
parmaxes    = (0.25088931712955054,)
nfits       = 2

Visualizing the errors

The IntervalProjection class is used to show how the statistic varies with a single parameter. It steps through a range of values for a single parameter, fitting the other thawed parameters, and displays the statistic value (this gives an indication if the assumptions used to calculate the errors are valid):

>>> from sherpa.plot import IntervalProjection
>>> iproj = IntervalProjection()
>>> iproj.calc(f, mdl.c1)
>>> iproj.plot()

The default options display around one sigma from the best-fit location (the range is estimated from the covariance error estimate). The prepare() method is used to change these defaults - e.g. by explicitly setting the min and max values to use - or, as shown below, by scaling the covariance error estimate using the fac argument:

>>> iproj.prepare(fac=5, nloop=51)

The number of points has also been increased (the nloop argument) to keep the curve smooth. Before re-plotting, the calc() method needs to be re-run to calculate the new data. The one-sigma range is also added as vertical dotted lines using vline():

>>> iproj.calc(f, mdl.c1)
>>> iproj.plot()
>>> pmin = c1errs.parvals[0] + c1errs.parmins[0]
>>> pmax = c1errs.parvals[0] + c1errs.parmaxes[0]
>>> iproj.vline(pmin, overplot=True, linestyle='dot')
>>> iproj.vline(pmax, overplot=True, linestyle='dot')


The vline() method is a simple wrapper routine. Direct calls to matplotlib can also be used to annotate the visualization.

The RegionProjection class allows the correlation between two parameters to be shown as a contour plot. It follows a similar approach as IntervalProjection, although the final visualization is created with a call to contour() rather than plot:

>>> from sherpa.plot import RegionProjection
>>> rproj = RegionProjection()
>>> rproj.calc(f, mdl.c0, mdl.c2)
>>> rproj.contour()

The limits can be changed, either using the fac parameter (as shown in the interval-projection case), or with the min and max parameters:

>>> rproj.prepare(min=(-22, 0.35), max=(3, 0.6), nloop=(41, 41))
>>> rproj.calc(f, mdl.c0, mdl.c2)
>>> rproj.contour()
>>> xlo, xhi = plt.xlim()
>>> ylo, yhi = plt.ylim()
>>> def get_limits(i):
...     return conferrs.parvals[i] + \
...            np.asarray([conferrs.parmins[i],
...                        conferrs.parmaxes[i]])
>>> plt.vlines(get_limits(0), ymin=ylo, ymax=yhi)
>>> plt.hlines(get_limits(2), xmin=xlo, xmax=xhi)

The vertical lines are added to indicate the one-sigma errors calculated by the confidence method earlier.

The calc call sets the fields of the RegionProjection object with the data needed to create the plot. In the following example the data is used to show the search statistic as an image, with the contours overplotted. First, the axes of the image are calculated (the extent argument to matplotlib’s imshow command requires the pixel edges, not the centers):

>>> xmin, xmax = rproj.x0.min(), rproj.x0.max()
>>> ymin, ymax = rproj.x1.min(), rproj.x1.max()
>>> nx, ny = rproj.nloop
>>> hx = 0.5 * (xmax - xmin) / (nx - 1)
>>> hy = 0.5 * (ymax - ymin) / (ny - 1)
>>> extent = (xmin - hx, xmax + hx, ymin - hy, ymax + hy)

The statistic data is stored as a one-dimensional array, and needs to be reshaped before it can be displayed:

>>> y = rproj.y.reshape((ny, nx))
>>> plt.clf()
>>> plt.imshow(y, origin='lower', extent=extent, aspect='auto', cmap='viridis_r')
>>> plt.colorbar()
>>> plt.xlabel(rproj.xlabel)
>>> plt.ylabel(rproj.ylabel)
>>> rproj.contour(overplot=True)

Simultaneous fits

Sherpa uses the DataSimulFit and SimulFitModel classes to fit multiple data seta and models simultaneously. This can be done explicitly, by combining individual data sets and models into instances of these classes, or implicitly with the simulfit() method.

It only makes sense to perform a simultaneous fit if there is some “link” between the various data sets or models, such as sharing one or model components or linking model parameters.

Poisson stats

Should there be something about using Poisson stats?