tweaks

docs/source/code.rst

@@ -13,10 +13,10 @@ recognized from a large distance, ignoring all technical details.
 
 From such a perspective,
 
-- IFT problems largely consist of the combination of several high dimensional 
+- IFT problems largely consist of the combination of several high dimensional
   *minimization* problems.
-- Within NIFTy, *models* are used to define the characteristic equations and  
-  properties of the problems. 
+- Within NIFTy, *models* are used to define the characteristic equations and
+  properties of the problems.
 - The equations are built mostly from the application of *linear operators*,
   but there may also be nonlinear functions involved.
 - The unknowns in the equations represent either continuous physical *fields*,
@@ -238,22 +238,24 @@ Models
 ======
 
 Model classes (represented by NIFTy5's abstract :class:`Model` class) are used to construct
-the equations of a specific inference problem. 
-Most models are defined via a position, which is a :class:`MultiField` object,  
-their value at these positions, which is again a :class:`MultiField` object and a jacobian derivative, 
+the equations of a specific inference problem.
+Most models are defined via a position, which is a :class:`MultiField` object,
+their value at this position, which is again a :class:`MultiField` object and a Jacobian derivative,
 which is a :class:`LinearOperator` and is needed for the minimization procedure.
+
 Using the existing basic model classes one can construct more complicated models, as
-NIFTy allows for easy and self-consinstent combination via pointwise multiplication, 
-addition and subtraction. The resulting model of these operations then automatically 
-contains the correct jacobians, positions and values. 
-Notably, :class:`Constant` and :class:`Variable` allows for an easy way to turn on and off the 
-inference of specific quantities.
-The basic model classes also allow for more complex operations on models such as 
+NIFTy allows for easy and self-consinstent combination via point-wise multiplication,
+addition and subtraction. The model resulting from these operations then automatically
+contains the correct Jacobians, positions and values.
+Notably, :class:`Constant` and :class:`Variable` allow for an easy way to turn
+inference of specific quantities on and off.
+
+The basic model classes also allow for more complex operations on models such as
 the application of :class:`LinearOperators` or local non-linearities.
 As an example one may consider the following combination of ``x``, which is a model of type
 :class:`Variable` and ``y``, which is a model of type :class:`Constant`::
 
-	z = x*x + y 
+	z = x*x + y
 
 ``z`` will then be a model with position::
 
@@ -263,27 +265,27 @@ As an example one may consider the following combination of ``x``, which is a mo
 
 
 Basic models
------------- 
+------------
 
-Basic model classes provided by NIFTy are 
+Basic model classes provided by NIFTy are
 
-- :class:`Constant` contains a constant value and has a zero valued jacobian. 
-It has no position (?currently it still has one?), as the value is the same everywhere.
+- :class:`Constant` contains a constant value and has a zero valued Jacobian.
+  Like other models, it has a position, but its value does not depend on it.
 - :class:`Variable` returns the position as its value, its derivative is one.
 - :class:`LinearModel` applies a :class:`LinearOperator` on the model.
 - :class:`LocalModel` applies a non-linearity locally on the model.
-- :class:`MultiModel` combines various models into one. In this case the position, 
-	value and jacobian get combined into corresponding :class:`MultiFields` and operators.  
- 
+- :class:`MultiModel` combines various models into one. In this case the position,
+	value and Jacobian are combined into corresponding :class:`MultiField`s and operators.
+
 
 Advanced models
 ---------------
 
-NIFTy also provides a library of more sophisticated models which are used for more 
+NIFTy also provides a library of more sophisticated models which are used for more
 specific inference problems. Currently these are:
 
-- :class:'AmplitudeModel', which returns a smooth power spectrum. 
-- :class:'PointModel', which models points sources which follow a inverse gamma distribution.
+- :class:'AmplitudeModel', which returns a smooth power spectrum.
+- :class:'PointModel', which models point sources which follow a inverse gamma distribution.
 - :class:'SmoothSkyModel', which models a diffuse lognormal field. It takes an amplitude model
 	to specify the correlation structure of the field.