The following software is freely available. However, if you use it for published research, you are requested to cite the paper where the method is described, highlighted in red. You are not allowed to redistribute any of these programs (modified or not) without explicit permission from the author.
NOTE: If you are just starting to program and are wondering which version you should use, I strongly recommend the Python version of my programs.
My packages above are on the Python Package Index (PyPI).
See my review on galaxy structure and evolution:
Illustration of the steps involved in the MGE fit to the S0 galaxy NGC 4342 using the MgeFit package. The figures were produced by the mge_fit_example.py script included in the Python distribution of the software.

This software obtains an accurate MultiGaussian Expansion (MGE) parameterizations (Emsellem et al. 1994) for a galaxy surface brightness with the fitting algorithm of Cappellari (2002, MNRAS, 333, 400). Given that Gaussians are not orthogonal functions, MGE fits are in general strongly degenerate, with difficult global convergence, but the MGE_FIT_SECTORS
method solves all problem, making MGE fitting an automated, reliable and robust process.
See Cappellari et al. (2006) for a large scale application of this software to the study of the M/L ratio and the Fundamental Plane of earlytype galaxies and Cappellari et al. (2012, Nature) for an application to the study of the stellar IMF. The MGE parameterizations is useful in the construction of realistic dynamical models of galaxies (see JAM modelling below), for PSF deconvolution of images, for the correction and estimation of dust absorption effects, or for galaxy photometry.
MgeFit
package in The source code of the MgeFit
package, including four test galaxy images, is on the Python Package Index (PyPI). It was last updated on the 21 May 2018. It is typically about 5× faster than the IDL one due to the use of SciPy's builtin NNSL procedure and NumPy's broadcasting. It is orders of magnitude faster when using the option linear=True
, which is now always recommended with Python.
How to install: pip install mgefit
MgeFit
requires the scientific core packages NumPy, SciPy and Matplotlib, and the examples use Astropy to read FITS images (it was tested with Python 3.6 using NumPy 1.14, SciPy 1.1 and Matplotlib 2.2).
Also included in the MgeFit
package is the mpfit
implementation by Markwardt (2009) of the MINPACK (Moré, Garbow & Hillstrom, 1980) LevenbergMarquardt nonlinear leastsquares optimization algorithm. The mpfit
routine was translated into Python by Mark River and updated here for NumPy by Sergey Koposov. I modified the latter version to support Python 3 and fixed some numerical instabilities. Note that MgeFit
uses the mpfit
implementation instead of the SciPy.optimize.least_squares
one, because of the ability of mpfit
to tie parameters or keep them fixed.
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
MGE_FIT_SECTORS
source code in The source code of the IDL package MGE_FIT_SECTORS
, with examples
and instructions, can be downloaded here in ZIP format (338 KB). This version was last updated on the 21 November 2017 and the changes are documented in the program file. Optionally the FITS files of the five galaxy images that are required to run the examples routine can be downloaded here in ZIP format (19 MB). The MGE_FIT_SECTORS
package was tested with IDL from 6.4 to 8.6.
Also required is the following IDL routine, which must be downloaded separately:
Also included in the MGE_FIT_SECTORS
distribution is the MPFIT
implementation by Markwardt (2009) of the MINPACK (Moré, Garbow & Hillstrom, 1980) LevenbergMarquardt nonlinear leastsquares optimization algorithm, with some specific modifications to make it work robustly with MGE_FIT_SECTORS
.
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download the above procedures. I would also like to know if you got the IDL or Python version.
2. The JAM dynamical modelling method 

Jeans Anisotropic Models of stellar kinematics or proper motions of axisymmetric or spherical galaxies 
Figure 1: Examples of JAM datamodel comparisons. The bisymmetrized SAURON stellar kinematics of 6 Elliptical (left) and 6 S0 (right) fastrotator earlytype galaxies is compared to the predictions of the anisotropic Jeans models with JAM. The kinematics varies widely for different galaxies, yet these twoparameters (!) models are able to correctly predict the shape of a pair of twodimensional functions (V and V_{rms}), once the observed surface brightness is given (this is fig.10 of Cappellari 2016, ARA&A). 
Figure 4: Validating black hole (BH) recovery with JAM. A detailed JAM modelling accurately recovers the "benchmark" BH mass in NGC4258, as inferred from maser observations (figure taken from Drehmer et al. 2015). An equally good agreement was found with JAM for the "benchmark" BH in the Milky Way (Sec.4.1.2 of FeldmeierKrause et al. 2017). Other successful BH comparisons, between JAM and Schwarzschild's method, were presented e.g. in Cappellari et al. (2010), for 25 galaxies, and Krajnović et al. (2018), for 7 galaxies. 
Figure 3: JAM models examples of kinematically decoupled components. (a) Threeparameters JAM description of the SAURON stellar kinematics of the earlytype galaxy NGC4550, which contains two counterrotating stellar disks (Cappellari et al. 2007). To reproduce the observed velocity field, the flattest (q' < 0.25) Gaussians of the MGE model were assigned opposite rotation (κ < 0). (b) Same as in [a] but with the model orbits all rotating in the same direction. (c) Best fitting JAM model of NGC5308, with constant anisotropy (β_{z} = 0.28 and κ = 1.02) (Cappellari 2008). (d) Same as in [c], but with a nonrotating bulge (κ = 0). (e) Same as in [c] but with an isotropic bulge (β_{z} = 0) and an anisotropic disk (β_{z} = 0.28). The best model has an oblate velocity ellipsoid, with the same strong anisotropy and the same rotation for both the bulge and the disk! 
Figure 2: Including both proper motions and radial velocities. Top Panels: the components of the symmetric velocity second moment tensor measured from the particles of a realistic Nbody simulation. Bottom Panels: the corresponding JAM model predictions. Note the striking agreement! (Cappellari 2012) 
The software in this section implements in Python and in IDL a solution of the Jeans equations which allows for orbital anisotropy (threeintegrals distribution function) and also provides the full second moment tensor, including both proper motions and radial velocities, for both axisymmetric (Cappellari 2012) and spherical geometry (Cappellari 2015). The technique was introduced in Cappellari (2008, MNRAS, 390, 71) and we call it the Jeans Anisotropic Modelling (JAM) method. It relies on the MultiGaussian Expansion parameterization (Emsellem et al. 1994; Cappellari 2002) for the galaxy surface brightness.
With the addition of a single extra parameter β_{z}=1(σ_{z}/σ_{R})^{2}, the simple and userfriendly JAM method already provides a dramatic improvement over the classic but less general twointegrals f(E,L_{z}) Jeans (1922) models. However JAM also allows for tangential ansiotropy γ=1(σ_{φ}/σ_{R})^{2} and/or for spatially varying anisotropy. The JAM models provide a remarkably good descriptions of stateoftheart integralfield stellar kinematics of real galaxies (Figure 1). This makes the technique well suited to measure the inclination, the dynamical M/L and angular momenta of earlytype fastrotators and spiral galaxies.
The JAM routines are designed for axisymmetric or spherical geometry, (i) they can provide the proper motion dispersion tensor (Cappellari 2012; Cappellari 2015; Figure 2), (ii) allow for the inclusion of dark matter, (iii) variable stellar M/L, (iv) spatially varying anisotropy and (v) multiple kinematic components (Figure 3) and (vi) supermassive black holes (BH; Figure 4). The JAM package also includes a routine to compute the circular velocity from the MGE models. Some sample applications of the JAM method are given below:
To construct dynamical models with the JAM method one needs to describe the galaxies surface brightness via the MultiGaussian Expansion parametrization using my MGE_FIT_SECTORS package above.
Figure 5: JAM works better than Schwarzschild on real galaxies. An extensive and detailed comparison between the circular velocity V_{CO} measured from CO gas and the corresponding circular velocity V_{JAM} and V_{SCH} inferred from dynamical modelling of integralfield stellar kinematics using the JAM and Schwarzschild's (SCH) methods, for 54 real disk galaxies with CALIFA data, found that JAM recovers the galaxy densities more accurately than SCH (this is Fig.8 from Leung et al. 2018). The smaller JAM scatter is particularly evident at large radii (inside the red boxes), where the gas V_{c} is better determined. 
JamPy
package in The source code of the JamPy
package is on the Python Package Index (PyPI). It was last updated on the 21 May 2018 and the changes are documented in the program files. The Python version of the mean velocity calculation is about 30× faster than the IDL version, due to a redesign of the double integration approach, made possible by NumPy's broadcasting.
How to install: pip install jampy
Also required is my plotbin package (automatically installed by pip
).
The JamPy
package requires the scientific core packages NumPy, SciPy and Matplotlib (it was tested with Python 3.6 using NumPy 1.14, SciPy 1.1 and Matplotlib 2.2).
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
The source code of the JAM modelling package in IDL, with documentation and examples, can be downloaded here in ZIP format (45 KB). This version was last updated on the 19 October 2017 and the changes are documented in the program files. The JAM package was tested with IDL from 6.4 to 8.6.
Also required are the generic plotting routines SAURON_COLORMAP
and PLOT_VELFIELD
which can be found in this ZIP file.
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download the above procedures. I would also like to know if you got the IDL or Python version.
Left: Fourcoloring of Voronoi binning; Middle: Unbinned versus Voronoi binned IntegralField Spectroscopy (Cappellari & Copin 2003); Right: Voronoi binning of Xray data (Sanders et al. 2004). 
The Voronoi Binning method of Cappellari & Copin (2003, MNRAS, 342, 345) optimally solves the problem of preserving the maximum spatial resolution of general twodimensional data (or higher dimensions), given a constraint on the minimum signaltonoise ratio.
The Voronoi binning method has been applied to a variety of types of data. A review of the concepts and applications to (i) Xray data, (ii) integralfield spectroscopy, (iii) FabryPerot interferometry, (iv) Nbody simulations, (v) standard images and (vi) other regularly or irregularly sampled data is given in Cappellari (2009).
The source code of the VorBin
package, with examples and instructions, is on the Python Package Index (PyPI). It was last updated on the 21 May 2018 and the changes are documented in the program files.
How to install: pip install vorbin
The VorBin
package requires the scientific core packages NumPy, SciPy and Matplotlib (it was tested with Python 3.6 using NumPy 1.14, SciPy 1.1 and Matplotlib 2.2).
My optional plotbin package contains routines to visualize Voronoi 2Dbinned or unbinned data like in the figures above.
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
The source code of the IDL program VORONOI_2D_BINNING, with examples and instructions, can be downloaded here in ZIP format (75 KB). This version was last updated on 10 October 2017 and the changes are documented in the program file. Some minor adaptations of the routine may be required to optimally use the method with different types of data. Please ask for suggestions if needed. VORONOI_2D_BINNING was tested with IDL from 6.4 to 8.6.
This optional ZIP file contains the routines display_bins
, display_bins_generators
, DISPLAY_PIXELS
, PLOT_VELFIELD
and SAURON_COLORMAP
which can be used to visualize Voronoi 2Dbinned or unbinned data, either using interpolation, or by showing the actual bins like in the figures above.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download the above procedures. I would also like to know if you got the IDL or Python version.
Figure 1: Stellar and gas kinematics fit with pPXF. The black line (mostly hidden by the fit) is the relative flux of the observed spectrum. The red line is the pPXF fit for the stellar component, while the orange line is a fit to the gas emission lines. The green symbols at the bottom are the fit residuals, while the blue lines is the gasonly bestfitting spectrum. The main absorption and emission features are indicated at the top of the plot (taken from Cappellari 2017). 
This software implements the Penalized PixelFitting method (pPXF) to extract the stellar kinematics or stellar population from absorptionline spectra of galaxies, using a maximum penalized likelihood approach. The method was originally described in Cappellari & Emsellem (2004, PASP, 116, 138) and upgraded in Cappellari (2017, MNRAS, 466, 798). The method is very general and robust. For this reason it was applied to a variety of situations. The following key features are implemented in the current pPXF program:
See Emsellem et al. (2004) and Cappellari et al. (2011) for two largescale applications of the pPXF method to the measurement of the stellar kinematics of galaxies. Cappellari et al. (2009) use pPXF to measure velocity dispersion of a sample of 9 passive earlytype galaxies at redshift z~2.
The ability of the pPXF method to fit a large set of stellar templates together with the kinematics allows the template mismatch problem to be virtually eliminated. This is particularly useful given the current availability of large stellar libraries spanning wide ranges of physical parameters and having good spectral resolution. Excellent results have been obtained by using a few hundred template stars with pPXF, from which generally about 1020 are selected by the program to provide detailed fits to high S/N galaxy spectra. An extensive account of the available stellar libraries is maintained by David Montes. An incomplete list of libraries that have been successfully used with pPXF for the kinematics extraction is given below:
Figure 2: Starformation history with pPXF. The plot shows the starformation history of ATLAS^{3D} galaxies, in bins of different galaxy stellar mass. This was recovered with pPXF using regularization (taken from McDermid et al. 2015).  Figure 3: Population and gas with pPXF. The plots show the pPXF fit to two MaNGA spectra for the spiral galaxy NGC2916 (from SDSS DR13). The Left Spectrum is located in the galaxy bulge, while the Right Spectrum is in the disk. The "Mass Fraction" maps, below each spectrum, show the corresponding pPXF solution in different age and metallicity intervals. The Left Maps have no regularization. These are the minimum χ^{2} solutions which all nonregularized fullspectrum fitting programs must return, if they properly converge. However these solutions are noisy and arbitrary as this inverse problem is illposed. Regularization is a standard approach to solve illposed problems (see Cappellari 2017, Sec.3.5). The Right Maps show the pPXF regularized solutions: here one can clearly recognize the change in the relative contribution of bulge (∼10Gyr) and disk (∼1Gyr) stars at the two spatial locations. The fits used as templates a subset of 24(Ages)×6([M/H])=144 MILES model spectra by Vazdekis et al. (2010), and 12 gas emission lines. 
When one uses as input templates a set of synthetic galaxy spectra, arranged in a grid of population parameters (e.g. age and metallicity), pPXF is the most efficient and reliable public implementation of the so called "FullSpectrum Fitting" method to study stellar populations. This technique has replaced the traditional use of linestrength indices, due to the availability of highquality model spectra (e.g. Bruzual & Charlot 2003; Vazdekis et al. 2010; Maraston & Stromback 2011; Conroy & van Dokkum 2012).
pPXF allows one to extract multiple kinematic components, with different stellar populations, from a spectrum. Gas emission lines can be fitted simultaneously, avoiding the need for masking them. This is particularly useful when studying the stellar population of galaxies with prominent emission lines filling important absorption features (see Figures 1 and 3).
Please also cite the source of the MILES stellar population models (Vazdekis et al. 2010) if you use pPXF with the included library of spectral templates.
A number of similar, but less optimized and less general implementations of the Full Spectrum Fitting method exist (e.g. STARLIGHT by Cid Fernandes et al. 2005; STECMAP by Ocvirk, et al. 2006; VESPA by Tojeiro et al. 2007). A major limitation of most available codes is that they ignore the fact that the recovery of the star formation history and chemical composition distribution from the galaxy spectra is an illposed problem. A standard technique to solve illposed problems is regularization (see Cappellari 2017, Sec.3.5), which is invoked in pPXF via the keyword REGUL. Regularization is essential to make sense of the derived star formation histories and to explore model degeneracies (see Figure 2 and 3). The regularized solution has a simple Bayesian interpretation: it represents the most likely solution for the weights, given an adjustable prior on the amplitude of the fluctuations.
See Cappellari et al. (2012, Nature) for a pPXF study of the M/L and IMF of stellar populations, and figure 20 of Onodera et al. (2012) for an application of pPXF to the study of the star formation history of passive galaxies at redshift z~2.
ppxf
package in ppxf
version 20160727, the Python code includes the upgrade introduced in Cappellari (2017, MNRAS, 466, 798). The interface has remained fully compatible with the previous version: If you used ppxf
before, you do not need to modify your scripts to benefit from the improvements.
The source code of the ppxf
package, with examples and instructions, is on the Python Package Index (PyPI). It was last updated on the 21 May 2018 and the changes are documented in the program files. This version contains extra options not present in the IDL version and uses different nonlinear optimization algorithms. The Python version is also faster than the IDL one (10× faster in the examples of Figure 3) when using a large number (>100) of templates, thanks to SciPy's builtin nnls
(a similar pPXF performance in IDL requires calling the compiled version of BVLS: see below).
How to install: pip install ppxf
User Manual: Is available here in HTML or as PDF.
A good starting point for your ppxf
fits are the examples contained in the ppxf/examples
directory.
ppxf
requires the scientific core packages NumPy, SciPy and Matplotlib, and the examples use Astropy to read FITS data (it was tested with Python 3.6 using NumPy 1.14, SciPy 1.1 and Matplotlib 2.2).
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
NOTE: The IDL version of pPXF lacks some utilities, that are only present in the Python version, to more easily interpret and visualize the stellar population and gas output. Moreover, the IDL version of pPXF can be one order of magnitude slower than the Python version, when fitting many spectral templates.
The source code of the IDL program pPXF, with examples and instructions, can be downloaded here in ZIP format (2.5 MB). This version was last updated on the 2 March 2018 and the changes are documented in the program file. The pPXF package was tested with IDL from 6.4 to 8.6.
The following two IDL routines are also required to run pPXF. They must be downloaded separately:
CALL_EXTERNAL
.
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download the above procedures. I would also like to know if you got the IDL or Python version.
GANDALF
in pPXF is a stateoftheart software for gas kinematics for both Python and IDL. An alternative, in IDL, consists of using pPXF in combination with GANDALF
. See Oh et al. (2011) for a largescale application of the pPXF and GANDALF
combination.
Please acknowledge both the pPXF (Cappellari 2017) and the GANDALF
(Sarzi et al. 2006) papers if you use the two programs together.
Best fitting symmetrized kinematics of NGC 2974 
This software implements the method presented in Appendix C of Krajnovic et al. (2006, MNRAS, 366, 787) to measure the global kinematic positionangle (PA) from integral field observations of a galaxy stellar or gas kinematics.
See Cappellari et al. (2007) and Krajnovic et al. (2011) for two large scale application of this software to the study of the stellar kinematical misalignment of earlytype galaxies. See Davor's Krajnovic page for the related Kinemetry package.
PaFit
package in The PaFit
package is on the Python Package Index (PyPI). It was last updated on the 21 May 2018.
How to install: pip install pafit
Also required is my plotbin package (automatically installed by pip
).
PaFit
requires the scientific core packages NumPy, SciPy and Matplotlib (it was tested with Python 3.6 using NumPy 1.14 and Matplotlib 2.2).
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
The source code of the IDL program FIT_KINEMATIC_PA, with examples and instructions, can be downloaded here in ZIP format (9 KB). This version was last updated on 2 February 2017 and the changes are documented in the program file. FIT_KINEMATICS_PA was tested with IDL from 6.4 to 8.6.
Also required are the generic plotting routines SAURON_COLORMAP
and PLOT_VELFIELD
which can be found in this ZIP file.
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download FIT_KINEMATIC_PA. I would also like to know if you got the IDL or Python version.
Figure 1: Fitting of the (M/L)σ relation in the Virgo cluster using LTS_LINEFIT (taken from Cappellari et al. 2013a). The green outliers above the relation are automatically removed from the fit. They turn out to be background galaxies and for this reason they do not follow the cluster relation.

This software implements the method presented in Sec. 3.2 of Cappellari et al. (2013a, MNRAS, 432, 1709) to to perform extremely robust fit of lines or planes to data with errors in all variables, possible large outliers (bada data) and unknown intrinsic scatter.
The code combines the Least Trimmed Squares (LTS) robust technique, proposed by Rousseeuw (1984) and speeded up in Rousseeuw & Driessen (2006), into a leastsquares fitting algorithm which allows for intrinsic scatter and errors in all coordinates. This method makes the fit converge to the correct solution even in the presence of a large number of catastrophic outliers (like in Figure 1), where the much simpler σclipping approach can converge to the wrong solution.
LtsFit
package in The LtsFit
package is on the Python Package Index (PyPI). It was last updated on the 21 May 2018.
How to install: pip install ltsfit
LtsFit
requires the scientific core packages NumPy, SciPy and Matplotlib (it was tested with Python 3.6 using NumPy 1.14, SciPy 1.1 and Matplotlib 2.2).
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
LTS_LINEFIT
and LTS_PLANEFIT
source code in The source code of the IDL programs LTS_LINEFIT
and LTS_PLANEFIT
can be downloaded here in ZIP format (9 KB). This version was last updated on the 26 July 2017 and the changes are documented in the program file. LTS_LINEFIT
and LTS_PLANEFIT
were tested with IDL from 6.4 to 8.6.
The following two IDL routine are also required to run the two programs. They must be downloaded separately:
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download LTS_LINEFIT
and LTS_PLANEFIT
.
Application of the CAP_LOESS_2D routine (with FRAC=0.6) to the recovery of two underlying functions from a noisy distribution of 200 scattered values. For comparison, the right panels show the distribution obtained via simple averaging on a grid, but using 100× more values than the ones used for the LOESS recovery. The LOESS approach achieves a comparable result while requiring a much smaller number of input values.

This software provides an improved implementation of the onedimensional (Cleveland 1979) and twodimensional (Cleveland & Devlin 1988) Locally Weighted Regression (LOESS) method to recover the mean trends of the population from noisy data in one or two dimensions. It includes a robust approach to deal with outliers (bad data).
These programs were implemented and used to produce the twodimensional maps and the onedimensional mean trends in Cappellari et al. (2013b, MNRAS, 432, 1862).
loess
package in The loess
package is on the Python Package Index (PyPI). It was last updated on the 21 May 2018 (it was tested with Python 3.6 using NumPy 1.14 and Matplotlib 2.2).
How to install: pip install loess
Also required to run the 2D example is my plotbin package (automatically installed by pip
).
If you are still using legacy Python 2.7, the last version supporting it, is still available here. To install it, copy the package folder to a directory in the Python path.
CAP_LOESS_1D
and CAP_LOESS_2D
source code in The source code of the IDL programs CAP_LOESS_1D
and CAP_LOESS_2D
can be downloaded here in ZIP format (6 KB). This version was last updated on 31 October 2013 and the changes are documented in the program file. CAP_LOESS_1D
and CAP_LOESS_2D
were tested with IDL from 6.4 to 8.6.
And if you just started using IDL and still do not have the IDL Astronomy User's Library installed, or if you have an old version, you should immediately get it from here.
NOTE: I would appreciate if you drop me an email (address at the bottom) when you download the code.
Figure 1: Corner plot for the posterior of the model parameters obtained when fitting the black hole mass in the galaxy NGC1277 using the jam modelling method and the AdaMet Bayesian code (taken from Krajnovic et al. 2018). The Python code to produce this figure is included in the jam package above.

This AdaMet
package is the implementation of Cappellari et al. (2013a, MNRAS, 432, 1709) of the Adaptive Metropolis algorithm of Haario (2001). In many realworld applications, it was found to be more efficient and robust than the emcee
approach, whose warmup phase scales linearly with the number of walkers. For this reason, and because of its didactic value, the AdaMet
code is provided here as an alternative.
AdaMet
package in The userfriendly AdaMet
package is on the Python Package Index (PyPI). It was last updated on the 21 May 2018 (it was tested with Python 3.6 using NumPy 1.14 and Matplotlib 2.2).
How to install: pip install adamet
Also required for plotting is my plotbin package (automatically installed by pip
).
Comments and suggestions are welcome to the address michele.cappellari
@physics.ox.ac.ukLatest changes: 22/MAY/2018
Go back to Michele Cappellari Homepage