diff --git a/pykat/optics/maps.py b/pykat/optics/maps.py
index 7268a1e4762a1605c852e7b5fc25af3b3cef201c..658e9a024fa3b97a466c7e3b9a959988671ad6f3 100644
--- a/pykat/optics/maps.py
+++ b/pykat/optics/maps.py
@@ -328,7 +328,7 @@ class surfacemap(object):
             ymax = len(self.y)-1
             ylim = [self.y.min()*100, self.y.max()*100]
             
-        # ALSO (SEE LONG TEXT BELOW) ADDED BY DT TO FIX LIMITS
+        # ALSO ADDED (SEE LONG TEXT BELOW) BY DT TO FIX LIMITS
         # ------------------------------------------------------
         xlim,ylim = ylim,xlim
         # ------------------------------------------------------
@@ -381,54 +381,116 @@ class surfacemap(object):
 
 
 
-    def remove_curvature(self, Rc0, w=0, display='off'):
-        # Removes curvature from mirror map by fitting a sphere to
-        # mirror surface. Based on the file
-        # 'FT_remove_curvature_from_mirror_map.m'.
-        # Rc0     - Initial guess of the radius of curvature
-        # w       - Beam radius on mirror [m], used for weighting. w=0
-        #           switches off weighting.
-        # display - Display mode of the fitting routine. Can be 'off',
-        #           'iter', 'notify', or 'final'.
-
-        # z-value at centre of the mirror.
-        zOffset = self.data[round(self.center[1]), round(self.center[0])]
+    def remove_curvature(self, Rc0, w=None, zOffset=None, isCenter=[False,False],
+                         display='off'):
+        '''
+        Removes curvature from mirror map by fitting a sphere to
+        mirror surface. Based on the file 'FT_remove_curvature_from_mirror_map.m'.
+        Rc0      - Initial guess of the radius of curvature [m]
+        w        - Beam radius on mirror [m], used for weighting.
+        zOffset  - Initial guess of the z-offset [surfacemap.scaling]. Generally not needed.
+        isCenter - 2D-list with booleans. isCenter[0] Determines if the center of the
+                   sphere is fitted (True) or not (False, recommended). If the center is
+                   fitted, then isCenter[1] determines if the weights are centered around
+                   the fitted center (True) or centered around the center of the data-grid
+                   (False, highly recommended).
+        display  - Display mode of the fitting routine. Can be 'off',
+                   'iter', 'notify', or 'final'.
+        '''
+        # z-value at centre of the data-grid. Serves as initial guess for deviation
+        # from z=0, if no other first guess is given.
+        if zOffset is None:
+            zOffset = self.data[round(self.center[1]), round(self.center[0])]
+            
+        # If fitting center of the sphere, four variables are fitted. Initial guess
+        # of deviation from notNan-data-grid-center: (x0,y0) = (0,0).
+        if isCenter[0]:
+            params = [Rc0, zOffset, 0.0, 0.0]
+        # Otherwise two.
+        else:
+            params = [Rc0, zOffset]
 
+        # Grid with X,Y and r2 = (X^2+Y^2) values. X and Y crosses zero in the center
+        # of the xy-plane.
         X,Y,r2 = self.createGrid()
+        
+        # Cost-function to minimize.
         def costFunc(params):
-            n = len(params)
-            if n==2:
+            # If the center of the mirror is fitted, four variables are fitted.
+            if isCenter[0]:
                 Rc = params[0]
                 zOffset = params[1]
-                x0 = 0
-                y0 = 0
+                x0 = params[2]
+                y0 = params[3]
+            # Otherwise 2 variables.
             else:
                 Rc = params[0]
                 zOffset = params[1]
-                x0 = params[2]
-                y0 = params[3]
+                x0 = 0
+                y0 = 0
+            
             Z = self.createSphere(Rc,X,Y,zOffset,x0,y0)
-            if  w==0:
+            
+            if w is None:
+                # Mean squared difference between map and the created sphere.
                 res = math.sqrt( ((self.data[self.notNan] -
                                    Z[self.notNan])**2).sum() )/self.notNan.sum()
             else:
-                weight = 2/(math.pi*w**2)*np.exp(-2*r2/w**2)
+                if isCenter[0] and isCenter[1]:
+                    # Weights centered around fitting spehere center. May give weird
+                    # results if the mirror deviates much from a sphere.
+                    weight = (2/(math.pi*w**2))*np.exp(-2*( (X-x0)**2 + (Y-y0)**2 )/w**2)
+                else:
+                    # Weights centered around the center of the mirror xy-plane.
+                    weight = (2/(math.pi*w**2))*np.exp(-2*r2/w**2)
+                # Weighted mean squared difference between map and the created sphere.
                 res = math.sqrt( (weight[self.notNan]*((self.data[self.notNan] -
-                                   Z[self.notNan])**2)).sum() )/self.notNan.sum()
-            print(Rc,zOffset,res)
+                                   Z[self.notNan])**2)).sum() )/weight[self.notNan].sum()
             return res
         
-        params = [Rc0,zOffset]
+        # Using the simplex Nelder-Mead method. This is the same or very
+        # similar to the method used in 'FT_remove_curvature_from_mirror_map.m',
+        # but there are probably better methods to use.
         out = minimize(costFunc, params, method='Nelder-Mead',tol=1.0e-6)
-        Rc = out['x'][0]
-        zOffset = out['x'][1]
-        Z = self.createSphere(Rc,X,Y,zOffset)
-        self.data[self.notNan] = self.data[self.notNan]-Z[self.notNan]
- 
-        return self.data, self.Rc, self.zOffset
+
+        # Assigning values to the instance variables
+        self.Rc = out['x'][0]
+        self.zOffset = out['x'][1]
+
+        # If center was fitted, assign new values to instance variable center, and
+        # subtract the fitted sphere from the mirror map.
+        if isCenter[0]:
+            x0 = out['x'][2]
+            y0 = out['x'][3]
+            # Converts the deviation into a new absolut center in data points.
+            self.center = (self.center[0] + x0/self.step_size[0],
+                           self.center[1] + y0/self.step_size[1])
+            # Creating fitted sphere
+            Z = self.createSphere(self.Rc, X, Y, self.zOffset, x0, y0)
+            # Subtracting sphere from map
+            self.data[self.notNan] = self.data[self.notNan]-Z[self.notNan]
+            return self.Rc, self.zOffset, x0, y0
+        # Subtracting fitted sphere from mirror map.
+        else:
+            # Creating fitted sphere
+            Z = self.createSphere(self.Rc,X,Y,self.zOffset)
+            # Subtracting sphere from map
+            self.data[self.notNan] = self.data[self.notNan]-Z[self.notNan]
+            return self.Rc, self.zOffset
 
     def createSphere(self,Rc,X,Y,zOffset=0,x0=0,y0=0,xTilt=0,yTilt=0,isPlot=False):
-        # Creating spherical surface. Based on 'FT_create_sphere_for_map.m'
+        '''
+        Creating spherical surface. Based on 'FT_create_sphere_for_map.m'
+        Rc      - Radius of curvature, and center of sphere on z-axis in case zOffset=0 [m].
+        X, Y    - Matrices of x,y-values generated by 'X,Y = numpy.meshgrid(xVec,yVec)'.
+                  Preferrably created by method 'surfacemap.createGrid()' [m].
+        zOffset - Surface center offset from 0. Positive value gives the surface center
+                  positive z-coordinate. [self.scaling]
+        x0,y0   - The center of the sphere in the xy-plane.
+        x/yTilt - Tilt of x/y-axis [rad].
+        isPlot  - Plot or not [boolean]. Not recommended when used within optimization
+                  algorithm.
+        '''
         
         # Adjusting for tilts and offset
         Z = zOffset + (X*np.tan(xTilt) + Y*np.tan(yTilt))/self.scaling
@@ -442,15 +504,22 @@ class surfacemap(object):
             axes = pylab.pcolormesh(X, Y, Z) #, vmin=zmin, vmax=zmax)
             cbar = fig.colorbar(axes)
             cbar.set_clim(Z.min(), Z.max())
-            pylab.title('Z_min = ' + str(Z.min()) + '      Z_max = ' + str(Z.max()))
+            pylab.title('Z_min = ' + str(Z.min()) + '   Z_max = ' + str(Z.max()))
             pylab.show()
         
         return Z
     
     def createGrid(self):
-        # Creating grid for the map. Based on 'FT_create_grid_for_map.m'
-        # and 'FT_init_grid.m'.
-        # ----------------------------------------------------------------
+        '''
+        Creating grid for fitting spherical surface to the map. Based on
+        'FT_create_grid_for_map.m' and 'FT_init_grid.m'. (x,y) = (0,0) is
+        placed at the centre of the mirror surface defined by the instance
+        variable surfacemap.center.
+        
+        Returns X,Y,r2
+        , where X,Y = numpy.meshgrid(x,y), and r2 = X^2 + Y^2.
+        '''
+        
         yPoints, xPoints = self.data.shape
         # Difference between the data point centre, and the centre of
         # the mirror surface.
@@ -461,22 +530,18 @@ class surfacemap(object):
         x = np.array([n for n in range(xPoints)])
         y = np.array([n for n in range(yPoints)])
 
-        # Shouldn't the real physical size be (points-1)*step_size?
+        # Physical size. Shouldn't this be (points-1)*step_size?
         xSize = xPoints*self.step_size[0]
         ySize = yPoints*self.step_size[1]
         # ...corrected here by subracting one step. Isn't this unnecessary
         # complicated btw?
         xAxis = x*self.step_size[0] + xOffset - (xSize-self.step_size[0])/2
         yAxis = y*self.step_size[1] + yOffset - (ySize-self.step_size[1])/2
-
-        #print(xAxis[round(self.center[0])-1:round(self.center[0])+2])
-        #print(yAxis[round(self.center[1])-1:round(self.center[1])+2])
         
         X,Y = np.meshgrid(xAxis,yAxis)
-        r = np.sqrt(X**2 + Y**2)
         r2 = X**2 + Y**2
-        phi = np.arctan2(Y,X)
-        print(X.min(),X.max(),Y.min(),Y.max())
+        # r = np.sqrt(X**2 + Y**2)
+        # phi = np.arctan2(Y,X)
         return X,Y,r2
         # ----------------------------------------------------------------
 
@@ -819,13 +884,20 @@ class zernikemap(surfacemap):
 		self.data = data
 	
 			
-# Reads surface map files and return surfacemap-object.
-# supported mapFormat: 'finesse', 'ligo', 'zygo'.
-# All ascii formats. 
-def read_map(filename, mapFormat='finesse'):
-    # Function turning input x into float.
-    g = lambda x: float(x)
+
+def read_map(filename, mapFormat='finesse', scaling=1.0e-9):
+    '''
+    Reads surface map files and return a surfacemap-object xy-centered at the
+    center of the mirror surface.
+    filename  - name of surface map file.
+    mapFormat - 'finesse', 'ligo', 'zygo'. Currently only for ascii formats.
+    scaling   - scaling of surface height of the mirror map [m].
+    '''
     
+    # Function converting string number into float.
+    g = lambda x: float(x)
+
+    # Reads finesse mirror maps.
     if mapFormat == 'finesse':
         
         with open(filename, 'r') as f:
@@ -838,13 +910,11 @@ def read_map(filename, mapFormat='finesse'):
             step = tuple(map(g, f.readline().split(':')[1].strip().split()))
             scaling = float(f.readline().split(':')[1].strip())
         
-        
-        
         data = np.loadtxt(filename, dtype=np.float64,ndmin=2,comments='%')    
 
     # Converts raw zygo and ligo mirror maps to the finesse
-    # format. Based on translation of the matlab scripts
-    # 'FT_read_zygo_map.m' and 'FT_read_ligo_map.m'
+    # format. Based on the matlab scripts 'FT_read_zygo_map.m' and
+    # 'FT_read_ligo_map.m'.
     elif mapFormat == 'ligo' or mapFormat == 'zygo':
         if mapFormat == 'ligo':
             isLigo = True
@@ -861,7 +931,8 @@ def read_map(filename, mapFormat='finesse'):
             else:
                 isAscii = False
                 
-        # Unknowns (why are these values hard coded here?)
+        # Unknowns (why are these values hard coded here?) Moving
+        # scaling to input. Fix the others later too.
         # ------------------------------------------------------
         # Standard maps have type 'phase' (they store surface
         # heights)
@@ -870,7 +941,7 @@ def read_map(filename, mapFormat='finesse'):
         # affected
         field = 0
         # Measurements in nanometers
-        scaling = 1.0e-9
+        # scaling = 1.0e-9
         # ------------------------------------------------------
 
         # Reading header of LIGO-map (Zygo file? Says Zygo in
@@ -890,7 +961,7 @@ def read_map(filename, mapFormat='finesse'):
                 iRows = float(line.split()[3])
                 
             line = f.readline().split()
-            # Unknown
+            # Unknown usage.
             # ----------------------------------------------
             if isLigo:
                 y0 = float(line[0])