started base.py to define Galaxy and Observation classes

To collect the various parameters used to define a galaxy and to
better separate the functions that generate galaxies from those that
produce observables, define Galaxy and Observation classes. Future
additions may define a Fit class that can centralize model definitions
and priors.

Currently, Galaxy class just collects the variables used to define the
intrinsic properties of a galaxy. Observation class takes a Galaxy
object and all the additional parameters that define an observer
(redshift, position angle, etc) and has methods to produce
observables. These are initially just wrappers to functions in sim.py,
and it may be helpful to retain the existing approach with arrays of
variables to define galaxies and image arrays, but as the list of
variables gets longer (with disk thickness, see e.g. Issue #8), the
object approach should be tidier.
started makeImageBessel in sim and test suite

makeImageBessel will port Eric's IDL code to generate galaxy images
using the Bessel profiles from Spergel 2010. Use scipy.special.kv and
np.meshgrid. Also started test_makegal.py in tests/ dir to compare
results of makeImageBessel from current approach that relies on
galsim.
first stab at makeImageBessel

basically a straight port from idl_scripts/datacube_simulate.pro
typo
add convertInclination function

should supercede getInclination since it allows for thick disks,
taking any two args of galBA, galCA, and inc and returns the 3rd. So
getInclination should be equivalent to convertInclination when
inc=None, galCA=0, and galBA=gal_q. Still TBD is to clarify whether
galBA is the intrinsic or observed axis ratio, and how to switch
between the two.
started test_image to compare galsim and bessel image profiles

see also scratch/make3dgal.py
testing script to make 3d galaxy profiles with bessel funcs

Trying to generate projected exponential surface brightness profiles
using Spergel's basis of Bessel functions to produce the 3d profiles.
tests with make3dgal help find effective r_s for inclined thick disks

producing 3d flux densities with Bessel functions following Spergel
2010 and producing projected images at different inclinations, results
suggest that effective scale radius can reasonably be approximated as
ry' = ry * sqrt[1 - sin(inc)**2 * (1 - (rz/ry)**2)] where ry=rx is the
scale radius for the face-on disk and rz is the disk thickness. The
approximation doesn't seem as good for face-on thin disks (Bessel
profiles appear less cuspy than exponential) and it hasn't been tested
for different values of nu, which approximate different Sersic
indices.

Continuing work on #8
clarified inputs for convertInclination docstring
replace getInclination with convertInclination allowing thickness

Add gal_thick arg to several functions usually following gal_q where
needed. In cases where pars array is unpacked, add gal_thick arg to
hold thickness. Other driver scripts will need to be updated here, but
goal is to have a more streamlined way to define model and pars array.
remove redundancy b/t gal_thick and gal_ca in makeImageBessel
Add Model object in base.py

Starting from a suggestion in #8, build a model object as the
clearinghouse for different model definitions and parameter
arrangments. Vision is that all parameters needed to construct a
galaxy and observables will be collected in base (currently there is
some redundancy defining these in both the Galaxy/Observation objects
and in the Model object - these could be unified eventually). Model
will have some methods borrowed from interpretPriors in fit.py to
handle fixing parameters and setting priors, and will eventually
remove the need for an ordered list of pars (except the one sent to
emcee) in all sim.py methods.
rename diskFlux to galFlux, modify default guess, remove fixPars and setPriors methods for triviality
replace arg list with model object for several functions to streamline
replace pars list with model object for ellModel and vmapModel
add updatePars method to Model class

part of building model object for more easily extensible modeling
suggested in Issue #8. Since several sim functions use parameters from
the model object now, but emcee needs a pars array (first arg to
lnProbVMapModel). This method glues those pieces together, updating
the model attributes when the pars array is updated. Also renamed
guess and guessScale array attributes, since interpretPriors now
writes abbreviated versions of those arrays to the model object when
there are fixed pars.
replace long arg arrays with model object in fit.py

interpretPriors, lnProbVMapModel, vmapFit, and fitObs all now
interface with the model object rather than lists of individual
parameters. The Model class should be pickleable so we can still
parallelize with emcee.
makeConvolutionKernel now takes model object

also removed deprecated args from vmapObs
makeObs and runGal take model object, rename generateEnsemble->generatePars

Also removed part of makeObs that adds noise, since that should be
done in vmapFit. PA should be assigned at model definition, so it it
doesn't need to follow ellObs assignment here. Since model
instantiation assigns some pars, makeObs now has to update them and
reassign origPars. model now also has inputPriors attribute (for
generatePars ensemble distribution) to separate that from priors array
which is to be used for fitting. Ultimately for #8.
add inputPriors attribute to model object

Comments clarify the difference between inputPriors, which describes
the distribution for an ensemble of objects, and priors, which is for
fitting. For example, you might generate a list of galaxies with a
gaussian distribution of shears, but when fitting the observables you
want to assume a wide flat prior.