diff --git a/boundaries/boundaryconditions.py b/boundaries/boundaryconditions.py
index 89359f233be55ed86dfe8363e46c7a2cd44e0a81..bc3c30117a859ede440a9970d9e92430d2946502 100644
--- a/boundaries/boundaryconditions.py
+++ b/boundaries/boundaryconditions.py
@@ -3,41 +3,41 @@ from pystencils import Field, Assignment
 from pystencils.astnodes import SympyAssignment
 from pystencils.sympyextensions import get_symmetric_part
 from pystencils.data_types import create_type
-from lbmpy.simplificationfactory import createSimplificationStrategy
+from lbmpy.simplificationfactory import create_simplification_strategy
 from lbmpy.boundaries.boundaryhandling import BoundaryOffsetInfo, LbmWeightInfo
 
 
-class Boundary(object):
+class Boundary:
     """Base class all boundaries should derive from"""
 
     def __init__(self, name=None):
         self._name = name
 
-    def __call__(self, pdfField, directionSymbol, lbMethod, indexField):
+    def __call__(self, pdf_field, direction_symbol, lb_method, index_field):
         """
         This function defines the boundary behavior and must therefore be implemented by all boundaries.
         Here the boundary is defined as a list of sympy equations, from which a boundary kernel is generated.
-        :param pdfField: pystencils field describing the pdf. The current cell is cell next to the boundary,
+        :param pdf_field: pystencils field describing the pdf. The current cell is cell next to the boundary,
                          which is influenced by the boundary cell i.e. has a link from the boundary cell to
                          itself.
-        :param directionSymbol: a sympy symbol that can be used as index to the pdfField. It describes
+        :param direction_symbol: a sympy symbol that can be used as index to the pdfField. It describes
                                 the direction pointing from the fluid to the boundary cell 
-        :param lbMethod: an instance of the LB method used. Use this to adapt the boundary to the method 
-                         (e.g. compressiblity)
-        :param indexField: the boundary index field that can be used to retrieve and update boundary data
+        :param lb_method: an instance of the LB method used. Use this to adapt the boundary to the method
+                         (e.g. compressibility)
+        :param index_field: the boundary index field that can be used to retrieve and update boundary data
         :return: list of sympy equations
         """
         raise NotImplementedError("Boundary class has to overwrite __call__")
 
     @property
-    def additionalData(self):
+    def additional_data(self):
         """Return a list of (name, type) tuples for additional data items required in this boundary
         These data items can either be initialized in separate kernel see additionalDataKernelInit or by 
         Python callbacks - see additionalDataCallback """
         return []
 
     @property
-    def additionalDataInitCallback(self):
+    def additional_data_init_callback(self):
         """Return a callback function called with a boundary data setter object and returning a dict of
         data-name to data for each element that should be initialized"""
         return None
@@ -50,8 +50,8 @@ class Boundary(object):
             return type(self).__name__
 
     @name.setter
-    def name(self, newValue):
-        self._name = newValue
+    def name(self, new_value):
+        self._name = new_value
 
 
 class NoSlip(Boundary):
@@ -61,10 +61,10 @@ class NoSlip(Boundary):
         super(NoSlip, self).__init__(name)
 
     """No-Slip, (half-way) simple bounce back boundary condition, enforcing zero velocity at obstacle"""
-    def __call__(self, pdfField, directionSymbol, lbMethod, **kwargs):
-        neighbor = BoundaryOffsetInfo.offsetFromDir(directionSymbol, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(directionSymbol)
-        return [Assignment(pdfField[neighbor](inverseDir), pdfField(directionSymbol))]
+    def __call__(self, pdf_field, direction_symbol, lb_method, **kwargs):
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction_symbol)
+        return [Assignment(pdf_field[neighbor](inverse_dir), pdf_field(direction_symbol))]
 
     def __hash__(self):
         # All boundaries of these class behave equal -> should also be equal (as long as name is equal)
@@ -80,17 +80,17 @@ class UBB(Boundary):
 
     """Velocity bounce back boundary condition, enforcing specified velocity at obstacle"""
 
-    def __init__(self, velocity, adaptVelocityToForce=False, dim=None, name=None):
+    def __init__(self, velocity, adapt_velocity_to_force=False, dim=None, name=None):
         """
         
         :param velocity: can either be a constant, an access into a field, or a callback function.
                          The callback functions gets a numpy record array with members, 'x','y','z', 'dir' (direction) 
                          and 'velocity' which has to be set to the desired velocity of the corresponding link
-        :param adaptVelocityToForce:
+        :param adapt_velocity_to_force:
         """
         super(UBB, self).__init__(name)
         self._velocity = velocity
-        self._adaptVelocityToForce = adaptVelocityToForce
+        self._adaptVelocityToForce = adapt_velocity_to_force
         if callable(self._velocity) and not dim:
             raise ValueError("When using a velocity callback the dimension has to be specified with the dim parameter")
         elif not callable(self._velocity):
@@ -98,56 +98,57 @@ class UBB(Boundary):
         self.dim = dim
 
     @property
-    def additionalData(self):
+    def additional_data(self):
         if callable(self._velocity):
             return [('vel_%d' % (i,), create_type("double")) for i in range(self.dim)]
         else:
             return []
 
     @property
-    def additionalDataInitCallback(self):
+    def additional_data_init_callback(self):
         if callable(self._velocity):
             return self._velocity
 
-    def __call__(self, pdfField, directionSymbol, lbMethod, indexField, **kwargs):
-        velFromIdxField = callable(self._velocity)
-        vel = [indexField('vel_%d' % (i,)) for i in range(self.dim)] if velFromIdxField else self._velocity
-        direction = directionSymbol
+    def __call__(self, pdf_field, direction_symbol, lb_method, index_field, **kwargs):
+        vel_from_idx_field = callable(self._velocity)
+        vel = [index_field('vel_%d' % (i,)) for i in range(self.dim)] if vel_from_idx_field else self._velocity
+        direction = direction_symbol
 
-        assert self.dim == lbMethod.dim, "Dimension of UBB (%d) does not match dimension of method (%d)" \
-                                         % (self.dim, lbMethod.dim)
+        assert self.dim == lb_method.dim, "Dimension of UBB (%d) does not match dimension of method (%d)" \
+                                          % (self.dim, lb_method.dim)
 
-        neighbor = BoundaryOffsetInfo.offsetFromDir(direction, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(direction)
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction)
 
-        velocity = tuple(v_i.getShifted(*neighbor) if isinstance(v_i, Field.Access) and not velFromIdxField else v_i
+        velocity = tuple(v_i.get_shifted(*neighbor) if isinstance(v_i, Field.Access) and not vel_from_idx_field else v_i
                          for v_i in vel)
 
         if self._adaptVelocityToForce:
-            cqc = lbMethod.conservedQuantityComputation
-            shiftedVelEqs = cqc.equilibriumInputEquationsFromInitValues(velocity=velocity)
-            velocity = [eq.rhs for eq in shiftedVelEqs.new_filtered(cqc.firstOrderMomentSymbols).main_assignments]
+            cqc = lb_method.conserved_quantity_computation
+            shifted_vel_eqs = cqc.equilibrium_input_equations_from_init_values(velocity=velocity)
+            velocity = [eq.rhs for eq in shifted_vel_eqs.new_filtered(cqc.first_order_moment_symbols).main_assignments]
 
         c_s_sq = sp.Rational(1, 3)
-        weightOfDirection = LbmWeightInfo.weightOfDirection
-        velTerm = 2 / c_s_sq * sum([d_i * v_i for d_i, v_i in zip(neighbor, velocity)]) * weightOfDirection(direction)
+        weight_of_direction = LbmWeightInfo.weight_of_direction
+        vel_term = 2 / c_s_sq * sum([d_i * v_i
+                                     for d_i, v_i in zip(neighbor, velocity)]) * weight_of_direction(direction)
 
         # Better alternative: in conserved value computation
         # rename what is currently called density to "virtualDensity"
         # provide a new quantity density, which is constant in case of incompressible models
-        if not lbMethod.conservedQuantityComputation.zeroCenteredPdfs:
-            cqc = lbMethod.conservedQuantityComputation
-            densitySymbol = sp.Symbol("rho")
-            pdfFieldAccesses = [pdfField(i) for i in range(len(lbMethod.stencil))]
-            densityEquations = cqc.outputEquationsFromPdfs(pdfFieldAccesses, {'density': densitySymbol})
-            densitySymbol = lbMethod.conservedQuantityComputation.defined_symbols()['density']
-            result = densityEquations.all_assignments
-            result += [Assignment(pdfField[neighbor](inverseDir),
-                                  pdfField(direction) - velTerm * densitySymbol)]
+        if not lb_method.conserved_quantity_computation.zero_centered_pdfs:
+            cqc = lb_method.conserved_quantity_computation
+            density_symbol = sp.Symbol("rho")
+            pdf_field_accesses = [pdf_field(i) for i in range(len(lb_method.stencil))]
+            density_equations = cqc.output_equations_from_pdfs(pdf_field_accesses, {'density': density_symbol})
+            density_symbol = lb_method.conserved_quantity_computation.defined_symbols()['density']
+            result = density_equations.all_assignments
+            result += [Assignment(pdf_field[neighbor](inverse_dir),
+                                  pdf_field(direction) - vel_term * density_symbol)]
             return result
         else:
-            return [Assignment(pdfField[neighbor](inverseDir),
-                               pdfField(direction) - velTerm)]
+            return [Assignment(pdf_field[neighbor](inverse_dir),
+                               pdf_field(direction) - vel_term)]
 
 
 class FixedDensity(Boundary):
@@ -156,49 +157,52 @@ class FixedDensity(Boundary):
         super(FixedDensity, self).__init__(name)
         self._density = density
 
-    def __call__(self, pdfField, directionSymbol, lbMethod, **kwargs):
+    def __call__(self, pdf_field, direction_symbol, lb_method, **kwargs):
         """Boundary condition that fixes the density/pressure at the obstacle"""
 
-        def removeAsymmetricPartOfmain_assignments(eqColl, dofs):
-            newmain_assignments = [Assignment(e.lhs, get_symmetric_part(e.rhs, dofs)) for e in eqColl.main_assignments]
-            return eqColl.copy(newmain_assignments)
+        def remove_asymmetric_part_of_main_assignments(assignment_collection, degrees_of_freedom):
+            new_main_assignments = [Assignment(a.lhs, get_symmetric_part(a.rhs, degrees_of_freedom))
+                                    for a in assignment_collection.main_assignments]
+            return assignment_collection.copy(new_main_assignments)
 
-        neighbor = BoundaryOffsetInfo.offsetFromDir(directionSymbol, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(directionSymbol)
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction_symbol)
 
-        cqc = lbMethod.conservedQuantityComputation
+        cqc = lb_method.conserved_quantity_computation
         velocity = cqc.defined_symbols()['velocity']
-        symmetricEq = removeAsymmetricPartOfmain_assignments(lbMethod.getEquilibrium(), dofs=velocity)
-        substitutions = {sym: pdfField(i) for i, sym in enumerate(lbMethod.preCollisionPdfSymbols)}
-        symmetricEq = symmetricEq.new_with_substitutions(substitutions)
+        symmetric_eq = remove_asymmetric_part_of_main_assignments(lb_method.get_equilibrium(),
+                                                                  degrees_of_freedom=velocity)
+        substitutions = {sym: pdf_field(i) for i, sym in enumerate(lb_method.pre_collision_pdf_symbols)}
+        symmetric_eq = symmetric_eq.new_with_substitutions(substitutions)
 
-        simplification = createSimplificationStrategy(lbMethod)
-        symmetricEq = simplification(symmetricEq)
+        simplification = create_simplification_strategy(lb_method)
+        symmetric_eq = simplification(symmetric_eq)
 
-        densitySymbol = cqc.defined_symbols()['density']
+        density_symbol = cqc.defined_symbols()['density']
 
         density = self._density
-        densityEq = cqc.equilibriumInputEquationsFromInitValues(density=density).new_without_subexpressions().main_assignments[0]
-        assert densityEq.lhs == densitySymbol
-        transformedDensity = densityEq.rhs
+        equilibrium_input = cqc.equilibrium_input_equations_from_init_values(density=density).new_without_subexpressions()
+        density_eq = equilibrium_input.main_assignments[0]
+        assert density_eq.lhs == density_symbol
+        transformed_density = density_eq.rhs
 
-        conditions = [(eq_i.rhs, sp.Equality(directionSymbol, i))
-                      for i, eq_i in enumerate(symmetricEq.main_assignments)] + [(0, True)]
+        conditions = [(eq_i.rhs, sp.Equality(direction_symbol, i))
+                      for i, eq_i in enumerate(symmetric_eq.main_assignments)] + [(0, True)]
         eq_component = sp.Piecewise(*conditions)
 
-        subExprs = [Assignment(eq.lhs, transformedDensity if eq.lhs == densitySymbol else eq.rhs)
-                    for eq in symmetricEq.subexpressions]
+        subexpressions = [Assignment(eq.lhs, transformed_density if eq.lhs == density_symbol else eq.rhs)
+                          for eq in symmetric_eq.subexpressions]
 
-        return subExprs + [SympyAssignment(pdfField[neighbor](inverseDir),
-                                           2 * eq_component - pdfField(directionSymbol))]
+        return subexpressions + [SympyAssignment(pdf_field[neighbor](inverse_dir),
+                                                 2 * eq_component - pdf_field(direction_symbol))]
 
 
 class NeumannByCopy(Boundary):
-    def __call__(self, pdfField, directionSymbol, lbMethod, **kwargs):
-        neighbor = BoundaryOffsetInfo.offsetFromDir(directionSymbol, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(directionSymbol)
-        return [Assignment(pdfField[neighbor](inverseDir), pdfField(inverseDir)),
-                Assignment(pdfField[neighbor](directionSymbol), pdfField(directionSymbol))]
+    def __call__(self, pdf_field, direction_symbol, lb_method, **kwargs):
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction_symbol)
+        return [Assignment(pdf_field[neighbor](inverse_dir), pdf_field(inverse_dir)),
+                Assignment(pdf_field[neighbor](direction_symbol), pdf_field(direction_symbol))]
 
     def __hash__(self):
         # All boundaries of these class behave equal -> should also be equal
@@ -209,11 +213,11 @@ class NeumannByCopy(Boundary):
 
 
 class StreamInZero(Boundary):
-    def __call__(self, pdfField, directionSymbol, lbMethod, **kwargs):
-        neighbor = BoundaryOffsetInfo.offsetFromDir(directionSymbol, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(directionSymbol)
-        return [Assignment(pdfField[neighbor](inverseDir), 0),
-                Assignment(pdfField[neighbor](directionSymbol), 0)]
+    def __call__(self, pdf_field, direction_symbol, lb_method, **kwargs):
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction_symbol)
+        return [Assignment(pdf_field[neighbor](inverse_dir), 0),
+                Assignment(pdf_field[neighbor](direction_symbol), 0)]
 
     def __hash__(self):
         # All boundaries of these class behave equal -> should also be equal
@@ -226,12 +230,12 @@ class StreamInZero(Boundary):
 class AntiBounceBack(Boundary):
 
     """No-Slip, (half-way) simple bounce back boundary condition, enforcing zero velocity at obstacle"""
-    def __call__(self, pdfField, directionSymbol, lbMethod, **kwargs):
-        neighbor = BoundaryOffsetInfo.offsetFromDir(directionSymbol, lbMethod.dim)
-        inverseDir = BoundaryOffsetInfo.invDir(directionSymbol)
-        rhs = pdfField(directionSymbol)
+    def __call__(self, pdf_field, direction_symbol, lb_method, **kwargs):
+        neighbor = BoundaryOffsetInfo.offset_from_dir(direction_symbol, lb_method.dim)
+        inverse_dir = BoundaryOffsetInfo.inv_dir(direction_symbol)
+        rhs = pdf_field(direction_symbol)
         t = -rhs
-        return [SympyAssignment(pdfField[neighbor](inverseDir), t)]
+        return [SympyAssignment(pdf_field[neighbor](inverse_dir), t)]
 
     def __hash__(self):
         # All boundaries of these class behave equal -> should also be equal (as long as name is equal)
@@ -241,4 +245,3 @@ class AntiBounceBack(Boundary):
         if not isinstance(other, AntiBounceBack):
             return False
         return self.name == other.name
-
diff --git a/boundaries/boundaryhandling.py b/boundaries/boundaryhandling.py
index cf3e490b638bc66f4670a06be39630958b3df000..8e7e64c2959224b9f20e547bcbe170b9cbb9a767 100644
--- a/boundaries/boundaryhandling.py
+++ b/boundaries/boundaryhandling.py
@@ -1,79 +1,79 @@
 import numpy as np
 import sympy as sp
-from pystencils import TypedSymbol, createIndexedKernel, Assignment
+from pystencils import TypedSymbol, create_indexed_kernel, Assignment
 from pystencils.backends.cbackend import CustomCppCode
 from pystencils.boundaries import BoundaryHandling
 from pystencils.boundaries.boundaryhandling import BoundaryOffsetInfo
-from lbmpy.stencils import inverseDirection
+from lbmpy.stencils import inverse_direction
 
 
 class LatticeBoltzmannBoundaryHandling(BoundaryHandling):
 
-    def __init__(self, lbMethod, dataHandling, pdfFieldName, name="boundaryHandling", flagInterface=None,
-                 target='cpu', openMP=True):
-        self.lbMethod = lbMethod
-        super(LatticeBoltzmannBoundaryHandling, self).__init__(dataHandling, pdfFieldName, lbMethod.stencil,
-                                                               name, flagInterface, target, openMP)
+    def __init__(self, lb_method, data_handling, pdf_field_name, name="boundary_handling", flag_interface=None,
+                 target='cpu', openmp=True):
+        self.lb_method = lb_method
+        super(LatticeBoltzmannBoundaryHandling, self).__init__(data_handling, pdf_field_name, lb_method.stencil,
+                                                               name, flag_interface, target, openmp)
 
-    def forceOnBoundary(self, boundaryObj):
+    def force_on_boundary(self, boundary_obj):
         from lbmpy.boundaries import NoSlip
-        if isinstance(boundaryObj, NoSlip):
-            return self._forceOnNoSlip(boundaryObj)
+        if isinstance(boundary_obj, NoSlip):
+            return self._force_on_no_slip(boundary_obj)
         else:
             self.__call__()
-            return self._forceOnBoundary(boundaryObj)
+            return self._force_on_boundary(boundary_obj)
 
     # ------------------------------ Implementation Details ------------------------------------------------------------
 
-    def _forceOnNoSlip(self, boundaryObj):
-        dh = self._dataHandling
-        ffGhostLayers = dh.ghostLayersOfField(self.flagInterface.flagFieldName)
-        method = self.lbMethod
+    def _force_on_no_slip(self, boundary_obj):
+        dh = self._data_handling
+        ff_ghost_layers = dh.ghost_layers_of_field(self.flag_interface.flag_field_name)
+        method = self.lb_method
         stencil = np.array(method.stencil)
 
         result = np.zeros(self.dim)
 
-        for b in dh.iterate(ghostLayers=ffGhostLayers):
-            objToIndList = b[self._indexArrayName].boundaryObjectToIndexList
-            pdfArray = b[self._fieldName]
-            if boundaryObj in objToIndList:
-                indArr = objToIndList[boundaryObj]
-                indices = [indArr[name] for name in ('x', 'y', 'z')[:method.dim]]
-                indices.append(indArr['dir'])
-                values = 2 * pdfArray[tuple(indices)]
-                forces = stencil[indArr['dir']] * values[:, np.newaxis]
+        for b in dh.iterate(ghost_layers=ff_ghost_layers):
+            obj_to_ind_list = b[self._index_array_name].boundary_object_to_index_list
+            pdf_array = b[self._field_name]
+            if boundary_obj in obj_to_ind_list:
+                ind_arr = obj_to_ind_list[boundary_obj]
+                indices = [ind_arr[name] for name in ('x', 'y', 'z')[:method.dim]]
+                indices.append(ind_arr['dir'])
+                values = 2 * pdf_array[tuple(indices)]
+                forces = stencil[ind_arr['dir']] * values[:, np.newaxis]
                 result += forces.sum(axis=0)
-        return dh.reduceFloatSequence(list(result), 'sum')
+        return dh.reduce_float_sequence(list(result), 'sum')
 
-    def _forceOnBoundary(self, boundaryObj):
-        dh = self._dataHandling
-        ffGhostLayers = dh.ghostLayersOfField(self.flagInterface.flagFieldName)
-        method = self.lbMethod
+    def _force_on_boundary(self, boundary_obj):
+        dh = self._data_handling
+        ff_ghost_layers = dh.ghost_layers_of_field(self.flag_interface.flag_field_name)
+        method = self.lb_method
         stencil = np.array(method.stencil)
-        invDirection = np.array([method.stencil.index(inverseDirection(d))
+        inv_direction = np.array([method.stencil.index(inverse_direction(d))
                                  for d in method.stencil])
 
         result = np.zeros(self.dim)
 
-        for b in dh.iterate(ghostLayers=ffGhostLayers):
-            objToIndList = b[self._indexArrayName].boundaryObjectToIndexList
-            pdfArray = b[self._fieldName]
-            if boundaryObj in objToIndList:
-                indArr = objToIndList[boundaryObj]
-                indices = [indArr[name] for name in ('x', 'y', 'z')[:method.dim]]
-                offsets = stencil[indArr['dir']]
-                invDir = invDirection[indArr['dir']]
-                fluidValues = pdfArray[tuple(indices) + (indArr['dir'],)]
-                boundaryValues = pdfArray[tuple(ind + offsets[:, i] for i, ind in enumerate(indices)) + (invDir,)]
-                values = fluidValues + boundaryValues
-                forces = stencil[indArr['dir']] * values[:, np.newaxis]
+        for b in dh.iterate(ghost_layers=ff_ghost_layers):
+            obj_to_ind_list = b[self._index_array_name].boundary_object_to_index_list
+            pdf_array = b[self._field_name]
+            if boundary_obj in obj_to_ind_list:
+                ind_arr = obj_to_ind_list[boundary_obj]
+                indices = [ind_arr[name] for name in ('x', 'y', 'z')[:method.dim]]
+                offsets = stencil[ind_arr['dir']]
+                inv_dir = inv_direction[ind_arr['dir']]
+                fluid_values = pdf_array[tuple(indices) + (ind_arr['dir'],)]
+                boundary_values = pdf_array[tuple(ind + offsets[:, i] for i, ind in enumerate(indices)) + (inv_dir,)]
+                values = fluid_values + boundary_values
+                forces = stencil[ind_arr['dir']] * values[:, np.newaxis]
                 result += forces.sum(axis=0)
 
-        return dh.reduceFloatSequence(list(result), 'sum')
+        return dh.reduce_float_sequence(list(result), 'sum')
 
-    def _createBoundaryKernel(self, symbolicField, symbolicIndexField, boundaryObject):
-        return createLatticeBoltzmannBoundaryKernel(symbolicField, symbolicIndexField, self.lbMethod,
-                                                    boundaryObject, target=self._target, openMP=self._openMP)
+    def _create_boundary_kernel(self, symbolic_field, symbolic_index_field, boundary_obj):
+        return create_lattice_boltzmann_boundary_kernel(symbolic_field, symbolic_index_field, self.lb_method,
+                                                        boundary_obj, target=self._target, openmp=self._openmp)
 
 
 class LbmWeightInfo(CustomCppCode):
@@ -81,24 +81,26 @@ class LbmWeightInfo(CustomCppCode):
     # --------------------------- Functions to be used by boundaries --------------------------
 
     @staticmethod
-    def weightOfDirection(dirIdx):
-        return sp.IndexedBase(LbmWeightInfo.WEIGHTS_SYMBOL, shape=(1,))[dirIdx]
+    def weight_of_direction(dir_idx):
+        return sp.IndexedBase(LbmWeightInfo.WEIGHTS_SYMBOL, shape=(1,))[dir_idx]
 
     # ---------------------------------- Internal ---------------------------------------------
 
     WEIGHTS_SYMBOL = TypedSymbol("weights", "double")
 
-    def __init__(self, lbMethod):
-        weights = [str(w.evalf()) for w in lbMethod.weights]
+    def __init__(self, lb_method):
+        weights = [str(w.evalf()) for w in lb_method.weights]
         code = "const double %s [] = { %s };\n" % (LbmWeightInfo.WEIGHTS_SYMBOL.name, ",".join(weights))
         super(LbmWeightInfo, self).__init__(code, symbols_read=set(),
-                                            symbols_defined=set([LbmWeightInfo.WEIGHTS_SYMBOL]))
-
-
-def createLatticeBoltzmannBoundaryKernel(pdfField, indexField, lbMethod, boundaryFunctor, target='cpu', openMP=True):
-    elements = [BoundaryOffsetInfo(lbMethod.stencil), LbmWeightInfo(lbMethod)]
-    indexArrDtype = indexField.dtype.numpy_dtype
-    dirSymbol = TypedSymbol("dir", indexArrDtype.fields['dir'][0])
-    elements += [Assignment(dirSymbol, indexField[0]('dir'))]
-    elements += boundaryFunctor(pdfField=pdfField, directionSymbol=dirSymbol, lbMethod=lbMethod, indexField=indexField)
-    return createIndexedKernel(elements, [indexField], target=target, cpuOpenMP=openMP)
+                                            symbols_defined={LbmWeightInfo.WEIGHTS_SYMBOL})
+
+
+def create_lattice_boltzmann_boundary_kernel(pdf_field, index_field, lb_method, boundary_functor,
+                                             target='cpu', openmp=True):
+    elements = [BoundaryOffsetInfo(lb_method.stencil), LbmWeightInfo(lb_method)]
+    index_arr_dtype = index_field.dtype.numpy_dtype
+    dir_symbol = TypedSymbol("dir", index_arr_dtype.fields['dir'][0])
+    elements += [Assignment(dir_symbol, index_field[0]('dir'))]
+    elements += boundary_functor(pdf_field=pdf_field, direction_symbol=dir_symbol,
+                                 lb_method=lb_method, index_field=index_field)
+    return create_indexed_kernel(elements, [index_field], target=target, cpu_openmp=openmp)
diff --git a/boundaries/createindexlistcython.pyx b/boundaries/createindexlistcython.pyx
index dfa84069d67442f4866fcec1924f6e5cd77fdd61..6592e5063e0c9e6fae980711597f3cad2fc0e65b 100644
--- a/boundaries/createindexlistcython.pyx
+++ b/boundaries/createindexlistcython.pyx
@@ -13,51 +13,51 @@ ctypedef fused IntegerType:
     unsigned int
     unsigned long
 
-@cython.boundscheck(False) # turn off bounds-checking for entire function
-@cython.wraparound(False)  # turn off negative index wrapping for entire function
-def createBoundaryIndexList2D(object[IntegerType, ndim=2] flagField,
-                              int nrOfGhostLayers, IntegerType boundaryMask, IntegerType fluidMask,
-                              object[int, ndim=2] stencil):
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def create_boundary_index_list_2d(object[IntegerType, ndim=2] flag_field,
+                                  int nr_of_ghost_layers, IntegerType boundary_mask, IntegerType fluid_mask,
+                                  object[int, ndim=2] stencil):
     cdef int xs, ys, x, y
-    cdef int dirIdx, numDirections, dx, dy
+    cdef int dirIdx, num_directions, dx, dy
 
-    xs, ys = flagField.shape
-    boundaryIndexList = []
-    numDirections = stencil.shape[0]
+    xs, ys = flag_field.shape
+    boundary_index_list = []
+    num_directions = stencil.shape[0]
 
-    for y in range(nrOfGhostLayers,ys-nrOfGhostLayers):
-        for x in range(nrOfGhostLayers,xs-nrOfGhostLayers):
-            if flagField[x,y] & fluidMask:
-                for dirIdx in range(1, numDirections):
+    for y in range(nr_of_ghost_layers, ys - nr_of_ghost_layers):
+        for x in range(nr_of_ghost_layers, xs - nr_of_ghost_layers):
+            if flag_field[x, y] & fluid_mask:
+                for dirIdx in range(1, num_directions):
                     dx = stencil[dirIdx,0]
                     dy = stencil[dirIdx,1]
-                    if flagField[x+dx, y+dy] & boundaryMask:
-                        boundaryIndexList.append((x,y, dirIdx))
-    return boundaryIndexList
+                    if flag_field[x + dx, y + dy] & boundary_mask:
+                        boundary_index_list.append((x,y, dirIdx))
+    return boundary_index_list
 
 
-@cython.boundscheck(False) # turn off bounds-checking for entire function
-@cython.wraparound(False)  # turn off negative index wrapping for entire function
-def createBoundaryIndexList3D(object[IntegerType, ndim=3] flagField,
-                              int nrOfGhostLayers, IntegerType boundaryMask, IntegerType fluidMask,
-                              object[int, ndim=2] stencil):
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def create_boundary_index_list_3d(object[IntegerType, ndim=3] flag_field,
+                                  int nr_of_ghost_layers, IntegerType boundary_mask, IntegerType fluid_mask,
+                                  object[int, ndim=2] stencil):
     cdef int xs, ys, zs, x, y, z
-    cdef int dirIdx, numDirections, dx, dy, dz
+    cdef int dirIdx, num_directions, dx, dy, dz
 
-    xs, ys, zs = flagField.shape
-    boundaryIndexList = []
-    numDirections = stencil.shape[0]
+    xs, ys, zs = flag_field.shape
+    boundary_index_list = []
+    num_directions = stencil.shape[0]
 
-    for z in range(nrOfGhostLayers, zs-nrOfGhostLayers):
-        for y in range(nrOfGhostLayers,ys-nrOfGhostLayers):
-            for x in range(nrOfGhostLayers,xs-nrOfGhostLayers):
-                if flagField[x, y, z] & fluidMask:
-                    for dirIdx in range(1, numDirections):
+    for z in range(nr_of_ghost_layers, zs - nr_of_ghost_layers):
+        for y in range(nr_of_ghost_layers, ys - nr_of_ghost_layers):
+            for x in range(nr_of_ghost_layers, xs - nr_of_ghost_layers):
+                if flag_field[x, y, z] & fluid_mask:
+                    for dirIdx in range(1, num_directions):
                         dx = stencil[dirIdx,0]
                         dy = stencil[dirIdx,1]
                         dz = stencil[dirIdx,2]
-                        if flagField[x + dx, y + dy, z + dz] & boundaryMask:
-                            boundaryIndexList.append((x,y,z, dirIdx))
-    return boundaryIndexList
+                        if flag_field[x + dx, y + dy, z + dz] & boundary_mask:
+                            boundary_index_list.append((x,y,z, dirIdx))
+    return boundary_index_list
 
 
diff --git a/chapman_enskog/__init__.py b/chapman_enskog/__init__.py
index abe7e69bdfe7f1f3fb11ef5e331d292b2548764b..2eb43a0b4cd68ca7beed6f2d004c50863906d809 100644
--- a/chapman_enskog/__init__.py
+++ b/chapman_enskog/__init__.py
@@ -1,4 +1,4 @@
-from lbmpy.chapman_enskog.derivative import DiffOperator, Diff, expandUsingLinearity, expandUsingProductRule, \
-    normalizeDiffOrder, chapmanEnskogDerivativeExpansion, chapmanEnskogDerivativeRecombination
-from lbmpy.chapman_enskog.chapman_enskog import LbMethodEqMoments, insertMoments, takeMoments, \
-    CeMoment, chainSolveAndSubstitute, timeDiffSelector, momentSelector, ChapmanEnskogAnalysis
+from lbmpy.chapman_enskog.derivative import DiffOperator, Diff, expand_using_linearity, expand_using_product_rule, \
+    normalize_diff_order, chapman_enskog_derivative_expansion, chapman_enskog_derivative_recombination
+from lbmpy.chapman_enskog.chapman_enskog import LbMethodEqMoments, insert_moments, take_moments, \
+    CeMoment, chain_solve_and_substitute, time_diff_selector, moment_selector, ChapmanEnskogAnalysis
diff --git a/chapman_enskog/chapman_enskog.py b/chapman_enskog/chapman_enskog.py
index 0c8f7fb36d7094a06088bfb50aed9c317da936b2..4e930de258463778ef021cc1f1fed87353b75c22 100644
--- a/chapman_enskog/chapman_enskog.py
+++ b/chapman_enskog/chapman_enskog.py
@@ -4,13 +4,13 @@ from collections import namedtuple
 import sympy as sp
 from sympy.core.cache import cacheit
 
-from lbmpy.chapman_enskog import Diff, expandUsingLinearity, expandUsingProductRule
-from lbmpy.chapman_enskog import DiffOperator, normalizeDiffOrder, chapmanEnskogDerivativeExpansion, \
-    chapmanEnskogDerivativeRecombination
-from lbmpy.chapman_enskog.derivative import collectDerivatives, createNestedDiff
-from lbmpy.moments import discreteMoment, momentMatrix, polynomialToExponentRepresentation, getMomentIndices, \
-    nonAliasedMoment
-from pystencils.cache import diskcache
+from lbmpy.chapman_enskog import Diff, expand_using_linearity, expand_using_product_rule
+from lbmpy.chapman_enskog import DiffOperator, normalize_diff_order, chapman_enskog_derivative_expansion, \
+    chapman_enskog_derivative_recombination
+from lbmpy.chapman_enskog.derivative import collect_derivatives, create_nested_diff
+from lbmpy.moments import discrete_moment, moment_matrix, polynomial_to_exponent_representation, get_moment_indices, \
+    non_aliased_moment
+from pystencils.cache import disk_cache
 from pystencils.sympyextensions import normalize_product, multidimensional_sum, kronecker_delta
 from pystencils.sympyextensions import symmetric_product
 
@@ -18,7 +18,7 @@ from pystencils.sympyextensions import symmetric_product
 # --------------------------------------------- Helper Functions -------------------------------------------------------
 
 
-def expandedSymbol(name, subscript=None, superscript=None, **kwargs):
+def expanded_symbol(name, subscript=None, superscript=None, **kwargs):
     if subscript is not None:
         name += "_{%s}" % (subscript,)
     if superscript is not None:
@@ -34,9 +34,9 @@ class CeMoment(sp.Symbol):
         obj = CeMoment.__xnew_cached_(cls, name, *args, **kwds)
         return obj
 
-    def __new_stage2__(cls, name, momentTuple, superscript=-1):
+    def __new_stage2__(cls, name, moment_tuple, superscript=-1):
         obj = super(CeMoment, cls).__xnew__(cls, name)
-        obj.momentTuple = momentTuple
+        obj.momentTuple = moment_tuple
         while len(obj.momentTuple) < 3:
             obj.momentTuple = obj.momentTuple + (0,)
         obj.superscript = superscript
@@ -46,22 +46,22 @@ class CeMoment(sp.Symbol):
     __xnew_cached_ = staticmethod(cacheit(__new_stage2__))
 
     def _hashable_content(self):
-        superClassContents = list(super(CeMoment, self)._hashable_content())
-        return tuple(superClassContents + [hash(repr(self.momentTuple)), hash(repr(self.superscript))])
+        super_class_contents = list(super(CeMoment, self)._hashable_content())
+        return tuple(super_class_contents + [hash(repr(self.momentTuple)), hash(repr(self.superscript))])
 
     @property
     def indices(self):
-        return getMomentIndices(self.momentTuple)
+        return get_moment_indices(self.momentTuple)
 
     def __getnewargs__(self):
         return self.name, self.momentTuple, self.superscript
 
     def _latex(self, printer, *args):
-        coordStr = []
+        coord_str = []
         for i, comp in enumerate(self.momentTuple):
-            coordStr += [str(i)] * comp
-        coordStr = "".join(coordStr)
-        result = "{%s_{%s}" % (self.name, coordStr)
+            coord_str += [str(i)] * comp
+        coord_str = "".join(coord_str)
+        result = "{%s_{%s}" % (self.name, coord_str)
         if self.superscript >= 0:
             result += "^{(%d)}}" % (self.superscript,)
         else:
@@ -76,56 +76,58 @@ class CeMoment(sp.Symbol):
 
 
 class LbMethodEqMoments:
-    def __init__(self, lbMethod):
-        self._eq = tuple(e.rhs for e in lbMethod.getEquilibrium().main_assignments)
+    def __init__(self, lb_method):
+        self._eq = tuple(e.rhs for e in lb_method.get_equilibrium().main_assignments)
         self._momentCache = dict()
         self._postCollisionMomentCache = dict()
-        self._stencil = lbMethod.stencil
-        self._inverseMomentMatrix = momentMatrix(lbMethod.moments, lbMethod.stencil).inv()
-        self._method = lbMethod
+        self._stencil = lb_method.stencil
+        self._inverseMomentMatrix = moment_matrix(lb_method.moments, lb_method.stencil).inv()
+        self._method = lb_method
 
-    def __call__(self, ceMoment):
-        return self.getPreCollisionMoment(ceMoment)
+    def __call__(self, ce_moment):
+        return self.get_pre_collision_moment(ce_moment)
 
-    def getPreCollisionMoment(self, ceMoment):
-        assert ceMoment.superscript == 0, "Only equilibrium moments can be obtained with this function"
-        if ceMoment not in self._momentCache:
-            self._momentCache[ceMoment] = discreteMoment(self._eq, ceMoment.momentTuple, self._stencil)
-        return self._momentCache[ceMoment]
+    def get_pre_collision_moment(self, ce_moment):
+        assert ce_moment.superscript == 0, "Only equilibrium moments can be obtained with this function"
+        if ce_moment not in self._momentCache:
+            self._momentCache[ce_moment] = discrete_moment(self._eq, ce_moment.momentTuple, self._stencil)
+        return self._momentCache[ce_moment]
 
-    def getPostCollisionMoment(self, ceMoment, exponent=1, preCollisionMomentName="\\Pi"):
+    def get_post_collision_moment(self, ceMoment, exponent=1, preCollisionMomentName="\\Pi"):
         if (ceMoment, exponent) in self._postCollisionMomentCache:
             return self._postCollisionMomentCache[(ceMoment, exponent)]
 
         stencil = self._method.stencil
-        Minv = self._inverseMomentMatrix
+        moment2pdf = self._inverseMomentMatrix
 
-        momentTuple = ceMoment.momentTuple
+        moment_tuple = ceMoment.momentTuple
 
-        momentSymbols = []
-        for moment, (eqValue, rr) in self._method.relaxationInfoDict.items():
+        moment_symbols = []
+        for moment, (eqValue, rr) in self._method.relaxation_info_dict.items():
             if isinstance(moment, tuple):
-                momentSymbols.append(-rr**exponent * CeMoment(preCollisionMomentName, moment, ceMoment.superscript))
+                moment_symbols.append(-rr**exponent * CeMoment(preCollisionMomentName, moment, ceMoment.superscript))
             else:
-                momentSymbols.append(-rr**exponent * sum(coeff * CeMoment(preCollisionMomentName, momentTuple, ceMoment.superscript)
-                                     for coeff, momentTuple in polynomialToExponentRepresentation(moment)))
-        momentSymbols = sp.Matrix(momentSymbols)
-        postCollisionValue = discreteMoment(tuple(Minv * momentSymbols), momentTuple, stencil)
-        self._postCollisionMomentCache[(ceMoment, exponent)] = postCollisionValue
-
-        return postCollisionValue
-
-    def substitutePreCollisionMoments(self, expr, preCollisionMomentName="\\Pi"):
-        substitutions = {m: self.getPreCollisionMoment(m) for m in expr.atoms(CeMoment)
-                         if m.superscript == 0 and m.name == preCollisionMomentName}
+                moment_symbols.append(-rr**exponent * sum(coeff * CeMoment(preCollisionMomentName, momentTuple,
+                                                                           ceMoment.superscript)
+                                                          for coeff, momentTuple in polynomial_to_exponent_representation(moment)))
+        moment_symbols = sp.Matrix(moment_symbols)
+        post_collision_value = discrete_moment(tuple(moment2pdf * moment_symbols), moment_tuple, stencil)
+        self._postCollisionMomentCache[(ceMoment, exponent)] = post_collision_value
+
+        return post_collision_value
+
+    def substitute_pre_collision_moments(self, expr, pre_collision_moment_name="\\Pi"):
+        substitutions = {m: self.get_pre_collision_moment(m) for m in expr.atoms(CeMoment)
+                         if m.superscript == 0 and m.name == pre_collision_moment_name}
         return expr.subs(substitutions)
 
-    def substitutePostCollisionMoments(self, expr, preCollisionMomentName="\\Pi", postCollisionMomentName="\\Upsilon"):
+    def substitute_post_collision_moments(self, expr,
+                                          pre_collision_moment_name="\\Pi", post_collision_moment_name="\\Upsilon"):
         """
         Substitutes post-collision equilibrium moments 
         :param expr: expression with fully expanded derivatives
-        :param preCollisionMomentName: post-collision moments are replaced by CeMoments with this name
-        :param postCollisionMomentName: name of post-collision CeMoments
+        :param pre_collision_moment_name: post-collision moments are replaced by CeMoments with this name
+        :param post_collision_moment_name: name of post-collision CeMoments
         :return: expressions where equilibrium post-collision moments have been replaced
         """
         expr = sp.expand(expr)
@@ -134,418 +136,420 @@ class LbMethodEqMoments:
             if node.func == sp.Pow:
                 base, exp = node.args
                 return visit(base, exp)
-            elif isinstance(node, CeMoment) and node.name == postCollisionMomentName:
-                return self.getPostCollisionMoment(node, exponent, preCollisionMomentName)
+            elif isinstance(node, CeMoment) and node.name == post_collision_moment_name:
+                return self.get_post_collision_moment(node, exponent, pre_collision_moment_name)
             else:
                 return node**exponent if not node.args else node.func(*[visit(k, 1) for k in node.args])
         return visit(expr, 1)
 
-    def substitute(self, expr,  preCollisionMomentName="\\Pi", postCollisionMomentName="\\Upsilon"):
-        result = self.substitutePostCollisionMoments(expr, preCollisionMomentName, postCollisionMomentName)
-        result = self.substitutePreCollisionMoments(result, preCollisionMomentName)
+    def substitute(self, expr, pre_collision_moment_name="\\Pi", post_collision_moment_name="\\Upsilon"):
+        result = self.substitute_post_collision_moments(expr, pre_collision_moment_name, post_collision_moment_name)
+        result = self.substitute_pre_collision_moments(result, pre_collision_moment_name)
         return result
 
 
-def insertMoments(eqn, lbMethodMoments, momentName="\\Pi", useSolvabilityConditions=True):
-    subsDict = {}
-    if useSolvabilityConditions:
-        condition = lambda m: m.superscript > 0 and sum(m.momentTuple) <= 1 and m.name == momentName
-        subsDict.update({m: 0 for m in eqn.atoms(CeMoment) if condition(m)})
+def insert_moments(eqn, lb_method_moments, moment_name="\\Pi", use_solvability_conditions=True):
+    substitutions = {}
+    if use_solvability_conditions:
+        condition = lambda m: m.superscript > 0 and sum(m.momentTuple) <= 1 and m.name == moment_name
+        substitutions.update({m: 0 for m in eqn.atoms(CeMoment) if condition(m)})
 
-    condition = lambda m: m.superscript == 0 and m.name == momentName
-    subsDict.update({m: lbMethodMoments(m) for m in eqn.atoms(CeMoment) if condition(m)})
-    return eqn.subs(subsDict)
+    condition = lambda m: m.superscript == 0 and m.name == moment_name
+    substitutions.update({m: lb_method_moments(m) for m in eqn.atoms(CeMoment) if condition(m)})
+    return eqn.subs(substitutions)
 
 
-def substituteCollisionOperatorMoments(expr, lbMomentComputation, collisionOpMomentName='\\Upsilon',
-                                       preCollisionMomentName="\\Pi"):
-    momentsToReplace = [m for m in expr.atoms(CeMoment) if m.name == collisionOpMomentName]
-    subsDict = {}
-    for ceMoment in momentsToReplace:
-        subsDict[ceMoment] = lbMomentComputation.getPostCollisionMoment(ceMoment, 1, preCollisionMomentName)
+def substitute_collision_operator_moments(expr, lb_moment_computation, collision_op_moment_name='\\Upsilon',
+                                          pre_collision_moment_name="\\Pi"):
+    moments_to_replace = [m for m in expr.atoms(CeMoment) if m.name == collision_op_moment_name]
+    subs_dict = {}
+    for ceMoment in moments_to_replace:
+        subs_dict[ceMoment] = lb_moment_computation.get_post_collision_moment(ceMoment, 1, pre_collision_moment_name)
 
-    return expr.subs(subsDict)
+    return expr.subs(subs_dict)
 
 
-def takeMoments(eqn, pdfToMomentName=(('f', '\Pi'), ('\Omega f', '\\Upsilon')), velocityName='c', maxExpansion=5,
-                useOneNeighborhoodAliasing=False):
+def take_moments(eqn, pdf_to_moment_name=(('f', '\Pi'), ('\Omega f', '\\Upsilon')), velocity_name='c', max_expansion=5,
+                 use_one_neighborhood_aliasing=False):
 
-    pdfSymbols = [tuple(expandedSymbol(name, superscript=i) for i in range(maxExpansion))
-                  for name, _ in pdfToMomentName]
+    pdf_symbols = [tuple(expanded_symbol(name, superscript=i) for i in range(max_expansion))
+                   for name, _ in pdf_to_moment_name]
 
-    velocityTerms = tuple(expandedSymbol(velocityName, subscript=i) for i in range(3))
+    velocity_terms = tuple(expanded_symbol(velocity_name, subscript=i) for i in range(3))
 
-    def determineFIndex(factor):
+    def determine_f_index(factor):
         FIndex = namedtuple("FIndex", ['momentName', 'superscript'])
-        for symbolListId, pdfSymbolsElement in enumerate(pdfSymbols):
+        for symbolListId, pdfSymbolsElement in enumerate(pdf_symbols):
             try:
-                return FIndex(pdfToMomentName[symbolListId][1], pdfSymbolsElement.index(factor))
+                return FIndex(pdf_to_moment_name[symbolListId][1], pdfSymbolsElement.index(factor))
             except ValueError:
                 pass
         return None
 
-    def handleProduct(productTerm):
-        fIndex = None
-        derivativeTerm = None
-        cIndices = []
+    def handle_product(product_term):
+        f_index = None
+        derivative_term = None
+        c_indices = []
         rest = 1
-        for factor in normalize_product(productTerm):
+        for factor in normalize_product(product_term):
             if isinstance(factor, Diff):
-                assert fIndex is None
-                fIndex = determineFIndex(factor.getArgRecursive())
-                derivativeTerm = factor
-            elif factor in velocityTerms:
-                cIndices += [velocityTerms.index(factor)]
+                assert f_index is None
+                f_index = determine_f_index(factor.get_arg_recursive())
+                derivative_term = factor
+            elif factor in velocity_terms:
+                c_indices += [velocity_terms.index(factor)]
             else:
-                newFIndex = determineFIndex(factor)
-                if newFIndex is None:
+                new_f_index = determine_f_index(factor)
+                if new_f_index is None:
                     rest *= factor
                 else:
-                    assert not(newFIndex and fIndex)
-                    fIndex = newFIndex
-
-        momentTuple = [0] * len(velocityTerms)
-        for cIdx in cIndices:
-            momentTuple[cIdx] += 1
-        momentTuple = tuple(momentTuple)
-
-        if useOneNeighborhoodAliasing:
-            momentTuple = nonAliasedMoment(momentTuple)
-        result = CeMoment(fIndex.momentName, momentTuple, fIndex.superscript)
-        if derivativeTerm is not None:
-            result = derivativeTerm.changeArgRecursive(result)
+                    assert not(new_f_index and f_index)
+                    f_index = new_f_index
+
+        moment_tuple = [0] * len(velocity_terms)
+        for cIdx in c_indices:
+            moment_tuple[cIdx] += 1
+        moment_tuple = tuple(moment_tuple)
+
+        if use_one_neighborhood_aliasing:
+            moment_tuple = non_aliased_moment(moment_tuple)
+        result = CeMoment(f_index.momentName, moment_tuple, f_index.superscript)
+        if derivative_term is not None:
+            result = derivative_term.change_arg_recursive(result)
         result *= rest
         return result
 
-    functions = sum(pdfSymbols, ())
-    eqn = expandUsingLinearity(eqn, functions).expand()
+    functions = sum(pdf_symbols, ())
+    eqn = expand_using_linearity(eqn, functions).expand()
 
     if eqn.func == sp.Mul:
-        return handleProduct(eqn)
+        return handle_product(eqn)
     else:
         assert eqn.func == sp.Add
-        return sum(handleProduct(t) for t in eqn.args)
+        return sum(handle_product(t) for t in eqn.args)
 
 
-def timeDiffSelector(eq):
+def time_diff_selector(eq):
     return [d for d in eq.atoms(Diff) if d.target == sp.Symbol("t")]
 
 
-def momentSelector(eq):
+def moment_selector(eq):
     return list(eq.atoms(CeMoment))
 
 
-def diffExpandNormalizer(eq):
-    return expandUsingProductRule(eq).expand()
+def diff_expand_normalizer(eq):
+    return expand_using_product_rule(eq).expand()
 
 
-def chainSolveAndSubstitute(eqSequence, unknownSelector, normalizingFunc=diffExpandNormalizer):
+def chain_solve_and_substitute(assignments, unknown_selector, normalizing_func=diff_expand_normalizer):
     """Takes a list (hierarchy) of equations and does the following:
        Loops over given equations and for every equation:
-        - normalizes the equation with the provided normalizingFunc
+        - normalizes the equation with the provided normalizing_func
         - substitute symbols that have been already solved for
-        - calls the unknownSelector function with an equation. This function should return a list of unknown symbols,
+        - calls the unknown_selector function with an equation. This function should return a list of unknown symbols,
           and has to have length 0 or 1
-        - if unknown was returned, the equation is solved for, and the pair (unknown-> solution) is entered into the dict
+        - if unknown was returned, the equation is solved for, and the pair (unknown-> solution)
+          is entered into the dict
     """
-    resultEquations = []
-    subsDict = {}
-    for i, eq in enumerate(eqSequence):
-        eq = normalizingFunc(eq)
-        eq = eq.subs(subsDict)
-        eq = normalizingFunc(eq)
-        resultEquations.append(eq)
-
-        symbolsToSolveFor = unknownSelector(eq)
-        if len(symbolsToSolveFor) == 0:
+    result_assignments = []
+    subs_dict = {}
+    for i, eq in enumerate(assignments):
+        eq = normalizing_func(eq)
+        eq = eq.subs(subs_dict)
+        eq = normalizing_func(eq)
+        result_assignments.append(eq)
+
+        symbols_to_solve_for = unknown_selector(eq)
+        if len(symbols_to_solve_for) == 0:
             continue
-        assert len(symbolsToSolveFor) <= 1, "Unknown Selector return multiple unknowns - expected <=1\n" + str(
-            symbolsToSolveFor)
-        symbolToSolveFor = symbolsToSolveFor[0]
-        solveRes = sp.solve(eq, symbolToSolveFor)
-        assert len(solveRes) == 1, "Could not solve uniquely for unknown" + str(symbolToSolveFor)
-        subsDict[symbolToSolveFor] = normalizingFunc(solveRes[0])
-    return resultEquations, subsDict
-
-
-def countVars(expr, variables):
-    factorList = normalize_product(expr)
-    diffsToUnpack = [e for e in factorList if isinstance(e, Diff)]
-    factorList = [e for e in factorList if not isinstance(e, Diff)]
-
-    while diffsToUnpack:
-        d = diffsToUnpack.pop()
+        assert len(symbols_to_solve_for) <= 1, "Unknown Selector return multiple unknowns - expected <=1\n" + str(
+            symbols_to_solve_for)
+        symbol_to_solve_for = symbols_to_solve_for[0]
+        solve_res = sp.solve(eq, symbol_to_solve_for)
+        assert len(solve_res) == 1, "Could not solve uniquely for unknown" + str(symbol_to_solve_for)
+        subs_dict[symbol_to_solve_for] = normalizing_func(solve_res[0])
+    return result_assignments, subs_dict
+
+
+def count_vars(expr, variables):
+    factor_list = normalize_product(expr)
+    diffs_to_unpack = [e for e in factor_list if isinstance(e, Diff)]
+    factor_list = [e for e in factor_list if not isinstance(e, Diff)]
+
+    while diffs_to_unpack:
+        d = diffs_to_unpack.pop()
         args = normalize_product(d.arg)
         for a in args:
             if isinstance(a, Diff):
-                diffsToUnpack.append(a)
+                diffs_to_unpack.append(a)
             else:
-                factorList.append(a)
+                factor_list.append(a)
 
     result = 0
     for v in variables:
-        result += factorList.count(v)
+        result += factor_list.count(v)
     return result
 
 
-def removeHigherOrderU(expr, order=1, u=sp.symbols("u_:3")):
-    return sum(a for a in expr.args if countVars(a, u) <= order)
+def remove_higher_order_u(expr, order=1, u=sp.symbols("u_:3")):
+    return sum(a for a in expr.args if count_vars(a, u) <= order)
 
 
-def removeErrorTerms(expr):
-    rhoDiffsToZero = {Diff(sp.Symbol("rho"), i): 0 for i in range(3)}
-    expr = expr.subs(rhoDiffsToZero)
+def remove_error_terms(expr):
+    rho_diffs_to_zero = {Diff(sp.Symbol("rho"), i): 0 for i in range(3)}
+    expr = expr.subs(rho_diffs_to_zero)
     if isinstance(expr, sp.Matrix):
-        expr = expr.applyfunc(removeHigherOrderU)
+        expr = expr.applyfunc(remove_higher_order_u)
     else:
-        expr = removeHigherOrderU(expr.expand())
+        expr = remove_higher_order_u(expr.expand())
     return sp.cancel(expr.expand())
 
 # ----------------------------------------------------------------------------------------------------------------------
 
 
-def getTaylorExpandedLbEquation(pdfSymbolName="f", pdfsAfterCollisionOperator="\Omega f", velocityName="c",
-                                dim=3, taylorOrder=2, shift=True):
-    dimLabels = [sp.Rational(i, 1) for i in range(dim)]
+def get_taylor_expanded_lb_equation(pdf_symbol_name="f", pdfs_after_collision_operator="\Omega f", velocity_name="c",
+                                    dim=3, taylor_order=2, shift=True):
+    dim_labels = [sp.Rational(i, 1) for i in range(dim)]
 
-    c = sp.Matrix([expandedSymbol(velocityName, subscript=label) for label in dimLabels])
+    c = sp.Matrix([expanded_symbol(velocity_name, subscript=label) for label in dim_labels])
     dt, t = sp.symbols("Delta_t t")
-    pdf = sp.Symbol(pdfSymbolName)
-    collidedPdf = sp.Symbol(pdfsAfterCollisionOperator)
+    pdf = sp.Symbol(pdf_symbol_name)
+    collided_pdf = sp.Symbol(pdfs_after_collision_operator)
 
-    Dt = DiffOperator(target=t)
-    Dx = sp.Matrix([DiffOperator(target=l) for l in dimLabels])
+    dt_operator = DiffOperator(target=t)
+    dx_operator = sp.Matrix([DiffOperator(target=l) for l in dim_labels])
 
-    taylorOperator = sum(dt ** k * (Dt + c.dot(Dx)) ** k / sp.functions.factorial(k)
-                         for k in range(1, taylorOrder + 1))
+    taylor_operator = sum(dt ** k * (dt_operator + c.dot(dx_operator)) ** k / sp.functions.factorial(k)
+                          for k in range(1, taylor_order + 1))
 
-    functions = [pdf, collidedPdf]
-    eq_4_5 = taylorOperator - dt * collidedPdf
-    applied_eq_4_5 = expandUsingLinearity(DiffOperator.apply(eq_4_5, pdf, applyToConstants=False), functions)
+    functions = [pdf, collided_pdf]
+    eq_4_5 = taylor_operator - dt * collided_pdf
+    applied_eq_4_5 = expand_using_linearity(DiffOperator.apply(eq_4_5, pdf, apply_to_constants=False), functions)
 
     if shift:
-        operator = ((dt / 2) * (Dt + c.dot(Dx))).expand()
-        opTimesEq_4_5 = expandUsingLinearity(DiffOperator.apply(operator, applied_eq_4_5, applyToConstants=False),
-                                             functions).expand()
-        opTimesEq_4_5 = normalizeDiffOrder(opTimesEq_4_5, functions)
-        eq_4_7 = (applied_eq_4_5 - opTimesEq_4_5).subs(dt ** (taylorOrder+1), 0)
+        operator = ((dt / 2) * (dt_operator + c.dot(dx_operator))).expand()
+        op_times_eq_4_5 = expand_using_linearity(DiffOperator.apply(operator, applied_eq_4_5, apply_to_constants=False),
+                                                 functions).expand()
+        op_times_eq_4_5 = normalize_diff_order(op_times_eq_4_5, functions)
+        eq_4_7 = (applied_eq_4_5 - op_times_eq_4_5).subs(dt ** (taylor_order + 1), 0)
     else:
-        eq_4_7 = applied_eq_4_5.subs(dt ** (taylorOrder + 1), 0)
+        eq_4_7 = applied_eq_4_5.subs(dt ** (taylor_order + 1), 0)
 
     eq_4_7 = eq_4_7.subs(dt, 1)
     return eq_4_7.expand()
 
 
-def useChapmanEnskogAnsatz(equation, timeDerivativeOrders=(1, 3), spatialDerivativeOrders=(1, 2),
-                           pdfs=(['f', 0, 3], ['\Omega f', 1, 3]), **kwargs):
+def use_chapman_enskog_ansatz(equation, time_derivative_orders=(1, 3), spatial_derivative_orders=(1, 2),
+                              pdfs=(['f', 0, 3], ['\Omega f', 1, 3]), **kwargs):
     """
     Uses a Chapman Enskog Ansatz to expand given equation.
     :param equation: equation to expand
-    :param timeDerivativeOrders: tuple describing range for time derivative to expand
-    :param spatialDerivativeOrders: tuple describing range for spatial derivatives to expand
+    :param time_derivative_orders: tuple describing range for time derivative to expand
+    :param spatial_derivative_orders: tuple describing range for spatial derivatives to expand
     :param pdfs: symbols to expand: sequence of triples (symbolName, startOrder, endOrder)
     :return: tuple mapping epsilon order to equation
     """
     t, eps = sp.symbols("t epsilon")
 
     # expand time derivatives
-    if timeDerivativeOrders:
-        equation = chapmanEnskogDerivativeExpansion(equation, t, eps, *timeDerivativeOrders)
+    if time_derivative_orders:
+        equation = chapman_enskog_derivative_expansion(equation, t, eps, *time_derivative_orders)
 
     # expand spatial derivatives
-    if spatialDerivativeOrders:
-        spatialDerivatives = [a for a in equation.atoms(Diff) if str(a.target) != 't']
-        labels = set(a.target for a in spatialDerivatives)
+    if spatial_derivative_orders:
+        spatial_derivatives = [a for a in equation.atoms(Diff) if str(a.target) != 't']
+        labels = set(a.target for a in spatial_derivatives)
         for label in labels:
-            equation = chapmanEnskogDerivativeExpansion(equation, label, eps, *spatialDerivativeOrders)
+            equation = chapman_enskog_derivative_expansion(equation, label, eps, *spatial_derivative_orders)
 
     # expand pdfs
-    subsDict = {}
-    expandedPdfSymbols = []
-
-    maxExpansionOrder = spatialDerivativeOrders[1] if spatialDerivativeOrders else 10
-    for pdfName, startOrder, stopOrder in pdfs:
-        if isinstance(pdfName, sp.Symbol):
-            pdfName = pdfName.name
-        expandedPdfSymbols += [expandedSymbol(pdfName, superscript=i, **kwargs) for i in range(startOrder, stopOrder)]
-        subsDict[sp.Symbol(pdfName, **kwargs)] = sum(eps ** i * expandedSymbol(pdfName, superscript=i, **kwargs)
-                                                     for i in range(startOrder, stopOrder))
-        maxExpansionOrder = max(maxExpansionOrder, stopOrder)
-    equation = equation.subs(subsDict)
-    equation = expandUsingLinearity(equation, functions=expandedPdfSymbols).expand().collect(eps)
-    result = {epsOrder: equation.coeff(eps ** epsOrder) for epsOrder in range(1, 2*maxExpansionOrder)}
+    subs_dict = {}
+    expanded_pdf_symbols = []
+
+    max_expansion_order = spatial_derivative_orders[1] if spatial_derivative_orders else 10
+    for pdf_name, startOrder, stopOrder in pdfs:
+        if isinstance(pdf_name, sp.Symbol):
+            pdf_name = pdf_name.name
+        expanded_pdf_symbols += [expanded_symbol(pdf_name, superscript=i, **kwargs)
+                                 for i in range(startOrder, stopOrder)]
+        subs_dict[sp.Symbol(pdf_name, **kwargs)] = sum(eps ** i * expanded_symbol(pdf_name, superscript=i, **kwargs)
+                                                       for i in range(startOrder, stopOrder))
+        max_expansion_order = max(max_expansion_order, stopOrder)
+    equation = equation.subs(subs_dict)
+    equation = expand_using_linearity(equation, functions=expanded_pdf_symbols).expand().collect(eps)
+    result = {eps_order: equation.coeff(eps ** eps_order) for eps_order in range(1, 2*max_expansion_order)}
     result[0] = equation.subs(eps, 0)
     return result
 
 
-def matchEquationsToNavierStokes(conservationEquations, rho=sp.Symbol("rho"), u=sp.symbols("u_:3"), t=sp.Symbol("t")):
-    dim = len(conservationEquations) - 1
+def match_to_navier_stokes(conservation_equations, rho=sp.Symbol("rho"), u=sp.symbols("u_:3"), t=sp.Symbol("t")):
+    dim = len(conservation_equations) - 1
     u = u[:dim]
     funcs = u + (rho,)
 
-    def diffSimplify(eq):
+    def diff_simplify(eq):
         variables = eq.atoms(CeMoment)
         variables.update(funcs)
-        return expandUsingProductRule(expandUsingLinearity(eq, variables)).expand()
-
-    def matchContinuityEq(continuityEq):
-        continuityEq = diffSimplify(continuityEq)
-        compressible = u[0] * Diff(rho, 0) in continuityEq.args
-        factor = rho if compressible else 1
-        refContinuityEq = diffSimplify(Diff(rho, t) + sum(Diff(factor * u[i], i) for i in range(dim)))
-        return refContinuityEq - continuityEq, compressible
-
-    def matchMomentEqs(momentEqs, compressible):
-        shearAndPressureEqs = []
-        for i, momEq in enumerate(momentEqs):
-            factor = rho if compressible else 1
-            ref = diffSimplify(Diff(factor * u[i], t) + sum(Diff(factor * u[i] * u[j], j) for j in range(dim)))
-            shearAndPressureEqs.append(diffSimplify(momentEqs[i]) - ref)
+        return expand_using_product_rule(expand_using_linearity(eq, variables)).expand()
+
+    def match_continuity_eq(continuity_eq):
+        continuity_eq = diff_simplify(continuity_eq)
+        is_compressible = u[0] * Diff(rho, 0) in continuity_eq.args
+        factor = rho if is_compressible else 1
+        ref_continuity_eq = diff_simplify(Diff(rho, t) + sum(Diff(factor * u[i], i) for i in range(dim)))
+        return ref_continuity_eq - continuity_eq, is_compressible
+
+    def match_moment_eqs(moment_eqs, is_compressible):
+        shear_and_pressure_eqs = []
+        for i, momEq in enumerate(moment_eqs):
+            factor = rho if is_compressible else 1
+            ref = diff_simplify(Diff(factor * u[i], t) + sum(Diff(factor * u[i] * u[j], j) for j in range(dim)))
+            shear_and_pressure_eqs.append(diff_simplify(moment_eqs[i]) - ref)
 
         # new_filtered pressure term
-        coefficentArgSets = []
-        for i, eq in enumerate(shearAndPressureEqs):
-            coefficentArgSets.append(set())
+        coefficient_arg_sets = []
+        for i, eq in enumerate(shear_and_pressure_eqs):
+            coefficient_arg_sets.append(set())
             eq = eq.expand()
             assert eq.func == sp.Add
             for term in eq.args:
                 if term.atoms(CeMoment):
                     continue
-                candidateList = [e for e in term.atoms(Diff) if e.target == i]
-                if len(candidateList) != 1:
+                candidate_list = [e for e in term.atoms(Diff) if e.target == i]
+                if len(candidate_list) != 1:
                     continue
-                coefficentArgSets[i].add((term / candidateList[0], candidateList[0].arg))
-        pressureTerms = set.intersection(*coefficentArgSets)
+                coefficient_arg_sets[i].add((term / candidate_list[0], candidate_list[0].arg))
+        pressure_terms = set.intersection(*coefficient_arg_sets)
 
         sigma = sp.zeros(dim)
-        errorTerms = []
-        for i, shearAndPressureEq in enumerate(shearAndPressureEqs):
-            eqWithoutPressure = shearAndPressureEq - sum(coeff * Diff(arg, i) for coeff, arg in pressureTerms)
-            for d in eqWithoutPressure.atoms(Diff):
-                eqWithoutPressure = eqWithoutPressure.collect(d)
-                sigma[i, d.target] += eqWithoutPressure.coeff(d) * d.arg
-                eqWithoutPressure = eqWithoutPressure.subs(d, 0)
+        error_terms = []
+        for i, shearAndPressureEq in enumerate(shear_and_pressure_eqs):
+            eq_without_pressure = shearAndPressureEq - sum(coeff * Diff(arg, i) for coeff, arg in pressure_terms)
+            for d in eq_without_pressure.atoms(Diff):
+                eq_without_pressure = eq_without_pressure.collect(d)
+                sigma[i, d.target] += eq_without_pressure.coeff(d) * d.arg
+                eq_without_pressure = eq_without_pressure.subs(d, 0)
 
-            errorTerms.append(eqWithoutPressure)
-        pressure = [coeff * arg for coeff, arg in pressureTerms]
+            error_terms.append(eq_without_pressure)
+        pressure = [coeff * arg for coeff, arg in pressure_terms]
 
-        return pressure, sigma, errorTerms
+        return pressure, sigma, error_terms
 
-    continuityErrorTerms, compressible = matchContinuityEq(conservationEquations[0])
-    pressure, sigma, momentErrorTerms = matchMomentEqs(conservationEquations[1:], compressible)
+    continuity_error_terms, compressible = match_continuity_eq(conservation_equations[0])
+    pressure, sigma, moment_error_terms = match_moment_eqs(conservation_equations[1:], compressible)
 
-    errorTerms = [continuityErrorTerms] + momentErrorTerms
-    for et in errorTerms:
+    error_terms = [continuity_error_terms] + moment_error_terms
+    for et in error_terms:
         assert et == 0
 
     return compressible, pressure, sigma
 
 
-@diskcache
-def computeHigherOrderMomentSubsDict(momentEquations):
-    oEpsWithoutTimeDiffs, timeDiffSubstitutions = chainSolveAndSubstitute(momentEquations, timeDiffSelector)
-    momentsToSolveFor = set()
+@disk_cache
+def compute_higher_order_moment_subs_dict(moment_equations):
+    o_eps_without_time_diffs, time_diff_substitutions = chain_solve_and_substitute(moment_equations, time_diff_selector)
+    moments_to_solve_for = set()
     pi_ab_equations = []
-    for eq in oEpsWithoutTimeDiffs:
-        foundMoments = momentSelector(eq)
-        if foundMoments:
-            momentsToSolveFor.update(foundMoments)
+    for eq in o_eps_without_time_diffs:
+        found_moments = moment_selector(eq)
+        if found_moments:
+            moments_to_solve_for.update(found_moments)
             pi_ab_equations.append(eq)
-    return sp.solve(pi_ab_equations, momentsToSolveFor)
+    return sp.solve(pi_ab_equations, moments_to_solve_for)
 
 
 class ChapmanEnskogAnalysis(object):
 
     def __init__(self, method, constants=None):
-        cqc = method.conservedQuantityComputation
+        cqc = method.conserved_quantity_computation
         self._method = method
-        self._momentCache = LbMethodEqMoments(method)
+        self._moment_cache = LbMethodEqMoments(method)
         self.rho = cqc.defined_symbols(order=0)[1]
         self.u = cqc.defined_symbols(order=1)[1]
         self.t = sp.Symbol("t")
         self.epsilon = sp.Symbol("epsilon")
 
-        tayloredLbEq = getTaylorExpandedLbEquation(dim=self._method.dim)
-        self.equationsGroupedByOrder = useChapmanEnskogAnsatz(tayloredLbEq)
+        taylored_lb_eq = get_taylor_expanded_lb_equation(dim=self._method.dim)
+        self.equations_by_order = use_chapman_enskog_ansatz(taylored_lb_eq)
 
         # Taking moments
-        c = sp.Matrix([expandedSymbol("c", subscript=i) for i in range(self._method.dim)])
-        momentsUntilOrder1 = [1] + list(c)
-        momentsOrder2 = [c_i * c_j for c_i, c_j in symmetric_product(c, c)]
+        c = sp.Matrix([expanded_symbol("c", subscript=i) for i in range(self._method.dim)])
+        moments_until_order1 = [1] + list(c)
+        moments_order2 = [c_i * c_j for c_i, c_j in symmetric_product(c, c)]
 
-        symbolicRelaxationRates = [rr for rr in method.relaxationRates if isinstance(rr, sp.Symbol)]
+        symbolic_relaxation_rates = [rr for rr in method.relaxation_rates if isinstance(rr, sp.Symbol)]
         if constants is None:
-            constants = set(symbolicRelaxationRates)
+            constants = set(symbolic_relaxation_rates)
         else:
-            constants.update(symbolicRelaxationRates)
+            constants.update(symbolic_relaxation_rates)
 
-        oEpsMoments1 = [expandUsingLinearity(self._takeAndInsertMoments(self.equationsGroupedByOrder[1] * moment),
-                                             constants=constants)
-                        for moment in momentsUntilOrder1]
-        oEpsMoments2 = [expandUsingLinearity(self._takeAndInsertMoments(self.equationsGroupedByOrder[1] * moment),
-                                             constants=constants)
-                        for moment in momentsOrder2]
-        oEpsSqMoments1 = [expandUsingLinearity(self._takeAndInsertMoments(self.equationsGroupedByOrder[2] * moment),
-                                               constants=constants)
-                          for moment in momentsUntilOrder1]
+        o_eps_moments1 = [expand_using_linearity(self._take_and_insert_moments(self.equations_by_order[1] * moment),
+                                                 constants=constants)
+                          for moment in moments_until_order1]
+        o_eps_moments2 = [expand_using_linearity(self._take_and_insert_moments(self.equations_by_order[1] * moment),
+                                                 constants=constants)
+                          for moment in moments_order2]
+        o_eps_sq_moments1 = [expand_using_linearity(self._take_and_insert_moments(self.equations_by_order[2] * moment),
+                                                    constants=constants)
+                             for moment in moments_until_order1]
 
-        self._equationsWithHigherOrderMoments = [self._ceRecombine(ord1 * self.epsilon + ord2 * self.epsilon ** 2)
-                                                 for ord1, ord2 in zip(oEpsMoments1, oEpsSqMoments1)]
+        self._equationsWithHigherOrderMoments = [self._ce_recombine(ord1 * self.epsilon + ord2 * self.epsilon ** 2)
+                                                 for ord1, ord2 in zip(o_eps_moments1, o_eps_sq_moments1)]
 
-        self.higherOrderMomentSubsDict = computeHigherOrderMomentSubsDict(tuple(oEpsMoments1 + oEpsMoments2))
+        self.higherOrderMomentSubsDict = compute_higher_order_moment_subs_dict(tuple(o_eps_moments1 + o_eps_moments2))
 
         # Match to Navier stokes
-        compressible, pressure, sigma = matchEquationsToNavierStokes(self._equationsWithHigherOrderMoments)
+        compressible, pressure, sigma = match_to_navier_stokes(self._equationsWithHigherOrderMoments)
         self.compressible = compressible
         self.pressureEquation = pressure
         self._sigmaWithHigherOrderMoments = sigma
-        self._sigma = sigma.subs(self.higherOrderMomentSubsDict).expand().applyfunc(self._ceRecombine)
-        self._sigmaWithoutErrorTerms = removeErrorTerms(self._sigma)
+        self._sigma = sigma.subs(self.higherOrderMomentSubsDict).expand().applyfunc(self._ce_recombine)
+        self._sigmaWithoutErrorTerms = remove_error_terms(self._sigma)
 
-    def getMacroscopicEquations(self, substituteHigherOrderMoments=False):
-        if substituteHigherOrderMoments:
+    def get_macroscopic_equations(self, substitute_higher_order_moments=False):
+        if substitute_higher_order_moments:
             return self._equationsWithHigherOrderMoments.subs(self.higherOrderMomentSubsDict)
         else:
             return self._equationsWithHigherOrderMoments
 
-    def getViscousStressTensor(self, substituteHigherOrderMoments=True):
-        if substituteHigherOrderMoments:
+    def get_viscous_stress_tensor(self, substitute_higher_order_moments=True):
+        if substitute_higher_order_moments:
             return self._sigma
         else:
             return self._sigmaWithHigherOrderMoments
 
-    def _takeAndInsertMoments(self, eq):
-        eq = takeMoments(eq)
-        eq = substituteCollisionOperatorMoments(eq, self._momentCache)
-        return insertMoments(eq, self._momentCache).expand()
+    def _take_and_insert_moments(self, eq):
+        eq = take_moments(eq)
+        eq = substitute_collision_operator_moments(eq, self._moment_cache)
+        return insert_moments(eq, self._moment_cache).expand()
 
-    def _ceRecombine(self, expr):
-        expr = chapmanEnskogDerivativeRecombination(expr, self.t, stopOrder=3)
+    def _ce_recombine(self, expr):
+        expr = chapman_enskog_derivative_recombination(expr, self.t, stop_order=3)
         for l in range(self._method.dim):
-            expr = chapmanEnskogDerivativeRecombination(expr, l, stopOrder=2)
+            expr = chapman_enskog_derivative_recombination(expr, l, stop_order=2)
         return expr
 
-    def getDynamicViscosity(self):
-        candidates = self.getShearViscosityCandidates()
+    def get_dynamic_viscosity(self):
+        candidates = self.get_shear_viscosity_candidates()
         if len(candidates) != 1:
             raise ValueError("Could not find expression for kinematic viscosity. "
                              "Probably method does not approximate Navier Stokes.")
         return candidates.pop()
 
-    def getKinematicViscosity(self):
+    def get_kinematic_viscosity(self):
         if self.compressible:
-            return (self.getDynamicViscosity() / self.rho).expand()
+            return (self.get_dynamic_viscosity() / self.rho).expand()
         else:
-            return self.getDynamicViscosity()
+            return self.get_dynamic_viscosity()
 
-    def getShearViscosityCandidates(self):
+    def get_shear_viscosity_candidates(self):
         result = set()
         dim = self._method.dim
         for i, j in symmetric_product(range(dim), range(dim), with_diagonal=False):
             result.add(-sp.cancel(self._sigmaWithoutErrorTerms[i, j] / (Diff(self.u[i], j) + Diff(self.u[j], i))))
         return result
 
-    def doesApproximateNavierStokes(self):
+    def does_approximate_navier_stokes(self):
         """Returns a set of equations that are required in order for the method to approximate Navier Stokes equations
         up to second order"""
         conditions = set([0])
@@ -553,59 +557,59 @@ class ChapmanEnskogAnalysis(object):
         assert dim > 1
         # Check that shear viscosity does not depend on any u derivatives - create conditions (equations) that
         # have to be fulfilled for this to be the case
-        viscosityReference = self._sigmaWithoutErrorTerms[0, 1].expand().coeff(Diff(self.u[0], 1))
+        viscosity_reference = self._sigmaWithoutErrorTerms[0, 1].expand().coeff(Diff(self.u[0], 1))
         for i, j in symmetric_product(range(dim), range(dim), with_diagonal=False):
             term = self._sigmaWithoutErrorTerms[i, j]
-            equalCrossTermCondition = sp.expand(term.coeff(Diff(self.u[i], j)) - viscosityReference)
+            equal_cross_term_condition = sp.expand(term.coeff(Diff(self.u[i], j)) - viscosity_reference)
             term = term.subs({Diff(self.u[i], j): 0,
                               Diff(self.u[j], i): 0})
 
-            conditions.add(equalCrossTermCondition)
+            conditions.add(equal_cross_term_condition)
             for k in range(dim):
-                symmetricTermCondition = term.coeff(Diff(self.u[k], k))
-                conditions.add(symmetricTermCondition)
+                symmetric_term_condition = term.coeff(Diff(self.u[k], k))
+                conditions.add(symmetric_term_condition)
             term = term.subs({Diff(self.u[k], k): 0 for k in range(dim)})
             conditions.add(term)
 
-        bulkCandidates = list(self.getBulkViscosityCandidates(-viscosityReference))
-        if len(bulkCandidates) > 0:
-            for i in range(1, len(bulkCandidates)):
-                conditions.add(bulkCandidates[0] - bulkCandidates[i])
+        bulk_candidates = list(self.get_bulk_viscosity_candidates(-viscosity_reference))
+        if len(bulk_candidates) > 0:
+            for i in range(1, len(bulk_candidates)):
+                conditions.add(bulk_candidates[0] - bulk_candidates[i])
 
         return conditions
 
-    def getBulkViscosityCandidates(self, viscosity=None):
+    def get_bulk_viscosity_candidates(self, viscosity=None):
         sigma = self._sigmaWithoutErrorTerms
         assert self._sigmaWithHigherOrderMoments.is_square
         result = set()
         if viscosity is None:
-            viscosity = self.getDynamicViscosity()
+            viscosity = self.get_dynamic_viscosity()
         for i in range(sigma.shape[0]):
-            bulkTerm = sigma[i, i] + 2 * viscosity * Diff(self.u[i], i)
-            bulkTerm = bulkTerm.expand()
-            for d in bulkTerm.atoms(Diff):
-                bulkTerm = bulkTerm.collect(d)
-                result.add(bulkTerm.coeff(d))
-                bulkTerm = bulkTerm.subs(d, 0)
-            if bulkTerm != 0:
+            bulk_term = sigma[i, i] + 2 * viscosity * Diff(self.u[i], i)
+            bulk_term = bulk_term.expand()
+            for d in bulk_term.atoms(Diff):
+                bulk_term = bulk_term.collect(d)
+                result.add(bulk_term.coeff(d))
+                bulk_term = bulk_term.subs(d, 0)
+            if bulk_term != 0:
                 return set()
         if len(result) == 0:
             result.add(0)
         return result
 
-    def getBulkViscosity(self):
-        candidates = self.getBulkViscosityCandidates()
+    def get_bulk_viscosity(self):
+        candidates = self.get_bulk_viscosity_candidates()
         if len(candidates) != 1:
             raise ValueError("Could not find expression for bulk viscosity. "
                              "Probably method does not approximate Navier Stokes.")
 
-        viscosity = self.getDynamicViscosity()
+        viscosity = self.get_dynamic_viscosity()
         return (candidates.pop() + 2 * viscosity / 3).expand()
 
-    def relaxationRateFromKinematicViscosity(self, nu):
-        kinematicViscosity = self.getKinematicViscosity()
-        solveRes = sp.solve(kinematicViscosity - nu, kinematicViscosity.atoms(sp.Symbol), dict=True)
-        return solveRes[0]
+    def relaxation_rate_from_kinematic_viscosity(self, nu):
+        kinematic_viscosity = self.get_kinematic_viscosity()
+        solve_res = sp.solve(kinematic_viscosity - nu, kinematic_viscosity.atoms(sp.Symbol), dict=True)
+        return solve_res[0]
 
 
 class SteadyStateChapmanEnskogAnalysis(object):
@@ -617,38 +621,38 @@ class SteadyStateChapmanEnskogAnalysis(object):
     def __init__(self, method, order=4):
         self.method = method
         dim = method.dim
-        momentComputation = LbMethodEqMoments(method)
+        moment_computation = LbMethodEqMoments(method)
 
         eps, B, f, dt = sp.symbols("epsilon B f Delta_t")
         self.dt = dt
-        expandedPdfSymbols = [expandedSymbol("f", superscript=i) for i in range(0, order + 1)]
-        feq = expandedPdfSymbols[0]
-        c = sp.Matrix([expandedSymbol("c", subscript=i) for i in range(dim)])
-        Dx = sp.Matrix([DiffOperator(target=l) for l in range(dim)])
-        differentialOperator = sum((dt * eps * c.dot(Dx)) ** n / sp.factorial(n) for n in range(1, order + 1))
-        taylorExpansion = DiffOperator.apply(differentialOperator.expand(), f, applyToConstants=False)
-        epsDict = useChapmanEnskogAnsatz(taylorExpansion,
-                                         spatialDerivativeOrders=None,  # do not expand the differential operator itself
-                                         pdfs=(['f', 0, order + 1],))  # expand only the 'f' terms
-
-        self.scaleHierarchy = [-B * epsDict[i] for i in range(0, order+1)]
+        expanded_pdf_symbols = [expanded_symbol("f", superscript=i) for i in range(0, order + 1)]
+        feq = expanded_pdf_symbols[0]
+        c = sp.Matrix([expanded_symbol("c", subscript=i) for i in range(dim)])
+        dx = sp.Matrix([DiffOperator(target=l) for l in range(dim)])
+        differential_operator = sum((dt * eps * c.dot(dx)) ** n / sp.factorial(n) for n in range(1, order + 1))
+        taylor_expansion = DiffOperator.apply(differential_operator.expand(), f, apply_to_constants=False)
+        eps_dict = use_chapman_enskog_ansatz(taylor_expansion,
+                                             spatial_derivative_orders=None,  # do not expand the differential operator
+                                             pdfs=(['f', 0, order + 1],))  # expand only the 'f' terms
+
+        self.scaleHierarchy = [-B * eps_dict[i] for i in range(0, order+1)]
         self.scaleHierarchyRaw = self.scaleHierarchy.copy()
 
-        expandedPdfs = [feq, self.scaleHierarchy[1]]
-        subsDict = {expandedPdfSymbols[1]: self.scaleHierarchy[1]}
+        expanded_pdfs = [feq, self.scaleHierarchy[1]]
+        subs_dict = {expanded_pdf_symbols[1]: self.scaleHierarchy[1]}
         for i in range(2, 5):
-            eq = self.scaleHierarchy[i].subs(subsDict)
-            eq = expandUsingLinearity(eq, functions=expandedPdfSymbols)
-            eq = normalizeDiffOrder(eq, functions=expandedPdfSymbols)
-            subsDict[expandedPdfSymbols[i]] = eq
-            expandedPdfs.append(eq)
-        self.scaleHierarchy = expandedPdfs
-
-        constants = sp.Matrix(method.relaxationRates).atoms(sp.Symbol)
+            eq = self.scaleHierarchy[i].subs(subs_dict)
+            eq = expand_using_linearity(eq, functions=expanded_pdf_symbols)
+            eq = normalize_diff_order(eq, functions=expanded_pdf_symbols)
+            subs_dict[expanded_pdf_symbols[i]] = eq
+            expanded_pdfs.append(eq)
+        self.scaleHierarchy = expanded_pdfs
+
+        constants = sp.Matrix(method.relaxation_rates).atoms(sp.Symbol)
         recombined = -sum(self.scaleHierarchy[n] for n in range(1, order + 1))  # Eq 18a
         recombined = sp.cancel(recombined / (dt * B)).expand()  # cancel common factors
 
-        def handlePostcollisionValues(eq):
+        def handle_postcollision_values(eq):
             eq = eq.expand()
             assert isinstance(eq, sp.Add)
             result = 0
@@ -656,54 +660,54 @@ class SteadyStateChapmanEnskogAnalysis(object):
 
                 moment = summand.atoms(CeMoment)
                 moment = moment.pop()
-                collisionOperatorExponent = normalize_product(summand).count(B)
-                if collisionOperatorExponent == 0:
+                collision_operator_exponent = normalize_product(summand).count(B)
+                if collision_operator_exponent == 0:
                     result += summand
                 else:
                     substitutions = {
                         B: 1,
-                        moment: -momentComputation.getPostCollisionMoment(moment, -collisionOperatorExponent),
+                        moment: -moment_computation.get_post_collision_moment(moment, -collision_operator_exponent),
                     }
                     result += summand.subs(substitutions)
 
             return result
 
         # Continuity equation (mass transport)
-        contEq = takeMoments(recombined, maxExpansion=(order + 1) * 2)
-        contEq = handlePostcollisionValues(contEq)
-        contEq = expandUsingLinearity(contEq, constants=constants).expand().collect(dt)
-        self.continuityEquationWithMoments = contEq
-        contEq = insertMoments(contEq, momentComputation, useSolvabilityConditions=False)
-        contEq = expandUsingLinearity(contEq, constants=constants).expand().collect(dt)
-        self.continuityEquation = contEq
+        cont_eq = take_moments(recombined, max_expansion=(order + 1) * 2)
+        cont_eq = handle_postcollision_values(cont_eq)
+        cont_eq = expand_using_linearity(cont_eq, constants=constants).expand().collect(dt)
+        self.continuityEquationWithMoments = cont_eq
+        cont_eq = insert_moments(cont_eq, moment_computation, use_solvability_conditions=False)
+        cont_eq = expand_using_linearity(cont_eq, constants=constants).expand().collect(dt)
+        self.continuityEquation = cont_eq
 
         # Momentum equation (momentum transport)
         self.momentumEquationsWithMoments = []
         self.momentumEquations = []
         for h in range(dim):
-            momEq = takeMoments(recombined * c[h], maxExpansion=(order + 1) * 2)
-            momEq = handlePostcollisionValues(momEq)
-            momEq = expandUsingLinearity(momEq, constants=constants).expand().collect(dt)
-            self.momentumEquationsWithMoments.append(momEq)
-            momEq = insertMoments(momEq, momentComputation, useSolvabilityConditions=False)
-            momEq = expandUsingLinearity(momEq, constants=constants).expand().collect(dt)
-            self.momentumEquations.append(momEq)
-
-    def getMassTransportEquation(self, order):
+            mom_eq = take_moments(recombined * c[h], max_expansion=(order + 1) * 2)
+            mom_eq = handle_postcollision_values(mom_eq)
+            mom_eq = expand_using_linearity(mom_eq, constants=constants).expand().collect(dt)
+            self.momentumEquationsWithMoments.append(mom_eq)
+            mom_eq = insert_moments(mom_eq, moment_computation, use_solvability_conditions=False)
+            mom_eq = expand_using_linearity(mom_eq, constants=constants).expand().collect(dt)
+            self.momentumEquations.append(mom_eq)
+
+    def get_mass_transport_equation(self, order):
         if order == 0:
             result = self.continuityEquation.subs(self.dt, 0)
         else:
             result = self.continuityEquation.coeff(self.dt ** order)
-        return collectDerivatives(result)
+        return collect_derivatives(result)
 
-    def getMomentumTransportEquation(self, coordinate, order):
+    def get_momentum_transport_equation(self, coordinate, order):
         if order == 0:
             result = self.momentumEquations[coordinate].subs(self.dt, 0)
         else:
             result = self.momentumEquations[coordinate].coeff(self.dt ** order)
-        return collectDerivatives(result)
+        return collect_derivatives(result)
 
-    def determineViscosities(self, coordinate):
+    def determine_viscosities(self, coordinate):
         """
         Matches the first order term of the momentum equation to Navier stokes
         Automatically neglects higher order velocity terms and rho derivatives
@@ -715,28 +719,27 @@ class SteadyStateChapmanEnskogAnalysis(object):
         """
         dim = self.method.dim
 
-        D = createNestedDiff
+        D = create_nested_diff
         s = functools.partial(multidimensional_sum, dim=dim)
         kd = kronecker_delta
 
         eta, eta_b = sp.symbols("nu nu_B")
         u = sp.symbols("u_:3")[:dim]
         a = coordinate
-        navierStokesRef = eta * sum(D(b, b, arg=u[a]) + D(b, a, arg=u[b]) for b, in s(1)) + \
-                          (eta_b - 2 * eta / 3) * sum(D(b, g, arg=u[g]) * kd(a, b) for b, g in s(2))
-        navierStokesRef = -navierStokesRef.expand()
+        navier_stokes_ref = eta * sum(D(b, b, arg=u[a]) + D(b, a, arg=u[b]) for b, in s(1)) + \
+                            (eta_b - 2 * eta / 3) * sum(D(b, g, arg=u[g]) * kd(a, b) for b, g in s(2))
+        navier_stokes_ref = -navier_stokes_ref.expand()
+
+        first_order_terms = self.get_momentum_transport_equation(coordinate, order=1)
+        first_order_terms = remove_higher_order_u(first_order_terms)
+        first_order_terms = expand_using_linearity(first_order_terms, constants=[sp.Symbol("rho")])
+
+        match_coeff_equations = []
+        for diff in navier_stokes_ref.atoms(Diff):
+            match_coeff_equations.append(navier_stokes_ref.coeff(diff) - first_order_terms.coeff(diff))
+        return sp.solve(match_coeff_equations, [eta, eta_b])
+
 
-        firstOrderTerms = self.getMomentumTransportEquation(coordinate, order=1)
-        firstOrderTerms = removeHigherOrderU(firstOrderTerms)
-        firstOrderTerms = expandUsingLinearity(firstOrderTerms, constants=[sp.Symbol("rho")])
 
-        matchCoeffEquations = []
-        for diff in navierStokesRef.atoms(Diff):
-            matchCoeffEquations.append(navierStokesRef.coeff(diff) - firstOrderTerms.coeff(diff))
-        return sp.solve(matchCoeffEquations, [eta, eta_b])
 
 
-if __name__ == '__main__':
-    from lbmpy.creationfunctions import createLatticeBoltzmannMethod
-    m = createLatticeBoltzmannMethod(stencil='D2Q9')
-    ce = ChapmanEnskogAnalysis(m)
\ No newline at end of file
diff --git a/chapman_enskog/chapman_enskog_higher_order.py b/chapman_enskog/chapman_enskog_higher_order.py
index 33e9fedb66210b62268aa65d8d886831534a13e4..16ea7e30030518c60d9861c570eeca6de31d816d 100644
--- a/chapman_enskog/chapman_enskog_higher_order.py
+++ b/chapman_enskog/chapman_enskog_higher_order.py
@@ -1,15 +1,15 @@
 import sympy as sp
-from lbmpy.chapman_enskog import CeMoment, Diff, takeMoments
-from lbmpy.chapman_enskog.derivative import fullDiffExpand
-from lbmpy.chapman_enskog.chapman_enskog import expandedSymbol
-from lbmpy.moments import momentsUpToOrder, momentsOfOrder
+from lbmpy.chapman_enskog import CeMoment, Diff, take_moments
+from lbmpy.chapman_enskog.derivative import full_diff_expand
+from lbmpy.chapman_enskog.chapman_enskog import expanded_symbol
+from lbmpy.moments import moments_up_to_order, moments_of_order
 from collections import OrderedDict
 
 
 def polyMoments(order, dim):
     from pystencils.sympyextensions import prod
-    c = sp.Matrix([expandedSymbol("c", subscript=i) for i in range(dim)])
-    return [prod(c_i ** m_i for c_i, m_i in zip(c, m)) for m in momentsOfOrder(order, dim=dim)]
+    c = sp.Matrix([expanded_symbol("c", subscript=i) for i in range(dim)])
+    return [prod(c_i ** m_i for c_i, m_i in zip(c, m)) for m in moments_of_order(order, dim=dim)]
 
 
 def specialLinSolve(eqs, dofs):
@@ -31,7 +31,7 @@ def specialLinSolve(eqs, dofs):
 def getSolvabilityConditions(dim, order):
     solvabilityConditions = {}
     for name in ["\Pi", "\\Upsilon"]:
-        for momentTuple in momentsUpToOrder(1, dim=dim):
+        for momentTuple in moments_up_to_order(1, dim=dim):
             for k in range(order+1):
                 solvabilityConditions[CeMoment(name, superscript=k, momentTuple=momentTuple)] = 0
     return solvabilityConditions
@@ -41,10 +41,10 @@ def determineHigherOrderMoments(epsilonHierarchy, relaxationRates, momentComputa
     solvabilityConditions = getSolvabilityConditions(dim, order)
 
     def fullExpand(expr):
-        return fullDiffExpand(expr, constants=relaxationRates)
+        return full_diff_expand(expr, constants=relaxationRates)
 
     def tm(expr):
-        expr = takeMoments(expr, useOneNeighborhoodAliasing=True)
+        expr = take_moments(expr, use_one_neighborhood_aliasing=True)
         return momentComputation.substitute(expr).subs(solvabilityConditions)
 
     timeDiffs = OrderedDict()
diff --git a/chapman_enskog/derivative.py b/chapman_enskog/derivative.py
index 0c8bf2c3daaeedc3ae8f6b8d8b51857394df49f6..f37e2ca9305dc794fe0a1b824bb2caca091bb9d0 100644
--- a/chapman_enskog/derivative.py
+++ b/chapman_enskog/derivative.py
@@ -1,21 +1,21 @@
 from pystencils.derivative import *
 
 
-def chapmanEnskogDerivativeExpansion(expr, label, eps=sp.Symbol("epsilon"), startOrder=1, stopOrder=4):
+def chapman_enskog_derivative_expansion(expr, label, eps=sp.Symbol("epsilon"), start_order=1, stop_order=4):
     """Substitutes differentials with given target and no superscript by the sum:
-    eps**(startOrder) * Diff(superscript=startOrder)   + ... + eps**(stopOrder) * Diff(superscript=stopOrder)"""
+    eps**(start_order) * Diff(superscript=start_order)   + ... + eps**(stop_order) * Diff(superscript=stop_order)"""
     diffs = [d for d in expr.atoms(Diff) if d.target == label]
-    subsDict = {d: sum([eps ** i * Diff(d.arg, d.target, i) for i in range(startOrder, stopOrder)])
-                for d in diffs}
-    return expr.subs(subsDict)
+    subs_dict = {d: sum([eps ** i * Diff(d.arg, d.target, i) for i in range(start_order, stop_order)])
+                 for d in diffs}
+    return expr.subs(subs_dict)
 
 
-def chapmanEnskogDerivativeRecombination(expr, label, eps=sp.Symbol("epsilon"), startOrder=1, stopOrder=4):
-    """Inverse operation of 'chapmanEnskogDerivativeExpansion'"""
+def chapman_enskog_derivative_recombination(expr, label, eps=sp.Symbol("epsilon"), start_order=1, stop_order=4):
+    """Inverse operation of 'chapman_enskog_derivative_expansion'"""
     expr = expr.expand()
-    diffs = [d for d in expr.atoms(Diff) if d.target == label and d.superscript == stopOrder - 1]
+    diffs = [d for d in expr.atoms(Diff) if d.target == label and d.superscript == stop_order - 1]
     for d in diffs:
         substitution = Diff(d.arg, label)
-        substitution -= sum([eps ** i * Diff(d.arg, label, i) for i in range(startOrder, stopOrder - 1)])
-        expr = expr.subs(d, substitution / eps**(stopOrder-1))
-    return expr
\ No newline at end of file
+        substitution -= sum([eps ** i * Diff(d.arg, label, i) for i in range(start_order, stop_order - 1)])
+        expr = expr.subs(d, substitution / eps ** (stop_order - 1))
+    return expr
diff --git a/chapman_enskog/steady_state.py b/chapman_enskog/steady_state.py
index 5cc8e9747ee314207cbfead271d72e65c40cc0f8..6f321988a2b1d3def5deed74ec6c2e43f1b9b412 100644
--- a/chapman_enskog/steady_state.py
+++ b/chapman_enskog/steady_state.py
@@ -1,58 +1,58 @@
 import sympy as sp
 from pystencils.sympyextensions import normalize_product
-from lbmpy.chapman_enskog.derivative import Diff, DiffOperator, expandUsingLinearity, normalizeDiffOrder
-from lbmpy.chapman_enskog.chapman_enskog import expandedSymbol, useChapmanEnskogAnsatz
+from lbmpy.chapman_enskog.derivative import Diff, DiffOperator, expand_using_linearity, normalize_diff_order
+from lbmpy.chapman_enskog.chapman_enskog import expanded_symbol, use_chapman_enskog_ansatz
 
 
 class SteadyStateChapmanEnskogAnalysis(object):
 
-    def __init__(self, method, forceModelClass=None, order=4):
+    def __init__(self, method, force_model_class=None, order=4):
         self.method = method
         self.dim = method.dim
         self.order = order
-        self.physicalVariables = list(sp.Matrix(self.method.momentEquilibriumValues).atoms(sp.Symbol))  # rho, u..
+        self.physicalVariables = list(sp.Matrix(self.method.moment_equilibrium_values).atoms(sp.Symbol))  # rho, u..
         self.eps = sp.Symbol("epsilon")
 
-        self.fSym = sp.Symbol("f", commutative=False)
-        self.fSyms = [expandedSymbol("f", superscript=i, commutative=False) for i in range(order + 1)]
+        self.f_sym = sp.Symbol("f", commutative=False)
+        self.f_syms = [expanded_symbol("f", superscript=i, commutative=False) for i in range(order + 1)]
         self.collisionOpSym = sp.Symbol("A", commutative=False)
-        self.forceSym = sp.Symbol("F_q", commutative=False)
-        self.velocitySyms = sp.Matrix([expandedSymbol("c", subscript=i, commutative=False) for i in range(self.dim)])
+        self.force_sym = sp.Symbol("F_q", commutative=False)
+        self.velocity_syms = sp.Matrix([expanded_symbol("c", subscript=i, commutative=False) for i in range(self.dim)])
 
         self.F_q = [0] * len(self.method.stencil)
-        self.forceModel = None
-        if forceModelClass:
-            accelerationSymbols = sp.symbols("a_:%d" % (self.dim,), commutative=False)
-            self.physicalVariables += accelerationSymbols
-            self.forceModel = forceModelClass(accelerationSymbols)
-            self.F_q = self.forceModel(self.method)
+        self.force_model = None
+        if force_model_class:
+            acceleration_symbols = sp.symbols("a_:%d" % (self.dim,), commutative=False)
+            self.physicalVariables += acceleration_symbols
+            self.force_model = force_model_class(acceleration_symbols)
+            self.F_q = self.force_model(self.method)
 
         # Perform the analysis
-        self.tayloredEquation = self._createTaylorExpandedEquation()
-        insertedHierarchy, rawHierarchy = self._createPdfHierarchy(self.tayloredEquation)
-        self.pdfHierarchy = insertedHierarchy
-        self.pdfHierarchyRaw = rawHierarchy
-        self.recombinedEq = self._recombinePdfs(self.pdfHierarchy)
-
-        symbolsToValues = self._getSymbolsToValuesDict()
-        self.continuityEquation = self._computeContinuityEquation(self.recombinedEq, symbolsToValues)
-        self.momentumEquations = [self._computeMomentumEquation(self.recombinedEq, symbolsToValues, h)
+        self.tayloredEquation = self._create_taylor_expanded_equation()
+        inserted_hierarchy, raw_hierarchy = self._create_pdf_hierarchy(self.tayloredEquation)
+        self.pdfHierarchy = inserted_hierarchy
+        self.pdfHierarchyRaw = raw_hierarchy
+        self.recombinedEq = self._recombine_pdfs(self.pdfHierarchy)
+
+        symbols_to_values = self._get_symbols_to_values_dict()
+        self.continuityEquation = self._compute_continuity_equation(self.recombinedEq, symbols_to_values)
+        self.momentumEquations = [self._compute_momentum_equation(self.recombinedEq, symbols_to_values, h)
                                   for h in range(self.dim)]
 
-    def getPdfHierarchy(self, order, collisionOperatorSymbol=sp.Symbol("omega")):
-        def substituteNonCommutingSymbols(eq):
+    def get_pdf_hierarchy(self, order, collision_operator_symbol=sp.Symbol("omega")):
+        def substitute_non_commuting_symbols(eq):
             return eq.subs({a: sp.Symbol(a.name) for a in eq.atoms(sp.Symbol)})
-        result = self.pdfHierarchy[order].subs(self.collisionOpSym, collisionOperatorSymbol)
-        result = normalizeDiffOrder(result, functions=(self.fSyms[0], self.forceSym))
-        return substituteNonCommutingSymbols(result)
+        result = self.pdfHierarchy[order].subs(self.collisionOpSym, collision_operator_symbol)
+        result = normalize_diff_order(result, functions=(self.f_syms[0], self.force_sym))
+        return substitute_non_commuting_symbols(result)
 
-    def getContinuityEquation(self, onlyOrder=None):
-        return self._extractOrder(self.continuityEquation, onlyOrder)
+    def get_continuity_equation(self, only_order=None):
+        return self._extract_order(self.continuityEquation, only_order)
 
-    def getMomentumEquation(self, onlyOrder=None):
-        return [self._extractOrder(e, onlyOrder) for e in self.momentumEquations]
+    def get_momentum_equation(self, only_order=None):
+        return [self._extract_order(e, only_order) for e in self.momentumEquations]
 
-    def _extractOrder(self, eq, order):
+    def _extract_order(self, eq, order):
         if order is None:
             return eq
         elif order == 0:
@@ -60,99 +60,99 @@ class SteadyStateChapmanEnskogAnalysis(object):
         else:
             return eq.coeff(self.eps ** order)
 
-    def _createTaylorExpandedEquation(self):
+    def _create_taylor_expanded_equation(self):
         """
         Creates a generic, Taylor expanded lattice Boltzmann update equation with collision and force term.
         Collision operator and force terms are represented symbolically.
         """
-        c = self.velocitySyms
-        Dx = sp.Matrix([DiffOperator(target=l) for l in range(self.dim)])
+        c = self.velocity_syms
+        dx = sp.Matrix([DiffOperator(target=l) for l in range(self.dim)])
 
-        differentialOperator = sum((self.eps * c.dot(Dx)) ** n / sp.factorial(n)
-                                   for n in range(1, self.order + 1))
-        taylorExpansion = DiffOperator.apply(differentialOperator.expand(), self.fSym)
+        differential_operator = sum((self.eps * c.dot(dx)) ** n / sp.factorial(n)
+                                    for n in range(1, self.order + 1))
+        taylor_expansion = DiffOperator.apply(differential_operator.expand(), self.f_sym)
 
-        fNonEq = self.fSym - self.fSyms[0]
-        return taylorExpansion + self.collisionOpSym * fNonEq - self.eps * self.forceSym
+        f_non_eq = self.f_sym - self.f_syms[0]
+        return taylor_expansion + self.collisionOpSym * f_non_eq - self.eps * self.force_sym
 
-    def _createPdfHierarchy(self, tayloredEquation):
+    def _create_pdf_hierarchy(self, taylored_equation):
         """
         Expresses the expanded pdfs f^1, f^2, ..  as functions of the equilibrium f^0.
         Returns a list where element [1] is the equation for f^1 etc.
         """
-        chapmanEnskogHierarchy = useChapmanEnskogAnsatz(tayloredEquation, spatialDerivativeOrders=None,
-                                                        pdfs=(['f', 0, self.order + 1],), commutative=False)
-        chapmanEnskogHierarchy = [chapmanEnskogHierarchy[i] for i in range(self.order + 1)]
-
-        insertedHierarchy = []
-        rawHierarchy = []
-        substitutionDict = {}
-        for ceEq, f_i in zip(chapmanEnskogHierarchy, self.fSyms):
-            newEq = -1 / self.collisionOpSym * (ceEq - self.collisionOpSym * f_i)
-            rawHierarchy.append(newEq)
-            newEq = expandUsingLinearity(newEq.subs(substitutionDict), functions=self.fSyms + [self.forceSym])
-            if newEq:
-                substitutionDict[f_i] = newEq
-            insertedHierarchy.append(newEq)
-
-        return insertedHierarchy, rawHierarchy
-
-    def _recombinePdfs(self, pdfHierarchy):
-        return sum(pdfHierarchy[i] * self.eps**(i-1) for i in range(1, self.order+1))
-
-    def _computeContinuityEquation(self, recombinedEq, symbolsToValues):
-        return self._computeMoments(recombinedEq, symbolsToValues)
-
-    def _computeMomentumEquation(self, recombinedEq, symbolsToValues, coordinate):
-        eq = sp.expand(self.velocitySyms[coordinate] * recombinedEq)
-
-        result = self._computeMoments(eq, symbolsToValues)
-        if self.forceModel and hasattr(self.forceModel, 'equilibriumVelocityShift'):
-            compressible = self.method.conservedQuantityComputation.compressible
-            shift = self.forceModel.equilibriumVelocityShift(sp.Symbol("rho") if compressible else 1)
+        chapman_enskog_hierarchy = use_chapman_enskog_ansatz(taylored_equation, spatial_derivative_orders=None,
+                                                             pdfs=(['f', 0, self.order + 1],), commutative=False)
+        chapman_enskog_hierarchy = [chapman_enskog_hierarchy[i] for i in range(self.order + 1)]
+
+        inserted_hierarchy = []
+        raw_hierarchy = []
+        substitution_dict = {}
+        for ceEq, f_i in zip(chapman_enskog_hierarchy, self.f_syms):
+            new_eq = -1 / self.collisionOpSym * (ceEq - self.collisionOpSym * f_i)
+            raw_hierarchy.append(new_eq)
+            new_eq = expand_using_linearity(new_eq.subs(substitution_dict), functions=self.f_syms + [self.force_sym])
+            if new_eq:
+                substitution_dict[f_i] = new_eq
+            inserted_hierarchy.append(new_eq)
+
+        return inserted_hierarchy, raw_hierarchy
+
+    def _recombine_pdfs(self, pdf_hierarchy):
+        return sum(pdf_hierarchy[i] * self.eps ** (i - 1) for i in range(1, self.order + 1))
+
+    def _compute_continuity_equation(self, recombined_eq, symbols_to_values):
+        return self._compute_moments(recombined_eq, symbols_to_values)
+
+    def _compute_momentum_equation(self, recombined_eq, symbols_to_values, coordinate):
+        eq = sp.expand(self.velocity_syms[coordinate] * recombined_eq)
+
+        result = self._compute_moments(eq, symbols_to_values)
+        if self.force_model and hasattr(self.force_model, 'equilibriumVelocityShift'):
+            compressible = self.method.conserved_quantity_computation.compressible
+            shift = self.force_model.equilibriumVelocityShift(sp.Symbol("rho") if compressible else 1)
             result += shift[coordinate]
         return result
 
-    def _getSymbolsToValuesDict(self):
-        result = {1 / self.collisionOpSym: self.method.inverseCollisionMatrix,
-                  self.forceSym: sp.Matrix(self.forceModel(self.method)) if self.forceModel else 0,
-                  self.fSyms[0]: self.method.getEquilibriumTerms()}
-        for i, c_i in enumerate(self.velocitySyms):
+    def _get_symbols_to_values_dict(self):
+        result = {1 / self.collisionOpSym: self.method.inverse_collision_matrix,
+                  self.force_sym: sp.Matrix(self.force_model(self.method)) if self.force_model else 0,
+                  self.f_syms[0]: self.method.get_equilibrium_terms()}
+        for i, c_i in enumerate(self.velocity_syms):
             result[c_i] = sp.Matrix([d[i] for d in self.method.stencil])
 
         return result
 
-    def _computeMoments(self, recombinedEq, symbolsToValues):
-        eq = recombinedEq.expand()
+    def _compute_moments(self, recombined_eq, symbols_to_values):
+        eq = recombined_eq.expand()
         assert eq.func is sp.Add
 
-        newProducts = []
+        new_products = []
         for product in eq.args:
             assert product.func is sp.Mul
 
             derivative = None
 
-            newProd = 1
+            new_prod = 1
             for arg in reversed(normalize_product(product)):
                 if isinstance(arg, Diff):
                     assert derivative is None, "More than one derivative term in the product"
                     derivative = arg
-                    arg = arg.getArgRecursive()  # new argument is inner part of derivative
+                    arg = arg.get_arg_recursive()  # new argument is inner part of derivative
 
-                if arg in symbolsToValues:
-                    arg = symbolsToValues[arg]
+                if arg in symbols_to_values:
+                    arg = symbols_to_values[arg]
 
-                haveShape = hasattr(arg, 'shape') and hasattr(newProd, 'shape')
-                if haveShape and arg.shape == newProd.shape and arg.shape[1] == 1:
-                    newProd = sp.matrix_multiply_elementwise(newProd, arg)
+                have_shape = hasattr(arg, 'shape') and hasattr(new_prod, 'shape')
+                if have_shape and arg.shape == new_prod.shape and arg.shape[1] == 1:
+                    new_prod = sp.matrix_multiply_elementwise(new_prod, arg)
                 else:
-                    newProd = arg * newProd
+                    new_prod = arg * new_prod
 
-            newProd = sp.expand(sum(newProd))
+            new_prod = sp.expand(sum(new_prod))
 
             if derivative is not None:
-                newProd = derivative.changeArgRecursive(newProd)
+                new_prod = derivative.change_arg_recursive(new_prod)
 
-            newProducts.append(newProd)
+            new_products.append(new_prod)
 
-        return normalizeDiffOrder(expandUsingLinearity(sp.Add(*newProducts), functions=self.physicalVariables))
+        return normalize_diff_order(expand_using_linearity(sp.Add(*new_products), functions=self.physicalVariables))
diff --git a/continuous_distribution_measures.py b/continuous_distribution_measures.py
index c6b88c95bd89a6ccd2e9ce1fbfa41d97a3e62e75..8e69cb593d8f1565bff5dd3bc1b5ae7df51b6ce0 100644
--- a/continuous_distribution_measures.py
+++ b/continuous_distribution_measures.py
@@ -4,13 +4,13 @@
 
 import sympy as sp
 
-from lbmpy.moments import polynomialToExponentRepresentation
-from pystencils.cache import diskcache, memorycache
+from lbmpy.moments import polynomial_to_exponent_representation
+from pystencils.cache import disk_cache, memorycache
 from pystencils.sympyextensions import complete_the_squares_in_exp
 
 
 @memorycache()
-def momentGeneratingFunction(generating_function, symbols, symbolsInResult):
+def moment_generating_function(generating_function, symbols, symbols_in_result):
     """
     Computes the moment generating function of a probability distribution. It is defined as:
 
@@ -19,7 +19,7 @@ def momentGeneratingFunction(generating_function, symbols, symbolsInResult):
 
     :param generating_function: sympy expression
     :param symbols: a sequence of symbols forming the vector x
-    :param symbolsInResult: a sequence forming the vector t
+    :param symbols_in_result: a sequence forming the vector t
     :return: transformation result F: an expression that depends now on symbolsInResult
              (symbols have been integrated out)
 
@@ -31,8 +31,8 @@ def momentGeneratingFunction(generating_function, symbols, symbolsInResult):
          of functions can be integrated quickly.
 
     """
-    assert len(symbols) == len(symbolsInResult)
-    for t_i, v_i in zip(symbolsInResult, symbols):
+    assert len(symbols) == len(symbols_in_result)
+    for t_i, v_i in zip(symbols_in_result, symbols):
         generating_function *= sp.exp(t_i * v_i)
 
     # This is a custom transformation that speeds up the integrating process
@@ -52,35 +52,35 @@ def momentGeneratingFunction(generating_function, symbols, symbolsInResult):
     return sp.simplify(result)
 
 
-def cumulantGeneratingFunction(function, symbols, symbolsInResult):
+def cumulant_generating_function(func, symbols, symbols_in_result):
     """
-    Computes cumulant generating function, which is the logarithm of the moment generating function.
-    For parameter description see :func:`momentGeneratingFunction`.
+    Computes cumulant generating func, which is the logarithm of the moment generating func.
+    For parameter description see :func:`moment_generating_function`.
     """
-    return sp.ln(momentGeneratingFunction(function, symbols, symbolsInResult))
+    return sp.ln(moment_generating_function(func, symbols, symbols_in_result))
 
 
-@diskcache
-def multiDifferentiation(generatingFunction, index, symbols):
+@disk_cache
+def multi_differentiation(generating_function, index, symbols):
     """
     Computes moment from moment-generating function or cumulant from cumulant-generating function,
     by differentiating the generating function, as specified by index and evaluating the derivative at symbols=0
 
-    :param generatingFunction: function with is differentiated
+    :param generating_function: function with is differentiated
     :param index: the i'th index specifies how often to differentiate w.r.t. to symbols[i]
     :param symbols: symbol to differentiate
     """
     assert len(index) == len(symbols), "Length of index and length of symbols has to match"
 
-    diffArgs = []
+    diff_args = []
     for order, t_i in zip(index, symbols):
         for i in range(order):
-            diffArgs.append(t_i)
+            diff_args.append(t_i)
 
-    if len(diffArgs) > 0:
-        r = sp.diff(generatingFunction, *diffArgs)
+    if len(diff_args) > 0:
+        r = sp.diff(generating_function, *diff_args)
     else:
-        r = generatingFunction
+        r = generating_function
 
     for t_i in symbols:
         r = r.subs(t_i, 0)
@@ -89,7 +89,7 @@ def multiDifferentiation(generatingFunction, index, symbols):
 
 
 @memorycache(maxsize=512)
-def __continuousMomentOrCumulant(function, moment, symbols, generatingFunction):
+def __continuous_moment_or_cumulant(func, moment, symbols, generating_function):
     if type(moment) is tuple and not symbols:
         symbols = sp.symbols("xvar yvar zvar")
 
@@ -98,36 +98,34 @@ def __continuousMomentOrCumulant(function, moment, symbols, generatingFunction):
     # not using sp.Dummy here - since it prohibits caching
     t = tuple([sp.Symbol("tmpvar_%d" % i, ) for i in range(dim)])
     symbols = symbols[:dim]
-    genFunc = generatingFunction(function, symbols, t)
+    generating_function = generating_function(func, symbols, t)
 
     if type(moment) is tuple:
-        return multiDifferentiation(genFunc, moment, t)
+        return multi_differentiation(generating_function, moment, t)
     else:
         assert symbols is not None, "When passing a polynomial as moment, also the moment symbols have to be passed"
         moment = sp.sympify(moment)
 
         result = 0
-        for coefficient, exponents in polynomialToExponentRepresentation(moment, dim=dim):
-            result += coefficient * multiDifferentiation(genFunc, exponents, t)
+        for coefficient, exponents in polynomial_to_exponent_representation(moment, dim=dim):
+            result += coefficient * multi_differentiation(generating_function, exponents, t)
 
         return result
 
 
-def continuousMoment(function, moment, symbols=None):
-    """
-    Computes moment of given function
+def continuous_moment(func, moment, symbols=None):
+    """Computes moment of given function.
 
-    :param function: function to compute moments of
+    :param func: function to compute moments of
     :param moment: tuple or polynomial describing the moment
     :param symbols: if moment is given as polynomial, pass the moment symbols, i.e. the dof of the polynomial
     """
-    return __continuousMomentOrCumulant(function, moment, symbols, momentGeneratingFunction)
+    return __continuous_moment_or_cumulant(func, moment, symbols, moment_generating_function)
 
 
-def continuousCumulant(function, moment, symbols=None):
-    """
-    Computes cumulant of continuous function
-    for parameter description see :func:`continuousMoment`
-    """
-    return __continuousMomentOrCumulant(function, moment, symbols, cumulantGeneratingFunction)
+def continuous_cumulant(func, moment, symbols=None):
+    """Computes cumulant of continuous function.
 
+    for parameter description see :func:`continuous_moment`
+    """
+    return __continuous_moment_or_cumulant(func, moment, symbols, cumulant_generating_function)
diff --git a/creationfunctions.py b/creationfunctions.py
index 8db2eb232831756ea427f87e9c65b34360e28bcc..14101d8bf34c29266e9e20741b527bd6215ecad7 100644
--- a/creationfunctions.py
+++ b/creationfunctions.py
@@ -13,48 +13,48 @@ Method parameters
 
 General:
 
-- ``stencil='D2Q9'``: stencil name e.g. 'D2Q9', 'D3Q19'. See :func:`pystencils.stencils.getStencil` for details
+- ``stencil='D2Q9'``: stencil name e.g. 'D2Q9', 'D3Q19'. See :func:`pystencils.stencils.get_stencil` for details
 - ``method='srt'``: name of lattice Boltzmann method. This determines the selection and relaxation pattern of
   moments/cumulants, i.e. which moment/cumulant basis is chosen, and which of the basis vectors are relaxed together
-    - ``srt``: single relaxation time (:func:`lbmpy.methods.createSRT`)
+    - ``srt``: single relaxation time (:func:`lbmpy.methods.create_srt`)
     - ``trt``: two relaxation time, first relaxation rate is for even moments and determines the viscosity (as in SRT),
       the second relaxation rate is used for relaxing odd moments, and controls the bulk viscosity.
-      (:func:`lbmpy.methods.createTRT`)
+      (:func:`lbmpy.methods.create_trt`)
     - ``mrt``: orthogonal multi relaxation time model, number of relaxation rates depends on the stencil
-      (:func:`lbmpy.methods.createOrthogonalMRT`)
+      (:func:`lbmpy.methods.create_mrt_orthogonal`)
     - ``mrt3``: three relaxation time method, where shear moments are relaxed with first relaxation rate (and therefore
       determine viscosity, second rate relaxes the shear tensor trace (determines bulk viscosity) and last rate relaxes
       all other, higher order moments. If two relaxation rates are chosen the same this is equivalent to a KBC type
-      relaxation (:func:`lbmpy.methods.createThreeRelaxationRateMRT`)
+      relaxation (:func:`lbmpy.methods.create_mrt3`)
     - ``mrt_raw``: non-orthogonal MRT where all relaxation rates can be specified independently i.e. there are as many
       relaxation rates as stencil entries. Look at the generated method in Jupyter to see which moment<->relaxation rate
-      mapping (:func:`lbmpy.methods.createRawMRT`)
+      mapping (:func:`lbmpy.methods.create_mrt_raw`)
     - ``trt-kbc-n<N>`` where <N> is 1,2,3 or 4. Special two-relaxation rate method. This is not the entropic method
       yet, only the relaxation pattern. To get the entropic method, see parameters below!
-      (:func:`lbmpy.methods.createKBCTypeTRT`)
-- ``relaxationRates``: sequence of relaxation rates, number depends on selected method. If you specify more rates than
+      (:func:`lbmpy.methods.create_trt_kbc`)
+- ``relaxation_rates``: sequence of relaxation rates, number depends on selected method. If you specify more rates than
   method needs, the additional rates are ignored. For SRT and TRT models it is possible ot define a single
-  ``relaxationRate`` instead of a list, the second rate for TRT is then determined via magic number.
+  ``relaxation_rate`` instead of a list, the second rate for TRT is then determined via magic number.
 - ``compressible=False``: affects the selection of equilibrium moments. Both options approximate the *incompressible*
   Navier Stokes Equations. However when chosen as False, the approximation is better, the standard LBM derivation is
   compressible.
-- ``equilibriumAccuracyOrder=2``: order in velocity, at which the equilibrium moment/cumulant approximation is
+- ``equilibrium_order=2``: order in velocity, at which the equilibrium moment/cumulant approximation is
   truncated. Order 2 is sufficient to approximate Navier-Stokes
-- ``forceModel=None``: possible values: ``None``, ``'simple'``, ``'luo'``, ``'guo'`` ``'buick'``, or an instance of a
+- ``force_model=None``: possible values: ``None``, ``'simple'``, ``'luo'``, ``'guo'`` ``'buick'``, or an instance of a
   class implementing the same methods as the classes in :mod:`lbmpy.forcemodels`. For details, see
   :mod:`lbmpy.forcemodels`
 - ``force=(0,0,0)``: either constant force or a symbolic expression depending on field value
-- ``useContinuousMaxwellianEquilibrium=True``: way to compute equilibrium moments/cumulants, if False the standard
+- ``maxwellian_moments=True``: way to compute equilibrium moments/cumulants, if False the standard
   discretized LBM equilibrium is used, otherwise the equilibrium moments are computed from the continuous Maxwellian.
   This makes only a difference if sparse stencils are used e.g. D2Q9 and D3Q27 are not affected, D319 and DQ15 are
 - ``cumulant=False``: use cumulants instead of moments
-- ``initialVelocity=None``: initial velocity in domain, can either be a tuple (x,y,z) velocity to set a constant
+- ``initial_velocity=None``: initial velocity in domain, can either be a tuple (x,y,z) velocity to set a constant
   velocity everywhere, or a numpy array with the same size of the domain, with a last coordinate of shape dim to set
   velocities on cell level
 - ``output={}``: a dictionary mapping macroscopic quantites e.g. the strings 'density' and 'velocity' to pystencils
                 fields. In each timestep the corresponding quantities are written to the given fields.
-- ``velocityInput``: symbolic field where the velocities are read from (for advection diffusion LBM)
-- ``kernelType``: supported values: 'streamPullCollide' (default), 'collideOnly' 
+- ``velocity_input``: symbolic field where the velocities are read from (for advection diffusion LBM)
+- ``kernel_type``: supported values: 'stream_pull_collide' (default), 'collide_only'
 
 
 Entropic methods:
@@ -62,15 +62,15 @@ Entropic methods:
 - ``entropic=False``: In case there are two distinct relaxation rate in a method, one of them (usually the one, not
   determining the viscosity) can be automatically chosen w.r.t an entropy condition. For details see
   :mod:`lbmpy.methods.entropic`
-- ``entropicNewtonIterations=None``: For moment methods the entropy optimum can be calculated in closed form.
+- ``entropic_newton_iterations=None``: For moment methods the entropy optimum can be calculated in closed form.
   For cumulant methods this is not possible, in that case it is computed using Newton iterations. This parameter can be
   used to force Newton iterations and specify how many should be done
-- ``omegaOutputField=None``: you can pass a pystencils Field here, where the calculated free relaxation
+- ``omega_output_field=None``: you can pass a pystencils Field here, where the calculated free relaxation
   rate is written to
 
 LES methods:
 
-- ``smagorinsky=False``: set to Smagorinsky constant to activate turbulence model, `omegaOutputField` can be set to
+- ``smagorinsky=False``: set to Smagorinsky constant to activate turbulence model, `omega_output_field` can be set to
                          write out adapted relaxation rates
 
 
@@ -79,11 +79,11 @@ Optimization Parameters
 
 Simplifications / Transformations:
 
-- ``doCseInOpposingDirections=False``: run common subexpression elimination for opposing stencil directions
-- ``doOverallCse=False``: run common subexpression elimination after all other simplifications have been executed
+- ``cse_pdfs=False``: run common subexpression elimination for opposing stencil directions
+- ``cse_global=False``: run common subexpression elimination after all other simplifications have been executed
 - ``split=False``: split innermost loop, to handle only 2 directions per loop. This reduces the number of parallel
   load/store streams and thus speeds up the kernel on most architectures
-- ``builtinPeriodicity=(False,False,False)``: instead of handling periodicity by copying ghost layers, the periodicity
+- ``builtin_periodicity=(False,False,False)``: instead of handling periodicity by copying ghost layers, the periodicity
   is built into the kernel. This parameters specifies if the domain is periodic in (x,y,z) direction. Even if the
   periodicity is built into the kernel, the fields have one ghost layer to be consistent with other functions. 
     
@@ -92,23 +92,23 @@ Field size information:
 
 - ``pdfArr=None``: pass a numpy array here to create kernels with fixed size and create the loop nest according to layout
   of this array
-- ``fieldSize=None``: create kernel for fixed field size
-- ``fieldLayout='c'``:   ``'c'`` or ``'numpy'`` for standard numpy layout, ``'reverseNumpy'`` or ``'f'`` for fortran
+- ``field_size=None``: create kernel for fixed field size
+- ``field_layout='c'``:   ``'c'`` or ``'numpy'`` for standard numpy layout, ``'reverseNumpy'`` or ``'f'`` for fortran
   layout, this does not apply when pdfArr was given, then the same layout as pdfArr is used
 
 GPU:
 
 - ``target='cpu'``: ``'cpu'`` or ``'gpu'``, last option requires a CUDA enabled graphics card
   and installed *pycuda* package
-- ``gpuIndexing='block'``: determines mapping of CUDA threads to cells. Can be either ``'block'`` or ``'line'``
-- ``gpuIndexingParams='block'``: parameters passed to init function of gpu indexing.
+- ``gpu_indexing='block'``: determines mapping of CUDA threads to cells. Can be either ``'block'`` or ``'line'``
+- ``gpu_indexing_params='block'``: parameters passed to init function of gpu indexing.
   For ``'block'`` indexing one can e.g. specify the block size ``{'blockSize' : (128, 4, 1)}``
 
 Other:
 
-- ``openMP=True``: only applicable for cpu simulations. Can be a boolean to turn multi threading on/off, or an integer
+- ``openmp=True``: only applicable for cpu simulations. Can be a boolean to turn multi threading on/off, or an integer
   specifying the number of threads. If True is specified OpenMP chooses the number of threads
-- ``doublePrecision=True``:  by default simulations run with double precision floating point numbers, by setting this
+- ``double_precision=True``:  by default simulations run with double precision floating point numbers, by setting this
   parameter to False, single precision is used, which is much faster, especially on GPUs
 
 
@@ -139,222 +139,222 @@ Kernel functions are created in three steps:
         This step compiles the AST into an executable function, either for CPU or GPUs. This function
         behaves like a normal Python function and runs one LBM time step.
 
-The function :func:`createLatticeBoltzmannFunction` runs the whole pipeline, the other functions in this module
+The function :func:`create_lb_function` runs the whole pipeline, the other functions in this module
 execute this pipeline only up to a certain step. Each function optionally also takes the result of the previous step.
 
 For example, to modify the AST one can run::
 
-    ast = createLatticeBoltzmannAst(...)
+    ast = create_lb_ast(...)
     # modify ast here
-    func = createLatticeBoltzmannFunction(ast=ast, ...)
+    func = create_lb_function(ast=ast, ...)
 
 """
 import sympy as sp
 from copy import copy
 
-from pystencils.cache import diskcacheNoFallback
+from pystencils.cache import disk_cache_no_fallback
 from pystencils.data_types import collate_types
 from pystencils.assignment_collection.assignment_collection import AssignmentCollection
-from pystencils.field import getLayoutOfArray, Field
-from pystencils import createKernel, Assignment
-from lbmpy.turbulence_models import addSmagorinskyModel
-from lbmpy.methods import createSRT, createTRT, createOrthogonalMRT, createKBCTypeTRT, \
-    createRawMRT, createThreeRelaxationRateMRT
-from lbmpy.methods.entropic import addIterativeEntropyCondition, addEntropyCondition
-from lbmpy.methods.entropic_eq_srt import createEntropicSRT
-from lbmpy.relaxationrates import relaxationRateFromMagicNumber
-from lbmpy.stencils import getStencil, stencilsHaveSameEntries
+from pystencils.field import get_layout_of_array, Field
+from pystencils import create_kernel, Assignment
+from lbmpy.turbulence_models import add_smagorinsky_model
+from lbmpy.methods import create_srt, create_trt, create_mrt_orthogonal, create_trt_kbc, \
+    create_mrt_raw, create_mrt3
+from lbmpy.methods.entropic import add_iterative_entropy_condition, add_entropy_condition
+from lbmpy.methods.entropic_eq_srt import create_srt_entropic
+from lbmpy.relaxationrates import relaxation_rate_from_magic_number
+from lbmpy.stencils import get_stencil, stencils_have_same_entries
 import lbmpy.forcemodels as forcemodels
-from lbmpy.simplificationfactory import createSimplificationStrategy
+from lbmpy.simplificationfactory import create_simplification_strategy
 from lbmpy.updatekernels import StreamPullTwoFieldsAccessor, PeriodicTwoFieldsAccessor, CollideOnlyInplaceAccessor, \
-    createLBMKernel, createStreamPullWithOutputKernel
+    create_lbm_kernel, create_stream_pull_with_output_kernel
 
 
-def createLatticeBoltzmannFunction(ast=None, optimizationParams={}, **kwargs):
-    params, optParams = updateWithDefaultParameters(kwargs, optimizationParams)
+def create_lb_function(ast=None, optimization={}, **kwargs):
+    params, optParams = update_with_default_parameters(kwargs, optimization)
 
     if ast is None:
-        params['optimizationParams'] = optParams
-        ast = createLatticeBoltzmannAst(**params)
+        params['optimization'] = optParams
+        ast = create_lb_ast(**params)
 
     res = ast.compile()
 
     res.method = ast.method
-    res.updateRule = ast.updateRule
+    res.update_rule = ast.update_rule
     res.ast = ast
     return res
 
 
-def createLatticeBoltzmannAst(updateRule=None, optimizationParams={}, **kwargs):
-    params, optParams = updateWithDefaultParameters(kwargs, optimizationParams)
+def create_lb_ast(update_rule=None, optimization={}, **kwargs):
+    params, opt_params = update_with_default_parameters(kwargs, optimization)
 
-    if updateRule is None:
-        params['optimizationParams'] = optimizationParams
-        updateRule = createLatticeBoltzmannUpdateRule(**params)
+    if update_rule is None:
+        params['optimization'] = optimization
+        update_rule = create_lb_update_rule(**params)
 
-    fieldTypes = set(fa.field.dtype for fa in updateRule.defined_symbols if isinstance(fa, Field.Access))
-    res = createKernel(updateRule, target=optParams['target'], dataType=collate_types(fieldTypes),
-                       cpuOpenMP=optParams['openMP'], cpuVectorizeInfo=optParams['vectorization'],
-                       gpuIndexing=optParams['gpuIndexing'], gpuIndexingParams=optParams['gpuIndexingParams'],
-                       ghostLayers=1)
+    field_types = set(fa.field.dtype for fa in update_rule.defined_symbols if isinstance(fa, Field.Access))
+    res = create_kernel(update_rule, target=opt_params['target'], data_type=collate_types(field_types),
+                        cpu_openmp=opt_params['openmp'], cpu_vectorize_info=opt_params['vectorization'],
+                        gpu_indexing=opt_params['gpu_indexing'], gpu_indexing_params=opt_params['gpu_indexing_params'],
+                        ghost_layers=1)
 
-    res.method = updateRule.method
-    res.updateRule = updateRule
+    res.method = update_rule.method
+    res.update_rule = update_rule
     return res
 
 
-@diskcacheNoFallback
-def createLatticeBoltzmannUpdateRule(collisionRule=None, optimizationParams={}, **kwargs):
-    params, opt_params = updateWithDefaultParameters(kwargs, optimizationParams)
+@disk_cache_no_fallback
+def create_lb_update_rule(collision_rule=None, optimization={}, **kwargs):
+    params, opt_params = update_with_default_parameters(kwargs, optimization)
 
-    if collisionRule is None:
-        collisionRule = createLatticeBoltzmannCollisionRule(**params, optimizationParams=opt_params)
+    if collision_rule is None:
+        collision_rule = create_lattice_boltzmann_collision_rule(**params, optimization=opt_params)
 
-    lb_method = collisionRule.method
+    lb_method = collision_rule.method
 
-    if params['output'] and params['kernelType'] == 'streamPullCollide':
-        cqc = lb_method.conservedQuantityComputation
-        output_eqs = cqc.outputEquationsFromPdfs(lb_method.preCollisionPdfSymbols, params['output'])
-        collisionRule = collisionRule.new_merged(output_eqs)
+    if params['output'] and params['kernel_type'] == 'stream_pull_collide':
+        cqc = lb_method.conserved_quantity_computation
+        output_eqs = cqc.output_equations_from_pdfs(lb_method.pre_collision_pdf_symbols, params['output'])
+        collision_rule = collision_rule.new_merged(output_eqs)
 
     if params['entropic']:
-        if params['entropicNewtonIterations']:
-            if isinstance(params['entropicNewtonIterations'], bool):
+        if params['entropic_newton_iterations']:
+            if isinstance(params['entropic_newton_iterations'], bool):
                 iterations = 3
             else:
-                iterations = params['entropicNewtonIterations']
-            collisionRule = addIterativeEntropyCondition(collisionRule, newtonIterations=iterations,
-                                                         omegaOutputField=params['omegaOutputField'])
+                iterations = params['entropic_newton_iterations']
+            collision_rule = add_iterative_entropy_condition(collision_rule, newton_iterations=iterations,
+                                                             omega_output_field=params['omega_output_field'])
         else:
-            collisionRule = addEntropyCondition(collisionRule, omegaOutputField=params['omegaOutputField'])
+            collision_rule = add_entropy_condition(collision_rule, omega_output_field=params['omega_output_field'])
     elif params['smagorinsky']:
         smagorinsky_constant = 0.12 if params['smagorinsky'] is True else params['smagorinsky']
-        collisionRule = addSmagorinskyModel(collisionRule, smagorinsky_constant,
-                                            omegaOutputField=params['omegaOutputField'])
+        collision_rule = add_smagorinsky_model(collision_rule, smagorinsky_constant,
+                                               omega_output_field=params['omega_output_field'])
 
-    field_data_type = 'float64' if opt_params['doublePrecision'] else 'float32'
+    field_data_type = 'float64' if opt_params['double_precision'] else 'float32'
 
-    if opt_params['symbolicField'] is not None:
-        src_field = opt_params['symbolicField']
-    elif opt_params['fieldSize']:
-        field_size = [s + 2 for s in opt_params['fieldSize']] + [len(collisionRule.stencil)]
-        src_field = Field.createFixedSize(params['fieldName'], field_size, indexDimensions=1,
-                                          layout=opt_params['fieldLayout'], dtype=field_data_type)
+    if opt_params['symbolic_field'] is not None:
+        src_field = opt_params['symbolic_field']
+    elif opt_params['field_size']:
+        field_size = [s + 2 for s in opt_params['field_size']] + [len(collision_rule.stencil)]
+        src_field = Field.create_fixed_size(params['field_name'], field_size, index_dimensions=1,
+                                            layout=opt_params['field_layout'], dtype=field_data_type)
     else:
-        src_field = Field.createGeneric(params['fieldName'], spatialDimensions=collisionRule.method.dim,
-                                        indexDimensions=1, layout=opt_params['fieldLayout'], dtype=field_data_type)
+        src_field = Field.create_generic(params['field_name'], spatial_dimensions=collision_rule.method.dim,
+                                         index_dimensions=1, layout=opt_params['field_layout'], dtype=field_data_type)
 
-    dst_field = src_field.newFieldWithDifferentName(params['secondFieldName'])
+    dst_field = src_field.new_field_with_different_name(params['temporary_field_name'])
 
-    if params['kernelType'] == 'streamPullCollide':
+    if params['kernel_type'] == 'stream_pull_collide':
         accessor = StreamPullTwoFieldsAccessor
-        if any(opt_params['builtinPeriodicity']):
-            accessor = PeriodicTwoFieldsAccessor(opt_params['builtinPeriodicity'], ghostLayers=1)
-        return createLBMKernel(collisionRule, src_field, dst_field, accessor)
-    elif params['kernelType'] == 'collideOnly':
-        return createLBMKernel(collisionRule, src_field, src_field, CollideOnlyInplaceAccessor)
-    elif params['kernelType'] == 'streamPullOnly':
-        return createStreamPullWithOutputKernel(lb_method, src_field, dst_field, params['output'])
+        if any(opt_params['builtin_periodicity']):
+            accessor = PeriodicTwoFieldsAccessor(opt_params['builtin_periodicity'], ghost_layers=1)
+        return create_lbm_kernel(collision_rule, src_field, dst_field, accessor)
+    elif params['kernel_type'] == 'collide_only':
+        return create_lbm_kernel(collision_rule, src_field, src_field, CollideOnlyInplaceAccessor)
+    elif params['kernel_type'] == 'stream_pull_only':
+        return create_stream_pull_with_output_kernel(lb_method, src_field, dst_field, params['output'])
     else:
-        raise ValueError("Invalid value of parameter 'kernelType'", params['kernelType'])
+        raise ValueError("Invalid value of parameter 'kernel_type'", params['kernel_type'])
 
 
-@diskcacheNoFallback
-def createLatticeBoltzmannCollisionRule(lbMethod=None, optimizationParams={}, **kwargs):
-    params, optParams = updateWithDefaultParameters(kwargs, optimizationParams)
+@disk_cache_no_fallback
+def create_lattice_boltzmann_collision_rule(lb_method=None, optimization={}, **kwargs):
+    params, opt_params = update_with_default_parameters(kwargs, optimization)
 
-    if lbMethod is None:
-        lbMethod = createLatticeBoltzmannMethod(**params)
+    if lb_method is None:
+        lb_method = create_lb_method(**params)
 
-    splitInnerLoop = 'split' in optParams and optParams['split']
+    split_inner_loop = 'split' in opt_params and opt_params['split']
 
-    dirCSE = 'doCseInOpposingDirections'
-    doCseInOpposingDirections = False if dirCSE not in optParams else optParams[dirCSE]
-    doOverallCse = False if 'doOverallCse' not in optParams else optParams['doOverallCse']
-    simplification = createSimplificationStrategy(lbMethod, doCseInOpposingDirections, doOverallCse, splitInnerLoop)
-    cqc = lbMethod.conservedQuantityComputation
+    dir_cse = 'cse_pdfs'
+    cse_pdfs = False if dir_cse not in opt_params else opt_params[dir_cse]
+    cse_global = False if 'cse_global' not in opt_params else opt_params['cse_global']
+    simplification = create_simplification_strategy(lb_method, cse_pdfs, cse_global, split_inner_loop)
+    cqc = lb_method.conserved_quantity_computation
 
-    if params['velocityInput'] is not None:
-        eqs = [Assignment(cqc.zerothOrderMomentSymbol, sum(lbMethod.preCollisionPdfSymbols))]
-        velocityField = params['velocityInput']
-        eqs += [Assignment(uSym, velocityField(i)) for i, uSym in enumerate(cqc.firstOrderMomentSymbols)]
+    if params['velocity_input'] is not None:
+        eqs = [Assignment(cqc.zeroth_order_moment_symbol, sum(lb_method.pre_collision_pdf_symbols))]
+        velocity_field = params['velocity_input']
+        eqs += [Assignment(uSym, velocity_field(i)) for i, uSym in enumerate(cqc.first_order_moment_symbols)]
         eqs = AssignmentCollection(eqs, [])
-        collisionRule = lbMethod.getCollisionRule(conservedQuantityEquations=eqs)
+        collision_rule = lb_method.get_collision_rule(conserved_quantity_equations=eqs)
     else:
-        collisionRule = lbMethod.getCollisionRule()
+        collision_rule = lb_method.get_collision_rule()
 
-    return simplification(collisionRule)
+    return simplification(collision_rule)
 
 
-def createLatticeBoltzmannMethod(**params):
-    params, _ = updateWithDefaultParameters(params, {}, failOnUnknownParameter=False)
+def create_lb_method(**params):
+    params, _ = update_with_default_parameters(params, {}, fail_on_unknown_parameter=False)
 
     if isinstance(params['stencil'], tuple) or isinstance(params['stencil'], list):
-        stencilEntries = params['stencil']
+        stencil_entries = params['stencil']
     else:
-        stencilEntries = getStencil(params['stencil'])
+        stencil_entries = get_stencil(params['stencil'])
 
-    dim = len(stencilEntries[0])
+    dim = len(stencil_entries[0])
 
     if isinstance(params['force'], Field):
         params['force'] = tuple(params['force'](i) for i in range(dim))
 
-    forceIsZero = True
+    force_is_zero = True
     for f_i in params['force']:
         if f_i != 0:
-            forceIsZero = False
+            force_is_zero = False
 
-    noForceModel = 'forceModel' not in params or params['forceModel'] == 'none' or params['forceModel'] is None
-    if not forceIsZero and noForceModel:
-        params['forceModel'] = 'guo'
+    no_force_model = 'force_model' not in params or params['force_model'] == 'none' or params['force_model'] is None
+    if not force_is_zero and no_force_model:
+        params['force_model'] = 'guo'
 
-    if 'forceModel' in params:
-        forceModel = forceModelFromString(params['forceModel'], params['force'][:dim])
+    if 'force_model' in params:
+        force_model = force_model_from_string(params['force_model'], params['force'][:dim])
     else:
-        forceModel = None
+        force_model = None
 
-    commonParams = {
+    common_params = {
         'compressible': params['compressible'],
-        'equilibriumAccuracyOrder': params['equilibriumAccuracyOrder'],
-        'forceModel': forceModel,
-        'useContinuousMaxwellianEquilibrium': params['useContinuousMaxwellianEquilibrium'],
+        'equilibrium_order': params['equilibrium_order'],
+        'force_model': force_model,
+        'maxwellian_moments': params['maxwellian_moments'],
         'cumulant': params['cumulant'],
         'c_s_sq': params['c_s_sq'],
     }
-    methodName = params['method']
-    relaxationRates = params['relaxationRates']
-
-    if methodName.lower() == 'srt':
-        assert len(relaxationRates) >= 1, "Not enough relaxation rates"
-        method = createSRT(stencilEntries, relaxationRates[0], **commonParams)
-    elif methodName.lower() == 'trt':
-        assert len(relaxationRates) >= 2, "Not enough relaxation rates"
-        method = createTRT(stencilEntries, relaxationRates[0], relaxationRates[1], **commonParams)
-    elif methodName.lower() == 'mrt':
-        nextRelaxationRate = [0]
-
-        def relaxationRateGetter(momentGroup):
-            res = relaxationRates[nextRelaxationRate[0]]
-            nextRelaxationRate[0] += 1
+    method_name = params['method']
+    relaxation_rates = params['relaxation_rates']
+
+    if method_name.lower() == 'srt':
+        assert len(relaxation_rates) >= 1, "Not enough relaxation rates"
+        method = create_srt(stencil_entries, relaxation_rates[0], **common_params)
+    elif method_name.lower() == 'trt':
+        assert len(relaxation_rates) >= 2, "Not enough relaxation rates"
+        method = create_trt(stencil_entries, relaxation_rates[0], relaxation_rates[1], **common_params)
+    elif method_name.lower() == 'mrt':
+        next_relaxation_rate = [0]
+
+        def relaxation_rate_getter(_):
+            res = relaxation_rates[next_relaxation_rate[0]]
+            next_relaxation_rate[0] += 1
             return res
-        method = createOrthogonalMRT(stencilEntries, relaxationRateGetter, **commonParams)
-    elif methodName.lower() == 'mrt_raw':
-        method = createRawMRT(stencilEntries, relaxationRates, **commonParams)
-    elif methodName.lower() == 'mrt3':
-        method = createThreeRelaxationRateMRT(stencilEntries, relaxationRates, **commonParams)
-    elif methodName.lower().startswith('trt-kbc-n'):
-        if stencilsHaveSameEntries(stencilEntries, getStencil("D2Q9")):
+        method = create_mrt_orthogonal(stencil_entries, relaxation_rate_getter, **common_params)
+    elif method_name.lower() == 'mrt_raw':
+        method = create_mrt_raw(stencil_entries, relaxation_rates, **common_params)
+    elif method_name.lower() == 'mrt3':
+        method = create_mrt3(stencil_entries, relaxation_rates, **common_params)
+    elif method_name.lower().startswith('trt-kbc-n'):
+        if stencils_have_same_entries(stencil_entries, get_stencil("D2Q9")):
             dim = 2
-        elif stencilsHaveSameEntries(stencilEntries, getStencil("D3Q27")):
+        elif stencils_have_same_entries(stencil_entries, get_stencil("D3Q27")):
             dim = 3
         else:
             raise NotImplementedError("KBC type TRT methods can only be constructed for D2Q9 and D3Q27 stencils")
-        methodNr = methodName[-1]
-        method = createKBCTypeTRT(dim, relaxationRates[0], relaxationRates[1], 'KBC-N' + methodNr, **commonParams)
-    elif methodName.lower() == 'entropic-srt':
-        method = createEntropicSRT(stencilEntries, relaxationRates[0], forceModel, params['compressible'])
+        method_nr = method_name[-1]
+        method = create_trt_kbc(dim, relaxation_rates[0], relaxation_rates[1], 'KBC-N' + method_nr, **common_params)
+    elif method_name.lower() == 'entropic-srt':
+        method = create_srt_entropic(stencil_entries, relaxation_rates[0], force_model, params['compressible'])
     else:
-        raise ValueError("Unknown method %s" % (methodName,))
+        raise ValueError("Unknown method %s" % (method_name,))
 
     return method
 
@@ -362,13 +362,13 @@ def createLatticeBoltzmannMethod(**params):
 # ----------------------------------------------------------------------------------------------------------------------
 
 
-def forceModelFromString(forceModelName, forceValues):
-    if type(forceModelName) is not str:
-        return forceModelName
-    if forceModelName == 'none':
+def force_model_from_string(force_model_name, force_values):
+    if type(force_model_name) is not str:
+        return force_model_name
+    if force_model_name == 'none':
         return None
 
-    forceModelDict = {
+    force_model_dict = {
         'simple': forcemodels.Simple,
         'luo': forcemodels.Luo,
         'guo': forcemodels.Guo,
@@ -376,124 +376,126 @@ def forceModelFromString(forceModelName, forceValues):
         'silva': forcemodels.Buick,
         'edm': forcemodels.EDM,
     }
-    if forceModelName.lower() not in forceModelDict:
-        raise ValueError("Unknown force model %s" % (forceModelName,))
+    if force_model_name.lower() not in force_model_dict:
+        raise ValueError("Unknown force model %s" % (force_model_name,))
 
-    forceModelClass = forceModelDict[forceModelName.lower()]
-    return forceModelClass(forceValues)
+    force_model_class = force_model_dict[force_model_name.lower()]
+    return force_model_class(force_values)
 
 
-def switchToSymbolicRelaxationRatesForOmegaAdaptingMethods(methodParameters, kernelParams):
+def switch_to_symbolic_relaxation_rates_for_omega_adapting_methods(method_parameters, kernel_params):
     """
     For entropic kernels the relaxation rate has to be a variable. If a constant was passed a
     new dummy variable is inserted and the value of this variable is later on passed to the kernel
     """
-    if methodParameters['entropic'] or methodParameters['smagorinsky']:
-        valueToSymbolMap = {}
-        newRelaxationRates = []
-        for rr in methodParameters['relaxationRates']:
+    if method_parameters['entropic'] or method_parameters['smagorinsky']:
+        value_to_symbol_map = {}
+        new_relaxation_rates = []
+        for rr in method_parameters['relaxation_rates']:
             if not isinstance(rr, sp.Symbol):
-                if rr not in valueToSymbolMap:
-                    valueToSymbolMap[rr] = sp.Dummy()
-                dummyVar = valueToSymbolMap[rr]
-                newRelaxationRates.append(dummyVar)
-                kernelParams[dummyVar.name] = rr
+                if rr not in value_to_symbol_map:
+                    value_to_symbol_map[rr] = sp.Dummy()
+                dummy_var = value_to_symbol_map[rr]
+                new_relaxation_rates.append(dummy_var)
+                kernel_params[dummy_var.name] = rr
             else:
-                newRelaxationRates.append(rr)
-        if len(newRelaxationRates) < 2:
-            newRelaxationRates.append(sp.Dummy())
-        methodParameters['relaxationRates'] = newRelaxationRates
+                new_relaxation_rates.append(rr)
+        if len(new_relaxation_rates) < 2:
+            new_relaxation_rates.append(sp.Dummy())
+        method_parameters['relaxation_rates'] = new_relaxation_rates
 
 
-def updateWithDefaultParameters(params, optParams, failOnUnknownParameter=True):
-    defaultMethodDescription = {
+def update_with_default_parameters(params, opt_params=None, fail_on_unknown_parameter=True):
+    opt_params = opt_params if opt_params is not None else {}
+
+    default_method_description = {
         'stencil': 'D2Q9',
         'method': 'srt',  # can be srt, trt or mrt
-        'relaxationRates': None,
+        'relaxation_rates': None,
         'compressible': False,
-        'equilibriumAccuracyOrder': 2,
+        'equilibrium_order': 2,
         'c_s_sq': sp.Rational(1, 3),
 
-        'forceModel': 'none',
+        'force_model': 'none',
         'force': (0, 0, 0),
-        'useContinuousMaxwellianEquilibrium': True,
+        'maxwellian_moments': True,
         'cumulant': False,
-        'initialVelocity': None,
+        'initial_velocity': None,
 
         'entropic': False,
-        'entropicNewtonIterations': None,
-        'omegaOutputField': None,
+        'entropic_newton_iterations': None,
+        'omega_output_field': None,
         'smagorinsky': False,
 
         'output': {},
-        'velocityInput': None,
+        'velocity_input': None,
 
-        'kernelType': 'streamPullCollide',
+        'kernel_type': 'stream_pull_collide',
 
-        'fieldName': 'src',
-        'secondFieldName': 'dst',
+        'field_name': 'src',
+        'temporary_field_name': 'dst',
 
-        'lbMethod': None,
-        'collisionRule': None,
-        'updateRule': None,
+        'lb_method': None,
+        'collision_rule': None,
+        'update_rule': None,
         'ast': None,
     }
 
-    defaultOptimizationDescription = {
-        'doCseInOpposingDirections': False,
-        'doOverallCse': False,
+    default_optimization_description = {
+        'cse_pdfs': False,
+        'cse_global': False,
         'split': False,
 
-        'fieldSize': None,
-        'fieldLayout': 'fzyx',  # can be 'numpy' (='c'), 'reverseNumpy' (='f'), 'fzyx', 'zyxf'
-        'symbolicField': None,
+        'field_size': None,
+        'field_layout': 'fzyx',  # can be 'numpy' (='c'), 'reverseNumpy' (='f'), 'fzyx', 'zyxf'
+        'symbolic_field': None,
 
         'target': 'cpu',
-        'openMP': False,
-        'doublePrecision': True,
+        'openmp': False,
+        'double_precision': True,
 
-        'gpuIndexing': 'block',
-        'gpuIndexingParams': {},
+        'gpu_indexing': 'block',
+        'gpu_indexing_params': {},
 
         'vectorization': None,
 
-        'builtinPeriodicity': (False, False, False),
+        'builtin_periodicity': (False, False, False),
     }
-    if 'relaxationRate' in params:
-        if 'relaxationRates' not in params:
+    if 'relaxation_rate' in params:
+        if 'relaxation_rates' not in params:
             if 'entropic' in params and params['entropic']:
-                params['relaxationRates'] = [params['relaxationRate']]
+                params['relaxation_rates'] = [params['relaxation_rate']]
             else:
-                params['relaxationRates'] = [params['relaxationRate'],
-                                             relaxationRateFromMagicNumber(params['relaxationRate'])]
-
-            del params['relaxationRate']
-
-    if 'pdfArr' in optParams:
-        arr = optParams['pdfArr']
-        optParams['fieldSize'] = tuple(e - 2 for e in arr.shape[:-1])
-        optParams['fieldLayout'] = getLayoutOfArray(arr)
-        del optParams['pdfArr']
-
-    if failOnUnknownParameter:
-        unknownParams = [k for k in params.keys() if k not in defaultMethodDescription]
-        unknownOptParams = [k for k in optParams.keys() if k not in defaultOptimizationDescription]
-        if unknownParams:
-            raise ValueError("Unknown parameter(s): " + ", ".join(unknownParams))
-        if unknownOptParams:
-            raise ValueError("Unknown optimization parameter(s): " + ",".join(unknownOptParams))
-
-    paramsResult = copy(defaultMethodDescription)
-    paramsResult.update(params)
-    optParamsResult = copy(defaultOptimizationDescription)
-    optParamsResult.update(optParams)
-
-    if paramsResult['relaxationRates'] is None:
-        stencilParam = paramsResult['stencil']
-        if isinstance(stencilParam, tuple) or isinstance(stencilParam, list):
-            stencilEntries = stencilParam
+                params['relaxation_rates'] = [params['relaxation_rate'],
+                                              relaxation_rate_from_magic_number(params['relaxation_rate'])]
+
+            del params['relaxation_rate']
+
+    if 'pdf_arr' in opt_params:
+        arr = opt_params['pdf_arr']
+        opt_params['field_size'] = tuple(e - 2 for e in arr.shape[:-1])
+        opt_params['field_layout'] = get_layout_of_array(arr)
+        del opt_params['pdf_arr']
+
+    if fail_on_unknown_parameter:
+        unknown_params = [k for k in params.keys() if k not in default_method_description]
+        unknown_opt_params = [k for k in opt_params.keys() if k not in default_optimization_description]
+        if unknown_params:
+            raise ValueError("Unknown parameter(s): " + ", ".join(unknown_params))
+        if unknown_opt_params:
+            raise ValueError("Unknown optimization parameter(s): " + ",".join(unknown_opt_params))
+
+    params_result = copy(default_method_description)
+    params_result.update(params)
+    opt_params_result = copy(default_optimization_description)
+    opt_params_result.update(opt_params)
+
+    if params_result['relaxation_rates'] is None:
+        stencil_param = params_result['stencil']
+        if isinstance(stencil_param, tuple) or isinstance(stencil_param, list):
+            stencil_entries = stencil_param
         else:
-            stencilEntries = getStencil(paramsResult['stencil'])
-        paramsResult['relaxationRates'] = sp.symbols("omega_:%d" % len(stencilEntries))
+            stencil_entries = get_stencil(params_result['stencil'])
+        params_result['relaxation_rates'] = sp.symbols("omega_:%d" % len(stencil_entries))
 
-    return paramsResult, optParamsResult
\ No newline at end of file
+    return params_result, opt_params_result
diff --git a/cumulants.py b/cumulants.py
index 2d1d808f50966c5a0b5a225da89a555cfc4748b9..025467fbd2157b3f168da624e91097f3e515ff46 100644
--- a/cumulants.py
+++ b/cumulants.py
@@ -5,8 +5,8 @@ Additionally functions are provided to compute cumulants from moments and vice v
 
 import sympy as sp
 
-from lbmpy.continuous_distribution_measures import multiDifferentiation
-from lbmpy.moments import momentsUpToComponentOrder
+from lbmpy.continuous_distribution_measures import multi_differentiation
+from lbmpy.moments import moments_up_to_component_order
 from pystencils.cache import memorycache
 # ------------------------------------------- Internal Functions -------------------------------------------------------
 from pystencils.sympyextensions import fast_subs
@@ -129,14 +129,14 @@ def discreteCumulant(function, cumulant, stencil):
 
     generatingFunction = __getDiscreteCumulantGeneratingFunction(function, stencil, waveNumbers)
     if type(cumulant) is tuple:
-        return multiDifferentiation(generatingFunction, cumulant, waveNumbers)
+        return multi_differentiation(generatingFunction, cumulant, waveNumbers)
     else:
         from lbmpy.moments import MOMENT_SYMBOLS
         result = 0
         for term, coefficient in cumulant.as_coefficients_dict().items():
             exponents = tuple([term.as_coeff_exponent(v_i)[1] for v_i in MOMENT_SYMBOLS[:dim]])
             generatingFunction = __getDiscreteCumulantGeneratingFunction(function, stencil, waveNumbers)
-            cm = multiDifferentiation(generatingFunction, exponents, waveNumbers)
+            cm = multi_differentiation(generatingFunction, exponents, waveNumbers)
             result += coefficient * cm
         return result
 
@@ -149,13 +149,13 @@ def cumulantsFromPdfs(stencil, cumulantIndices=None, pdfSymbols=None):
     :param stencil:
     :param cumulantIndices: sequence of cumulant indices, could be tuples or polynomial representation
                             if left to default and a full stencil was passed,
-                            the full set i.e. `momentsUpToComponentOrder(2)` is used
+                            the full set i.e. `moments_up_to_component_order(2)` is used
     :param pdfSymbols: symbolic values for pdf values, if not passed they default to :math:`f_0, f_1, ...`
     :return: dict mapping cumulant index to expression
     """
     dim = len(stencil[0])
     if cumulantIndices is None:
-        cumulantIndices = momentsUpToComponentOrder(2, dim=dim)
+        cumulantIndices = moments_up_to_component_order(2, dim=dim)
     assert len(stencil) == len(cumulantIndices), "Stencil has to have same length as cumulantIndices sequence"
     if pdfSymbols is None:
         pdfSymbols = __getIndexedSymbols(pdfSymbols, "f", range(len(stencil)))
diff --git a/fieldaccess.py b/fieldaccess.py
index b48e7f3394c167ee05be2d0d488e16a5fabdfc94..17d579043b34a830adb9aed817e9a1120cb8c4d7 100644
--- a/fieldaccess.py
+++ b/fieldaccess.py
@@ -1,6 +1,6 @@
 import sympy as sp
 import abc
-from lbmpy.stencils import inverseDirection
+from lbmpy.stencils import inverse_direction
 from pystencils import Field
 
 
@@ -45,7 +45,7 @@ class CollideOnlyInplaceAccessor(PdfFieldAccessor):
 class StreamPullTwoFieldsAccessor(PdfFieldAccessor):
     @staticmethod
     def read(field, stencil):
-        return [field[inverseDirection(d)](i) for i, d in enumerate(stencil)]
+        return [field[inverse_direction(d)](i) for i, d in enumerate(stencil)]
 
     @staticmethod
     def write(field, stencil):
@@ -63,7 +63,7 @@ class Pseudo2DTwoFieldsAccessor(PdfFieldAccessor):
         for i, d in enumerate(stencil):
             direction = list(d)
             direction[self._collapsedDim] = 0
-            result.append(field[inverseDirection(tuple(direction))](i))
+            result.append(field[inverse_direction(tuple(direction))](i))
         return result
 
     @staticmethod
@@ -74,38 +74,38 @@ class Pseudo2DTwoFieldsAccessor(PdfFieldAccessor):
 class PeriodicTwoFieldsAccessor(PdfFieldAccessor):
     """Access scheme that builds periodicity into the kernel, by introducing a condition on every load,
     such that at the borders the periodic value is loaded. The periodicity is specified as a tuple of booleans, one for
-    each direction. The second parameter `ghostLayers` specifies the number of assumed ghost layers of the field. 
+    each direction. The second parameter `ghost_layers` specifies the number of assumed ghost layers of the field.
     For the periodic kernel itself no ghost layers are required, however other kernels might need them. 
     """
-    def __init__(self, periodicity, ghostLayers=0):
+    def __init__(self, periodicity, ghost_layers=0):
         self._periodicity = periodicity
-        self._ghostLayers = ghostLayers
+        self._ghostLayers = ghost_layers
 
     def read(self, field, stencil):
         result = []
         for i, d in enumerate(stencil):
-            pullDirection = inverseDirection(d)
-            periodicPullDirection = []
-            for coordId, dirElement in enumerate(pullDirection):
+            pull_direction = inverse_direction(d)
+            periodic_pull_direction = []
+            for coordId, dirElement in enumerate(pull_direction):
                 if not self._periodicity[coordId]:
-                    periodicPullDirection.append(dirElement)
+                    periodic_pull_direction.append(dirElement)
                     continue
 
-                lowerLimit = self._ghostLayers
-                upperLimit = field.spatialShape[coordId] - 1 - self._ghostLayers
-                limitDiff = upperLimit - lowerLimit
-                loopCounter = LoopOverCoordinate.get_loop_counter_symbol(coordId)
+                lower_limit = self._ghostLayers
+                upper_limit = field.spatial_shape[coordId] - 1 - self._ghostLayers
+                limit_diff = upper_limit - lower_limit
+                loop_counter = LoopOverCoordinate.get_loop_counter_symbol(coordId)
                 if dirElement == 0:
-                    periodicPullDirection.append(0)
+                    periodic_pull_direction.append(0)
                 elif dirElement == 1:
-                    newDirElement = sp.Piecewise((dirElement, loopCounter < upperLimit), (-limitDiff, True))
-                    periodicPullDirection.append(newDirElement)
+                    new_dir_element = sp.Piecewise((dirElement, loop_counter < upper_limit), (-limit_diff, True))
+                    periodic_pull_direction.append(new_dir_element)
                 elif dirElement == -1:
-                    newDirElement = sp.Piecewise((dirElement, loopCounter > lowerLimit), (limitDiff, True))
-                    periodicPullDirection.append(newDirElement)
+                    new_dir_element = sp.Piecewise((dirElement, loop_counter > lower_limit), (limit_diff, True))
+                    periodic_pull_direction.append(new_dir_element)
                 else:
                     raise NotImplementedError("This accessor supports only nearest neighbor stencils")
-            result.append(field[tuple(periodicPullDirection)](i))
+            result.append(field[tuple(periodic_pull_direction)](i))
         return result
 
     @staticmethod
@@ -120,7 +120,7 @@ class AABBEvenTimeStepAccessor(PdfFieldAccessor):
 
     @staticmethod
     def write(field, stencil):
-        return [field(stencil.index(inverseDirection(d))) for d in stencil]
+        return [field(stencil.index(inverse_direction(d))) for d in stencil]
 
 
 class AABBOddTimeStepAccessor(PdfFieldAccessor):
@@ -128,9 +128,9 @@ class AABBOddTimeStepAccessor(PdfFieldAccessor):
     def read(field, stencil):
         res = []
         for i, d in enumerate(stencil):
-            invDir = inverseDirection(d)
-            fieldAccess = field[invDir](stencil.index(invDir))
-            res.append(fieldAccess)
+            inv_dir = inverse_direction(d)
+            field_access = field[inv_dir](stencil.index(inv_dir))
+            res.append(field_access)
         return
 
     @staticmethod
@@ -143,59 +143,59 @@ class EsotericTwistAccessor(PdfFieldAccessor):
     def read(field, stencil):
         result = []
         for i, direction in enumerate(stencil):
-            direction = inverseDirection(direction)
-            neighborOffset = tuple([-e if e <= 0 else 0 for e in direction])
-            result.append(field[neighborOffset](i))
+            direction = inverse_direction(direction)
+            neighbor_offset = tuple([-e if e <= 0 else 0 for e in direction])
+            result.append(field[neighbor_offset](i))
         return result
 
     @staticmethod
     def write(field, stencil):
         result = []
         for i, direction in enumerate(stencil):
-            neighborOffset = tuple([e if e >= 0 else 0 for e in direction])
-            inverseIndex = stencil.index(inverseDirection(direction))
-            result.append(field[neighborOffset](inverseIndex))
+            neighbor_offset = tuple([e if e >= 0 else 0 for e in direction])
+            inverse_index = stencil.index(inverse_direction(direction))
+            result.append(field[neighbor_offset](inverse_index))
         return result
 
 
 # -------------------------------------------- Visualization -----------------------------------------------------------
 
 
-def visualizeFieldMapping(axes, stencil, fieldMapping, color='b'):
-    from lbmpy.gridvisualization import Grid
-    grid = Grid(3, 3)
-    grid.fillWithDefaultArrows()
-    for fieldAccess, direction in zip(fieldMapping, stencil):
-        fieldPosition = stencil[fieldAccess.index[0]]
+def visualize_field_mapping(axes, stencil, field_mapping, color='b'):
+    from lbmpy.plot2d import LbGrid
+    grid = LbGrid(3, 3)
+    grid.fill_with_default_arrows()
+    for fieldAccess, direction in zip(field_mapping, stencil):
+        field_position = stencil[fieldAccess.index[0]]
         neighbor = fieldAccess.offsets
-        grid.addArrow((1 + neighbor[0], 1 + neighbor[1]),
-                      arrowPosition=fieldPosition, arrowDirection=direction, color=color)
+        grid.add_arrow((1 + neighbor[0], 1 + neighbor[1]),
+                       arrow_position=field_position, arrow_direction=direction, color=color)
     grid.draw(axes)
 
 
-def visualizePdfFieldAccessor(pdfFieldAccessor, figure=None):
-    from lbmpy.stencils import getStencil
+def visualize_pdf_field_accessor(pdf_field_accessor, figure=None):
+    from lbmpy.stencils import get_stencil
 
     if figure is None:
         import matplotlib.pyplot as plt
         figure = plt.gcf()
 
-    stencil = getStencil('D2Q9')
+    stencil = get_stencil('D2Q9')
 
     figure.patch.set_facecolor('white')
 
-    field = Field.createGeneric('f', spatialDimensions=2, indexDimensions=1)
-    preCollisionAccesses = pdfFieldAccessor.read(field, stencil)
-    postCollisionAccesses = pdfFieldAccessor.write(field, stencil)
+    field = Field.create_generic('f', spatial_dimensions=2, index_dimensions=1)
+    pre_collision_accesses = pdf_field_accessor.read(field, stencil)
+    post_collision_accesses = pdf_field_accessor.write(field, stencil)
 
-    axLeft = figure.add_subplot(1, 2, 1)
-    axRight = figure.add_subplot(1, 2, 2)
+    ax_left = figure.add_subplot(1, 2, 1)
+    ax_right = figure.add_subplot(1, 2, 2)
 
-    visualizeFieldMapping(axLeft, stencil, preCollisionAccesses, color='k')
-    visualizeFieldMapping(axRight, stencil, postCollisionAccesses, color='r')
+    visualize_field_mapping(ax_left, stencil, pre_collision_accesses, color='k')
+    visualize_field_mapping(ax_right, stencil, post_collision_accesses, color='r')
 
-    axLeft.set_title("Read")
-    axRight.set_title("Write")
+    ax_left.set_title("Read")
+    ax_right.set_title("Write")
 
 
 
diff --git a/forcemodels.py b/forcemodels.py
index ee193f6bcd46075cbf65a5398b464b5646e1c18a..88e53b902d836842447659c065f3c69d4e14f164 100644
--- a/forcemodels.py
+++ b/forcemodels.py
@@ -86,15 +86,15 @@ second moment nonzero   :class:`Luo`         :class:`Guo`
 """
 
 import sympy as sp
-from lbmpy.relaxationrates import getShearRelaxationRate
+from lbmpy.relaxationrates import get_shear_relaxation_rate
 
 
 class ScalarSource(object):
     def __init__(self, source):
         self._source = source
 
-    def __call__(self, lbMethod, **kwargs):
-        return [w_i * self._source for w_i in lbMethod.weights]
+    def __call__(self, lb_method, **kwargs):
+        return [w_i * self._source for w_i in lb_method.weights]
 
 
 class Simple(object):
@@ -107,39 +107,38 @@ class Simple(object):
     def __init__(self, force):
         self._force = force
 
-    def __call__(self, lbMethod, **kwargs):
-        assert len(self._force) == lbMethod.dim
+    def __call__(self, lb_method, **kwargs):
+        assert len(self._force) == lb_method.dim
 
         def scalarProduct(a, b):
             return sum(a_i * b_i for a_i, b_i in zip(a, b))
 
         return [3 * w_i * scalarProduct(self._force, direction)
-                for direction, w_i in zip(lbMethod.stencil, lbMethod.weights)]
+                for direction, w_i in zip(lb_method.stencil, lb_method.weights)]
 
-    def macroscopicVelocityShift(self, density):
+    def macroscopic_velocity_shift(self, density):
         return defaultVelocityShift(density, self._force)
 
 
 class Luo(object):
-    r"""
-    Force model by Luo :cite:`luo1993lattice`
+    r"""Force model by Luo :cite:`luo1993lattice`.
 
     Shifts the macroscopic velocity by F/2, but does not change the equilibrium velocity.
     """
     def __init__(self, force):
         self._force = force
 
-    def __call__(self, lbMethod):
-        u = sp.Matrix(lbMethod.firstOrderEquilibriumMomentSymbols)
+    def __call__(self, lb_method):
+        u = sp.Matrix(lb_method.first_order_equilibrium_moment_symbols)
         force = sp.Matrix(self._force)
 
         result = []
-        for direction, w_i in zip(lbMethod.stencil, lbMethod.weights):
+        for direction, w_i in zip(lb_method.stencil, lb_method.weights):
             direction = sp.Matrix(direction)
             result.append(3 * w_i * force.dot(direction - u + 3 * direction * direction.dot(u)))
         return result
 
-    def macroscopicVelocityShift(self, density):
+    def macroscopic_velocity_shift(self, density):
         return defaultVelocityShift(density, self._force)
 
 
@@ -151,14 +150,14 @@ class Guo(object):
     def __init__(self, force):
         self._force = force
 
-    def __call__(self, lbMethod):
+    def __call__(self, lb_method):
         luo = Luo(self._force)
 
-        shearRelaxationRate = getShearRelaxationRate(lbMethod)
+        shearRelaxationRate = get_shear_relaxation_rate(lb_method)
         correctionFactor = (1 - sp.Rational(1, 2) * shearRelaxationRate)
-        return [correctionFactor * t for t in luo(lbMethod)]
+        return [correctionFactor * t for t in luo(lb_method)]
 
-    def macroscopicVelocityShift(self, density):
+    def macroscopic_velocity_shift(self, density):
         return defaultVelocityShift(density, self._force)
 
     def equilibriumVelocityShift(self, density):
@@ -174,14 +173,14 @@ class Buick(object):
     def __init__(self, force):
         self._force = force
 
-    def __call__(self, lbMethod, **kwargs):
+    def __call__(self, lb_method, **kwargs):
         simple = Simple(self._force)
 
-        shearRelaxationRate = getShearRelaxationRate(lbMethod)
+        shearRelaxationRate = get_shear_relaxation_rate(lb_method)
         correctionFactor = (1 - sp.Rational(1, 2) * shearRelaxationRate)
-        return [correctionFactor * t for t in simple(lbMethod)]
+        return [correctionFactor * t for t in simple(lb_method)]
 
-    def macroscopicVelocityShift(self, density):
+    def macroscopic_velocity_shift(self, density):
         return defaultVelocityShift(density, self._force)
 
     def equilibriumVelocityShift(self, density):
@@ -194,17 +193,17 @@ class EDM(object):
     def __init__(self, force):
         self._force = force
 
-    def __call__(self, lbMethod, **kwargs):
-        cqc = lbMethod.conservedQuantityComputation
-        rho = cqc.zerothOrderMomentSymbol if cqc.compressible else 1
-        u = cqc.firstOrderMomentSymbols
+    def __call__(self, lb_method, **kwargs):
+        cqc = lb_method.conserved_quantity_computation
+        rho = cqc.zeroth_order_moment_symbol if cqc.compressible else 1
+        u = cqc.first_order_moment_symbols
 
         shiftedU = (u_i + f_i / rho for u_i, f_i in zip(u, self._force))
-        eqTerms = lbMethod.getEquilibriumTerms()
+        eqTerms = lb_method.get_equilibrium_terms()
         shiftedEq = eqTerms.subs({u_i: su_i for u_i, su_i in zip(u, shiftedU)})
         return shiftedEq - eqTerms
 
-    def macroscopicVelocityShift(self, density):
+    def macroscopic_velocity_shift(self, density):
         return defaultVelocityShift(density, self._force)
 
 
diff --git a/geometry.py b/geometry.py
index 9dfe7bd07778382bf1a1dc5d54711dfc231a7c37..217a305517cca332432f59d5090993428719b751 100644
--- a/geometry.py
+++ b/geometry.py
@@ -1,120 +1,120 @@
 import numpy as np
 from lbmpy.boundaries import NoSlip, UBB
-from pystencils.slicing import normalizeSlice, shiftSlice, sliceIntersection, sliceFromDirection
+from pystencils.slicing import normalize_slice, shift_slice, slice_intersection, slice_from_direction
 
 
-def getParabolicInitialVelocity(domainSize, u_max, velCoord=0, diameter=None):
+def get_parabolic_initial_velocity(domain_size, u_max, vel_coord=0, diameter=None):
     if diameter is None:
-        radius = int(round(min(sh for i, sh in enumerate(domainSize) if i != velCoord) / 2))
+        radius = int(round(min(sh for i, sh in enumerate(domain_size) if i != vel_coord) / 2))
     else:
         radius = int(round(diameter / 2))
 
-    params = [np.arange(s) + 0.5 for s in domainSize]
+    params = [np.arange(s) + 0.5 for s in domain_size]
     grid = np.meshgrid(*params, indexing='ij')
 
     dist = 0
-    for i in range(len(domainSize)):
-        if i == velCoord:
+    for i in range(len(domain_size)):
+        if i == vel_coord:
             continue
-        center = int(round(domainSize[i] / 2))
+        center = int(round(domain_size[i] / 2))
         dist += (grid[i] - center) ** 2
     dist = np.sqrt(dist)
 
-    u = np.zeros(domainSize + [len(domainSize)])
-    u[..., velCoord] = u_max * (1 - (dist / radius) ** 2)
+    u = np.zeros(domain_size + [len(domain_size)])
+    u[..., vel_coord] = u_max * (1 - (dist / radius) ** 2)
     return u
 
 
-def addBox(boundaryHandling, boundary=NoSlip(), replace=True):
+def add_box(boundary_handling, boundary=NoSlip(), replace=True):
     borders = ['N', 'S', 'E', 'W']
-    if boundaryHandling.dim == 3:
+    if boundary_handling.dim == 3:
         borders += ['T', 'B']
     for d in borders:
-        flag = boundaryHandling.setBoundary(boundary, sliceFromDirection(d, boundaryHandling.dim), replace=replace)
+        flag = boundary_handling.set_boundary(boundary, slice_from_direction(d, boundary_handling.dim), replace=replace)
     return flag
 
 
-def addParabolicVelocityInflow(boundaryHandling, u_max, indexExpr, velCoord=0, diameter=None):
-    dim = boundaryHandling.dim
+def add_parabolic_velocity_inflow(boundary_handling, u_max, index_expr, vel_coord=0, diameter=None):
+    dim = boundary_handling.dim
 
-    def velocityInfoCallback(boundaryData):
+    def velocity_info_callback(boundary_data):
         for i, name in enumerate(['vel_0', 'vel_1', 'vel_2'][:dim]):
-            if i != velCoord:
-                boundaryData[name] = 0.0
+            if i != vel_coord:
+                boundary_data[name] = 0.0
         if diameter is None:
-            radius = int(round(min(sh for i, sh in enumerate(boundaryHandling.shape) if i != velCoord) / 2))
+            radius = int(round(min(sh for i, sh in enumerate(boundary_handling.shape) if i != vel_coord) / 2))
         else:
             radius = int(round(diameter / 2))
 
         if dim == 3:
-            normalCoord1 = (velCoord + 1) % 3
-            normalCoord2 = (velCoord + 2) % 3
-            y, z = boundaryData.linkPositions(normalCoord1), boundaryData.linkPositions(normalCoord2)
-            centeredNormal1 = y - int(round(boundaryHandling.shape[normalCoord1] / 2))
-            centeredNormal2 = z - int(round(boundaryHandling.shape[normalCoord2] / 2))
-            distToCenter = np.sqrt(centeredNormal1 ** 2 + centeredNormal2 ** 2)
+            normal_coord1 = (vel_coord + 1) % 3
+            normal_coord2 = (vel_coord + 2) % 3
+            y, z = boundary_data.link_positions(normal_coord1), boundary_data.link_positions(normal_coord2)
+            centered_normal1 = y - int(round(boundary_handling.shape[normal_coord1] / 2))
+            centered_normal2 = z - int(round(boundary_handling.shape[normal_coord2] / 2))
+            dist_to_center = np.sqrt(centered_normal1 ** 2 + centered_normal2 ** 2)
         elif dim == 2:
-            normalCoord = (velCoord + 1) % 2
-            centeredNormal = boundaryData.linkPositions(normalCoord) - radius
-            distToCenter = np.sqrt(centeredNormal ** 2)
+            normal_coord = (vel_coord + 1) % 2
+            centered_normal = boundary_data.link_positions(normal_coord) - radius
+            dist_to_center = np.sqrt(centered_normal ** 2)
         else:
             raise ValueError("Invalid dimension")
 
-        velProfile = u_max * (1 - (distToCenter / radius)**2)
-        boundaryData['vel_%d' % (velCoord,)] = velProfile
+        vel_profile = u_max * (1 - (dist_to_center / radius)**2)
+        boundary_data['vel_%d' % (vel_coord,)] = vel_profile
 
-    inflow = UBB(velocityInfoCallback, dim=boundaryHandling.dim)
-    boundaryHandling.setBoundary(inflow, sliceObj=indexExpr, ghostLayers=True)
+    inflow = UBB(velocity_info_callback, dim=boundary_handling.dim)
+    boundary_handling.set_boundary(inflow, slice_obj=index_expr, ghost_layers=True)
 
 
-def setupChannelWalls(boundaryHandling, diameterCallback, duct=False, wallBoundary=NoSlip()):
-    dim = boundaryHandling.dim
+def setup_channel_walls(boundary_handling, diameter_callback, duct=False, wall_boundary=NoSlip()):
+    dim = boundary_handling.dim
     directions = ('N', 'S', 'T', 'B') if dim == 3 else ('N', 'S')
     for direction in directions:
-        boundaryHandling.setBoundary(wallBoundary, sliceFromDirection(direction, dim))
+        boundary_handling.set_boundary(wall_boundary, slice_from_direction(direction, dim))
 
-    if duct and diameterCallback is not None:
+    if duct and diameter_callback is not None:
         raise ValueError("For duct flows, passing a diameter callback does not make sense.")
 
     if not duct:
-        diameter = min(boundaryHandling.shape[1:])
-        addPipe(boundaryHandling, diameterCallback if diameterCallback else diameter, wallBoundary)
+        diameter = min(boundary_handling.shape[1:])
+        add_pipe(boundary_handling, diameter_callback if diameter_callback else diameter, wall_boundary)
 
 
-def addPipe(boundaryHandling, diameter, boundary=NoSlip()):
+def add_pipe(boundary_handling, diameter, boundary=NoSlip()):
     """
     Sets boundary for the wall of a pipe with flow in x direction.
 
-    :param boundaryHandling: boundary handling object, works for serial and parallel versions 
+    :param boundary_handling: boundary handling object, works for serial and parallel versions
     :param diameter: pipe diameter, can be either a constant value or a callback function.
                      the callback function has the signature (xCoordArray, domainShapeInCells) andp has to return
                      a array of same shape as the received xCoordArray, with the diameter for each x position
     :param boundary: boundary object that is set at the wall, defaults to NoSlip (bounce back)
     """
-    domainShape = boundaryHandling.shape
-    dim = len(domainShape)
+    domain_shape = boundary_handling.shape
+    dim = len(domain_shape)
     assert dim in (2, 3)
 
     def callback(*coordinates):
-        flowCoord = coordinates[0]
+        flow_coord = coordinates[0]
 
         if callable(diameter):
-            flowCoordLine = flowCoord[:, 0, 0] if dim == 3 else flowCoord[:, 0]
-            diameterValue = diameter(flowCoordLine, domainShape)
-            diameterValue = diameterValue[:, np.newaxis, np.newaxis] if dim == 3 else diameterValue[:, np.newaxis]
+            flow_coord_line = flow_coord[:, 0, 0] if dim == 3 else flow_coord[:, 0]
+            diameter_value = diameter(flow_coord_line, domain_shape)
+            diameter_value = diameter_value[:, np.newaxis, np.newaxis] if dim == 3 else diameter_value[:, np.newaxis]
         else:
-            diameterValue = diameter
+            diameter_value = diameter
 
-        radiusSq = (diameterValue / 2) ** 2
+        radius_sq = (diameter_value / 2) ** 2
 
-        mid = [domainShape[i] // 2 for i in range(1, dim)]
+        mid = [domain_shape[i] // 2 for i in range(1, dim)]
         distance = sum((c_i - mid_i) ** 2 for c_i, mid_i in zip(coordinates[1:], mid))
-        return distance > radiusSq
+        return distance > radius_sq
 
-    boundaryHandling.setBoundary(boundary, maskCallback=callback)
+    boundary_handling.set_boundary(boundary, mask_callback=callback)
 
 
-def readImage(path, flatten=False):
+def read_image(path, flatten=False):
     try:
         from PIL import Image
     except ImportError:
@@ -126,65 +126,55 @@ def readImage(path, flatten=False):
     return np.array(im)
 
 
-def addBlackAndWhiteImage(boundaryHandling, imageFile, targetSlice=None, plane=(0, 1), boundary=NoSlip(),
-                          keepAspectRatio=False):
-    """
-    
-    :param boundaryHandling: 
-    :param imageFile: 
-    :param targetSlice: 
-    :param plane: 
-    :param boundary: 
-    :param keepAspectRatio: 
-    :return: 
-    """
+def add_black_and_white_image(boundary_handling, image_file, target_slice=None, plane=(0, 1), boundary=NoSlip(),
+                              keep_aspect_ratio=False):
     from scipy.ndimage import zoom
 
-    domainSize = boundaryHandling.shape
-    if targetSlice is None:
-        targetSlice = [slice(None, None, None)] * len(domainSize)
+    domain_size = boundary_handling.shape
+    if target_slice is None:
+        target_slice = [slice(None, None, None)] * len(domain_size)
 
-    dim = boundaryHandling.dim
+    dim = boundary_handling.dim
 
-    imageSlice = normalizeSlice(targetSlice, domainSize)
-    targetSize = [imageSlice[i].stop - imageSlice[i].start for i in plane]
+    image_slice = normalize_slice(target_slice, domain_size)
+    target_size = [image_slice[i].stop - image_slice[i].start for i in plane]
 
-    imgArr = readImage(imageFile, flatten=True).astype(int)
-    imgArr = np.rot90(imgArr, 3)
+    img_arr = read_image(image_file, flatten=True).astype(int)
+    img_arr = np.rot90(img_arr, 3)
 
-    zoomFactor = [targetSize[i] / imgArr.shape[i] for i in range(2)]
-    if keepAspectRatio:
-        zoomFactor = min(zoomFactor)
-    zoomedImage = zoom(imgArr, zoomFactor, order=0)
+    zoom_factor = [target_size[i] / img_arr.shape[i] for i in range(2)]
+    if keep_aspect_ratio:
+        zoom_factor = min(zoom_factor)
+    zoomed_image = zoom(img_arr, zoom_factor, order=0)
 
     # binarize
-    zoomedImage[zoomedImage <= 254] = 0
-    zoomedImage[zoomedImage > 254] = 1
-    zoomedImage = np.logical_not(zoomedImage.astype(np.bool))
+    zoomed_image[zoomed_image <= 254] = 0
+    zoomed_image[zoomed_image > 254] = 1
+    zoomed_image = np.logical_not(zoomed_image.astype(np.bool))
 
     # resize necessary if aspect ratio should be constant
-    if zoomedImage.shape != targetSize:
-        resizedImage = np.zeros(targetSize, dtype=np.bool)
-        mid = [(ts - s)//2 for ts, s in zip(targetSize, zoomedImage.shape)]
-        resizedImage[mid[0]:zoomedImage.shape[0]+mid[0], mid[1]:zoomedImage.shape[1]+mid[1]] = zoomedImage
-        zoomedImage = resizedImage
+    if zoomed_image.shape != target_size:
+        resized_image = np.zeros(target_size, dtype=np.bool)
+        mid = [(ts - s)//2 for ts, s in zip(target_size, zoomed_image.shape)]
+        resized_image[mid[0]:zoomed_image.shape[0]+mid[0], mid[1]:zoomed_image.shape[1]+mid[1]] = zoomed_image
+        zoomed_image = resized_image
 
     def callback(*coordinates):
         result = np.zeros_like(coordinates[0], dtype=np.bool)
-        maskStart = [int(coordinates[i][(0,) * dim] - 0.5) for i in range(dim)]
-        maskEnd = [int(coordinates[i][(-1,) * dim] + 1 - 0.5) for i in range(dim)]
+        mask_start = [int(coordinates[i][(0,) * dim] - 0.5) for i in range(dim)]
+        mask_end = [int(coordinates[i][(-1,) * dim] + 1 - 0.5) for i in range(dim)]
 
-        maskSlice = [slice(start, stop) for start, stop in zip(maskStart, maskEnd)]
-        intersectionSlice = sliceIntersection(maskSlice, imageSlice)
-        if intersectionSlice is None:
+        mask_slice = [slice(start, stop) for start, stop in zip(mask_start, mask_end)]
+        intersection_slice = slice_intersection(mask_slice, image_slice)
+        if intersection_slice is None:
             return result
         else:
-            maskTargetSlice = shiftSlice(intersectionSlice, [-e for e in maskStart])
-            imageTargetSlice = shiftSlice(intersectionSlice, [-s.start for s in imageSlice])
-            maskTargetSlice = [maskTargetSlice[i] if i in plane else slice(None, None) for i in range(dim)]
-            imageTargetSlice = [imageTargetSlice[i] if i in plane else np.newaxis for i in range(dim)]
-            result[maskTargetSlice] = zoomedImage[imageTargetSlice]
+            mask_target_slice = shift_slice(intersection_slice, [-e for e in mask_start])
+            image_target_slice = shift_slice(intersection_slice, [-s.start for s in image_slice])
+            mask_target_slice = [mask_target_slice[i] if i in plane else slice(None, None) for i in range(dim)]
+            image_target_slice = [image_target_slice[i] if i in plane else np.newaxis for i in range(dim)]
+            result[mask_target_slice] = zoomed_image[image_target_slice]
             return result
 
-    boundaryHandling.setBoundary(boundary, sliceObj=imageSlice, maskCallback=callback,
-                                 ghostLayers=False, innerGhostLayers=True)
+    boundary_handling.set_boundary(boundary, slice_obj=image_slice, mask_callback=callback,
+                                   ghost_layers=False, inner_ghost_layers=True)
diff --git a/gridvisualization.py b/gridvisualization.py
deleted file mode 100644
index 5cf887db35983754c31e59c6c045d0f89962b584..0000000000000000000000000000000000000000
--- a/gridvisualization.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import matplotlib.patches as patches
-
-
-class Grid(object):
-    """Visualizes a 2D LBM grid with matplotlib by drawing cells and pdf arrows"""
-
-    def __init__(self, xCells, yCells):
-        """Create a new grid with the given number of cells in x (horizontal) and y (vertical) direction"""
-
-        self._xCells = xCells
-        self._yCells = yCells
-
-        self._patches = []
-        for x in range(xCells):
-            for y in range(yCells):
-                self._patches.append(patches.Rectangle((x, y), 1.0, 1.0, fill=False, linewidth=3, color='#bbbbbb'))
-
-        self._cellBoundaries = dict()  # mapping cell to rectangle patch
-        self._arrows = dict()  # mapping (cell, direction) tuples to arrow patches
-
-    def addCellBoundary(self, cell, **kwargs):
-        """Draws a rectangle around a single cell. Keyword arguments are passed to the matplotlib Rectangle patch"""
-        if 'fill' not in kwargs: kwargs['fill'] = False
-        if 'linewidth' not in kwargs: kwargs['linewidth'] = 3
-        if 'color' not in kwargs: kwargs['#bbbbbb']
-        self._cellBoundaries[cell] = patches.Rectangle(cell, 1.0, 1.0, **kwargs)
-
-    def addCellBoundaries(self, **kwargs):
-        """Draws a rectangle around all cells. Keyword arguments are passed to the matplotlib Rectangle patch"""
-        for x in range(self._xCells):
-            for y in range(self._yCells):
-                self.addCellBoundary((x, y), **kwargs)
-
-    def addArrow(self, cell, arrowPosition, arrowDirection, **kwargs):
-        """
-        Draws an arrow in a cell. If an arrow exists already at this position, it is replaced.
-
-        :param cell: cell coordinate as tuple (x,y)
-        :param arrowPosition: each cell has 9 possible positions specified as tuple e.g. upper left (-1, 1)
-        :param arrowDirection: direction of the arrow as (x,y) tuple
-        :param kwargs: arguments passed directly to the FancyArrow patch of matplotlib
-        """
-        cellMidpoint = (0.5 + cell[0], 0.5 + cell[1])
-
-        if 'width' not in kwargs: kwargs['width'] = 0.005
-        if 'color' not in kwargs: kwargs['color'] = 'k'
-
-        if arrowPosition == (0, 0):
-            del kwargs['width']
-            self._arrows[(cell, arrowPosition)] = patches.Circle(cellMidpoint, radius=0.03, **kwargs)
-        else:
-            arrowMidpoint = (cellMidpoint[0] + arrowPosition[0] * 0.25,
-                             cellMidpoint[1] + arrowPosition[1] * 0.25)
-            length = 0.75
-            arrowStart = (arrowMidpoint[0] - arrowDirection[0] * 0.25 * length,
-                          arrowMidpoint[1] - arrowDirection[1] * 0.25 * length)
-
-            patch = patches.FancyArrow(arrowStart[0], arrowStart[1],
-                                       0.25 * length * arrowDirection[0],
-                                       0.25 * length * arrowDirection[1],
-                                       **kwargs)
-            self._arrows[(cell, arrowPosition)] = patch
-
-    def fillWithDefaultArrows(self, **kwargs):
-        """Fills the complete grid with the default pdf arrows"""
-        for x in range(self._xCells):
-            for y in range(self._yCells):
-                for dx in [-1, 0, 1]:
-                    for dy in [-1, 0, 1]:
-                        if 'color' not in kwargs: kwargs['color'] = '#bbbbbb'
-                        if 'width' not in kwargs: kwargs['width'] = 0.006
-
-                        self.addArrow((x, y), (dx, dy), (dx, dy), **kwargs)
-
-    def draw(self, ax):
-        """Draw the grid into a given matplotlib axes object"""
-
-        for p in self._patches:
-            ax.add_patch(p)
-
-        for arrowPatch in self._arrows.values():
-            ax.add_patch(arrowPatch)
-
-        offset = 0.1
-        ax.set_xlim(-offset, self._xCells+offset)
-        ax.set_xlim(-offset, self._xCells + offset)
-        ax.set_ylim(-offset, self._yCells + offset)
-        ax.set_aspect('equal')
-        ax.set_axis_off()
diff --git a/innerloopsplit.py b/innerloopsplit.py
index 5c89f551a8ebdb345a979b6fa87eb3a33f98ef05..ea1524cf8d3c15421e82e70fbfd5cb18777e1e02 100644
--- a/innerloopsplit.py
+++ b/innerloopsplit.py
@@ -1,13 +1,14 @@
 import sympy as sp
 from collections import defaultdict
 from pystencils import Field
+from lbmpy.methods.abstractlbmethod import LbmCollisionRule
 
 
-def createLbmSplitGroups(lbmCollisionEqs):
+def create_lbm_split_groups(cr: LbmCollisionRule):
     """
     Creates split groups for LBM collision equations. For details about split groups see
-    :func:`pystencils.transformation.splitInnerLoop` .
-    The split groups are added as simplification hint 'splitGroups'
+    :func:`pystencils.transformation.split_inner_loop` .
+    The split groups are added as simplification hint 'split_groups'
 
     Split groups are created in the following way: Opposing directions are put into a single group.
     The velocity subexpressions are pre-computed as well as all subexpressions which are used in all
@@ -16,46 +17,46 @@ def createLbmSplitGroups(lbmCollisionEqs):
     Required simplification hints:
         - velocity: sequence of velocity symbols
     """
-    sh = lbmCollisionEqs.simplification_hints
+    sh = cr.simplification_hints
     assert 'velocity' in sh, "Needs simplification hint 'velocity': Sequence of velocity symbols"
 
-    preCollisionSymbols = set(lbmCollisionEqs.method.preCollisionPdfSymbols)
-    nonCenterPostCollisionSymbols = set(lbmCollisionEqs.method.postCollisionPdfSymbols[1:])
-    postCollisionSymbols = set(lbmCollisionEqs.method.postCollisionPdfSymbols)
+    pre_collision_symbols = set(cr.method.pre_collision_pdf_symbols)
+    non_center_post_collision_symbols = set(cr.method.post_collision_pdf_symbols[1:])
+    post_collision_symbols = set(cr.method.post_collision_pdf_symbols)
 
-    stencil = lbmCollisionEqs.method.stencil
+    stencil = cr.method.stencil
 
-    importantSubExpressions = {e.lhs for e in lbmCollisionEqs.subexpressions
-                               if preCollisionSymbols.intersection(lbmCollisionEqs.dependent_symbols([e.lhs]))}
+    important_sub_expressions = {e.lhs for e in cr.subexpressions
+                                 if pre_collision_symbols.intersection(cr.dependent_symbols([e.lhs]))}
 
-    otherWrittenFields = []
-    for eq in lbmCollisionEqs.main_assignments:
-        if eq.lhs not in postCollisionSymbols and isinstance(eq.lhs, Field.Access):
-            otherWrittenFields.append(eq.lhs)
-        if eq.lhs not in nonCenterPostCollisionSymbols:
+    other_written_fields = []
+    for eq in cr.main_assignments:
+        if eq.lhs not in post_collision_symbols and isinstance(eq.lhs, Field.Access):
+            other_written_fields.append(eq.lhs)
+        if eq.lhs not in non_center_post_collision_symbols:
             continue
-        importantSubExpressions.intersection_update(eq.rhs.atoms(sp.Symbol))
+        important_sub_expressions.intersection_update(eq.rhs.atoms(sp.Symbol))
 
-    importantSubExpressions.update(sh['velocity'])
+    important_sub_expressions.update(sh['velocity'])
 
-    subexpressionsToPreCompute = list(importantSubExpressions)
-    splitGroups = [subexpressionsToPreCompute + otherWrittenFields, ]
+    subexpressions_to_pre_compute = list(important_sub_expressions)
+    split_groups = [subexpressions_to_pre_compute + other_written_fields, ]
 
-    directionGroups = defaultdict(list)
+    direction_groups = defaultdict(list)
     dim = len(stencil[0])
 
-    for direction, eq in zip(stencil, lbmCollisionEqs.main_assignments):
+    for direction, eq in zip(stencil, cr.main_assignments):
         if direction == tuple([0]*dim):
-            splitGroups[0].append(eq.lhs)
+            split_groups[0].append(eq.lhs)
             continue
 
-        inverseDir = tuple([-i for i in direction])
+        inverse_dir = tuple([-i for i in direction])
 
-        if inverseDir in directionGroups:
-            directionGroups[inverseDir].append(eq.lhs)
+        if inverse_dir in direction_groups:
+            direction_groups[inverse_dir].append(eq.lhs)
         else:
-            directionGroups[direction].append(eq.lhs)
-    splitGroups += directionGroups.values()
+            direction_groups[direction].append(eq.lhs)
+    split_groups += direction_groups.values()
 
-    lbmCollisionEqs.simplification_hints['splitGroups'] = splitGroups
-    return lbmCollisionEqs
+    cr.simplification_hints['split_groups'] = split_groups
+    return cr
diff --git a/lbstep.py b/lbstep.py
index 991803763e1f74aa7774ef64511e533f2c449962..5ef8d946ef38eb751b196874101fc9ed71531967 100644
--- a/lbstep.py
+++ b/lbstep.py
@@ -1,164 +1,167 @@
 import numpy as np
 from lbmpy.boundaries.boundaryhandling import LatticeBoltzmannBoundaryHandling
-from lbmpy.creationfunctions import switchToSymbolicRelaxationRatesForOmegaAdaptingMethods, \
-    createLatticeBoltzmannFunction, \
-    updateWithDefaultParameters
-from lbmpy.simplificationfactory import createSimplificationStrategy
-from lbmpy.stencils import getStencil
+from lbmpy.creationfunctions import switch_to_symbolic_relaxation_rates_for_omega_adapting_methods, \
+    create_lb_function, \
+    update_with_default_parameters
+from lbmpy.simplificationfactory import create_simplification_strategy
+from lbmpy.stencils import get_stencil
 from pystencils.datahandling.serial_datahandling import SerialDataHandling
-from pystencils import createKernel, makeSlice
+from pystencils import create_kernel, makeSlice
 from pystencils.slicing import SlicedGetter
 from pystencils.timeloop import TimeLoop
 
 
 class LatticeBoltzmannStep:
 
-    def __init__(self, domainSize=None, lbmKernel=None, periodicity=False,
-                 kernelParams={}, dataHandling=None, name="lbm", optimizationParams={},
-                 velocityDataName=None, densityDataName=None, densityDataIndex=None,
-                 computeVelocityInEveryStep=False, computeDensityInEveryStep=False,
-                 velocityInputArrayName=None, timeStepOrder='streamCollide', flagInterface=None,
-                 **methodParameters):
+    def __init__(self, domain_size=None, lbm_kernel=None, periodicity=False,
+                 kernel_params={}, data_handling=None, name="lbm", optimization=None,
+                 velocity_data_name=None, density_data_name=None, density_data_index=None,
+                 compute_velocity_in_every_step=False, compute_density_in_every_step=False,
+                 velocity_input_array_name=None, time_step_order='streamCollide', flag_interface=None,
+                 **method_parameters):
 
         # --- Parameter normalization  ---
-        if dataHandling is not None:
-            if domainSize is not None:
-                raise ValueError("When passing a dataHandling, the domainSize parameter can not be specified")
+        if data_handling is not None:
+            if domain_size is not None:
+                raise ValueError("When passing a data_handling, the domain_size parameter can not be specified")
 
-        if dataHandling is None:
-            if domainSize is None:
-                raise ValueError("Specify either domainSize or dataHandling")
-            dataHandling = SerialDataHandling(domainSize, defaultGhostLayers=1, periodicity=periodicity)
+        if data_handling is None:
+            if domain_size is None:
+                raise ValueError("Specify either domain_size or data_handling")
+            data_handling = SerialDataHandling(domain_size, default_ghost_layers=1, periodicity=periodicity)
 
-        if 'stencil' not in methodParameters:
-            methodParameters['stencil'] = 'D2Q9' if dataHandling.dim == 2 else 'D3Q27'
+        if 'stencil' not in method_parameters:
+            method_parameters['stencil'] = 'D2Q9' if data_handling.dim == 2 else 'D3Q27'
 
-        methodParameters, optimizationParams = updateWithDefaultParameters(methodParameters, optimizationParams)
-        del methodParameters['kernelType']
+        method_parameters, optimization = update_with_default_parameters(method_parameters, optimization)
+        del method_parameters['kernel_type']
 
-        if lbmKernel:
-            Q = len(lbmKernel.method.stencil)
+        if lbm_kernel:
+            q = len(lbm_kernel.method.stencil)
         else:
-            Q = len(getStencil(methodParameters['stencil']))
-        target = optimizationParams['target']
+            q = len(get_stencil(method_parameters['stencil']))
+        target = optimization['target']
 
         self.name = name
-        self._dataHandling = dataHandling
-        self._pdfArrName = name + "_pdfSrc"
-        self._tmpArrName = name + "_pdfTmp"
-        self.velocityDataName = name + "_velocity" if velocityDataName is None else velocityDataName
-        self.densityDataName = name + "_density" if densityDataName is None else densityDataName
-        self.densityDataIndex = densityDataIndex
+        self._data_handling = data_handling
+        self._pdf_arr_name = name + "_pdfSrc"
+        self._tmp_arr_name = name + "_pdfTmp"
+        self.velocity_data_name = name + "_velocity" if velocity_data_name is None else velocity_data_name
+        self.density_data_name = name + "_density" if density_data_name is None else density_data_name
+        self.density_data_index = density_data_index
 
         self._gpu = target == 'gpu'
-        layout = optimizationParams['fieldLayout']
-        self._dataHandling.addArray(self._pdfArrName, fSize=Q, gpu=self._gpu, layout=layout, latexName='src')
-        self._dataHandling.addArray(self._tmpArrName, fSize=Q, gpu=self._gpu, cpu=not self._gpu,
-                                    layout=layout, latexName='dst')
-
-        if velocityDataName is None:
-            self._dataHandling.addArray(self.velocityDataName, fSize=self._dataHandling.dim,
-                                        gpu=self._gpu and computeVelocityInEveryStep, layout=layout, latexName='u')
-        if densityDataName is None:
-            self._dataHandling.addArray(self.densityDataName, fSize=1,
-                                        gpu=self._gpu and computeDensityInEveryStep, layout=layout, latexName='ρ')
-
-        if computeVelocityInEveryStep:
-            methodParameters['output']['velocity'] = self._dataHandling.fields[self.velocityDataName]
-        if computeDensityInEveryStep:
-            densityField = self._dataHandling.fields[self.densityDataName]
-            if self.densityDataIndex is not None:
-                densityField = densityField(densityDataIndex)
-            methodParameters['output']['density'] = densityField
-        if velocityInputArrayName is not None:
-            methodParameters['velocityInput'] = self._dataHandling.fields[velocityInputArrayName]
-        if methodParameters['omegaOutputField'] and isinstance(methodParameters['omegaOutputField'], str):
-            methodParameters['omegaOutputField'] = dataHandling.addArray(methodParameters['omegaOutputField'])
-
-        self.kernelParams = kernelParams
+        layout = optimization['field_layout']
+        self._data_handling.add_array(self._pdf_arr_name, values_per_cell=q, gpu=self._gpu, layout=layout,
+                                      latex_name='src')
+        self._data_handling.add_array(self._tmp_arr_name, values_per_cell=q, gpu=self._gpu, cpu=not self._gpu,
+                                      layout=layout, latex_name='dst')
+
+        if velocity_data_name is None:
+            self._data_handling.add_array(self.velocity_data_name, values_per_cell=self._data_handling.dim,
+                                          gpu=self._gpu and compute_velocity_in_every_step,
+                                          layout=layout, latex_name='u')
+        if density_data_name is None:
+            self._data_handling.add_array(self.density_data_name, values_per_cell=1,
+                                          gpu=self._gpu and compute_density_in_every_step,
+                                          layout=layout, latex_name='ρ')
+
+        if compute_velocity_in_every_step:
+            method_parameters['output']['velocity'] = self._data_handling.fields[self.velocity_data_name]
+        if compute_density_in_every_step:
+            density_field = self._data_handling.fields[self.density_data_name]
+            if self.density_data_index is not None:
+                density_field = density_field(density_data_index)
+            method_parameters['output']['density'] = density_field
+        if velocity_input_array_name is not None:
+            method_parameters['velocity_input'] = self._data_handling.fields[velocity_input_array_name]
+        if method_parameters['omega_output_field'] and isinstance(method_parameters['omega_output_field'], str):
+            method_parameters['omega_output_field'] = data_handling.add_array(method_parameters['omega_output_field'])
+
+        self.kernelParams = kernel_params
 
         # --- Kernel creation ---
-        if lbmKernel is None:
-            switchToSymbolicRelaxationRatesForOmegaAdaptingMethods(methodParameters, self.kernelParams)
-            optimizationParams['symbolicField'] = dataHandling.fields[self._pdfArrName]
-            methodParameters['fieldName'] = self._pdfArrName
-            methodParameters['secondFieldName'] = self._tmpArrName
-            if timeStepOrder == 'streamCollide':
-                self._lbmKernels = [createLatticeBoltzmannFunction(optimizationParams=optimizationParams,
-                                                                   **methodParameters)]
-            elif timeStepOrder == 'collideStream':
-                self._lbmKernels = [createLatticeBoltzmannFunction(optimizationParams=optimizationParams,
-                                                                   kernelType='collideOnly',
-                                                                   **methodParameters),
-                                    createLatticeBoltzmannFunction(optimizationParams=optimizationParams,
-                                                                   kernelType='streamPullOnly',
-                                                                   ** methodParameters)]
+        if lbm_kernel is None:
+            switch_to_symbolic_relaxation_rates_for_omega_adapting_methods(method_parameters, self.kernelParams)
+            optimization['symbolic_field'] = data_handling.fields[self._pdf_arr_name]
+            method_parameters['field_name'] = self._pdf_arr_name
+            method_parameters['temporary_field_name'] = self._tmp_arr_name
+            if time_step_order == 'streamCollide':
+                self._lbmKernels = [create_lb_function(optimization=optimization,
+                                                       **method_parameters)]
+            elif time_step_order == 'collideStream':
+                self._lbmKernels = [create_lb_function(optimization=optimization,
+                                                       kernel_type='collide_only',
+                                                       **method_parameters),
+                                    create_lb_function(optimization=optimization,
+                                                       kernel_type='stream_pull_only',
+                                                       ** method_parameters)]
 
         else:
-            assert self._dataHandling.dim == lbmKernel.method.dim, \
-                "Error: %dD Kernel for %D domain" % (lbmKernel.method.dim, self._dataHandling.dim)
-            self._lbmKernels = [lbmKernel]
+            assert self._data_handling.dim == lbm_kernel.method.dim, \
+                "Error: %dD Kernel for %d dimensional domain" % (lbm_kernel.method.dim, self._data_handling.dim)
+            self._lbmKernels = [lbm_kernel]
 
         self.method = self._lbmKernels[0].method
         self.ast = self._lbmKernels[0].ast
 
         # -- Boundary Handling  & Synchronization ---
-        self._sync = dataHandling.synchronizationFunction([self._pdfArrName], methodParameters['stencil'], target)
-        self._boundaryHandling = LatticeBoltzmannBoundaryHandling(self.method, self._dataHandling, self._pdfArrName,
-                                                                  name=name + "_boundaryHandling",
-                                                                  flagInterface=flagInterface,
-                                                                  target=target, openMP=optimizationParams['openMP'])
+        self._sync = data_handling.synchronization_function([self._pdf_arr_name], method_parameters['stencil'], target)
+        self._boundary_handling = LatticeBoltzmannBoundaryHandling(self.method, self._data_handling, self._pdf_arr_name,
+                                                                   name=name + "_boundary_handling",
+                                                                   flag_interface=flag_interface,
+                                                                   target=target, openmp=optimization['openmp'])
 
         # -- Macroscopic Value Kernels
-        self._getterKernel, self._setterKernel = self._compilerMacroscopicSetterAndGetter()
+        self._getterKernel, self._setterKernel = self._compile_macroscopic_setter_and_getter()
 
-        self._dataHandling.fill(self.densityDataName, 1.0, fValue=self.densityDataIndex,
-                                ghostLayers=True, innerGhostLayers=True)
-        self._dataHandling.fill(self.velocityDataName, 0.0, ghostLayers=True, innerGhostLayers=True)
-        self.setPdfFieldsFromMacroscopicValues()
+        self._data_handling.fill(self.density_data_name, 1.0, value_idx=self.density_data_index,
+                                 ghost_layers=True, inner_ghost_layers=True)
+        self._data_handling.fill(self.velocity_data_name, 0.0, ghost_layers=True, inner_ghost_layers=True)
+        self.set_pdf_fields_from_macroscopic_values()
 
         # -- VTK output
-        self.vtkWriter = self.dataHandling.vtkWriter(name, [self.velocityDataName, self.densityDataName])
+        self.vtkWriter = self.data_handling.create_vtk_writer(name, [self.velocity_data_name, self.density_data_name])
         self.timeStepsRun = 0
 
     @property
-    def boundaryHandling(self):
+    def boundary_handling(self):
         """Boundary handling instance of the scenario. Use this to change the boundary setup"""
-        return self._boundaryHandling
+        return self._boundary_handling
 
     @property
-    def dataHandling(self):
-        return self._dataHandling
+    def data_handling(self):
+        return self._data_handling
 
     @property
     def dim(self):
-        return self._dataHandling.dim
+        return self._data_handling.dim
 
     @property
-    def domainSize(self):
-        return self._dataHandling.shape
+    def domain_size(self):
+        return self._data_handling.shape
 
     @property
-    def numberOfCells(self):
+    def number_of_cells(self):
         result = 1
-        for d in self.domainSize:
+        for d in self.domain_size:
             result *= d
         return result
 
     @property
-    def pdfArrayName(self):
-        return self._pdfArrName
+    def pdf_array_name(self):
+        return self._pdf_arr_name
 
-    def _getSlice(self, dataName, sliceObj, masked):
-        if sliceObj is None:
-            sliceObj = makeSlice[:, :] if self.dim == 2 else makeSlice[:, :, 0.5]
+    def _get_slice(self, data_name, slice_obj, masked):
+        if slice_obj is None:
+            slice_obj = makeSlice[:, :] if self.dim == 2 else makeSlice[:, :, 0.5]
 
-        result = self._dataHandling.gatherArray(dataName, sliceObj)
+        result = self._data_handling.gather_array(data_name, slice_obj)
         if result is None:
             return
 
         if masked:
-            mask = self.boundaryHandling.getMask(sliceObj[:self.dim], 'domain', True)
+            mask = self.boundary_handling.get_mask(slice_obj[:self.dim], 'domain', True)
             if len(mask.shape) < len(result.shape):
                 assert len(mask.shape) + 1 == len(result.shape)
                 mask = np.repeat(mask[..., np.newaxis], result.shape[-1], axis=2)
@@ -166,94 +169,95 @@ class LatticeBoltzmannStep:
             result = np.ma.masked_array(result, mask)
         return result.squeeze()
 
-    def velocitySlice(self, sliceObj=None, masked=True):
-        return self._getSlice(self.velocityDataName, sliceObj, masked)
+    def velocity_slice(self, slice_obj=None, masked=True):
+        return self._get_slice(self.velocity_data_name, slice_obj, masked)
 
-    def densitySlice(self, sliceObj=None, masked=True):
-        if self.densityDataIndex is not None:
-            sliceObj += (self.densityDataIndex,)
-        return self._getSlice(self.densityDataName, sliceObj, masked)
+    def density_slice(self, slice_obj=None, masked=True):
+        if self.density_data_index is not None:
+            slice_obj += (self.density_data_index,)
+        return self._get_slice(self.density_data_name, slice_obj, masked)
 
     @property
     def velocity(self):
-        return SlicedGetter(self.velocitySlice)
+        return SlicedGetter(self.velocity_slice)
 
     @property
     def density(self):
-        return SlicedGetter(self.densitySlice)
+        return SlicedGetter(self.density_slice)
 
-    def preRun(self):
+    def pre_run(self):
         if self._gpu:
-            self._dataHandling.toGpu(self._pdfArrName)
-            if self._dataHandling.isOnGpu(self.velocityDataName):
-                self._dataHandling.toGpu(self.velocityDataName)
-            if self._dataHandling.isOnGpu(self.densityDataName):
-                self._dataHandling.toGpu(self.densityDataName)
+            self._data_handling.to_gpu(self._pdf_arr_name)
+            if self._data_handling.is_on_gpu(self.velocity_data_name):
+                self._data_handling.to_gpu(self.velocity_data_name)
+            if self._data_handling.is_on_gpu(self.density_data_name):
+                self._data_handling.to_gpu(self.density_data_name)
 
-    def setPdfFieldsFromMacroscopicValues(self):
-        self._dataHandling.runKernel(self._setterKernel, **self.kernelParams)
+    def set_pdf_fields_from_macroscopic_values(self):
+        self._data_handling.run_kernel(self._setterKernel, **self.kernelParams)
 
-    def timeStep(self):
+    def time_step(self):
         if len(self._lbmKernels) == 2:  # collide stream
-            self._dataHandling.runKernel(self._lbmKernels[0], **self.kernelParams)
+            self._data_handling.run_kernel(self._lbmKernels[0], **self.kernelParams)
             self._sync()
-            self._boundaryHandling(**self.kernelParams)
-            self._dataHandling.runKernel(self._lbmKernels[1], **self.kernelParams)
+            self._boundary_handling(**self.kernelParams)
+            self._data_handling.run_kernel(self._lbmKernels[1], **self.kernelParams)
         else:  # stream collide
             self._sync()
-            self._boundaryHandling(**self.kernelParams)
-            self._dataHandling.runKernel(self._lbmKernels[0], **self.kernelParams)
+            self._boundary_handling(**self.kernelParams)
+            self._data_handling.run_kernel(self._lbmKernels[0], **self.kernelParams)
 
-        self._dataHandling.swap(self._pdfArrName, self._tmpArrName, self._gpu)
+        self._data_handling.swap(self._pdf_arr_name, self._tmp_arr_name, self._gpu)
         self.timeStepsRun += 1
 
-    def postRun(self):
+    def post_run(self):
         if self._gpu:
-            self._dataHandling.toCpu(self._pdfArrName)
-        self._dataHandling.runKernel(self._getterKernel, **self.kernelParams)
+            self._data_handling.to_cpu(self._pdf_arr_name)
+        self._data_handling.run_kernel(self._getterKernel, **self.kernelParams)
 
     def run(self, timeSteps):
-        self.preRun()
+        self.pre_run()
         for i in range(timeSteps):
-            self.timeStep()
-        self.postRun()
-
-    def benchmarkRun(self, timeSteps):
-        timeLoop = TimeLoop()
-        timeLoop.addStep(self)
-        durationOfTimeStep = timeLoop.benchmarkRun(timeSteps)
-        mlups = self.numberOfCells / durationOfTimeStep * 1e-6
+            self.time_step()
+        self.post_run()
+
+    def benchmark_run(self, time_steps):
+        time_loop = TimeLoop()
+        time_loop.add_step(self)
+        duration_of_time_step = time_loop.benchmark_run(time_steps)
+        mlups = self.number_of_cells / duration_of_time_step * 1e-6
         return mlups
 
-    def benchmark(self, timeForBenchmark=5, initTimeSteps=10, numberOfTimeStepsForEstimation=20):
-        timeLoop = TimeLoop()
-        timeLoop.addStep(self)
-        durationOfTimeStep = timeLoop.benchmark(timeForBenchmark, initTimeSteps, numberOfTimeStepsForEstimation)
-        mlups = self.numberOfCells / durationOfTimeStep * 1e-6
+    def benchmark(self, time_for_benchmark=5, init_time_steps=10, number_of_time_steps_for_estimation=20):
+        time_loop = TimeLoop()
+        time_loop.add_step(self)
+        duration_of_time_step = time_loop.benchmark(time_for_benchmark, init_time_steps,
+                                                    number_of_time_steps_for_estimation)
+        mlups = self.number_of_cells / duration_of_time_step * 1e-6
         return mlups
 
-    def writeVTK(self):
+    def write_vtk(self):
         self.vtkWriter(self.timeStepsRun)
 
-    def _compilerMacroscopicSetterAndGetter(self):
-        lbMethod = self.method
-        D = lbMethod.dim
-        Q = len(lbMethod.stencil)
-        cqc = lbMethod.conservedQuantityComputation
-        pdfField = self._dataHandling.fields[self._pdfArrName]
-        rhoField = self._dataHandling.fields[self.densityDataName]
-        rhoField = rhoField.center if self.densityDataIndex is None else rhoField(self.densityDataIndex)
-        velField = self._dataHandling.fields[self.velocityDataName]
-        pdfSymbols = [pdfField(i) for i in range(Q)]
-
-        getterEqs = cqc.outputEquationsFromPdfs(pdfSymbols, {'density': rhoField, 'velocity': velField})
-        getterKernel = createKernel(getterEqs, target='cpu').compile()
-
-        inpEqs = cqc.equilibriumInputEquationsFromInitValues(rhoField, [velField(i) for i in range(D)])
-        setterEqs = lbMethod.getEquilibrium(conservedQuantityEquations=inpEqs)
-        setterEqs = setterEqs.new_with_substitutions({sym: pdfField(i)
-                                                      for i, sym in enumerate(lbMethod.postCollisionPdfSymbols)})
-
-        setterEqs = createSimplificationStrategy(lbMethod)(setterEqs)
-        setterKernel = createKernel(setterEqs, target='cpu').compile()
-        return getterKernel, setterKernel
+    def _compile_macroscopic_setter_and_getter(self):
+        lb_method = self.method
+        dim = lb_method.dim
+        q = len(lb_method.stencil)
+        cqc = lb_method.conserved_quantity_computation
+        pdf_field = self._data_handling.fields[self._pdf_arr_name]
+        rho_field = self._data_handling.fields[self.density_data_name]
+        rho_field = rho_field.center if self.density_data_index is None else rho_field(self.density_data_index)
+        vel_field = self._data_handling.fields[self.velocity_data_name]
+        pdf_symbols = [pdf_field(i) for i in range(q)]
+
+        getter_eqs = cqc.output_equations_from_pdfs(pdf_symbols, {'density': rho_field, 'velocity': vel_field})
+        getter_kernel = create_kernel(getter_eqs, target='cpu').compile()
+
+        inp_eqs = cqc.equilibrium_input_equations_from_init_values(rho_field, [vel_field(i) for i in range(dim)])
+        setter_eqs = lb_method.get_equilibrium(conserved_quantity_equations=inp_eqs)
+        setter_eqs = setter_eqs.new_with_substitutions({sym: pdf_field(i)
+                                                      for i, sym in enumerate(lb_method.post_collision_pdf_symbols)})
+
+        setter_eqs = create_simplification_strategy(lb_method)(setter_eqs)
+        setter_kernel = create_kernel(setter_eqs, target='cpu').compile()
+        return getter_kernel, setter_kernel
diff --git a/macroscopic_value_kernels.py b/macroscopic_value_kernels.py
index 660d85c61419a85a0b91e8ec40b0f6ee61a27f1c..5e997c90d1c56137c042778b5d5561d7ca83db82 100644
--- a/macroscopic_value_kernels.py
+++ b/macroscopic_value_kernels.py
@@ -1,66 +1,66 @@
 from copy import deepcopy
-from pystencils.field import Field, getLayoutOfArray
-from lbmpy.simplificationfactory import createSimplificationStrategy
+from pystencils.field import Field, get_layout_of_array
+from lbmpy.simplificationfactory import create_simplification_strategy
 
 
-def compileMacroscopicValuesGetter(lbMethod, outputQuantities, pdfArr=None, fieldLayout='numpy', target='cpu'):
+def compileMacroscopicValuesGetter(lb_method, outputQuantities, pdfArr=None, field_layout='numpy', target='cpu'):
     """
     Create kernel to compute macroscopic value(s) from a pdf field (e.g. density or velocity)
 
-    :param lbMethod: instance of :class:`lbmpy.methods.AbstractLbMethod`
+    :param lb_method: instance of :class:`lbmpy.methods.AbstractLbMethod`
     :param outputQuantities: sequence of quantities to compute e.g. ['density', 'velocity']
     :param pdfArr: optional numpy array for pdf field - used to get optimal loop structure for kernel
-    :param fieldLayout: layout for output field, also used for pdf field if pdfArr is not given
+    :param field_layout: layout for output field, also used for pdf field if pdfArr is not given
     :param target: 'cpu' or 'gpu'
     :return: a function to compute macroscopic values:
-        - pdfArray
+        - pdf_array
         - keyword arguments from name of conserved quantity (as in outputQuantities) to numpy field
     """
     if not (isinstance(outputQuantities, list) or isinstance(outputQuantities, tuple)):
         outputQuantities = [outputQuantities]
 
-    cqc = lbMethod.conservedQuantityComputation
-    unknownQuantities = [oq for oq in outputQuantities if oq not in cqc.conservedQuantities]
+    cqc = lb_method.conserved_quantity_computation
+    unknownQuantities = [oq for oq in outputQuantities if oq not in cqc.conserved_quantities]
     if unknownQuantities:
         raise ValueError("No such conserved quantity: %s, conserved quantities are %s" %
-                         (str(unknownQuantities), str(cqc.conservedQuantities.keys())))
+                         (str(unknownQuantities), str(cqc.conserved_quantities.keys())))
 
     if pdfArr is None:
-        pdfField = Field.createGeneric('pdfs', lbMethod.dim, indexDimensions=1, layout=fieldLayout)
+        pdfField = Field.create_generic('pdfs', lb_method.dim, index_dimensions=1, layout=field_layout)
     else:
-        pdfField = Field.createFromNumpyArray('pdfs', pdfArr, indexDimensions=1)
+        pdfField = Field.create_from_numpy_array('pdfs', pdfArr, index_dimensions=1)
 
     outputMapping = {}
     for outputQuantity in outputQuantities:
-        numberOfElements = cqc.conservedQuantities[outputQuantity]
+        numberOfElements = cqc.conserved_quantities[outputQuantity]
         assert numberOfElements >= 1
 
         indDims = 0 if numberOfElements <= 1 else 1
         if pdfArr is None:
-            outputField = Field.createGeneric(outputQuantity, lbMethod.dim, layout=fieldLayout, indexDimensions=indDims)
+            outputField = Field.create_generic(outputQuantity, lb_method.dim, layout=field_layout, index_dimensions=indDims)
         else:
             outputFieldShape = pdfArr.shape[:-1]
             if indDims > 0:
                 outputFieldShape += (numberOfElements,)
-                fieldLayout = getLayoutOfArray(pdfArr)
+                field_layout = get_layout_of_array(pdfArr)
             else:
-                fieldLayout = getLayoutOfArray(pdfArr, indexDimensionIds=[len(pdfField.shape) - 1])
-            outputField = Field.createFixedSize(outputQuantity, outputFieldShape, indDims, pdfArr.dtype, fieldLayout)
+                field_layout = get_layout_of_array(pdfArr, index_dimension_ids=[len(pdfField.shape) - 1])
+            outputField = Field.create_fixed_size(outputQuantity, outputFieldShape, indDims, pdfArr.dtype, field_layout)
 
         outputMapping[outputQuantity] = [outputField(i) for i in range(numberOfElements)]
         if len(outputMapping[outputQuantity]) == 1:
             outputMapping[outputQuantity] = outputMapping[outputQuantity][0]
 
-    stencil = lbMethod.stencil
+    stencil = lb_method.stencil
     pdfSymbols = [pdfField(i) for i in range(len(stencil))]
-    eqs = cqc.outputEquationsFromPdfs(pdfSymbols, outputMapping).all_assignments
+    eqs = cqc.output_equations_from_pdfs(pdfSymbols, outputMapping).all_assignments
 
     if target == 'cpu':
         import pystencils.cpu as cpu
-        kernel = cpu.makePythonFunction(cpu.createKernel(eqs))
+        kernel = cpu.make_python_function(cpu.create_kernel(eqs))
     elif target == 'gpu':
         import pystencils.gpucuda as gpu
-        kernel = gpu.makePythonFunction(gpu.createCUDAKernel(eqs))
+        kernel = gpu.make_python_function(gpu.create_cuda_kernel(eqs))
     else:
         raise ValueError("Unknown target '%s'. Possible targets are 'cpu' and 'gpu'" % (target,))
 
@@ -76,25 +76,25 @@ def compileMacroscopicValuesGetter(lbMethod, outputQuantities, pdfArr=None, fiel
     return getter
 
 
-def compileMacroscopicValuesSetter(lbMethod, quantitiesToSet, pdfArr=None, fieldLayout='numpy', target='cpu'):
+def compileMacroscopicValuesSetter(lb_method, quantitiesToSet, pdfArr=None, field_layout='numpy', target='cpu'):
     """
     Creates a function that sets a pdf field to specified macroscopic quantities
     The returned function can be called with the pdf field to set as single argument
 
-    :param lbMethod: instance of :class:`lbmpy.methods.AbstractLbMethod`
+    :param lb_method: instance of :class:`lbmpy.methods.AbstractLbMethod`
     :param quantitiesToSet: map from conserved quantity name to fixed value or numpy array
     :param pdfArr: optional numpy array for pdf field - used to get optimal loop structure for kernel
-    :param fieldLayout: layout of the pdf field if pdfArr was not given
+    :param field_layout: layout of the pdf field if pdfArr was not given
     :param target: 'cpu' or 'gpu'
     :return: function taking pdf array as single argument and which sets the field to the given values
     """
     if pdfArr is not None:
-        pdfField = Field.createFromNumpyArray('pdfs', pdfArr, indexDimensions=1)
+        pdfField = Field.create_from_numpy_array('pdfs', pdfArr, index_dimensions=1)
     else:
-        pdfField = Field.createGeneric('pdfs', lbMethod.dim, indexDimensions=1, layout=fieldLayout)
+        pdfField = Field.create_generic('pdfs', lb_method.dim, index_dimensions=1, layout=field_layout)
 
     fixedKernelParameters = {}
-    cqc = lbMethod.conservedQuantityComputation
+    cqc = lb_method.conserved_quantity_computation
 
     valueMap = {}
     atLeastOneFieldInput = False
@@ -102,8 +102,8 @@ def compileMacroscopicValuesSetter(lbMethod, quantitiesToSet, pdfArr=None, field
         if hasattr(value, 'shape'):
             fixedKernelParameters[quantityName] = value
             atLeastOneFieldInput = True
-            numComponents = cqc.conservedQuantities[quantityName]
-            field = Field.createFromNumpyArray(quantityName, value, indexDimensions=0 if numComponents <= 1 else 1)
+            numComponents = cqc.conserved_quantities[quantityName]
+            field = Field.create_from_numpy_array(quantityName, value, index_dimensions=0 if numComponents <= 1 else 1)
             if numComponents == 1:
                 value = field(0)
             else:
@@ -111,24 +111,24 @@ def compileMacroscopicValuesSetter(lbMethod, quantitiesToSet, pdfArr=None, field
 
         valueMap[quantityName] = value
 
-    cqEquations = cqc.equilibriumInputEquationsFromInitValues(**valueMap)
+    cqEquations = cqc.equilibrium_input_equations_from_init_values(**valueMap)
 
-    eq = lbMethod.getEquilibrium(conservedQuantityEquations=cqEquations)
+    eq = lb_method.get_equilibrium(conserved_quantity_equations=cqEquations)
     if atLeastOneFieldInput:
-        simplification = createSimplificationStrategy(lbMethod)
+        simplification = create_simplification_strategy(lb_method)
         eq = simplification(eq)
     else:
         eq = eq.new_without_subexpressions()
 
-    substitutions = {sym: pdfField(i) for i, sym in enumerate(lbMethod.postCollisionPdfSymbols)}
+    substitutions = {sym: pdfField(i) for i, sym in enumerate(lb_method.post_collision_pdf_symbols)}
     eq = eq.new_with_substitutions(substitutions).all_assignments
 
     if target == 'cpu':
         import pystencils.cpu as cpu
-        kernel = cpu.makePythonFunction(cpu.createKernel(eq), argumentDict=fixedKernelParameters)
+        kernel = cpu.make_python_function(cpu.create_kernel(eq), argument_dict=fixedKernelParameters)
     elif target == 'gpu':
         import pystencils.gpucuda as gpu
-        kernel = gpu.makePythonFunction(gpu.createCUDAKernel(eq), argumentDict=fixedKernelParameters)
+        kernel = gpu.make_python_function(gpu.create_cuda_kernel(eq), argument_dict=fixedKernelParameters)
     else:
         raise ValueError("Unknown target '%s'. Possible targets are 'cpu' and 'gpu'" % (target,))
 
@@ -141,36 +141,36 @@ def compileMacroscopicValuesSetter(lbMethod, quantitiesToSet, pdfArr=None, field
     return setter
 
 
-def createAdvancedVelocitySetterCollisionRule(lbMethod, velocityArray, velocityRelaxationRate=0.8):
+def createAdvancedVelocitySetterCollisionRule(lb_method, velocityArray, velocityRelaxationRate=0.8):
 
-    velocityField = Field.createFromNumpyArray('velInput', velocityArray, indexDimensions=1)
+    velocityField = Field.create_from_numpy_array('velInput', velocityArray, index_dimensions=1)
 
-    cqc = lbMethod.conservedQuantityComputation
+    cqc = lb_method.conserved_quantity_computation
     densitySymbol = cqc.defined_symbols(order=0)[1]
     velocitySymbols = cqc.defined_symbols(order=1)[1]
 
     # density is computed from pdfs
-    eqInputFromPdfs = cqc.equilibriumInputEquationsFromPdfs(lbMethod.preCollisionPdfSymbols)
+    eqInputFromPdfs = cqc.equilibrium_input_equations_from_pdfs(lb_method.pre_collision_pdf_symbols)
     eqInputFromPdfs = eqInputFromPdfs.new_filtered([densitySymbol])
     # velocity is read from input field
-    velSymbols = [velocityField(i) for i in range(lbMethod.dim)]
-    eqInputFromField = cqc.equilibriumInputEquationsFromInitValues(velocity=velSymbols)
+    velSymbols = [velocityField(i) for i in range(lb_method.dim)]
+    eqInputFromField = cqc.equilibrium_input_equations_from_init_values(velocity=velSymbols)
     eqInputFromField = eqInputFromField.new_filtered(velocitySymbols)
     # then both are merged together
     eqInput = eqInputFromPdfs.new_merged(eqInputFromField)
 
     # set first order relaxation rate
-    lbMethod = deepcopy(lbMethod)
-    lbMethod.setFirstMomentRelaxationRate(velocityRelaxationRate)
+    lb_method = deepcopy(lb_method)
+    lb_method.set_first_moment_relaxation_rate(velocityRelaxationRate)
 
-    simplificationStrategy = createSimplificationStrategy(lbMethod)
-    newCollisionRule = simplificationStrategy(lbMethod.getCollisionRule(eqInput))
+    simplificationStrategy = create_simplification_strategy(lb_method)
+    newCollisionRule = simplificationStrategy(lb_method.get_collision_rule(eqInput))
 
     return newCollisionRule
 
 
 def compileAdvancedVelocitySetter(method, velocityArray, velocityRelaxationRate=0.8, pdfArr=None,
-                                  fieldLayout='numpy', optimizationParams={}):
+                                  field_layout='numpy', optimization={}):
     """
     Advanced initialization of velocity field through iteration procedure according to
     Mei, Luo, Lallemand and Humieres: Consistent initial conditions for LBM simulations, 2005
@@ -180,13 +180,13 @@ def compileAdvancedVelocitySetter(method, velocityArray, velocityRelaxationRate=
     :param velocityRelaxationRate: relaxation rate for the velocity moments - determines convergence behaviour
                                    of the initialization scheme
     :param pdfArr: optional numpy array for pdf field - used to get optimal loop structure for kernel
-    :param fieldLayout: layout of the pdf field if pdfArr was not given
-    :param optimizationParams: dictionary with optimization hints
+    :param field_layout: layout of the pdf field if pdfArr was not given
+    :param optimization: dictionary with optimization hints
     :return: stream-collide update function
     """
-    from lbmpy.updatekernels import createStreamPullCollideKernel
-    from lbmpy.creationfunctions import createLatticeBoltzmannAst, createLatticeBoltzmannFunction
+    from lbmpy.updatekernels import create_stream_pull_collide_kernel
+    from lbmpy.creationfunctions import create_lb_ast, create_lb_function
     newCollisionRule = createAdvancedVelocitySetterCollisionRule(method, velocityArray, velocityRelaxationRate)
-    updateRule = createStreamPullCollideKernel(newCollisionRule, pdfArr, genericLayout=fieldLayout)
-    ast = createLatticeBoltzmannAst(updateRule, optimizationParams)
-    return createLatticeBoltzmannFunction(ast, optimizationParams)
+    update_rule = create_stream_pull_collide_kernel(newCollisionRule, pdfArr, generic_layout=field_layout)
+    ast = create_lb_ast(update_rule, optimization)
+    return create_lb_function(ast, optimization)
diff --git a/maxwellian_equilibrium.py b/maxwellian_equilibrium.py
index 1070e9bfc9b9d8f2b15557bad12217544094eb58..811f56607839d5f4fe81b8a03729a73a472997e5 100644
--- a/maxwellian_equilibrium.py
+++ b/maxwellian_equilibrium.py
@@ -9,20 +9,22 @@ import warnings
 import sympy as sp
 from sympy import Rational as R
 
-from pystencils.cache import diskcache
+from pystencils.cache import disk_cache
 
 
-def getWeights(stencil, c_s_sq):
-    Q = len(stencil)
+def get_weights(stencil, c_s_sq):
+    q = len(stencil)
 
     if c_s_sq != sp.Rational(1, 3):
-        warnings.warn("Weigths of discrete equilibrium are only valid if c_s^2 = 1/3")
+        warnings.warn("Weights of discrete equilibrium are only valid if c_s^2 = 1/3")
+
+    def weight_for_direction(direction):
+        abs_sum = sum([abs(d) for d in direction])
+        return get_weights.weights[q][abs_sum]
+    return [weight_for_direction(d) for d in stencil]
+
 
-    def weightForDirection(direction):
-        absSum = sum([abs(d) for d in direction])
-        return getWeights.weights[Q][absSum]
-    return [weightForDirection(d) for d in stencil]
-getWeights.weights = {
+get_weights.weights = {
     9: {
         0: R(4, 9),
         1: R(1, 9),
@@ -47,9 +49,9 @@ getWeights.weights = {
 }
 
 
-@diskcache
-def discreteMaxwellianEquilibrium(stencil, rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")), order=2,
-                                  c_s_sq=sp.Symbol("c_s") ** 2, compressible=True):
+@disk_cache
+def discrete_maxwellian_equilibrium(stencil, rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")), order=2,
+                                    c_s_sq=sp.Symbol("c_s") ** 2, compressible=True):
     """
     Returns the common discrete LBM equilibrium as a list of sympy expressions
 
@@ -60,67 +62,67 @@ def discreteMaxwellianEquilibrium(stencil, rho=sp.Symbol("rho"), u=tuple(sp.symb
     :param c_s_sq: square of speed of sound
     :param compressible: compressibility
     """
-    weights = getWeights(stencil, c_s_sq)
+    weights = get_weights(stencil, c_s_sq)
     assert len(stencil) == len(weights)
 
     dim = len(stencil[0])
     u = u[:dim]
 
-    rhoOutside = rho if compressible else sp.Rational(1, 1)
-    rhoInside = rho if not compressible else sp.Rational(1, 1)
+    rho_outside = rho if compressible else sp.Rational(1, 1)
+    rho_inside = rho if not compressible else sp.Rational(1, 1)
 
     res = []
     for w_q, e_q in zip(weights, stencil):
-        eTimesU = 0
+        e_times_u = 0
         for c_q_alpha, u_alpha in zip(e_q, u):
-            eTimesU += c_q_alpha * u_alpha
+            e_times_u += c_q_alpha * u_alpha
 
-        fq = rhoInside + eTimesU / c_s_sq
+        fq = rho_inside + e_times_u / c_s_sq
 
         if order <= 1:
-            res.append(fq * rhoOutside * w_q)
+            res.append(fq * rho_outside * w_q)
             continue
 
-        uTimesU = 0
+        u_times_u = 0
         for u_alpha in u:
-            uTimesU += u_alpha * u_alpha
-        fq += sp.Rational(1, 2) / c_s_sq**2 * eTimesU ** 2 - sp.Rational(1, 2) / c_s_sq * uTimesU
+            u_times_u += u_alpha * u_alpha
+        fq += sp.Rational(1, 2) / c_s_sq**2 * e_times_u ** 2 - sp.Rational(1, 2) / c_s_sq * u_times_u
 
         if order <= 2:
-            res.append(fq * rhoOutside * w_q)
+            res.append(fq * rho_outside * w_q)
             continue
 
-        fq += sp.Rational(1, 6) / c_s_sq**3 * eTimesU**3 - sp.Rational(1, 2) / c_s_sq**2 * uTimesU * eTimesU
+        fq += sp.Rational(1, 6) / c_s_sq**3 * e_times_u**3 - sp.Rational(1, 2) / c_s_sq**2 * u_times_u * e_times_u
 
-        res.append(sp.expand(fq * rhoOutside * w_q))
+        res.append(sp.expand(fq * rho_outside * w_q))
 
     return tuple(res)
 
 
-@diskcache
-def generateEquilibriumByMatchingMoments(stencil, moments, rho=sp.Symbol("rho"),
-                                         u=tuple(sp.symbols("u_0 u_1 u_2")), c_s_sq=sp.Symbol("c_s") ** 2, order=None):
+@disk_cache
+def generate_equilibrium_by_matching_moments(stencil, moments, rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
+                                             c_s_sq=sp.Symbol("c_s") ** 2, order=None):
     """
     Computes discrete equilibrium, by setting the discrete moments to values taken from the continuous Maxwellian.
     The number of moments has to match the number of directions in the stencil. For documentation of other parameters
-    see :func:`getMomentsOfContinuousMaxwellianEquilibrium`
+    see :func:`get_moments_of_continuous_maxwellian_equilibrium`
     """
-    from lbmpy.moments import momentMatrix
+    from lbmpy.moments import moment_matrix
     dim = len(stencil[0])
     Q = len(stencil)
     assert len(moments) == Q, "Moment count(%d) does not match stencil size(%d)" % (len(moments), Q)
-    continuousMomentsVector = getMomentsOfContinuousMaxwellianEquilibrium(moments, dim, rho, u, c_s_sq, order)
-    continuousMomentsVector = sp.Matrix(continuousMomentsVector)
-    M = momentMatrix(moments, stencil)
+    continuous_moments_vector = get_moments_of_continuous_maxwellian_equilibrium(moments, dim, rho, u, c_s_sq, order)
+    continuous_moments_vector = sp.Matrix(continuous_moments_vector)
+    M = moment_matrix(moments, stencil)
     assert M.rank() == Q, "Rank of moment matrix (%d) does not match stencil size (%d)" % (M.rank(), Q)
-    return M.inv() * continuousMomentsVector
+    return M.inv() * continuous_moments_vector
 
 
-@diskcache
-def continuousMaxwellianEquilibrium(dim=3, rho=sp.Symbol("rho"),
-                                    u=tuple(sp.symbols("u_0 u_1 u_2")),
-                                    v=tuple(sp.symbols("v_0 v_1 v_2")),
-                                    c_s_sq=sp.Symbol("c_s") ** 2):
+@disk_cache
+def continuous_maxwellian_equilibrium(dim=3, rho=sp.Symbol("rho"),
+                                      u=tuple(sp.symbols("u_0 u_1 u_2")),
+                                      v=tuple(sp.symbols("v_0 v_1 v_2")),
+                                      c_s_sq=sp.Symbol("c_s") ** 2):
     """
     Returns sympy expression of Maxwell Boltzmann distribution
 
@@ -133,16 +135,17 @@ def continuousMaxwellianEquilibrium(dim=3, rho=sp.Symbol("rho"),
     u = u[:dim]
     v = v[:dim]
 
-    velTerm = sum([(v_i - u_i) ** 2 for v_i, u_i in zip(v, u)])
-    return rho / (2 * sp.pi * c_s_sq) ** (sp.Rational(dim, 2)) * sp.exp(- velTerm / (2 * c_s_sq))
+    vel_term = sum([(v_i - u_i) ** 2 for v_i, u_i in zip(v, u)])
+    return rho / (2 * sp.pi * c_s_sq) ** (sp.Rational(dim, 2)) * sp.exp(- vel_term / (2 * c_s_sq))
 
 
 # -------------------------------- Equilibrium moments/cumulants  ------------------------------------------------------
 
 
-@diskcache
-def getMomentsOfContinuousMaxwellianEquilibrium(moments, dim, rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
-                                                c_s_sq=sp.Symbol("c_s") ** 2, order=None):
+@disk_cache
+def get_moments_of_continuous_maxwellian_equilibrium(moments, dim, rho=sp.Symbol("rho"),
+                                                     u=tuple(sp.symbols("u_0 u_1 u_2")),
+                                                     c_s_sq=sp.Symbol("c_s") ** 2, order=None):
     """
     Computes moments of the continuous Maxwell Boltzmann equilibrium distribution
 
@@ -154,47 +157,47 @@ def getMomentsOfContinuousMaxwellianEquilibrium(moments, dim, rho=sp.Symbol("rho
     :param order: if this parameter is not None, terms that have a higher polynomial order in the macroscopic velocity
                   are removed
 
-    >>> getMomentsOfContinuousMaxwellianEquilibrium( ( (0,0,0), (1,0,0), (0,1,0), (0,0,1), (2,0,0) ), dim=3 )
+    >>> get_moments_of_continuous_maxwellian_equilibrium( ( (0,0,0), (1,0,0), (0,1,0), (0,0,1), (2,0,0) ), dim=3 )
     [rho, rho*u_0, rho*u_1, rho*u_2, rho*(c_s**2 + u_0**2)]
     """
     from pystencils.sympyextensions import remove_higher_order_terms
     from lbmpy.moments import MOMENT_SYMBOLS
-    from lbmpy.continuous_distribution_measures import continuousMoment
+    from lbmpy.continuous_distribution_measures import continuous_moment
 
     # trick to speed up sympy integration (otherwise it takes multiple minutes, or aborts):
     # use a positive, real symbol to represent c_s_sq -> then replace this symbol afterwards with the real c_s_sq
     c_s_sq_helper = sp.Symbol("csqHelper", positive=True, real=True)
-    mb = continuousMaxwellianEquilibrium(dim, rho, u, MOMENT_SYMBOLS[:dim], c_s_sq_helper)
-    result = [continuousMoment(mb, moment, MOMENT_SYMBOLS[:dim]).subs(c_s_sq_helper, c_s_sq) for moment in moments]
+    mb = continuous_maxwellian_equilibrium(dim, rho, u, MOMENT_SYMBOLS[:dim], c_s_sq_helper)
+    result = [continuous_moment(mb, moment, MOMENT_SYMBOLS[:dim]).subs(c_s_sq_helper, c_s_sq) for moment in moments]
     if order is not None:
         result = [remove_higher_order_terms(r, order=order, symbols=u) for r in result]
 
     return result
 
 
-@diskcache
-def getMomentsOfDiscreteMaxwellianEquilibrium(stencil, moments,
-                                              rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
-                                              c_s_sq=sp.Symbol("c_s") ** 2, order=None, compressible=True):
+@disk_cache
+def get_moments_of_discrete_maxwellian_equilibrium(stencil, moments,
+                                                   rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
+                                                   c_s_sq=sp.Symbol("c_s") ** 2, order=None, compressible=True):
+    """Compute moments of discrete maxwellian equilibrium.
+
+    Args:
+        stencil: stencil is required to compute moments of discrete function
+        moments: moments in polynomial or exponent-tuple form
+        rho: symbol or value for the density
+        u: symbols or values for the macroscopic velocity
+        c_s_sq: symbol for speed of sound squared, defaults to symbol c_s**2
+        order: highest order of u terms
+        compressible: compressible or incompressible form
     """
-    Compute moments of discrete maxwellian equilibrium
-
-    :param stencil: stencil is required to compute moments of discrete function
-    :param moments: moments in polynomial or exponent-tuple form
-    :param rho: symbol or value for the density
-    :param u: symbols or values for the macroscopic velocity
-    :param c_s_sq: symbol for speed of sound squared, defaults to symbol c_s**2
-    :param order: highest order of u terms
-    :param compressible: compressible or incompressible form
-    """
-    from lbmpy.moments import discreteMoment
+    from lbmpy.moments import discrete_moment
     if order is None:
         order = 4
-    mb = discreteMaxwellianEquilibrium(stencil, rho, u, order, c_s_sq, compressible)
-    return tuple([discreteMoment(mb, moment, stencil).expand() for moment in moments])
+    mb = discrete_maxwellian_equilibrium(stencil, rho, u, order, c_s_sq, compressible)
+    return tuple([discrete_moment(mb, moment, stencil).expand() for moment in moments])
 
 
-def compressibleToIncompressibleMomentValue(term, rho, u):
+def compressible_to_incompressible_moment_value(term, rho, u):
     term = sp.sympify(term)
     term = term.expand()
     if term.func != sp.Add:
@@ -204,8 +207,8 @@ def compressibleToIncompressibleMomentValue(term, rho, u):
 
     res = 0
     for t in args:
-        containedSymbols = t.atoms(sp.Symbol)
-        if rho in containedSymbols and len(containedSymbols.intersection(set(u))) > 0:
+        contained_symbols = t.atoms(sp.Symbol)
+        if rho in contained_symbols and len(contained_symbols.intersection(set(u))) > 0:
             res += t / rho
         else:
             res += t
@@ -215,30 +218,31 @@ def compressibleToIncompressibleMomentValue(term, rho, u):
 # -------------------------------- Equilibrium moments -----------------------------------------------------------------
 
 
-def getCumulantsOfContinuousMaxwellianEquilibrium(cumulants, dim, rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
-                                                  c_s_sq=sp.Symbol("c_s") ** 2, order=None):
+def get_cumulants_of_continuous_maxwellian_equilibrium(cumulants, dim, rho=sp.Symbol("rho"),
+                                                       u=tuple(sp.symbols("u_0 u_1 u_2")), c_s_sq=sp.Symbol("c_s") ** 2,
+                                                       order=None):
     from lbmpy.moments import MOMENT_SYMBOLS
-    from lbmpy.continuous_distribution_measures import continuousCumulant
+    from lbmpy.continuous_distribution_measures import continuous_cumulant
     from pystencils.sympyextensions import remove_higher_order_terms
 
     # trick to speed up sympy integration (otherwise it takes multiple minutes, or aborts):
     # use a positive, real symbol to represent c_s_sq -> then replace this symbol afterwards with the real c_s_sq
     c_s_sq_helper = sp.Symbol("csqHelper", positive=True, real=True)
-    mb = continuousMaxwellianEquilibrium(dim, rho, u, MOMENT_SYMBOLS[:dim], c_s_sq_helper)
-    result = [continuousCumulant(mb, cumulant, MOMENT_SYMBOLS[:dim]).subs(c_s_sq_helper, c_s_sq) for cumulant in cumulants]
+    mb = continuous_maxwellian_equilibrium(dim, rho, u, MOMENT_SYMBOLS[:dim], c_s_sq_helper)
+    result = [continuous_cumulant(mb, cumulant, MOMENT_SYMBOLS[:dim]).subs(c_s_sq_helper, c_s_sq)
+              for cumulant in cumulants]
     if order is not None:
         result = [remove_higher_order_terms(r, order=order, symbols=u) for r in result]
 
     return result
 
 
-@diskcache
-def getCumulantsOfDiscreteMaxwellianEquilibrium(stencil, cumulants,
-                                                rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
-                                                c_s_sq=sp.Symbol("c_s") ** 2, order=None, compressible=True):
+@disk_cache
+def get_cumulants_of_discrete_maxwellian_equilibrium(stencil, cumulants,
+                                                     rho=sp.Symbol("rho"), u=tuple(sp.symbols("u_0 u_1 u_2")),
+                                                     c_s_sq=sp.Symbol("c_s") ** 2, order=None, compressible=True):
     from lbmpy.cumulants import discreteCumulant
     if order is None:
         order = 4
-    mb = discreteMaxwellianEquilibrium(stencil, rho, u, order, c_s_sq, compressible)
+    mb = discrete_maxwellian_equilibrium(stencil, rho, u, order, c_s_sq, compressible)
     return tuple([discreteCumulant(mb, cumulant, stencil).expand() for cumulant in cumulants])
-
diff --git a/methods/__init__.py b/methods/__init__.py
index d842bfcd3bd68f73f38ae54caacb5fea33ec4a2e..b364fe560c98e323cd547f7831deb403d5e16ab5 100644
--- a/methods/__init__.py
+++ b/methods/__init__.py
@@ -1,6 +1,6 @@
 from lbmpy.methods.abstractlbmethod import AbstractLbMethod
 from lbmpy.methods.momentbased import MomentBasedLbMethod, RelaxationInfo
-from lbmpy.methods.creationfunctions import createSRT, createTRT, createTRTWithMagicNumber, createOrthogonalMRT, \
-    createWithContinuousMaxwellianEqMoments, createWithDiscreteMaxwellianEqMoments, createKBCTypeTRT, createRawMRT, \
-    createThreeRelaxationRateMRT
+from lbmpy.methods.creationfunctions import create_srt, create_trt, create_trt_with_magic_number, create_mrt_orthogonal, \
+    create_with_continuous_maxwellian_eq_moments, create_with_discrete_maxwellian_eq_moments, create_trt_kbc, create_mrt_raw, \
+    create_mrt3
 from lbmpy.methods.conservedquantitycomputation import AbstractConservedQuantityComputation, DensityVelocityComputation
diff --git a/methods/abstractlbmethod.py b/methods/abstractlbmethod.py
index 4d75910ea7adc55e9f74730f208f33b9f38223ef..c7d7bbad213f5905b5f6228efdbb0f27fb7431f5 100644
--- a/methods/abstractlbmethod.py
+++ b/methods/abstractlbmethod.py
@@ -4,7 +4,7 @@ from collections import namedtuple
 from pystencils.assignment_collection import AssignmentCollection
 
 
-RelaxationInfo = namedtuple('RelaxationInfo', ['equilibriumValue', 'relaxationRate'])
+RelaxationInfo = namedtuple('RelaxationInfo', ['equilibriumValue', 'relaxation_rate'])
 
 
 class LbmCollisionRule(AssignmentCollection):
@@ -13,10 +13,8 @@ class LbmCollisionRule(AssignmentCollection):
         self.method = lb_method
 
 
-class AbstractLbMethod(abc.ABCMeta('ABC', (object,), {})):
-    """
-    Abstract base class for all LBM methods
-    """
+class AbstractLbMethod(abc.ABC):
+    """Abstract base class for all LBM methods."""
 
     def __init__(self, stencil):
         self._stencil = stencil
@@ -31,19 +29,19 @@ class AbstractLbMethod(abc.ABCMeta('ABC', (object,), {})):
         return len(self.stencil[0])
 
     @property
-    def preCollisionPdfSymbols(self):
+    def pre_collision_pdf_symbols(self):
         """Tuple of symbols representing the pdf values before collision"""
         return sp.symbols("f_:%d" % (len(self.stencil),))
 
     @property
-    def postCollisionPdfSymbols(self):
+    def post_collision_pdf_symbols(self):
         """Tuple of symbols representing the pdf values after collision"""
         return sp.symbols("d_:%d" % (len(self.stencil),))
 
     # ------------------------- Abstract Methods & Properties ----------------------------------------------------------
 
     @abc.abstractmethod
-    def conservedQuantityComputation(self):
+    def conserved_quantity_computation(self):
         """Returns an instance of class :class:`lbmpy.methods.AbstractConservedQuantityComputation`"""
 
     @abc.abstractmethod
@@ -51,13 +49,13 @@ class AbstractLbMethod(abc.ABCMeta('ABC', (object,), {})):
         """Returns a sequence of weights, one for each lattice direction"""
 
     @abc.abstractmethod
-    def getEquilibrium(self):
+    def get_equilibrium(self):
         """Returns equation collection, to compute equilibrium values.
         The equations have the post collision symbols as left hand sides and are
         functions of the conserved quantities"""
 
     @abc.abstractmethod
-    def getCollisionRule(self):
+    def get_collision_rule(self):
         """Returns an LbmCollisionRule i.e. an equation collection with a reference to the method.
          This collision rule defines the collision operator."""
 
diff --git a/methods/conservedquantitycomputation.py b/methods/conservedquantitycomputation.py
index 75a276e5c1c1cae11d2f5361ebf5c67d440bc4f9..a40b1e9b8a5f94f107baffeea18411cf362232dc 100644
--- a/methods/conservedquantitycomputation.py
+++ b/methods/conservedquantitycomputation.py
@@ -5,7 +5,7 @@ from pystencils.assignment_collection import AssignmentCollection
 from pystencils.field import Field, Assignment
 
 
-class AbstractConservedQuantityComputation(abc.ABCMeta('ABC', (object,), {})):
+class AbstractConservedQuantityComputation(abc.ABC):
     """
 
     This class defines how conserved quantities are computed as functions of the pdfs.
@@ -24,12 +24,12 @@ class AbstractConservedQuantityComputation(abc.ABCMeta('ABC', (object,), {})):
 
     @property
     @abc.abstractmethod
-    def conservedQuantities(self):
+    def conserved_quantities(self):
         """
         Dict, mapping names (symbol) to dimensionality (int)
         For example: {'density' : 1, 'velocity' : 3}
-        The naming strings can be used in :func:`outputEquationsFromPdfs`
-        and :func:`equilibriumInputEquationsFromInitValues`
+        The naming strings can be used in :func:`output_equations_from_pdfs`
+        and :func:`equilibrium_input_equations_from_init_values`
         """
 
     def defined_symbols(self, order='all'):
@@ -39,7 +39,7 @@ class AbstractConservedQuantityComputation(abc.ABCMeta('ABC', (object,), {})):
 
     @property
     @abc.abstractmethod
-    def defaultValues(self):
+    def default_values(self):
         """
         Returns a dict of symbol to default value, where "default" means that
         the equilibrium simplifies to the weights if these values are inserted.
@@ -47,7 +47,7 @@ class AbstractConservedQuantityComputation(abc.ABCMeta('ABC', (object,), {})):
         """
 
     @abc.abstractmethod
-    def equilibriumInputEquationsFromPdfs(self, pdfs):
+    def equilibrium_input_equations_from_pdfs(self, pdfs):
         """
         Returns an equation collection that defines all necessary quantities to compute the equilibrium as functions
         of the pdfs.
@@ -57,40 +57,40 @@ class AbstractConservedQuantityComputation(abc.ABCMeta('ABC', (object,), {})):
         """
 
     @abc.abstractmethod
-    def outputEquationsFromPdfs(self, pdfs, outputQuantityNamesToSymbols):
+    def output_equations_from_pdfs(self, pdfs, output_quantity_names_to_symbols):
         """
         Returns an equation collection that defines conserved quantities for output. These conserved quantities might
         be slightly different that the ones used as input for the equilibrium e.g. due to a force model.
 
         :param pdfs: values for the pdf entries
-        :param outputQuantityNamesToSymbols: dict mapping of conserved quantity names (See :func:`conservedQuantities`)
+        :param output_quantity_names_to_symbols: dict mapping of conserved quantity names (See :func:`conserved_quantities`)
                                             to symbols or field accesses where they should be written to
         """
 
     @abc.abstractmethod
-    def equilibriumInputEquationsFromInitValues(self, **kwargs):
+    def equilibrium_input_equations_from_init_values(self, **kwargs):
         """
         Returns an equation collection that defines all necessary quantities to compute the equilibrium as function of
         given conserved quantities. Parameters can be names that are given by
-        symbol names of :func:`conservedQuantities`.
+        symbol names of :func:`conserved_quantities`.
         For all parameters not specified each implementation should use sensible defaults. For example hydrodynamic
         schemes use density=1 and velocity=0.
         """
 
 
 class DensityVelocityComputation(AbstractConservedQuantityComputation):
-    def __init__(self, stencil, compressible, forceModel=None,
-                 zerothOrderMomentSymbol=sp.Symbol("rho"),
-                 firstOrderMomentSymbols=sp.symbols("u_:3")):
+    def __init__(self, stencil, compressible, force_model=None,
+                 zeroth_order_moment_symbol=sp.Symbol("rho"),
+                 first_order_moment_symbols=sp.symbols("u_:3")):
         dim = len(stencil[0])
         self._stencil = stencil
         self._compressible = compressible
-        self._forceModel = forceModel
-        self._symbolOrder0 = zerothOrderMomentSymbol
-        self._symbolsOrder1 = firstOrderMomentSymbols[:dim]
+        self._forceModel = force_model
+        self._symbolOrder0 = zeroth_order_moment_symbol
+        self._symbolsOrder1 = first_order_moment_symbols[:dim]
 
     @property
-    def conservedQuantities(self):
+    def conserved_quantities(self):
         return {'density': 1,
                 'velocity': len(self._stencil[0])}
 
@@ -110,71 +110,72 @@ class DensityVelocityComputation(AbstractConservedQuantityComputation):
             return None
 
     @property
-    def zeroCenteredPdfs(self):
+    def zero_centered_pdfs(self):
         return not self._compressible
 
     @property
-    def zerothOrderMomentSymbol(self):
+    def zeroth_order_moment_symbol(self):
         return self._symbolOrder0
 
     @property
-    def firstOrderMomentSymbols(self):
+    def first_order_moment_symbols(self):
         return self._symbolsOrder1
 
     @property
-    def defaultValues(self):
+    def default_values(self):
         result = {self._symbolOrder0: 1}
         for s in self._symbolsOrder1:
             result[s] = 0
         return result
 
-    def equilibriumInputEquationsFromPdfs(self, pdfs):
+    def equilibrium_input_equations_from_pdfs(self, pdfs):
         dim = len(self._stencil[0])
-        eq_coll = getEquationsForZerothAndFirstOrderMoment(self._stencil, pdfs, self._symbolOrder0,
+        eq_coll = get_equations_for_zeroth_and_first_order_moment(self._stencil, pdfs, self._symbolOrder0,
                                                           self._symbolsOrder1[:dim])
         if self._compressible:
-            eq_coll = divideFirstOrderMomentsByRho(eq_coll, dim)
+            eq_coll = divide_first_order_moments_by_rho(eq_coll, dim)
 
-        eq_coll = applyForceModelShift('equilibriumVelocityShift', dim, eq_coll, self._forceModel, self._compressible)
+        eq_coll = apply_force_model_shift('equilibriumVelocityShift', dim, eq_coll, self._forceModel, self._compressible)
         return eq_coll
 
-    def equilibriumInputEquationsFromInitValues(self, density=1, velocity=(0, 0, 0)):
+    def equilibrium_input_equations_from_init_values(self, density=1, velocity=(0, 0, 0)):
         dim = len(self._stencil[0])
-        zerothOrderMoment = density
+        zeroth_order_moment = density
         first_order_moments = velocity[:dim]
         vel_offset = [0] * dim
 
         if self._compressible:
-            if self._forceModel and hasattr(self._forceModel, 'macroscopicVelocityShift'):
-                vel_offset = self._forceModel.macroscopicVelocityShift(zerothOrderMoment)
+            if self._forceModel and hasattr(self._forceModel, 'macroscopic_velocity_shift'):
+                vel_offset = self._forceModel.macroscopic_velocity_shift(zeroth_order_moment)
         else:
-            if self._forceModel and hasattr(self._forceModel, 'macroscopicVelocityShift'):
-                vel_offset = self._forceModel.macroscopicVelocityShift(sp.Rational(1, 1))
-            zerothOrderMoment -= sp.Rational(1, 1)
-        eqs = [Assignment(self._symbolOrder0, zerothOrderMoment)]
+            if self._forceModel and hasattr(self._forceModel, 'macroscopic_velocity_shift'):
+                vel_offset = self._forceModel.macroscopic_velocity_shift(sp.Rational(1, 1))
+            zeroth_order_moment -= sp.Rational(1, 1)
+        eqs = [Assignment(self._symbolOrder0, zeroth_order_moment)]
 
         first_order_moments = [a - b for a, b in zip(first_order_moments, vel_offset)]
         eqs += [Assignment(l, r) for l, r in zip(self._symbolsOrder1, first_order_moments)]
 
         return AssignmentCollection(eqs, [])
 
-    def outputEquationsFromPdfs(self, pdfs, outputQuantityNamesToSymbols):
+    def output_equations_from_pdfs(self, pdfs, output_quantity_names_to_symbols):
         dim = len(self._stencil[0])
 
-        ac = getEquationsForZerothAndFirstOrderMoment(self._stencil, pdfs, self._symbolOrder0, self._symbolsOrder1)
+        ac = get_equations_for_zeroth_and_first_order_moment(self._stencil, pdfs,
+                                                             self._symbolOrder0, self._symbolsOrder1)
 
         if self._compressible:
-            ac = divideFirstOrderMomentsByRho(ac, dim)
+            ac = divide_first_order_moments_by_rho(ac, dim)
         else:
-            ac = addDensityOffset(ac)
+            ac = add_density_offset(ac)
 
-        ac = applyForceModelShift('macroscopicVelocityShift', dim, ac, self._forceModel, self._compressible)
+        ac = apply_force_model_shift('macroscopic_velocity_shift', dim, ac, self._forceModel, self._compressible)
 
         main_assignments = []
         eqs = OrderedDict([(eq.lhs, eq.rhs) for eq in ac.all_assignments])
 
-        if 'density' in outputQuantityNamesToSymbols:
-            density_output_symbol = outputQuantityNamesToSymbols['density']
+        if 'density' in output_quantity_names_to_symbols:
+            density_output_symbol = output_quantity_names_to_symbols['density']
             if isinstance(density_output_symbol, Field):
                 density_output_symbol = density_output_symbol()
             if density_output_symbol != self._symbolOrder0:
@@ -182,8 +183,8 @@ class DensityVelocityComputation(AbstractConservedQuantityComputation):
             else:
                 main_assignments.append(Assignment(self._symbolOrder0, eqs[self._symbolOrder0]))
                 del eqs[self._symbolOrder0]
-        if 'velocity' in outputQuantityNamesToSymbols:
-            vel_output_symbols = outputQuantityNamesToSymbols['velocity']
+        if 'velocity' in output_quantity_names_to_symbols:
+            vel_output_symbols = output_quantity_names_to_symbols['velocity']
             if isinstance(vel_output_symbols, Field):
                 field = vel_output_symbols
                 vel_output_symbols = [field(i) for i in range(len(self._symbolsOrder1))]
@@ -193,16 +194,17 @@ class DensityVelocityComputation(AbstractConservedQuantityComputation):
                 for u_i in self._symbolsOrder1:
                     main_assignments.append(Assignment(u_i, eqs[u_i]))
                     del eqs[u_i]
-        if 'momentumDensity' in outputQuantityNamesToSymbols:
+        if 'momentum_density' in output_quantity_names_to_symbols:
             # get zeroth and first moments again - force-shift them if necessary
             # and add their values directly to the main equations assuming that subexpressions are already in
             # main equation collection
-            # Is not optimal when velocity and momentumDensity are calculated together, but this is usually not the case
-            momentum_density_output_symbols = outputQuantityNamesToSymbols['momentumDensity']
-            mom_density_eq_coll = getEquationsForZerothAndFirstOrderMoment(self._stencil, pdfs,
-                                                                        self._symbolOrder0, self._symbolsOrder1)
-            mom_density_eq_coll = applyForceModelShift('macroscopicVelocityShift', dim, mom_density_eq_coll,
-                                                    self._forceModel, self._compressible)
+            # Is not optimal when velocity and momentum_density are calculated together,
+            # but this is usually not the case
+            momentum_density_output_symbols = output_quantity_names_to_symbols['momentum_density']
+            mom_density_eq_coll = get_equations_for_zeroth_and_first_order_moment(self._stencil, pdfs,
+                                                                                  self._symbolOrder0, self._symbolsOrder1)
+            mom_density_eq_coll = apply_force_model_shift('macroscopic_velocity_shift', dim, mom_density_eq_coll,
+                                                          self._forceModel, self._compressible)
             for sym, val in zip(momentum_density_output_symbols, mom_density_eq_coll.main_assignments[1:]):
                 main_assignments.append(Assignment(sym, val.rhs))
 
@@ -210,13 +212,14 @@ class DensityVelocityComputation(AbstractConservedQuantityComputation):
         return ac.new_without_unused_subexpressions()
 
     def __repr__(self):
-        return "ConservedValueComputation for %s" % (", " .join(self.conservedQuantities.keys()),)
+        return "ConservedValueComputation for %s" % (", " .join(self.conserved_quantities.keys()),)
 
 
 # -----------------------------------------  Helper functions ----------------------------------------------------------
 
 
-def getEquationsForZerothAndFirstOrderMoment(stencil, symbolicPdfs, symbolicZerothMoment, symbolicFirstMoments):
+def get_equations_for_zeroth_and_first_order_moment(stencil, symbolic_pdfs,
+                                                    symbolic_zeroth_moment, symbolic_first_moments):
     """
     Returns an equation system that computes the zeroth and first order moments with the least amount of operations
 
@@ -228,9 +231,9 @@ def getEquationsForZerothAndFirstOrderMoment(stencil, symbolicPdfs, symbolicZero
         u_j = \sum_{d \in S} f_d u_jd
 
     :param stencil: called :math:`S` above
-    :param symbolicPdfs: called :math:`f` above
-    :param symbolicZerothMoment:  called :math:`\rho` above
-    :param symbolicFirstMoments: called :math:`u` above
+    :param symbolic_pdfs: called :math:`f` above
+    :param symbolic_zeroth_moment:  called :math:`\rho` above
+    :param symbolic_first_moments: called :math:`u` above
     """
     def filter_out_plus_terms(expr):
         result = 0
@@ -242,9 +245,9 @@ def getEquationsForZerothAndFirstOrderMoment(stencil, symbolicPdfs, symbolicZero
     dim = len(stencil[0])
 
     subexpressions = []
-    pdf_sum = sum(symbolicPdfs)
+    pdf_sum = sum(symbolic_pdfs)
     u = [0] * dim
-    for f, offset in zip(symbolicPdfs, stencil):
+    for f, offset in zip(symbolic_pdfs, stencil):
         for i in range(dim):
             u[i] += f * int(offset[i])
 
@@ -263,13 +266,13 @@ def getEquationsForZerothAndFirstOrderMoment(stencil, symbolicPdfs, symbolicZero
         u[i] = u[i].subs(subexpressions[i].rhs, subexpressions[i].lhs)
 
     equations = []
-    equations += [Assignment(symbolicZerothMoment, pdf_sum)]
-    equations += [Assignment(u_i_sym, u_i) for u_i_sym, u_i in zip(symbolicFirstMoments, u)]
+    equations += [Assignment(symbolic_zeroth_moment, pdf_sum)]
+    equations += [Assignment(u_i_sym, u_i) for u_i_sym, u_i in zip(symbolic_first_moments, u)]
 
     return AssignmentCollection(equations, subexpressions)
 
 
-def divideFirstOrderMomentsByRho(assignment_collection, dim):
+def divide_first_order_moments_by_rho(assignment_collection, dim):
     """
     Assumes that the equations of the passed equation collection are the following
         - rho = f_0  + f_1 + ...
@@ -285,7 +288,7 @@ def divideFirstOrderMomentsByRho(assignment_collection, dim):
     return assignment_collection.copy(new_eqs)
 
 
-def addDensityOffset(assignment_collection, offset=sp.Rational(1, 1)):
+def add_density_offset(assignment_collection, offset=sp.Rational(1, 1)):
     """
     Assumes that first equation is the density (zeroth moment). Changes the density equations by adding offset to it.
     """
@@ -294,17 +297,17 @@ def addDensityOffset(assignment_collection, offset=sp.Rational(1, 1)):
     return assignment_collection.copy([new_density] + old_eqs[1:])
 
 
-def applyForceModelShift(shiftMemberName, dim, assignment_collection, forceModel, compressible, reverse=False):
+def apply_force_model_shift(shift_member_name, dim, assignment_collection, force_model, compressible, reverse=False):
     """
     Modifies the first order moment equations in assignment collection according to the force model shift.
-    It is applied if force model has a method named shiftMemberName. The equations 1: dim+1 of the passed
+    It is applied if force model has a method named shift_member_name. The equations 1: dim+1 of the passed
     equation collection are assumed to be the velocity equations.
     """
-    if forceModel is not None and hasattr(forceModel, shiftMemberName):
+    if force_model is not None and hasattr(force_model, shift_member_name):
         old_eqs = assignment_collection.main_assignments
         density = old_eqs[0].lhs if compressible else sp.Rational(1, 1)
         old_vel_eqs = old_eqs[1:dim + 1]
-        shift_func = getattr(forceModel, shiftMemberName)
+        shift_func = getattr(force_model, shift_member_name)
         vel_offsets = shift_func(density)
         if reverse:
             vel_offsets = [-v for v in vel_offsets]
diff --git a/methods/creationfunctions.py b/methods/creationfunctions.py
index 98a576a034001b3de56eb751761af80b8ca72641..3d4ea2c1bd2dd8b952ca9b1c12d7fe80cea23573 100644
--- a/methods/creationfunctions.py
+++ b/methods/creationfunctions.py
@@ -7,369 +7,383 @@ import operator
 import itertools
 from lbmpy.methods.cumulantbased import CumulantBasedLbMethod
 from lbmpy.methods.momentbased import MomentBasedLbMethod
-from lbmpy.stencils import stencilsHaveSameEntries, getStencil
-from lbmpy.moments import isEven, gramSchmidt, getDefaultMomentSetForStencil, MOMENT_SYMBOLS, \
-    exponentsToPolynomialRepresentations, momentsOfOrder, momentsUpToComponentOrder, sortMomentsIntoGroupsOfSameOrder, \
-    getOrder, discreteMoment
+from lbmpy.stencils import stencils_have_same_entries, get_stencil
+from lbmpy.moments import is_even, gram_schmidt, get_default_moment_set_for_stencil, MOMENT_SYMBOLS, \
+    exponents_to_polynomial_representations, moments_of_order, moments_up_to_component_order, sort_moments_into_groups_of_same_order, \
+    get_order, discrete_moment
 from pystencils.sympyextensions import common_denominator
 from lbmpy.methods.conservedquantitycomputation import DensityVelocityComputation
 from lbmpy.methods.abstractlbmethod import RelaxationInfo
-from lbmpy.maxwellian_equilibrium import getMomentsOfDiscreteMaxwellianEquilibrium, \
-    getMomentsOfContinuousMaxwellianEquilibrium, getCumulantsOfDiscreteMaxwellianEquilibrium, \
-    getCumulantsOfContinuousMaxwellianEquilibrium, compressibleToIncompressibleMomentValue
-from lbmpy.relaxationrates import relaxationRateFromMagicNumber, defaultRelaxationRateNames
+from lbmpy.maxwellian_equilibrium import get_moments_of_discrete_maxwellian_equilibrium, \
+    get_moments_of_continuous_maxwellian_equilibrium, get_cumulants_of_discrete_maxwellian_equilibrium, \
+    get_cumulants_of_continuous_maxwellian_equilibrium, compressible_to_incompressible_moment_value
+from lbmpy.relaxationrates import relaxation_rate_from_magic_number, default_relaxation_rate_names
 
 
-def createWithDiscreteMaxwellianEqMoments(stencil, momentToRelaxationRateDict, compressible=False, forceModel=None,
-                                          equilibriumAccuracyOrder=2, cumulant=False, c_s_sq=sp.Rational(1, 3)):
+def create_with_discrete_maxwellian_eq_moments(stencil, moment_to_relaxation_rate_dict, compressible=False,
+                                               force_model=None, equilibrium_order=2,
+                                               cumulant=False, c_s_sq=sp.Rational(1, 3)):
     r"""
     Creates a moment-based LBM by taking a list of moments with corresponding relaxation rate. These moments are
     relaxed against the moments of the discrete Maxwellian distribution.
 
-    :param stencil: nested tuple defining the discrete velocity space. See `func:lbmpy.stencils.getStencil`
-    :param momentToRelaxationRateDict: dict that has as many entries as the stencil. Each moment, which can be
-                                       represented by an exponent tuple or in polynomial form
-                                       (see `lbmpy.moments`), is mapped to a relaxation rate.
-    :param compressible: incompressible LBM methods split the density into :math:`\rho = \rho_0 + \Delta \rho`
-         where :math:`\rho_0` is chosen as one, and the first moment of the pdfs is :math:`\Delta \rho` .
-         This approximates the incompressible Navier-Stokes equations better than the standard
-         compressible model.
-    :param forceModel: force model instance, or None if no external forces
-    :param equilibriumAccuracyOrder: approximation order of macroscopic velocity :math:`\mathbf{u}` in the equilibrium
-    :param cumulant: if True relax cumulants instead of moments
-    :param c_s_sq: Speed of sound squared
-    :return: :class:`lbmpy.methods.MomentBasedLbMethod` instance
+    Args:
+        stencil: nested tuple defining the discrete velocity space. See `func:lbmpy.stencils.get_stencil`
+        moment_to_relaxation_rate_dict: dict that has as many entries as the stencil. Each moment, which can be
+                                    represented by an exponent tuple or in polynomial form
+                                    (see `lbmpy.moments`), is mapped to a relaxation rate.
+        compressible: incompressible LBM methods split the density into :math:`\rho = \rho_0 + \Delta \rho`
+        where :math:`\rho_0` is chosen as one, and the first moment of the pdfs is :math:`\Delta \rho` .
+        This approximates the incompressible Navier-Stokes equations better than the standard
+        compressible model.
+        force_model: force model instance, or None if no external forces
+        equilibrium_order: approximation order of macroscopic velocity :math:`\mathbf{u}` in the equilibrium
+        cumulant: if True relax cumulants instead of moments
+        c_s_sq: Speed of sound squared
+
+    Returns:
+        :class:`lbmpy.methods.MomentBasedLbMethod` instance
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    momToRrDict = OrderedDict(momentToRelaxationRateDict)
-    assert len(momToRrDict) == len(stencil), \
+        stencil = get_stencil(stencil)
+    mom_to_rr_dict = OrderedDict(moment_to_relaxation_rate_dict)
+    assert len(mom_to_rr_dict) == len(stencil), \
         "The number of moments has to be the same as the number of stencil entries"
 
-    densityVelocityComputation = DensityVelocityComputation(stencil, compressible, forceModel)
+    density_velocity_computation = DensityVelocityComputation(stencil, compressible, force_model)
 
     if cumulant:
-        warn("Cumulant methods should be created with useContinuousMaxwellianEquilibrium=True")
-        eqValues = getCumulantsOfDiscreteMaxwellianEquilibrium(stencil, tuple(momToRrDict.keys()),
-                                                               c_s_sq=c_s_sq, compressible=compressible,
-                                                               order=equilibriumAccuracyOrder)
+        warn("Cumulant methods should be created with maxwellian_moments=True")
+        eq_values = get_cumulants_of_discrete_maxwellian_equilibrium(stencil, tuple(mom_to_rr_dict.keys()),
+                                                                     c_s_sq=c_s_sq, compressible=compressible,
+                                                                     order=equilibrium_order)
     else:
-        eqValues = getMomentsOfDiscreteMaxwellianEquilibrium(stencil, tuple(momToRrDict.keys()),
-                                                             c_s_sq=c_s_sq, compressible=compressible,
-                                                             order=equilibriumAccuracyOrder)
+        eq_values = get_moments_of_discrete_maxwellian_equilibrium(stencil, tuple(mom_to_rr_dict.keys()),
+                                                                   c_s_sq=c_s_sq, compressible=compressible,
+                                                                   order=equilibrium_order)
 
-    rrDict = OrderedDict([(mom, RelaxationInfo(eqMom, rr))
-                          for mom, rr, eqMom in zip(momToRrDict.keys(), momToRrDict.values(), eqValues)])
+    rr_dict = OrderedDict([(mom, RelaxationInfo(eqMom, rr))
+                           for mom, rr, eqMom in zip(mom_to_rr_dict.keys(), mom_to_rr_dict.values(), eq_values)])
     if cumulant:
-        return CumulantBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return CumulantBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
     else:
-        return MomentBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return MomentBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
 
 
-def createWithContinuousMaxwellianEqMoments(stencil, momentToRelaxationRateDict, compressible=False, forceModel=None,
-                                            equilibriumAccuracyOrder=2, cumulant=False, c_s_sq=sp.Rational(1, 3)):
+def create_with_continuous_maxwellian_eq_moments(stencil, moment_to_relaxation_rate_dict, compressible=False,
+                                                 force_model=None, equilibrium_order=2,
+                                                 cumulant=False, c_s_sq=sp.Rational(1, 3)):
     r"""
     Creates a moment-based LBM by taking a list of moments with corresponding relaxation rate. These moments are
     relaxed against the moments of the continuous Maxwellian distribution.
-    For parameter description see :func:`lbmpy.methods.createWithDiscreteMaxwellianEqMoments`.
+    For parameter description see :func:`lbmpy.methods.create_with_discrete_maxwellian_eq_moments`.
     By using the continuous Maxwellian we automatically get a compressible model.
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    momToRrDict = OrderedDict(momentToRelaxationRateDict)
-    assert len(momToRrDict) == len(stencil), "The number of moments has to be the same as the number of stencil entries"
+        stencil = get_stencil(stencil)
+    mom_to_rr_dict = OrderedDict(moment_to_relaxation_rate_dict)
+    assert len(mom_to_rr_dict) == len(stencil), "The number of moments has to be equal to the number of stencil entries"
     dim = len(stencil[0])
-    densityVelocityComputation = DensityVelocityComputation(stencil, compressible, forceModel)
+    density_velocity_computation = DensityVelocityComputation(stencil, compressible, force_model)
 
     if cumulant:
-        eqValues = getCumulantsOfContinuousMaxwellianEquilibrium(tuple(momToRrDict.keys()), dim, c_s_sq=c_s_sq,
-                                                                 order=equilibriumAccuracyOrder)
+        eq_values = get_cumulants_of_continuous_maxwellian_equilibrium(tuple(mom_to_rr_dict.keys()), dim, c_s_sq=c_s_sq,
+                                                                       order=equilibrium_order)
     else:
-        eqValues = getMomentsOfContinuousMaxwellianEquilibrium(tuple(momToRrDict.keys()), dim, c_s_sq=c_s_sq,
-                                                               order=equilibriumAccuracyOrder)
+        eq_values = get_moments_of_continuous_maxwellian_equilibrium(tuple(mom_to_rr_dict.keys()), dim, c_s_sq=c_s_sq,
+                                                                     order=equilibrium_order)
 
     if not compressible:
         if not compressible and cumulant:
             raise NotImplementedError("Incompressible cumulants not yet supported")
-        rho = densityVelocityComputation.defined_symbols(order=0)[1]
-        u = densityVelocityComputation.defined_symbols(order=1)[1]
-        eqValues = [compressibleToIncompressibleMomentValue(em, rho, u) for em in eqValues]
+        rho = density_velocity_computation.defined_symbols(order=0)[1]
+        u = density_velocity_computation.defined_symbols(order=1)[1]
+        eq_values = [compressible_to_incompressible_moment_value(em, rho, u) for em in eq_values]
 
-    rrDict = OrderedDict([(mom, RelaxationInfo(eqMom, rr))
-                          for mom, rr, eqMom in zip(momToRrDict.keys(), momToRrDict.values(), eqValues)])
+    rr_dict = OrderedDict([(mom, RelaxationInfo(eqMom, rr))
+                          for mom, rr, eqMom in zip(mom_to_rr_dict.keys(), mom_to_rr_dict.values(), eq_values)])
     if cumulant:
-        return CumulantBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return CumulantBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
     else:
-        return MomentBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return MomentBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
 
 
-def createGenericMRT(stencil, momentEqValueRelaxationRateTuples, compressible=False, forceModel=None, cumulant=False):
+def create_generic_mrt(stencil, moment_eq_value_relaxation_rate_tuples, compressible=False,
+                       force_model=None, cumulant=False):
     r"""
-    Creates a generic moment-based LB method
-    :param stencil: sequence of lattice velocities
-    :param momentEqValueRelaxationRateTuples: sequence of tuples containing (moment, equilibrium value, relax. rate)
-    :param compressible: compressibility, determines calculation of velocity for force models
-    :param forceModel: see createWithDiscreteMaxwellianEqMoments
-    :param cumulant: true for cumulant methods, False for moment-based methods
+    Creates a generic moment-based LB method.
+
+    Args:
+        stencil: sequence of lattice velocities
+        moment_eq_value_relaxation_rate_tuples: sequence of tuples containing (moment, equilibrium value, relax. rate)
+        compressible: compressibility, determines calculation of velocity for force models
+        force_model: see create_with_discrete_maxwellian_eq_moments
+        cumulant: true for cumulant methods, False for moment-based methods
     """
-    densityVelocityComputation = DensityVelocityComputation(stencil, compressible, forceModel)
+    density_velocity_computation = DensityVelocityComputation(stencil, compressible, force_model)
 
-    rrDict = OrderedDict()
-    for moment, eqValue, rr in momentEqValueRelaxationRateTuples:
+    rr_dict = OrderedDict()
+    for moment, eqValue, rr in moment_eq_value_relaxation_rate_tuples:
         moment = sp.sympify(moment)
-        rrDict[moment] = RelaxationInfo(eqValue, rr)
+        rr_dict[moment] = RelaxationInfo(eqValue, rr)
     if cumulant:
-        return CumulantBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return CumulantBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
     else:
-        return MomentBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+        return MomentBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
 
 
-def createFromEquilibrium(stencil, equilibrium, momentToRelaxationRateDict, compressible=False, forceModel=None):
+def create_from_equilibrium(stencil, equilibrium, moment_to_relaxation_rate_dict, compressible=False, force_model=None):
     r"""
     Creates a moment-based LB method using a given equilibrium distribution function
-    :param stencil: see createWithDiscreteMaxwellianEqMoments
-    :param equilibrium: list of equilibrium terms, dependent on rho and u, one for each stencil direction
-    :param momentToRelaxationRateDict: relaxation rate for each moment, or a symbol/float if all should relaxed with the
-                                       same rate
-    :param compressible: see createWithDiscreteMaxwellianEqMoments
-    :param forceModel: see createWithDiscreteMaxwellianEqMoments
+
+    Args:
+        stencil: see create_with_discrete_maxwellian_eq_moments
+        equilibrium: list of equilibrium terms, dependent on rho and u, one for each stencil direction
+        moment_to_relaxation_rate_dict: relaxation rate for each moment, or a symbol/float if all should relaxed with
+                                        the same rate
+        compressible: see create_with_discrete_maxwellian_eq_moments
+        force_model: see create_with_discrete_maxwellian_eq_moments
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    if any(isinstance(momentToRelaxationRateDict, t) for t in (sp.Symbol, float, int)):
-        momentToRelaxationRateDict = {m: momentToRelaxationRateDict for m in getDefaultMomentSetForStencil(stencil)}
+        stencil = get_stencil(stencil)
+    if any(isinstance(moment_to_relaxation_rate_dict, t) for t in (sp.Symbol, float, int)):
+        moment_to_relaxation_rate_dict = {m: moment_to_relaxation_rate_dict
+                                          for m in get_default_moment_set_for_stencil(stencil)}
 
-    momToRrDict = OrderedDict(momentToRelaxationRateDict)
-    assert len(momToRrDict) == len(stencil), "The number of moments has to be the same as the number of stencil entries"
-    densityVelocityComputation = DensityVelocityComputation(stencil, compressible, forceModel)
+    mom_to_rr_dict = OrderedDict(moment_to_relaxation_rate_dict)
+    assert len(mom_to_rr_dict) == len(stencil), "The number of moments has to be equal to the number of stencil entries"
+    density_velocity_computation = DensityVelocityComputation(stencil, compressible, force_model)
 
-    rrDict = OrderedDict([(mom, RelaxationInfo(discreteMoment(equilibrium, mom, stencil).expand(), rr))
-                          for mom, rr in zip(momToRrDict.keys(), momToRrDict.values())])
-    return MomentBasedLbMethod(stencil, rrDict, densityVelocityComputation, forceModel)
+    rr_dict = OrderedDict([(mom, RelaxationInfo(discrete_moment(equilibrium, mom, stencil).expand(), rr))
+                          for mom, rr in zip(mom_to_rr_dict.keys(), mom_to_rr_dict.values())])
+    return MomentBasedLbMethod(stencil, rr_dict, density_velocity_computation, force_model)
 
 
 # ------------------------------------ SRT / TRT/ MRT Creators ---------------------------------------------------------
 
 
-def createSRT(stencil, relaxationRate, useContinuousMaxwellianEquilibrium=False, **kwargs):
-    r"""
-    Creates a single relaxation time (SRT) lattice Boltzmann model also known as BGK model.
+def create_srt(stencil, relaxation_rate, maxwellian_moments=False, **kwargs):
+    r"""Creates a single relaxation time (SRT) lattice Boltzmann model also known as BGK model.
 
-    :param stencil: nested tuple defining the discrete velocity space. See :func:`lbmpy.stencils.getStencil`
-    :param relaxationRate: relaxation rate (inverse of the relaxation time)
-                           usually called :math:`\omega` in LBM literature
-    :param useContinuousMaxwellianEquilibrium: determines if the discrete or continuous maxwellian equilibrium is
-                           used to compute the equilibrium moments
-    :return: :class:`lbmpy.methods.MomentBasedLbMethod` instance
+    Args:
+        stencil: nested tuple defining the discrete velocity space. See :func:`lbmpy.stencils.get_stencil`
+        relaxation_rate: relaxation rate (inverse of the relaxation time)
+                        usually called :math:`\omega` in LBM literature
+        maxwellian_moments: determines if the discrete or continuous maxwellian equilibrium is
+                        used to compute the equilibrium moments
+
+    Returns:
+        :class:`lbmpy.methods.MomentBasedLbMethod` instance
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    moments = getDefaultMomentSetForStencil(stencil)
-    rrDict = OrderedDict([(m, relaxationRate) for m in moments])
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, rrDict,  **kwargs)
+        stencil = get_stencil(stencil)
+    moments = get_default_moment_set_for_stencil(stencil)
+    rr_dict = OrderedDict([(m, relaxation_rate) for m in moments])
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, rrDict, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
 
 
-def createTRT(stencil, relaxationRateEvenMoments, relaxationRateOddMoments,
-              useContinuousMaxwellianEquilibrium=False, **kwargs):
+def create_trt(stencil, relaxation_rate_even_moments, relaxation_rate_odd_moments,
+               maxwellian_moments=False, **kwargs):
     """
     Creates a two relaxation time (TRT) lattice Boltzmann model, where even and odd moments are relaxed differently.
     In the SRT model the exact wall position of no-slip boundaries depends on the viscosity, the TRT method does not
     have this problem.
 
-    Parameters are similar to :func:`lbmpy.methods.createSRT`, but instead of one relaxation rate there are
+    Parameters are similar to :func:`lbmpy.methods.create_srt`, but instead of one relaxation rate there are
     two relaxation rates: one for even moments (determines viscosity) and one for odd moments.
-    If unsure how to choose the odd relaxation rate, use the function :func:`lbmpy.methods.createTRTWithMagicNumber`.
+    If unsure how to choose the odd relaxation rate, use the function :func:`lbmpy.methods.create_trt_with_magic_number`
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    moments = getDefaultMomentSetForStencil(stencil)
-    rrDict = OrderedDict([(m, relaxationRateEvenMoments if isEven(m) else relaxationRateOddMoments) for m in moments])
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, rrDict,  **kwargs)
+        stencil = get_stencil(stencil)
+    moments = get_default_moment_set_for_stencil(stencil)
+    rr_dict = OrderedDict([(m, relaxation_rate_even_moments if is_even(m) else relaxation_rate_odd_moments)
+                           for m in moments])
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, rrDict, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
 
 
-def createTRTWithMagicNumber(stencil, relaxationRate, magicNumber=sp.Rational(3, 16), **kwargs):
+def create_trt_with_magic_number(stencil, relaxation_rate, magic_number=sp.Rational(3, 16), **kwargs):
     """
     Creates a two relaxation time (TRT) lattice Boltzmann method, where the relaxation time for odd moments is
     determines from the even moment relaxation time and a "magic number".
-    For possible parameters see :func:`lbmpy.methods.createTRT`
+    For possible parameters see :func:`lbmpy.methods.create_trt`
     """
-    rrOdd = relaxationRateFromMagicNumber(relaxationRate, magicNumber)
-    return createTRT(stencil, relaxationRateEvenMoments=relaxationRate, relaxationRateOddMoments=rrOdd, **kwargs)
+    rr_odd = relaxation_rate_from_magic_number(relaxation_rate, magic_number)
+    return create_trt(stencil, relaxation_rate_even_moments=relaxation_rate,
+                      relaxation_rate_odd_moments=rr_odd, **kwargs)
 
 
-def createRawMRT(stencil, relaxationRates, useContinuousMaxwellianEquilibrium=False, **kwargs):
-    """
-    Creates a MRT method using non-orthogonalized moments
-    """
+def create_mrt_raw(stencil, relaxation_rates, maxwellian_moments=False, **kwargs):
+    """Creates a MRT method using non-orthogonalized moments."""
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    moments = getDefaultMomentSetForStencil(stencil)
-    rrDict = OrderedDict(zip(moments, relaxationRates))
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, rrDict,  **kwargs)
+        stencil = get_stencil(stencil)
+    moments = get_default_moment_set_for_stencil(stencil)
+    rr_dict = OrderedDict(zip(moments, relaxation_rates))
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, rrDict, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, rr_dict, **kwargs)
 
 
-def createThreeRelaxationRateMRT(stencil, relaxationRates, useContinuousMaxwellianEquilibrium=False, **kwargs):
-    """
-    Creates a MRT with three relaxation times, one to control viscosity, one for bulk viscosity and one for all
-    higher order moments
+def create_mrt3(stencil, relaxation_rates, maxwellian_moments=False, **kwargs):
+    """Creates a MRT with three relaxation times.
+
+    The first rate controls viscosity, the second the bulk viscosity and the last is used to relax higher order moments.
     """
     def product(iterable):
         return reduce(operator.mul, iterable, 1)
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
+        stencil = get_stencil(stencil)
 
     dim = len(stencil[0])
-    theMoment = MOMENT_SYMBOLS[:dim]
+    the_moment = MOMENT_SYMBOLS[:dim]
 
-    shearTensorOffDiagonal = [product(t) for t in itertools.combinations(theMoment, 2)]
-    shearTensorDiagonal = [m_i * m_i for m_i in theMoment]
-    shearTensorTrace = sum(shearTensorDiagonal)
-    shearTensorTraceFreeDiagonal = [dim * d - shearTensorTrace for d in shearTensorDiagonal]
+    shear_tensor_off_diagonal = [product(t) for t in itertools.combinations(the_moment, 2)]
+    shear_tensor_diagonal = [m_i * m_i for m_i in the_moment]
+    shear_tensor_trace = sum(shear_tensor_diagonal)
+    shear_tensor_trace_free_diagonal = [dim * d - shear_tensor_trace for d in shear_tensor_diagonal]
 
-    rest = [defaultMoment for defaultMoment in getDefaultMomentSetForStencil(stencil) if getOrder(defaultMoment) != 2]
+    rest = [defaultMoment for defaultMoment in get_default_moment_set_for_stencil(stencil) if get_order(defaultMoment) != 2]
 
-    D = shearTensorOffDiagonal + shearTensorTraceFreeDiagonal[:-1]
-    T = [shearTensorTrace]
-    Q = rest
+    d = shear_tensor_off_diagonal + shear_tensor_trace_free_diagonal[:-1]
+    t = [shear_tensor_trace]
+    q = rest
 
-    if 'magicNumber' in kwargs:
-        magicNumber = kwargs['magicNumber']
+    if 'magic_number' in kwargs:
+        magic_number = kwargs['magic_number']
     else:
-        magicNumber = sp.Rational(3, 16)
-
-    if len(relaxationRates) == 1:
-        relaxationRates = [relaxationRates[0],
-                           relaxationRateFromMagicNumber(relaxationRates[0], magicNumber=magicNumber),
-                           1]
-    elif len(relaxationRates) == 2:
-        relaxationRates = [relaxationRates[0],
-                           relaxationRateFromMagicNumber(relaxationRates[0], magicNumber=magicNumber),
-                           relaxationRates[1]]
-
-    relaxationRates = [relaxationRates[0]] * len(D) + \
-                      [relaxationRates[1]] * len(T) + \
-                      [relaxationRates[2]] * len(Q)
-
-    allMoments = D + T + Q
-    momentToRr = OrderedDict((m, rr) for m, rr in zip(allMoments, relaxationRates))
-
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, momentToRr,  **kwargs)
+        magic_number = sp.Rational(3, 16)
+
+    if len(relaxation_rates) == 1:
+        relaxation_rates = [relaxation_rates[0],
+                            relaxation_rate_from_magic_number(relaxation_rates[0], magic_number=magic_number),
+                            1]
+    elif len(relaxation_rates) == 2:
+        relaxation_rates = [relaxation_rates[0],
+                            relaxation_rate_from_magic_number(relaxation_rates[0], magic_number=magic_number),
+                            relaxation_rates[1]]
+
+    relaxation_rates = [relaxation_rates[0]] * len(d) + \
+                       [relaxation_rates[1]] * len(t) + \
+                       [relaxation_rates[2]] * len(q)
+
+    all_moments = d + t + q
+    moment_to_rr = OrderedDict((m, rr) for m, rr in zip(all_moments, relaxation_rates))
+
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, moment_to_rr, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, momentToRr, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, moment_to_rr, **kwargs)
 
 
-def createKBCTypeTRT(dim, shearRelaxationRate, higherOrderRelaxationRate, methodName='KBC-N4',
-                     useContinuousMaxwellianEquilibrium=False, **kwargs):
+def create_trt_kbc(dim, shear_relaxation_rate, higher_order_relaxation_rate, method_name='KBC-N4',
+                   maxwellian_moments=False, **kwargs):
     """
     Creates a method with two relaxation rates, one for lower order moments which determines the viscosity and
     one for higher order moments. In entropic models this second relaxation rate is chosen subject to an entropy
-    condition. Which moments are relaxed by which rate is determined by the methodName
+    condition. Which moments are relaxed by which rate is determined by the method_name
 
     :param dim: 2 or 3, leads to stencil D2Q9 or D3Q27
-    :param shearRelaxationRate: relaxation rate that determines viscosity
-    :param higherOrderRelaxationRate: relaxation rate for higher order moments
-    :param methodName: string 'KBC-Nx' where x can be an number from 1 to 4, for details see
-                       "Karlin 2015: Entropic multirelaxation lattice Boltzmann models for turbulent flows"
-    :param useContinuousMaxwellianEquilibrium: determines if the discrete or continuous maxwellian equilibrium is
+    :param shear_relaxation_rate: relaxation rate that determines viscosity
+    :param higher_order_relaxation_rate: relaxation rate for higher order moments
+    :param method_name: string 'KBC-Nx' where x can be an number from 1 to 4, for details see
+                       "Karlin 2015: Entropic multi relaxation lattice Boltzmann models for turbulent flows"
+    :param maxwellian_moments: determines if the discrete or continuous maxwellian equilibrium is
                            used to compute the equilibrium moments
     """
     def product(iterable):
         return reduce(operator.mul, iterable, 1)
 
-    theMoment = MOMENT_SYMBOLS[:dim]
+    the_moment = MOMENT_SYMBOLS[:dim]
 
     rho = [sp.Rational(1, 1)]
-    velocity = list(theMoment)
+    velocity = list(the_moment)
 
-    shearTensorOffDiagonal = [product(t) for t in itertools.combinations(theMoment, 2)]
-    shearTensorDiagonal = [m_i * m_i for m_i in theMoment]
-    shearTensorTrace = sum(shearTensorDiagonal)
-    shearTensorTraceFreeDiagonal = [dim * d - shearTensorTrace for d in shearTensorDiagonal]
+    shear_tensor_off_diagonal = [product(t) for t in itertools.combinations(the_moment, 2)]
+    shear_tensor_diagonal = [m_i * m_i for m_i in the_moment]
+    shear_tensor_trace = sum(shear_tensor_diagonal)
+    shear_tensor_trace_free_diagonal = [dim * d - shear_tensor_trace for d in shear_tensor_diagonal]
 
-    energyTransportTensor = list(exponentsToPolynomialRepresentations([a for a in momentsOfOrder(3, dim, True)
-                                                                       if 3 not in a]))
+    energy_transport_tensor = list(exponents_to_polynomial_representations([a for a in moments_of_order(3, dim, True)
+                                                                            if 3 not in a]))
 
-    explicitlyDefined = set(rho + velocity + shearTensorOffDiagonal + shearTensorDiagonal + energyTransportTensor)
-    rest = list(set(exponentsToPolynomialRepresentations(momentsUpToComponentOrder(2, dim))) - explicitlyDefined)
-    assert len(rest) + len(explicitlyDefined) == 3**dim
+    explicitly_defined = set(rho + velocity + shear_tensor_off_diagonal +
+                             shear_tensor_diagonal + energy_transport_tensor)
+    rest = list(set(exponents_to_polynomial_representations(moments_up_to_component_order(2, dim))) - explicitly_defined)
+    assert len(rest) + len(explicitly_defined) == 3**dim
 
     # naming according to paper Karlin 2015: Entropic multirelaxation lattice Boltzmann models for turbulent flows
-    D = shearTensorOffDiagonal + shearTensorTraceFreeDiagonal[:-1]
-    T = [shearTensorTrace]
-    Q = energyTransportTensor
-    if methodName == 'KBC-N1':
-        decomposition = [D, T+Q+rest]
-    elif methodName == 'KBC-N2':
-        decomposition = [D+T, Q+rest]
-    elif methodName == 'KBC-N3':
-        decomposition = [D+Q, T+rest]
-    elif methodName == 'KBC-N4':
-        decomposition = [D+T+Q, rest]
+    d = shear_tensor_off_diagonal + shear_tensor_trace_free_diagonal[:-1]
+    t = [shear_tensor_trace]
+    q = energy_transport_tensor
+    if method_name == 'KBC-N1':
+        decomposition = [d, t+q+rest]
+    elif method_name == 'KBC-N2':
+        decomposition = [d+t, q+rest]
+    elif method_name == 'KBC-N3':
+        decomposition = [d+q, t+rest]
+    elif method_name == 'KBC-N4':
+        decomposition = [d+t+q, rest]
     else:
         raise ValueError("Unknown model. Supported models KBC-Nx where x in (1,2,3,4)")
 
-    omega_s, omega_h = shearRelaxationRate, higherOrderRelaxationRate
-    shearPart, restPart = decomposition
+    omega_s, omega_h = shear_relaxation_rate, higher_order_relaxation_rate
+    shear_part, rest_part = decomposition
 
-    relaxationRates = [omega_s] + \
-                      [omega_s] * len(velocity) + \
-                      [omega_s] * len(shearPart) + \
-                      [omega_h] * len(restPart)
+    relaxation_rates = [omega_s] + \
+                       [omega_s] * len(velocity) + \
+                       [omega_s] * len(shear_part) + \
+                       [omega_h] * len(rest_part)
 
-    stencil = getStencil("D2Q9") if dim == 2 else getStencil("D3Q27")
-    allMoments = rho + velocity + shearPart + restPart
-    momentToRr = OrderedDict((m, rr) for m, rr in zip(allMoments, relaxationRates))
+    stencil = get_stencil("D2Q9") if dim == 2 else get_stencil("D3Q27")
+    all_moments = rho + velocity + shear_part + rest_part
+    moment_to_rr = OrderedDict((m, rr) for m, rr in zip(all_moments, relaxation_rates))
 
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, momentToRr, **kwargs)
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, moment_to_rr, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, momentToRr, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, moment_to_rr, **kwargs)
 
 
-def createOrthogonalMRT(stencil, relaxationRateGetter=None, useContinuousMaxwellianEquilibrium=False, **kwargs):
+def create_mrt_orthogonal(stencil, relaxation_rate_getter=None, maxwellian_moments=False, **kwargs):
     r"""
     Returns a orthogonal multi-relaxation time model for the stencils D2Q9, D3Q15, D3Q19 and D3Q27.
     These MRT methods are just one specific version - there are many MRT methods possible for all these stencils
     which differ by the linear combination of moments and the grouping into equal relaxation times.
-    To create a generic MRT method use :func:`lbmpy.methods.createWithDiscreteMaxwellianEqMoments`
+    To create a generic MRT method use :func:`lbmpy.methods.create_with_discrete_maxwellian_eq_moments`
 
-    :param stencil: nested tuple defining the discrete velocity space. See `func:lbmpy.stencils.getStencil`
-    :param relaxationRateGetter: function getting a list of moments as argument, returning the associated relaxation
+    :param stencil: nested tuple defining the discrete velocity space. See `func:lbmpy.stencils.get_stencil`
+    :param relaxation_rate_getter: function getting a list of moments as argument, returning the associated relaxation
                                  time. The default returns:
 
                                     - 0 for moments of order 0 and 1 (conserved)
                                     - :math:`\omega`: from moments of order 2 (rate that determines viscosity)
                                     - numbered :math:`\omega_i` for the rest
-    :param useContinuousMaxwellianEquilibrium: determines if the discrete or continuous maxwellian equilibrium is
+    :param maxwellian_moments: determines if the discrete or continuous maxwellian equilibrium is
                                                used to compute the equilibrium moments
     """
-    if relaxationRateGetter is None:
-        relaxationRateGetter = defaultRelaxationRateNames()
+    if relaxation_rate_getter is None:
+        relaxation_rate_getter = default_relaxation_rate_names()
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
+        stencil = get_stencil(stencil)
 
     x, y, z = MOMENT_SYMBOLS
     one = sp.Rational(1, 1)
 
-    momentToRelaxationRateDict = OrderedDict()
-    if stencilsHaveSameEntries(stencil, getStencil("D2Q9")):
-        moments = getDefaultMomentSetForStencil(stencil)
-        orthogonalMoments = gramSchmidt(moments, stencil)
-        orthogonalMomentsScaled = [e * common_denominator(e) for e in orthogonalMoments]
-        nestedMoments = list(sortMomentsIntoGroupsOfSameOrder(orthogonalMomentsScaled).values())
-    elif stencilsHaveSameEntries(stencil, getStencil("D3Q15")):
+    moment_to_relaxation_rate_dict = OrderedDict()
+    if stencils_have_same_entries(stencil, get_stencil("D2Q9")):
+        moments = get_default_moment_set_for_stencil(stencil)
+        orthogonal_moments = gram_schmidt(moments, stencil)
+        orthogonal_moments_scaled = [e * common_denominator(e) for e in orthogonal_moments]
+        nested_moments = list(sort_moments_into_groups_of_same_order(orthogonal_moments_scaled).values())
+    elif stencils_have_same_entries(stencil, get_stencil("D3Q15")):
         sq = x ** 2 + y ** 2 + z ** 2
-        nestedMoments = [
+        nested_moments = [
             [one, x, y, z],  # [0, 3, 5, 7]
             [sq - 1],  # [1]
             [3 * sq ** 2 - 6 * sq + 1],  # [2]
@@ -377,9 +391,9 @@ def createOrthogonalMRT(stencil, relaxationRateGetter=None, useContinuousMaxwell
             [3 * x ** 2 - sq, y ** 2 - z ** 2, x * y, y * z, x * z],  # [9, 10, 11, 12, 13]
             [x * y * z]
         ]
-    elif stencilsHaveSameEntries(stencil, getStencil("D3Q19")):
+    elif stencils_have_same_entries(stencil, get_stencil("D3Q19")):
         sq = x ** 2 + y ** 2 + z ** 2
-        nestedMoments = [
+        nested_moments = [
             [one, x, y, z],  # [0, 3, 5, 7]
             [sq - 1],  # [1]
             [3 * sq ** 2 - 6 * sq + 1],  # [2]
@@ -388,9 +402,9 @@ def createOrthogonalMRT(stencil, relaxationRateGetter=None, useContinuousMaxwell
             [(2 * sq - 3) * (3 * x ** 2 - sq), (2 * sq - 3) * (y ** 2 - z ** 2)],  # [10, 12]
             [(y ** 2 - z ** 2) * x, (z ** 2 - x ** 2) * y, (x ** 2 - y ** 2) * z]  # [16, 17, 18]
         ]
-    elif stencilsHaveSameEntries(stencil, getStencil("D3Q27")):
+    elif stencils_have_same_entries(stencil, get_stencil("D3Q27")):
         xsq, ysq, zsq = x ** 2, y ** 2, z ** 2
-        allMoments = [
+        all_moments = [
             sp.Rational(1, 1),  # 0
             x, y, z,  # 1, 2, 3
             x * y, x * z, y * z,  # 4, 5, 6
@@ -415,82 +429,81 @@ def createOrthogonalMRT(stencil, relaxationRateGetter=None, useContinuousMaxwell
             9 * (xsq * ysq * z) - 6 * (xsq * z + ysq * z) + 4 * z,  # 25
             27 * (xsq * ysq * zsq) - 18 * (xsq * ysq + xsq * zsq + ysq * zsq) + 12 * (xsq + ysq + zsq) - 8,  # 26
         ]
-        nestedMoments = list(sortMomentsIntoGroupsOfSameOrder(allMoments).values())
+        nested_moments = list(sort_moments_into_groups_of_same_order(all_moments).values())
     else:
         raise NotImplementedError("No MRT model is available (yet) for this stencil. "
-                                  "Create a custom MRT using 'createWithDiscreteMaxwellianEqMoments'")
+                                  "Create a custom MRT using 'create_with_discrete_maxwellian_eq_moments'")
 
-    for momentList in nestedMoments:
-        rr = relaxationRateGetter(momentList)
+    for momentList in nested_moments:
+        rr = relaxation_rate_getter(momentList)
         for m in momentList:
-            momentToRelaxationRateDict[m] = rr
+            moment_to_relaxation_rate_dict[m] = rr
 
-    if useContinuousMaxwellianEquilibrium:
-        return createWithContinuousMaxwellianEqMoments(stencil, momentToRelaxationRateDict, **kwargs)
+    if maxwellian_moments:
+        return create_with_continuous_maxwellian_eq_moments(stencil, moment_to_relaxation_rate_dict, **kwargs)
     else:
-        return createWithDiscreteMaxwellianEqMoments(stencil, momentToRelaxationRateDict, **kwargs)
+        return create_with_discrete_maxwellian_eq_moments(stencil, moment_to_relaxation_rate_dict, **kwargs)
 
 
-def modifyRelaxationTable(method, modificationFunction):
+def modify_relaxation_table(method, modification_function):
     """
     Creates a new method, based on an existing method with modified relaxation table
     :param method: old method
-    :param modificationFunction: function receiving (moment, equilibriumValue, relaxationRate) tuple, i.e. on row
+    :param modification_function: function receiving (moment, equilibriumValue, relaxation_rate) tuple, i.e. on row
                                  of the relaxation table, returning a modified tuple
     """
-    relaxationTable = (modificationFunction(m, eq, rr)
-                       for m, eq, rr in zip(method.moments, method.momentEquilibriumValues, method.relaxationRates))
-    compressible = method.conservedQuantityComputation.compressible
+    relaxation_table = (modification_function(m, eq, rr)
+                        for m, eq, rr in zip(method.moments, method.moment_equilibrium_values, method.relaxation_rates))
+    compressible = method.conserved_quantity_computation.compressible
     cumulant = isinstance(method, CumulantBasedLbMethod)
-    return createGenericMRT(method.stencil, relaxationTable, compressible, method.forceModel, cumulant)
+    return create_generic_mrt(method.stencil, relaxation_table, compressible, method.force_model, cumulant)
 
 # ----------------------------------------- Comparison view for notebooks ----------------------------------------------
 
 
-def compareMomentBasedLbMethods(reference, other, showDeviationsOnly=False):
+def compare_moment_based_lb_methods(reference, other, show_deviations_only=False):
     import ipy_table
     table = []
-    captionRows = [len(table)]
+    caption_rows = [len(table)]
     table.append(['Shared Moment', 'ref', 'other', 'difference'])
 
-    referenceMoments = set(reference.moments)
-    otherMoments = set(other.moments)
-    for moment in referenceMoments.intersection(otherMoments):
-        referenceValue = reference.relaxationInfoDict[moment].equilibriumValue
-        otherValue = other.relaxationInfoDict[moment].equilibriumValue
-        diff = sp.simplify(referenceValue - otherValue)
-        if showDeviationsOnly and diff == 0:
+    reference_moments = set(reference.moments)
+    other_moments = set(other.moments)
+    for moment in reference_moments.intersection(other_moments):
+        reference_value = reference.relaxation_info_dict[moment].equilibriumValue
+        other_value = other.relaxation_info_dict[moment].equilibriumValue
+        diff = sp.simplify(reference_value - other_value)
+        if show_deviations_only and diff == 0:
             pass
         else:
             table.append(["$%s$" % (sp.latex(moment), ),
-                          "$%s$" % (sp.latex(referenceValue), ),
-                          "$%s$" % (sp.latex(otherValue), ),
+                          "$%s$" % (sp.latex(reference_value), ),
+                          "$%s$" % (sp.latex(other_value), ),
                           "$%s$" % (sp.latex(diff),)])
 
-    onlyInRef = referenceMoments - otherMoments
-    if onlyInRef:
-        captionRows.append(len(table))
+    only_in_ref = reference_moments - other_moments
+    if only_in_ref:
+        caption_rows.append(len(table))
         table.append(['Only in Ref', 'value', '', ''])
-        for moment in onlyInRef:
-            val = reference.relaxationInfoDict[moment].equilibriumValue
+        for moment in only_in_ref:
+            val = reference.relaxation_info_dict[moment].equilibriumValue
             table.append(["$%s$" % (sp.latex(moment),),
                           "$%s$" % (sp.latex(val),),
                           " ", " "])
 
-    onlyInOther = otherMoments - referenceMoments
-    if onlyInOther:
-        captionRows.append(len(table))
+    only_in_other = other_moments - reference_moments
+    if only_in_other:
+        caption_rows.append(len(table))
         table.append(['Only in Other', '', 'value', ''])
-        for moment in onlyInOther:
-            val = other.relaxationInfoDict[moment].equilibriumValue
+        for moment in only_in_other:
+            val = other.relaxation_info_dict[moment].equilibriumValue
             table.append(["$%s$" % (sp.latex(moment),),
                           " ",
                           "$%s$" % (sp.latex(val),),
                           " "])
 
-    tableDisplay = ipy_table.make_table(table)
-    for rowIdx in captionRows:
+    table_display = ipy_table.make_table(table)
+    for row_idx in caption_rows:
         for col in range(4):
-            ipy_table.set_cell_style(rowIdx, col, color='#bbbbbb')
-    return tableDisplay
-
+            ipy_table.set_cell_style(row_idx, col, color='#bbbbbb')
+    return table_display
diff --git a/methods/cumulantbased.py b/methods/cumulantbased.py
index 3845c76d666a8a76b6ed673ba2598e6ffed0d194..bcf60fc108bc832febc71422b86567579920cb26 100644
--- a/methods/cumulantbased.py
+++ b/methods/cumulantbased.py
@@ -4,68 +4,69 @@ from pystencils import Assignment
 from pystencils.sympyextensions import fast_subs, subs_additive
 from lbmpy.methods.abstractlbmethod import AbstractLbMethod, LbmCollisionRule, RelaxationInfo
 from lbmpy.methods.conservedquantitycomputation import AbstractConservedQuantityComputation
-from lbmpy.moments import MOMENT_SYMBOLS, extractMonomials, momentMatrix, monomialToPolynomialTransformationMatrix
+from lbmpy.moments import MOMENT_SYMBOLS, extract_monomials, moment_matrix, monomial_to_polynomial_transformation_matrix
 from lbmpy.cumulants import cumulantAsFunctionOfRawMoments, rawMomentAsFunctionOfCumulants
 
 
 class CumulantBasedLbMethod(AbstractLbMethod):
 
-    def __init__(self, stencil, cumulantToRelaxationInfoDict, conservedQuantityComputation, forceModel=None):
-        assert isinstance(conservedQuantityComputation, AbstractConservedQuantityComputation)
+    def __init__(self, stencil, cumulant_to_relaxation_info_dict, conserved_quantity_computation, force_model=None):
+        assert isinstance(conserved_quantity_computation, AbstractConservedQuantityComputation)
         super(CumulantBasedLbMethod, self).__init__(stencil)
 
-        self._forceModel = forceModel
-        self._cumulantToRelaxationInfoDict = OrderedDict(cumulantToRelaxationInfoDict.items())
-        self._conservedQuantityComputation = conservedQuantityComputation
+        self._force_model = force_model
+        self._cumulant_to_relaxation_info_dict = OrderedDict(cumulant_to_relaxation_info_dict.items())
+        self._conserved_quantity_computation = conserved_quantity_computation
         self._weights = None
 
     @property
-    def forceModel(self):
-        return self._forceModel
+    def force_model(self):
+        return self._force_model
 
     @property
-    def relaxationInfoDict(self):
-        return self._cumulantToRelaxationInfoDict
+    def relaxation_info_dict(self):
+        return self._cumulant_to_relaxation_info_dict
 
     @property
-    def zerothOrderEquilibriumMomentSymbol(self, ):
-        return self._conservedQuantityComputation.zerothOrderMomentSymbol
+    def zeroth_order_equilibrium_moment_symbol(self, ):
+        return self._conserved_quantity_computation.zeroth_order_moment_symbol
 
     @property
-    def firstOrderEquilibriumMomentSymbols(self, ):
-        return self._conservedQuantityComputation.firstOrderMomentSymbols
+    def first_order_equilibrium_moment_symbols(self, ):
+        return self._conserved_quantity_computation.first_order_moment_symbols
 
-    def setFirstMomentRelaxationRate(self, relaxationRate):
+    def set_first_moment_relaxation_rate(self, relaxation_rate):
         for e in MOMENT_SYMBOLS[:self.dim]:
-            assert e in self._cumulantToRelaxationInfoDict, "First cumulants are not relaxed separately by this method"
+            assert e in self._cumulant_to_relaxation_info_dict, \
+                "First cumulants are not relaxed separately by this method"
         for e in MOMENT_SYMBOLS[:self.dim]:
-            prevEntry = self._cumulantToRelaxationInfoDict[e]
-            newEntry = RelaxationInfo(prevEntry[0], relaxationRate)
-            self._cumulantToRelaxationInfoDict[e] = newEntry
+            prev_entry = self._cumulant_to_relaxation_info_dict[e]
+            new_entry = RelaxationInfo(prev_entry[0], relaxation_rate)
+            self._cumulant_to_relaxation_info_dict[e] = new_entry
 
     @property
     def cumulants(self):
-        return tuple(self._cumulantToRelaxationInfoDict.keys())
+        return tuple(self._cumulant_to_relaxation_info_dict.keys())
 
     @property
-    def cumulantEquilibriumValues(self):
-        return tuple([e.equilibriumValue for e in self._cumulantToRelaxationInfoDict.values()])
+    def cumulant_equilibrium_values(self):
+        return tuple([e.equilibriumValue for e in self._cumulant_to_relaxation_info_dict.values()])
 
     @property
-    def relaxationRates(self):
-        return tuple([e.relaxationRate for e in self._cumulantToRelaxationInfoDict.values()])
+    def relaxation_rates(self):
+        return tuple([e.relaxation_rate for e in self._cumulant_to_relaxation_info_dict.values()])
 
     @property
-    def conservedQuantityComputation(self):
-        return self._conservedQuantityComputation
+    def conserved_quantity_computation(self):
+        return self._conserved_quantity_computation
 
     @property
     def weights(self):
         if self._weights is None:
-            self._weights = self._computeWeights()
+            self._weights = self._compute_weights()
         return self._weights
 
-    def overrideWeights(self, weights):
+    def override_weights(self, weights):
         assert len(weights) == len(self.stencil)
         self._weights = weights
 
@@ -81,7 +82,7 @@ class CumulantBasedLbMethod(AbstractLbMethod):
         </table>
         """
         content = ""
-        for cumulant, (eqValue, rr) in self._cumulantToRelaxationInfoDict.items():
+        for cumulant, (eqValue, rr) in self._cumulant_to_relaxation_info_dict.items():
             vals = {
                 'rr': sp.latex(rr),
                 'cumulant': sp.latex(cumulant),
@@ -95,40 +96,42 @@ class CumulantBasedLbMethod(AbstractLbMethod):
                          </tr>\n""".format(**vals)
         return table.format(content=content, nb='style="border:none"')
 
-    def getEquilibrium(self, conservedQuantityEquations=None):
-        D = sp.eye(len(self.relaxationRates))
-        return self._getCollisionRuleWithRelaxationMatrix(D, conservedQuantityEquations, False, False, False, False)
+    def get_equilibrium(self, conserved_quantity_equations=None):
+        d = sp.eye(len(self.relaxation_rates))
+        return self._get_collision_rule_with_relaxation_matrix(d, conserved_quantity_equations,
+                                                               False, False, False, False)
 
-    def getEquilibriumTerms(self):
-        equilibrium = self.getEquilibrium()
+    def get_equilibrium_terms(self):
+        equilibrium = self.get_equilibrium()
         return sp.Matrix([eq.rhs for eq in equilibrium.main_assignments])
 
-    def getCollisionRule(self, conservedQuantityEquations=None, momentSubexpressions=False,
-                         preCollisionSubexpressions=True, postCollisionSubexpressions=False):
-        return self._getCollisionRuleWithRelaxationMatrix(sp.diag(*self.relaxationRates), conservedQuantityEquations,
-                                                          momentSubexpressions, preCollisionSubexpressions,
-                                                          postCollisionSubexpressions)
-
-    def _computeWeights(self):
-        replacements = self._conservedQuantityComputation.defaultValues
-        eq = self.getEquilibrium()
-        eqColl = eq.new_with_substitutions(replacements, substitute_on_lhs=False).new_without_subexpressions()
-        newMainEqs = [Assignment(e.lhs,
-                                 subs_additive(e.rhs, 1, sum(self.preCollisionPdfSymbols),
-                                               required_match_replacement=1.0))
-                      for e in eqColl.main_assignments]
-        eqColl = eqColl.copy(newMainEqs)
+    def get_collision_rule(self, conserved_quantity_equations=None, moment_subexpressions=False,
+                           pre_collision_subexpressions=True, post_collision_subexpressions=False):
+        return self._get_collision_rule_with_relaxation_matrix(sp.diag(*self.relaxation_rates),
+                                                               conserved_quantity_equations,
+                                                               moment_subexpressions, pre_collision_subexpressions,
+                                                               post_collision_subexpressions)
+
+    def _compute_weights(self):
+        replacements = self._conserved_quantity_computation.default_values
+        eq = self.get_equilibrium()
+        ac = eq.new_with_substitutions(replacements, substitute_on_lhs=False).new_without_subexpressions()
+        new_main_eqs = [Assignment(e.lhs,
+                                   subs_additive(e.rhs, sp.sympify(1), sum(self.pre_collision_pdf_symbols),
+                                                 required_match_replacement=1.0))
+                        for e in ac.main_assignments]
+        ac = ac.copy(new_main_eqs)
 
         weights = []
-        for eq in eqColl.main_assignments:
+        for eq in ac.main_assignments:
             value = eq.rhs.expand()
             assert len(value.atoms(sp.Symbol)) == 0, "Failed to compute weights"
             weights.append(value)
         return weights
 
-    def _getCollisionRuleWithRelaxationMatrix(self, relaxationMatrix, conserved_quantity_equations=None,
-                                              momentSubexpressions=False, preCollisionSubexpressions=True,
-                                              postCollisionSubexpressions=False, includeForceTerms=True):
+    def _get_collision_rule_with_relaxation_matrix(self, relaxation_matrix, conserved_quantity_equations=None,
+                                                   moment_subexpressions=False, pre_collision_subexpressions=True,
+                                                   post_collision_subexpressions=False, include_force_terms=True):
         def tuple_to_symbol(exp, prefix):
             dim = len(exp)
             format_string = prefix + "_" + "_".join(["%d"]*dim)
@@ -141,14 +144,14 @@ class CumulantBasedLbMethod(AbstractLbMethod):
             substitution_dict.update({density * eq.rhs: density * eq.lhs for eq in cqe.main_assignments[1:]})
             return [fast_subs(e, substitution_dict) for e in expressions]
 
-        f = self.preCollisionPdfSymbols
+        f = self.pre_collision_pdf_symbols
         if conserved_quantity_equations is None:
-            conserved_quantity_equations = self._conservedQuantityComputation.equilibriumInputEquationsFromPdfs(f)
+            conserved_quantity_equations = self._conserved_quantity_computation.equilibrium_input_equations_from_pdfs(f)
 
         subexpressions = conserved_quantity_equations.all_assignments
 
         # 1) Determine monomial indices, and arrange them such that the zeroth and first order indices come first
-        indices = list(extractMonomials(self.cumulants, dim=len(self.stencil[0])))
+        indices = list(extract_monomials(self.cumulants, dim=len(self.stencil[0])))
         zeroth_moment_exponent = (0,) * self.dim
         first_moment_exponents = [tuple([1 if i == j else 0 for i in range(self.dim)]) for j in range(self.dim)]
         lower_order_indices = [zeroth_moment_exponent] + first_moment_exponents
@@ -159,32 +162,33 @@ class CumulantBasedLbMethod(AbstractLbMethod):
         indices = lower_order_indices + higher_order_indices  # reorder
 
         # 2) Transform pdfs to moments
-        moment_transformation_matrix = momentMatrix(indices, self.stencil)
+        moment_transformation_matrix = moment_matrix(indices, self.stencil)
         moments = moment_transformation_matrix * sp.Matrix(f)
         moments = substitute_conserved_quantities(moments, conserved_quantity_equations)
-        if momentSubexpressions:
+        if moment_subexpressions:
             symbols = [tuple_to_symbol(t, "m") for t in higher_order_indices]
-            subexpressions += [Assignment(sym, moment) for sym, moment in zip(symbols, moments[num_lower_order_indices:])]
+            subexpressions += [Assignment(sym, moment)
+                               for sym, moment in zip(symbols, moments[num_lower_order_indices:])]
             moments = moments[:num_lower_order_indices] + symbols
 
         # 3) Transform moments to monomial cumulants
         moments_dict = {idx: m for idx, m in zip(indices, moments)}
         monomial_cumulants = [cumulantAsFunctionOfRawMoments(idx, moments_dict) for idx in indices]
 
-        if preCollisionSubexpressions:
+        if pre_collision_subexpressions:
             symbols = [tuple_to_symbol(t, "preC") for t in higher_order_indices]
             subexpressions += [Assignment(sym, c)
                                for sym, c in zip(symbols, monomial_cumulants[num_lower_order_indices:])]
             monomial_cumulants = monomial_cumulants[:num_lower_order_indices] + symbols
 
         # 4) Transform monomial to polynomial cumulants which are then relaxed and transformed back
-        mon_to_poly = monomialToPolynomialTransformationMatrix(indices, self.cumulants)
+        mon_to_poly = monomial_to_polynomial_transformation_matrix(indices, self.cumulants)
         poly_values = mon_to_poly * sp.Matrix(monomial_cumulants)
-        eq_values = sp.Matrix(self.cumulantEquilibriumValues)
-        collided_poly_values = poly_values + relaxationMatrix * (eq_values - poly_values)  # collision
+        eq_values = sp.Matrix(self.cumulant_equilibrium_values)
+        collided_poly_values = poly_values + relaxation_matrix * (eq_values - poly_values)  # collision
         relaxed_monomial_cumulants = mon_to_poly.inv() * collided_poly_values
 
-        if postCollisionSubexpressions:
+        if post_collision_subexpressions:
             symbols = [tuple_to_symbol(t, "postC") for t in higher_order_indices]
             subexpressions += [Assignment(sym, c)
                                for sym, c in zip(symbols, relaxed_monomial_cumulants[num_lower_order_indices:])]
@@ -194,11 +198,11 @@ class CumulantBasedLbMethod(AbstractLbMethod):
         cumulant_dict = {idx: value for idx, value in zip(indices, relaxed_monomial_cumulants)}
         collided_moments = [rawMomentAsFunctionOfCumulants(idx, cumulant_dict) for idx in indices]
         result = moment_transformation_matrix.inv() * sp.Matrix(collided_moments)
-        main_assignments = [Assignment(sym, val) for sym, val in zip(self.postCollisionPdfSymbols, result)]
+        main_assignments = [Assignment(sym, val) for sym, val in zip(self.post_collision_pdf_symbols, result)]
 
         # 6) Add forcing terms
-        if self._forceModel is not None and includeForceTerms:
-            force_model_terms = self._forceModel(self)
+        if self._force_model is not None and include_force_terms:
+            force_model_terms = self._force_model(self)
             force_term_symbols = sp.symbols("forceTerm_:%d" % (len(force_model_terms,)))
             force_subexpressions = [Assignment(sym, forceModelTerm)
                                     for sym, forceModelTerm in zip(force_term_symbols, force_model_terms)]
@@ -206,10 +210,5 @@ class CumulantBasedLbMethod(AbstractLbMethod):
             main_assignments = [Assignment(eq.lhs, eq.rhs + forceTermSymbol)
                                 for eq, forceTermSymbol in zip(main_assignments, force_term_symbols)]
 
-        sh = {'relaxationRates': list(self.relaxationRates)}
+        sh = {'relaxation_rates': list(self.relaxation_rates)}
         return LbmCollisionRule(self, main_assignments, subexpressions, simplification_hints=sh)
-
-
-
-
-
diff --git a/methods/entropic.py b/methods/entropic.py
index 829cfe3aab694f5c6fb518e23d67137014ee6146..58b1d0edd2f193ee9bd148151f612619a08ddaf7 100644
--- a/methods/entropic.py
+++ b/methods/entropic.py
@@ -1,223 +1,223 @@
 import sympy as sp
 from pystencils import Assignment
 from pystencils.sympyextensions import fast_subs
-from lbmpy.relaxationrates import getShearRelaxationRate
+from lbmpy.relaxationrates import get_shear_relaxation_rate
 
 
-def addEntropyCondition(collisionRule, omegaOutputField=None):
+def add_entropy_condition(collision_rule, omega_output_field=None):
     """
     Transforms an update rule with two relaxation rate into a single relaxation rate rule, where the second
     rate is locally chosen to maximize an entropy condition. This function works for update rules which are
     linear in the relaxation rate, as all moment-based methods are. Cumulant update rules don't work since they are
-    quadratic. For these, use :func:`addIterativeEntropyCondition`
+    quadratic. For these, use :func:`add_iterative_entropy_condition`
 
     The entropy is approximated such that the optimality condition can be written explicitly, no Newton iterations
     have to be done.
 
-    :param collisionRule: collision rule with two relaxation times
-    :param omegaOutputField: pystencils field where computed omegas are stored
+    :param collision_rule: collision rule with two relaxation times
+    :param omega_output_field: pystencils field where computed omegas are stored
     :return: new collision rule which only one relaxation rate
     """
-    if collisionRule.method.conservedQuantityComputation.zeroCenteredPdfs:
+    if collision_rule.method.conserved_quantity_computation.zero_centered_pdfs:
         raise NotImplementedError("Entropic Methods only implemented for models where pdfs are centered around 1. "
                                   "Use compressible=1")
 
-    omega_s, omega_h = _getRelaxationRates(collisionRule)
+    omega_s, omega_h = _get_relaxation_rates(collision_rule)
 
-    decomp = RelaxationRatePolynomialDecomposition(collisionRule, [omega_h], [omega_s])
+    decomposition = RelaxationRatePolynomialDecomposition(collision_rule, [omega_h], [omega_s])
     dh = []
-    for entry in decomp.relaxationRateFactors(omega_h):
+    for entry in decomposition.relaxation_rate_factors(omega_h):
         assert len(entry) == 1, "The non-iterative entropic procedure works only for moment based methods, which have" \
                                 "an update rule linear in the relaxation rate."
         dh.append(entry[0])
     ds = []
-    for entry in decomp.relaxationRateFactors(omega_s):
+    for entry in decomposition.relaxation_rate_factors(omega_s):
         assert len(entry) <= 1, "The non-iterative entropic procedure works only for moment based methods, which have" \
                                 "an update rule linear in the relaxation rate."
         if len(entry) == 0:
             entry.append(0)
         ds.append(entry[0])
 
-    stencil = collisionRule.method.stencil
-    Q = len(stencil)
-    fSymbols = collisionRule.method.preCollisionPdfSymbols
+    stencil = collision_rule.method.stencil
+    q = len(stencil)
+    f_symbols = collision_rule.method.pre_collision_pdf_symbols
 
-    dsSymbols = [sp.Symbol("entropicDs_%d" % (i,)) for i in range(Q)]
-    dhSymbols = [sp.Symbol("entropicDh_%d" % (i,)) for i in range(Q)]
-    feqSymbols = [sp.Symbol("entropicFeq_%d" % (i,)) for i in range(Q)]
+    ds_symbols = [sp.Symbol("entropicDs_%d" % (i,)) for i in range(q)]
+    dh_symbols = [sp.Symbol("entropicDh_%d" % (i,)) for i in range(q)]
+    feq_symbols = [sp.Symbol("entropicFeq_%d" % (i,)) for i in range(q)]
 
-    subexprs = [Assignment(a, b) for a, b in zip(dsSymbols, ds)] + \
-               [Assignment(a, b) for a, b in zip(dhSymbols, dh)] + \
-               [Assignment(a, f_i + ds_i + dh_i) for a, f_i, ds_i, dh_i in
-                zip(feqSymbols, fSymbols, dsSymbols, dhSymbols)]
+    subexpressions = [Assignment(a, b) for a, b in zip(ds_symbols, ds)] + \
+                     [Assignment(a, b) for a, b in zip(dh_symbols, dh)] + \
+                     [Assignment(a, f_i + ds_i + dh_i) for a, f_i, ds_i, dh_i in
+                      zip(feq_symbols, f_symbols, ds_symbols, dh_symbols)]
 
-    optimalOmegaH = _getEntropyMaximizingOmega(omega_s, feqSymbols, dsSymbols, dhSymbols)
+    optimal_omega_h = _get_entropy_maximizing_omega(omega_s, feq_symbols, ds_symbols, dh_symbols)
 
-    subexprs += [Assignment(omega_h, optimalOmegaH)]
+    subexpressions += [Assignment(omega_h, optimal_omega_h)]
 
-    newUpdateEquations = []
+    new_update_equations = []
 
-    constPart = decomp.constantExprs()
-    for updateEq in collisionRule.main_assignments:
-        index = collisionRule.method.postCollisionPdfSymbols.index(updateEq.lhs)
-        newEq = Assignment(updateEq.lhs, constPart[index] + omega_s * dsSymbols[index] + omega_h * dhSymbols[index])
-        newUpdateEquations.append(newEq)
-    newCollisionRule = collisionRule.copy(newUpdateEquations, collisionRule.subexpressions + subexprs)
-    newCollisionRule.simplification_hints['entropic'] = True
-    newCollisionRule.simplification_hints['entropicNewtonIterations'] = None
+    const_part = decomposition.constant_exprs()
+    for updateEq in collision_rule.main_assignments:
+        index = collision_rule.method.post_collision_pdf_symbols.index(updateEq.lhs)
+        new_eq = Assignment(updateEq.lhs, const_part[index] + omega_s * ds_symbols[index] + omega_h * dh_symbols[index])
+        new_update_equations.append(new_eq)
+    new_collision_rule = collision_rule.copy(new_update_equations, collision_rule.subexpressions + subexpressions)
+    new_collision_rule.simplification_hints['entropic'] = True
+    new_collision_rule.simplification_hints['entropic_newton_iterations'] = None
 
-    if omegaOutputField:
-        from lbmpy.updatekernels import writeQuantitiesToField
-        newCollisionRule = writeQuantitiesToField(newCollisionRule, omega_h, omegaOutputField)
+    if omega_output_field:
+        from lbmpy.updatekernels import write_quantities_to_field
+        new_collision_rule = write_quantities_to_field(new_collision_rule, omega_h, omega_output_field)
 
-    return newCollisionRule
+    return new_collision_rule
 
 
-def addIterativeEntropyCondition(collisionRule, freeOmega=None, newtonIterations=3, initialValue=1,
-                                 omegaOutputField=None):
+def add_iterative_entropy_condition(collision_rule, free_omega=None, newton_iterations=3, initial_value=1,
+                                    omega_output_field=None):
     """
-    More generic, but slower version of :func:`addEntropyCondition`
+    More generic, but slower version of :func:`add_entropy_condition`
 
     A fixed number of Newton iterations is used to determine the maximum entropy relaxation rate.
 
-    :param collisionRule: collision rule with two relaxation times
-    :param freeOmega: relaxation rate which should be determined by entropy condition. If left to None, the
+    :param collision_rule: collision rule with two relaxation times
+    :param free_omega: relaxation rate which should be determined by entropy condition. If left to None, the
                       relaxation rate is automatically detected, which works only if there are 2 relaxation times
-    :param newtonIterations: (integer) number of newton iterations
-    :param initialValue: initial value of the relaxation rate
-    :param omegaOutputField: pystencils field where computed omegas are stored
+    :param newton_iterations: (integer) number of newton iterations
+    :param initial_value: initial value of the relaxation rate
+    :param omega_output_field: pystencils field where computed omegas are stored
     :return: new collision rule which only one relaxation rate
     """
 
-    if collisionRule.method.conservedQuantityComputation.zeroCenteredPdfs:
+    if collision_rule.method.conserved_quantity_computation.zero_centered_pdfs:
         raise NotImplementedError("Entropic Methods only implemented for models where pdfs are centered around 1")
 
-    if freeOmega is None:
-        _, freeOmega = _getRelaxationRates(collisionRule)
+    if free_omega is None:
+        _, free_omega = _get_relaxation_rates(collision_rule)
 
-    decomp = RelaxationRatePolynomialDecomposition(collisionRule, [freeOmega], [])
+    decomposition = RelaxationRatePolynomialDecomposition(collision_rule, [free_omega], [])
 
-    newUpdateEquations = []
+    new_update_equations = []
 
-    # 1) decompose into constant + freeOmega * ent1 + freeOmega**2 * ent2
-    polynomialSubexpressions = []
-    rrPolynomials = []
-    for i, constantExpr in enumerate(decomp.constantExprs()):
-        constantExprEq = Assignment(decomp.symbolicConstantExpr(i), constantExpr)
-        polynomialSubexpressions.append(constantExprEq)
-        rrPolynomial = constantExprEq.lhs
+    # 1) decompose into constant + free_omega * ent1 + free_omega**2 * ent2
+    polynomial_subexpressions = []
+    rr_polynomials = []
+    for i, constantExpr in enumerate(decomposition.constant_exprs()):
+        constant_expr_eq = Assignment(decomposition.symbolic_constant_expr(i), constantExpr)
+        polynomial_subexpressions.append(constant_expr_eq)
+        rr_polynomial = constant_expr_eq.lhs
 
-        factors = decomp.relaxationRateFactors(freeOmega)
+        factors = decomposition.relaxation_rate_factors(free_omega)
         for idx, f in enumerate(factors[i]):
             power = idx + 1
-            symbolicFactor = decomp.symbolicRelaxationRateFactors(freeOmega, power)[i]
-            polynomialSubexpressions.append(Assignment(symbolicFactor, f))
-            rrPolynomial += freeOmega ** power * symbolicFactor
-        rrPolynomials.append(rrPolynomial)
-        newUpdateEquations.append(Assignment(collisionRule.method.postCollisionPdfSymbols[i], rrPolynomial))
+            symbolic_factor = decomposition.symbolic_relaxation_rate_factors(free_omega, power)[i]
+            polynomial_subexpressions.append(Assignment(symbolic_factor, f))
+            rr_polynomial += free_omega ** power * symbolic_factor
+        rr_polynomials.append(rr_polynomial)
+        new_update_equations.append(Assignment(collision_rule.method.post_collision_pdf_symbols[i], rr_polynomial))
 
     # 2) get equilibrium from method and define subexpressions for it
-    eqTerms = [eq.rhs for eq in collisionRule.method.getEquilibrium().main_assignments]
-    eqSymbols = sp.symbols("entropicFeq_:%d" % (len(eqTerms,)))
-    eqSubexpressions = [Assignment(a, b) for a, b in zip(eqSymbols, eqTerms)]
+    eq_terms = [eq.rhs for eq in collision_rule.method.get_equilibrium().main_assignments]
+    eq_symbols = sp.symbols("entropicFeq_:%d" % (len(eq_terms,)))
+    eq_subexpressions = [Assignment(a, b) for a, b in zip(eq_symbols, eq_terms)]
 
     # 3) find coefficients of entropy derivatives
-    entropyDiff = sp.diff(discreteApproxEntropy(rrPolynomials, eqSymbols), freeOmega)
-    coefficientsFirstDiff = [c.expand() for c in reversed(sp.poly(entropyDiff, freeOmega).all_coeffs())]
-    symCoeffDiff1 = sp.symbols("entropicDiffCoeff_:%d" % (len(coefficientsFirstDiff,)))
-    coefficientEqs = [Assignment(a, b) for a, b in zip(symCoeffDiff1, coefficientsFirstDiff)]
-    symCoeffDiff2 = [(i+1) * coeff for i, coeff in enumerate(symCoeffDiff1[1:])]
+    entropy_diff = sp.diff(discrete_approx_entropy(rr_polynomials, eq_symbols), free_omega)
+    coefficients_first_diff = [c.expand() for c in reversed(sp.poly(entropy_diff, free_omega).all_coeffs())]
+    sym_coeff_diff1 = sp.symbols("entropicDiffCoeff_:%d" % (len(coefficients_first_diff,)))
+    coefficient_eqs = [Assignment(a, b) for a, b in zip(sym_coeff_diff1, coefficients_first_diff)]
+    sym_coeff_diff2 = [(i+1) * coeff for i, coeff in enumerate(sym_coeff_diff1[1:])]
 
     # 4) define Newtons method update iterations
-    newtonIterationEquations = []
-    intermediateOmegas = [sp.Symbol("omega_iter_%i" % (i,)) for i in range(newtonIterations+1)]
-    intermediateOmegas[0] = initialValue
-    intermediateOmegas[-1] = freeOmega
-    for omega_idx in range(len(intermediateOmegas)-1):
-        rhsOmega = intermediateOmegas[omega_idx]
-        lhsOmega = intermediateOmegas[omega_idx+1]
-        diff1Poly = sum([coeff * rhsOmega**i for i, coeff in enumerate(symCoeffDiff1)])
-        diff2Poly = sum([coeff * rhsOmega**i for i, coeff in enumerate(symCoeffDiff2)])
-        newtonEq = Assignment(lhsOmega, rhsOmega - diff1Poly / diff2Poly)
-        newtonIterationEquations.append(newtonEq)
+    newton_iteration_equations = []
+    intermediate_omegas = [sp.Symbol("omega_iter_%i" % (i,)) for i in range(newton_iterations + 1)]
+    intermediate_omegas[0] = initial_value
+    intermediate_omegas[-1] = free_omega
+    for omega_idx in range(len(intermediate_omegas)-1):
+        rhs_omega = intermediate_omegas[omega_idx]
+        lhs_omega = intermediate_omegas[omega_idx+1]
+        diff1_poly = sum([coeff * rhs_omega**i for i, coeff in enumerate(sym_coeff_diff1)])
+        diff2_poly = sum([coeff * rhs_omega**i for i, coeff in enumerate(sym_coeff_diff2)])
+        newton_eq = Assignment(lhs_omega, rhs_omega - diff1_poly / diff2_poly)
+        newton_iteration_equations.append(newton_eq)
 
     # 5) final update equations
-    newSubExprs = polynomialSubexpressions + eqSubexpressions + coefficientEqs + newtonIterationEquations
-    newCollisionRule = collisionRule.copy(newUpdateEquations, collisionRule.subexpressions + newSubExprs)
-    newCollisionRule.simplification_hints['entropic'] = True
-    newCollisionRule.simplification_hints['entropicNewtonIterations'] = newtonIterations
+    new_sub_exprs = polynomial_subexpressions + eq_subexpressions + coefficient_eqs + newton_iteration_equations
+    new_collision_rule = collision_rule.copy(new_update_equations, collision_rule.subexpressions + new_sub_exprs)
+    new_collision_rule.simplification_hints['entropic'] = True
+    new_collision_rule.simplification_hints['entropic_newton_iterations'] = newton_iterations
 
-    if omegaOutputField:
-        from lbmpy.updatekernels import writeQuantitiesToField
-        newCollisionRule = writeQuantitiesToField(newCollisionRule, freeOmega, omegaOutputField)
+    if omega_output_field:
+        from lbmpy.updatekernels import write_quantities_to_field
+        new_collision_rule = write_quantities_to_field(new_collision_rule, free_omega, omega_output_field)
 
-    return newCollisionRule
+    return new_collision_rule
 
 
 # --------------------------------- Helper Functions and Classes -------------------------------------------------------
 
 
-def discreteEntropy(function, reference):
+def discrete_entropy(func, reference):
     r"""
-    Computes relative entropy between a function :math:`f` and a reference function :math:`r`,
+    Computes relative entropy between a func :math:`f` and a reference func :math:`r`,
     which is chosen as the equilibrium for entropic methods
 
     .. math ::
         S = - \sum_i f_i \ln \frac{f_i}{r_i}
     """
-    return -sum([f_i * sp.ln(f_i / r_i) for f_i, r_i in zip(function, reference)])
+    return -sum([f_i * sp.ln(f_i / r_i) for f_i, r_i in zip(func, reference)])
 
 
-def discreteApproxEntropy(function, reference):
+def discrete_approx_entropy(func, reference):
     r"""
-    Computes an approximation of the relative entropy between a function :math:`f` and a reference function :math:`r`,
-    which is chosen as the equilibrium for entropic methods. The non-approximated version is :func:`discreteEntropy`.
+    Computes an approximation of the relative entropy between a func :math:`f` and a reference func :math:`r`,
+    which is chosen as the equilibrium for entropic methods. The non-approximated version is :func:`discrete_entropy`.
 
-    This approximation assumes that the argument of the logarithm is close to 1, i.e. that the function and reference
+    This approximation assumes that the argument of the logarithm is close to 1, i.e. that the func and reference
     are close, then :math:`\ln \frac{f_i}{r_i} \approx  \frac{f_i}{r_i} - 1`
 
     .. math ::
         S = - \sum_i f_i \left( \frac{f_i}{r_i} - 1 \right)
     """
-    return -sum([f_i * ((f_i / r_i)-1) for f_i, r_i in zip(function, reference)])
+    return -sum([f_i * ((f_i / r_i)-1) for f_i, r_i in zip(func, reference)])
 
 
-def _getEntropyMaximizingOmega(omega_s, f_eq, ds, dh):
-    dsdh = sum([ds_i * dh_i / f_eq_i for ds_i, dh_i, f_eq_i in zip(ds, dh, f_eq)])
-    dhdh = sum([dh_i * dh_i / f_eq_i for dh_i, f_eq_i in zip(dh, f_eq)])
-    return 1 - ((omega_s - 1) * dsdh / dhdh)
+def _get_entropy_maximizing_omega(omega_s, f_eq, ds, dh):
+    ds_dh = sum([ds_i * dh_i / f_eq_i for ds_i, dh_i, f_eq_i in zip(ds, dh, f_eq)])
+    dh_dh = sum([dh_i * dh_i / f_eq_i for dh_i, f_eq_i in zip(dh, f_eq)])
+    return 1 - ((omega_s - 1) * ds_dh / dh_dh)
 
 
 class RelaxationRatePolynomialDecomposition(object):
 
-    def __init__(self, collisionRule, freeRelaxationRates, fixedRelaxationRates):
-        self._collisionRule = collisionRule
-        self._freeRelaxationRates = freeRelaxationRates
-        self._fixedRelaxationRates = fixedRelaxationRates
-        self._allRelaxationRates = fixedRelaxationRates + freeRelaxationRates
-        for se in collisionRule.subexpressions:
-            for rr in freeRelaxationRates:
+    def __init__(self, collision_rule, free_relaxation_rates, fixed_relaxation_rates):
+        self._collisionRule = collision_rule
+        self._free_relaxation_rates = free_relaxation_rates
+        self._fixed_relaxation_rates = fixed_relaxation_rates
+        self._all_relaxation_rates = fixed_relaxation_rates + free_relaxation_rates
+        for se in collision_rule.subexpressions:
+            for rr in free_relaxation_rates:
                 assert rr not in se.rhs.atoms(sp.Symbol), \
                     "Decomposition not possible since free relaxation rates are already in subexpressions"
 
-    def symbolicRelaxationRateFactors(self, relaxationRate, power):
-        Q = len(self._collisionRule.method.stencil)
-        omegaIdx = self._allRelaxationRates.index(relaxationRate)
-        return [sp.Symbol("entFacOmega_%d_%d_%d" % (i, omegaIdx, power)) for i in range(Q)]
+    def symbolic_relaxation_rate_factors(self, relaxation_rate, power):
+        q = len(self._collisionRule.method.stencil)
+        omega_idx = self._all_relaxation_rates.index(relaxation_rate)
+        return [sp.Symbol("entFacOmega_%d_%d_%d" % (i, omega_idx, power)) for i in range(q)]
 
-    def relaxationRateFactors(self, relaxationRate):
-        updateEquations = self._collisionRule.main_assignments
+    def relaxation_rate_factors(self, relaxation_rate):
+        update_equations = self._collisionRule.main_assignments
 
         result = []
-        for updateEquation in updateEquations:
+        for updateEquation in update_equations:
             factors = []
             rhs = updateEquation.rhs
             power = 0
             while True:
                 power += 1
-                factor = rhs.coeff(relaxationRate ** power)
+                factor = rhs.coeff(relaxation_rate ** power)
                 if factor != 0:
-                    if relaxationRate in factor.atoms(sp.Symbol):
+                    if relaxation_rate in factor.atoms(sp.Symbol):
                         raise ValueError("Relaxation Rate decomposition failed - run simplification first")
                     factors.append(factor)
                 else:
@@ -227,48 +227,41 @@ class RelaxationRatePolynomialDecomposition(object):
 
         return result
 
-    def symbolicConstantExpr(self, i):
+    @staticmethod
+    def symbolic_constant_expr(i):
         return sp.Symbol("entOffset_%d" % (i,))
 
-    def constantExprs(self):
-        subsDict = {rr: 0 for rr in self._freeRelaxationRates}
-        subsDict.update({rr: 0 for rr in self._fixedRelaxationRates})
-        updateEquations = self._collisionRule.main_assignments
-        return [fast_subs(eq.rhs, subsDict) for eq in updateEquations]
+    def constant_exprs(self):
+        subs_dict = {rr: 0 for rr in self._free_relaxation_rates}
+        subs_dict.update({rr: 0 for rr in self._fixed_relaxation_rates})
+        update_equations = self._collisionRule.main_assignments
+        return [fast_subs(eq.rhs, subs_dict) for eq in update_equations]
 
-    def equilibriumExprs(self):
-        subsDict = {rr: 1 for rr in self._freeRelaxationRates}
-        subsDict.update({rr: 1 for rr in self._fixedRelaxationRates})
-        updateEquations = self._collisionRule.main_assignments
-        return [fast_subs(eq.rhs, subsDict) for eq in updateEquations]
+    def equilibrium_exprs(self):
+        subs_dict = {rr: 1 for rr in self._free_relaxation_rates}
+        subs_dict.update({rr: 1 for rr in self._fixed_relaxation_rates})
+        update_equations = self._collisionRule.main_assignments
+        return [fast_subs(eq.rhs, subs_dict) for eq in update_equations]
 
-    def symbolicEquilibrium(self):
-        Q = len(self._collisionRule.method.stencil)
-        return [sp.Symbol("entFeq_%d" % (i,)) for i in range(Q)]
+    def symbolic_equilibrium(self):
+        q = len(self._collisionRule.method.stencil)
+        return [sp.Symbol("entFeq_%d" % (i,)) for i in range(q)]
 
 
-def _getRelaxationRates(collisionRule):
-    sh = collisionRule.simplification_hints
-    assert 'relaxationRates' in sh, "Needs simplification hint 'relaxationRates': Sequence of relaxation rates"
+def _get_relaxation_rates(collision_rule):
+    sh = collision_rule.simplification_hints
+    assert 'relaxation_rates' in sh, "Needs simplification hint 'relaxation_rates': Sequence of relaxation rates"
 
-    relaxationRates = set(sh['relaxationRates'])
-    if len(relaxationRates) != 2:
+    relaxation_rates = set(sh['relaxation_rates'])
+    if len(relaxation_rates) != 2:
         raise ValueError("Entropic methods can only be created for methods with two relaxation rates.\n"
                          "One free relaxation rate determining the viscosity and one to be determined by the "
                          "entropy condition")
 
-    method = collisionRule.method
-    omega_s = getShearRelaxationRate(method)
-    assert omega_s in relaxationRates
+    method = collision_rule.method
+    omega_s = get_shear_relaxation_rate(method)
+    assert omega_s in relaxation_rates
 
-    relaxationRatesWithoutOmegaS = relaxationRates - {omega_s}
-    omega_h = list(relaxationRatesWithoutOmegaS)[0]
+    relaxation_rates_without_omega_s = relaxation_rates - {omega_s}
+    omega_h = list(relaxation_rates_without_omega_s)[0]
     return omega_s, omega_h
-
-
-if __name__ == '__main__':
-    from lbmpy.creationfunctions import createLatticeBoltzmannUpdateRule
-
-    createLatticeBoltzmannUpdateRule(stencil='D2Q9', compressible=True, method='trt-kbc-n4', entropic=True,
-                                     force=[0.01, 0])
-
diff --git a/methods/entropic_eq_srt.py b/methods/entropic_eq_srt.py
index 1b90716873e656863a8b5daa9ee6982a33a7ba8e..fc18ef1feca057391913abdb51ab0cb923ba82ac 100644
--- a/methods/entropic_eq_srt.py
+++ b/methods/entropic_eq_srt.py
@@ -1,22 +1,22 @@
 import sympy as sp
 from pystencils import Assignment
-from lbmpy.maxwellian_equilibrium import getWeights
+from lbmpy.maxwellian_equilibrium import get_weights
 from lbmpy.methods.abstractlbmethod import AbstractLbMethod, LbmCollisionRule
 from lbmpy.methods.conservedquantitycomputation import DensityVelocityComputation
 
 
 class EntropicEquilibriumSRT(AbstractLbMethod):
-    def __init__(self, stencil, relaxationRate, forceModel, conservedQuantityCalculation):
+    def __init__(self, stencil, relaxation_rate, force_model, conserved_quantity_calculation):
         super(EntropicEquilibriumSRT, self).__init__(stencil)
 
-        self._cqc = conservedQuantityCalculation
-        self._weights = getWeights(stencil, c_s_sq=sp.Rational(1, 3))
-        self._relaxationRate = relaxationRate
-        self._forceModel = forceModel
-        self.shearRelaxationRate = relaxationRate
+        self._cqc = conserved_quantity_calculation
+        self._weights = get_weights(stencil, c_s_sq=sp.Rational(1, 3))
+        self._relaxationRate = relaxation_rate
+        self._forceModel = force_model
+        self.shearRelaxationRate = relaxation_rate
 
     @property
-    def conservedQuantityComputation(self):
+    def conserved_quantity_computation(self):
         return self._cqc
 
     @property
@@ -24,26 +24,27 @@ class EntropicEquilibriumSRT(AbstractLbMethod):
         return self._weights
 
     @property
-    def zerothOrderEquilibriumMomentSymbol(self, ):
-        return self._cqc.zerothOrderMomentSymbol
+    def zeroth_order_equilibrium_moment_symbol(self, ):
+        return self._cqc.zeroth_order_moment_symbol
 
     @property
-    def firstOrderEquilibriumMomentSymbols(self, ):
-        return self._cqc.firstOrderMomentSymbols
+    def first_order_equilibrium_moment_symbols(self, ):
+        return self._cqc.first_order_moment_symbols
 
-    def getEquilibrium(self, conservedQuantityEquations=None, includeForceTerms=False):
-        return self._getCollisionRuleWithRelaxationRate(1, conservedQuantityEquations=conservedQuantityEquations,
-                                                        includeForceTerms=includeForceTerms)
+    def get_equilibrium(self, conserved_quantity_equations=None, include_force_terms=False):
+        return self._get_collision_rule_with_relaxation_rate(1,
+                                                             conserved_quantity_equations=conserved_quantity_equations,
+                                                             include_force_terms=include_force_terms)
 
-    def _getCollisionRuleWithRelaxationRate(self, relaxationRate, includeForceTerms=True,
-                                            conservedQuantityEquations=None):
-        f = sp.Matrix(self.preCollisionPdfSymbols)
-        rho = self._cqc.zerothOrderMomentSymbol
-        u = self._cqc.firstOrderMomentSymbols
+    def _get_collision_rule_with_relaxation_rate(self, relaxation_rate, include_force_terms=True,
+                                                 conserved_quantity_equations=None):
+        f = sp.Matrix(self.pre_collision_pdf_symbols)
+        rho = self._cqc.zeroth_order_moment_symbol
+        u = self._cqc.first_order_moment_symbols
 
-        if conservedQuantityEquations is None:
-            conservedQuantityEquations = self._cqc.equilibriumInputEquationsFromPdfs(f)
-        allSubexpressions = conservedQuantityEquations.allEquations
+        if conserved_quantity_equations is None:
+            conserved_quantity_equations = self._cqc.equilibrium_input_equations_from_pdfs(f)
+        all_subexpressions = conserved_quantity_equations.allEquations
 
         eq = []
         for w_i, direction in zip(self.weights, self.stencil):
@@ -53,26 +54,26 @@ class EntropicEquilibriumSRT(AbstractLbMethod):
                 f_i *= (2 - B) * ((2 * u_a + B) / (1 - u_a)) ** e_ia
             eq.append(f_i)
 
-        collisionEqs = [Assignment(lhs, (1 - relaxationRate) * f_i + relaxationRate * eq_i)
-                        for lhs, f_i, eq_i in zip(self.postCollisionPdfSymbols, self.preCollisionPdfSymbols, eq)]
+        collision_eqs = [Assignment(lhs, (1 - relaxation_rate) * f_i + relaxation_rate * eq_i)
+                         for lhs, f_i, eq_i in zip(self.post_collision_pdf_symbols, self.pre_collision_pdf_symbols, eq)]
 
-        if (self._forceModel is not None) and includeForceTerms:
-            forceModelTerms = self._forceModel(self)
-            forceTermSymbols = sp.symbols("forceTerm_:%d" % (len(forceModelTerms, )))
-            forceSubexpressions = [Assignment(sym, forceModelTerm)
-                                   for sym, forceModelTerm in zip(forceTermSymbols, forceModelTerms)]
-            allSubexpressions += forceSubexpressions
-            collisionEqs = [Assignment(eq.lhs, eq.rhs + forceTermSymbol)
-                            for eq, forceTermSymbol in zip(collisionEqs, forceTermSymbols)]
+        if (self._forceModel is not None) and include_force_terms:
+            force_model_terms = self._forceModel(self)
+            force_term_symbols = sp.symbols("forceTerm_:%d" % (len(force_model_terms, )))
+            force_subexpressions = [Assignment(sym, forceModelTerm)
+                                   for sym, forceModelTerm in zip(force_term_symbols, force_model_terms)]
+            all_subexpressions += force_subexpressions
+            collision_eqs = [Assignment(eq.lhs, eq.rhs + forceTermSymbol)
+                             for eq, forceTermSymbol in zip(collision_eqs, force_term_symbols)]
 
-        return LbmCollisionRule(self, collisionEqs, allSubexpressions)
+        return LbmCollisionRule(self, collision_eqs, all_subexpressions)
 
-    def getCollisionRule(self):
-        return self._getCollisionRuleWithRelaxationRate(self._relaxationRate)
+    def get_collision_rule(self):
+        return self._get_collision_rule_with_relaxation_rate(self._relaxationRate)
 
 
-def createEntropicSRT(stencil, relaxationRate, forceModel, compressible):
+def create_srt_entropic(stencil, relaxation_rate, force_model, compressible):
     if not compressible:
         raise NotImplementedError("entropic-srt only implemented for compressible models")
-    densityVelocityComputation = DensityVelocityComputation(stencil, compressible, forceModel)
-    return EntropicEquilibriumSRT(stencil, relaxationRate, forceModel, densityVelocityComputation)
+    density_velocity_computation = DensityVelocityComputation(stencil, compressible, force_model)
+    return EntropicEquilibriumSRT(stencil, relaxation_rate, force_model, density_velocity_computation)
diff --git a/methods/lattice_tensors.py b/methods/lattice_tensors.py
index 8ee9ed2b4e4ed73bd5ba38f3f2be4ad23262164b..91bae9434f0a85017833abecfad18c420a2a021f 100644
--- a/methods/lattice_tensors.py
+++ b/methods/lattice_tensors.py
@@ -1,4 +1,3 @@
-import sympy as sp
 import itertools
 from pystencils.sympyextensions import kronecker_delta as kd
 
diff --git a/methods/momentbased.py b/methods/momentbased.py
index 1fe106ca0ad2dadba168aaec8263cf0a4ced922b..fe91f4bca74662ac4cda91562c6e829c0da3ded9 100644
--- a/methods/momentbased.py
+++ b/methods/momentbased.py
@@ -4,44 +4,44 @@ from pystencils import Assignment
 from pystencils.sympyextensions import subs_additive
 from lbmpy.methods.abstractlbmethod import AbstractLbMethod, LbmCollisionRule, RelaxationInfo
 from lbmpy.methods.conservedquantitycomputation import AbstractConservedQuantityComputation
-from lbmpy.moments import MOMENT_SYMBOLS, momentMatrix
+from lbmpy.moments import MOMENT_SYMBOLS, moment_matrix
 
 
 class MomentBasedLbMethod(AbstractLbMethod):
-    def __init__(self, stencil, momentToRelaxationInfoDict, conservedQuantityComputation=None, forceModel=None):
+    def __init__(self, stencil, moment_to_relaxation_info_dict, conserved_quantity_computation=None, force_model=None):
         """
         Moment based LBM is a class to represent the single (SRT), two (TRT) and multi relaxation time (MRT) methods.
         These methods work by transforming the pdfs into moment space using a linear transformation. In the moment
         space each component (moment) is relaxed to an equilibrium moment by a certain relaxation rate. These
         equilibrium moments can e.g. be determined by taking the equilibrium moments of the continuous Maxwellian.
 
-        :param stencil: see :func:`lbmpy.stencils.getStencil`
-        :param momentToRelaxationInfoDict: a dictionary mapping moments in either tuple or polynomial formulation
+        :param stencil: see :func:`lbmpy.stencils.get_stencil`
+        :param moment_to_relaxation_info_dict: a dictionary mapping moments in either tuple or polynomial formulation
                                            to a RelaxationInfo, which consists of the corresponding equilibrium moment
                                            and a relaxation rate
-        :param conservedQuantityComputation: instance of :class:`lbmpy.methods.AbstractConservedQuantityComputation`.
+        :param conserved_quantity_computation: instance of :class:`lbmpy.methods.AbstractConservedQuantityComputation`.
                                              This determines how conserved quantities are computed, and defines
                                              the symbols used in the equilibrium moments like e.g. density and velocity
-        :param forceModel: force model instance, or None if no forcing terms are required
+        :param force_model: force model instance, or None if no forcing terms are required
         """
-        assert isinstance(conservedQuantityComputation, AbstractConservedQuantityComputation)
+        assert isinstance(conserved_quantity_computation, AbstractConservedQuantityComputation)
         super(MomentBasedLbMethod, self).__init__(stencil)
 
-        self._forceModel = forceModel
-        self._momentToRelaxationInfoDict = OrderedDict(momentToRelaxationInfoDict.items())
-        self._conservedQuantityComputation = conservedQuantityComputation
+        self._forceModel = force_model
+        self._momentToRelaxationInfoDict = OrderedDict(moment_to_relaxation_info_dict.items())
+        self._conservedQuantityComputation = conserved_quantity_computation
         self._weights = None
 
     @property
-    def forceModel(self):
+    def force_model(self):
         return self._forceModel
 
     @property
-    def relaxationInfoDict(self):
+    def relaxation_info_dict(self):
         return self._momentToRelaxationInfoDict
 
     @property
-    def conservedQuantityComputation(self):
+    def conserved_quantity_computation(self):
         return self._conservedQuantityComputation
 
     @property
@@ -49,76 +49,77 @@ class MomentBasedLbMethod(AbstractLbMethod):
         return tuple(self._momentToRelaxationInfoDict.keys())
 
     @property
-    def momentEquilibriumValues(self):
+    def moment_equilibrium_values(self):
         return tuple([e.equilibriumValue for e in self._momentToRelaxationInfoDict.values()])
 
     @property
-    def relaxationRates(self):
-        return tuple([e.relaxationRate for e in self._momentToRelaxationInfoDict.values()])
+    def relaxation_rates(self):
+        return tuple([e.relaxation_rate for e in self._momentToRelaxationInfoDict.values()])
 
     @property
-    def zerothOrderEquilibriumMomentSymbol(self, ):
-        return self._conservedQuantityComputation.zerothOrderMomentSymbol
+    def zeroth_order_equilibrium_moment_symbol(self, ):
+        return self._conservedQuantityComputation.zeroth_order_moment_symbol
 
     @property
-    def firstOrderEquilibriumMomentSymbols(self, ):
-        return self._conservedQuantityComputation.firstOrderMomentSymbols
+    def first_order_equilibrium_moment_symbols(self, ):
+        return self._conservedQuantityComputation.first_order_moment_symbols
 
     @property
     def weights(self):
         if self._weights is None:
-            self._weights = self._computeWeights()
+            self._weights = self._compute_weights()
         return self._weights
 
-    def overrideWeights(self, weights):
+    def override_weights(self, weights):
         assert len(weights) == len(self.stencil)
         self._weights = weights
 
-    def getEquilibrium(self, conservedQuantityEquations=None, includeForceTerms=False):
-        D = sp.eye(len(self.relaxationRates))
-        return self._getCollisionRuleWithRelaxationMatrix(D, conserved_quantity_equations=conservedQuantityEquations,
-                                                          includeForceTerms=includeForceTerms)
+    def get_equilibrium(self, conserved_quantity_equations=None, include_force_terms=False):
+        relaxation_matrix = sp.eye(len(self.relaxation_rates))
+        return self._get_collision_rule_with_relaxation_matrix(relaxation_matrix,
+                                                               conserved_quantity_equations=conserved_quantity_equations,
+                                                               include_force_terms=include_force_terms)
 
-    def getEquilibriumTerms(self):
-        equilibrium = self.getEquilibrium()
+    def get_equilibrium_terms(self):
+        equilibrium = self.get_equilibrium()
         return sp.Matrix([eq.rhs for eq in equilibrium.main_assignments])
 
-    def getCollisionRule(self, conservedQuantityEquations=None):
-        D = sp.diag(*self.relaxationRates)
-        relaxationRateSubExpressions, D = self._generateRelaxationMatrix(D)
-        eqColl = self._getCollisionRuleWithRelaxationMatrix(D, relaxationRateSubExpressions,
-                                                            True, conservedQuantityEquations)
-        return eqColl
+    def get_collision_rule(self, conserved_quantity_equations=None):
+        d = sp.diag(*self.relaxation_rates)
+        relaxation_rate_sub_expressions, d = self._generate_relaxation_matrix(d)
+        ac = self._get_collision_rule_with_relaxation_matrix(d, relaxation_rate_sub_expressions,
+                                                             True, conserved_quantity_equations)
+        return ac
 
-    def setZerothMomentRelaxationRate(self, relaxationRate):
+    def set_zeroth_moment_relaxation_rate(self, relaxation_rate):
         e = sp.Rational(1, 1)
-        prevEntry = self._momentToRelaxationInfoDict[e]
-        newEntry = RelaxationInfo(prevEntry[0], relaxationRate)
-        self._momentToRelaxationInfoDict[e] = newEntry
+        prev_entry = self._momentToRelaxationInfoDict[e]
+        new_entry = RelaxationInfo(prev_entry[0], relaxation_rate)
+        self._momentToRelaxationInfoDict[e] = new_entry
 
-    def setFirstMomentRelaxationRate(self, relaxationRate):
+    def set_first_moment_relaxation_rate(self, relaxation_rate):
         for e in MOMENT_SYMBOLS[:self.dim]:
             assert e in self._momentToRelaxationInfoDict, "First moments are not relaxed separately by this method"
         for e in MOMENT_SYMBOLS[:self.dim]:
-            prevEntry = self._momentToRelaxationInfoDict[e]
-            newEntry = RelaxationInfo(prevEntry[0], relaxationRate)
-            self._momentToRelaxationInfoDict[e] = newEntry
+            prev_entry = self._momentToRelaxationInfoDict[e]
+            new_entry = RelaxationInfo(prev_entry[0], relaxation_rate)
+            self._momentToRelaxationInfoDict[e] = new_entry
 
     @property
-    def collisionMatrix(self):
-        M = self.momentMatrix
-        D = sp.diag(*self.relaxationRates)
-        return M.inv() * D * M
+    def collision_matrix(self):
+        pdfs_to_moments = self.moment_matrix
+        relaxation_matrix = sp.diag(*self.relaxation_rates)
+        return pdfs_to_moments.inv() * relaxation_matrix * pdfs_to_moments
 
     @property
-    def inverseCollisionMatrix(self):
-        M = self.momentMatrix
-        Dinv = sp.diag(*[1/e for e in self.relaxationRates])
-        return M.inv() * Dinv * M
+    def inverse_collision_matrix(self):
+        pdfs_to_moments = self.moment_matrix
+        inverse_relaxation_matrix = sp.diag(*[1 / e for e in self.relaxation_rates])
+        return pdfs_to_moments.inv() * inverse_relaxation_matrix * pdfs_to_moments
 
     @property
-    def momentMatrix(self):
-        return momentMatrix(self.moments, self.stencil)
+    def moment_matrix(self):
+        return moment_matrix(self.moments, self.stencil)
 
     def __getstate__(self):
         # Workaround for a bug in joblib
@@ -151,79 +152,76 @@ class MomentBasedLbMethod(AbstractLbMethod):
                          </tr>\n""".format(**vals)
         return table.format(content=content, nb='style="border:none"')
 
-    def _computeWeights(self):
-        replacements = self._conservedQuantityComputation.defaultValues
-        eqColl = self.getEquilibrium(includeForceTerms=False)
-        eqColl = eqColl.new_with_substitutions(replacements, substitute_on_lhs=False).new_without_subexpressions()
+    def _compute_weights(self):
+        replacements = self._conservedQuantityComputation.default_values
+        ac = self.get_equilibrium(include_force_terms=False)
+        ac = ac.new_with_substitutions(replacements, substitute_on_lhs=False).new_without_subexpressions()
 
-        newMainEqs = [Assignment(e.lhs,
-                                 subs_additive(e.rhs, 1, sum(self.preCollisionPdfSymbols), required_match_replacement=1.0))
-                      for e in eqColl.main_assignments]
-        eqColl = eqColl.copy(newMainEqs)
+        new_assignments = [Assignment(e.lhs,
+                                      subs_additive(e.rhs, sp.sympify(1), sum(self.pre_collision_pdf_symbols),
+                                                    required_match_replacement=1.0))
+                           for e in ac.main_assignments]
+        ac = ac.copy(new_assignments)
 
         weights = []
-        for eq in eqColl.main_assignments:
+        for eq in ac.main_assignments:
             value = eq.rhs.expand()
             assert len(value.atoms(sp.Symbol)) == 0, "Failed to compute weights " + str(value)
             weights.append(value)
         return weights
 
-    def _getCollisionRuleWithRelaxationMatrix(self, D, additionalSubexpressions=(), includeForceTerms=True,
-                                              conserved_quantity_equations=None):
-        f = sp.Matrix(self.preCollisionPdfSymbols)
-        M = self.momentMatrix
-        m_eq = sp.Matrix(self.momentEquilibriumValues)
+    def _get_collision_rule_with_relaxation_matrix(self, d, additional_subexpressions=(), include_force_terms=True,
+                                                   conserved_quantity_equations=None):
+        f = sp.Matrix(self.pre_collision_pdf_symbols)
+        pdf_to_moment = self.moment_matrix
+        m_eq = sp.Matrix(self.moment_equilibrium_values)
 
-        collision_rule = f + M.inv() * D * (m_eq - M * f)
-        collision_eqs = [Assignment(lhs, rhs) for lhs, rhs in zip(self.postCollisionPdfSymbols, collision_rule)]
+        collision_rule = f + pdf_to_moment.inv() * d * (m_eq - pdf_to_moment * f)
+        collision_eqs = [Assignment(lhs, rhs) for lhs, rhs in zip(self.post_collision_pdf_symbols, collision_rule)]
 
         if conserved_quantity_equations is None:
-            conserved_quantity_equations = self._conservedQuantityComputation.equilibriumInputEquationsFromPdfs(f)
+            conserved_quantity_equations = self._conservedQuantityComputation.equilibrium_input_equations_from_pdfs(f)
 
         simplification_hints = conserved_quantity_equations.simplification_hints.copy()
         simplification_hints.update(self._conservedQuantityComputation.defined_symbols())
-        simplification_hints['relaxationRates'] = [D[i, i] for i in range(D.rows)]
+        simplification_hints['relaxation_rates'] = [d[i, i] for i in range(d.rows)]
 
-        all_subexpressions = list(additionalSubexpressions) + conserved_quantity_equations.all_assignments
+        all_subexpressions = list(additional_subexpressions) + conserved_quantity_equations.all_assignments
 
-        if self._forceModel is not None and includeForceTerms:
+        if self._forceModel is not None and include_force_terms:
             force_model_terms = self._forceModel(self)
             force_term_symbols = sp.symbols("forceTerm_:%d" % (len(force_model_terms,)))
             force_subexpressions = [Assignment(sym, forceModelTerm)
-                                   for sym, forceModelTerm in zip(force_term_symbols, force_model_terms)]
+                                    for sym, forceModelTerm in zip(force_term_symbols, force_model_terms)]
             all_subexpressions += force_subexpressions
             collision_eqs = [Assignment(eq.lhs, eq.rhs + forceTermSymbol)
-                            for eq, forceTermSymbol in zip(collision_eqs, force_term_symbols)]
+                             for eq, forceTermSymbol in zip(collision_eqs, force_term_symbols)]
             simplification_hints['forceTerms'] = force_term_symbols
 
         return LbmCollisionRule(self, collision_eqs, all_subexpressions,
                                 simplification_hints)
 
     @staticmethod
-    def _generateRelaxationMatrix(relaxationMatrix):
+    def _generate_relaxation_matrix(relaxation_matrix):
         """
         For SRT and TRT the equations can be easier simplified if the relaxation times are symbols, not numbers.
         This function replaces the numbers in the relaxation matrix with symbols in this case, and returns also
          the subexpressions, that assign the number to the newly introduced symbol
         """
-        rr = [relaxationMatrix[i, i] for i in range(relaxationMatrix.rows)]
-        uniqueRelaxationRates = set(rr)
-        if len(uniqueRelaxationRates) <= 2:
+        rr = [relaxation_matrix[i, i] for i in range(relaxation_matrix.rows)]
+        unique_relaxation_rates = set(rr)
+        if len(unique_relaxation_rates) <= 2:
             # special handling for SRT and TRT
             subexpressions = {}
-            for rt in uniqueRelaxationRates:
+            for rt in unique_relaxation_rates:
                 rt = sp.sympify(rt)
                 if not isinstance(rt, sp.Symbol):
-                    rtSymbol = sp.Symbol("rr_%d" % (len(subexpressions),))
-                    subexpressions[rt] = rtSymbol
+                    rt_symbol = sp.Symbol("rr_%d" % (len(subexpressions),))
+                    subexpressions[rt] = rt_symbol
 
-            newRR = [subexpressions[sp.sympify(e)] if sp.sympify(e) in subexpressions else e
-                     for e in rr]
+            new_rr = [subexpressions[sp.sympify(e)] if sp.sympify(e) in subexpressions else e
+                      for e in rr]
             substitutions = [Assignment(e[1], e[0]) for e in subexpressions.items()]
-            return substitutions, sp.diag(*newRR)
+            return substitutions, sp.diag(*new_rr)
         else:
-            return [], relaxationMatrix
-
-
-
-
+            return [], relaxation_matrix
diff --git a/methods/momentbasedsimplifications.py b/methods/momentbasedsimplifications.py
index 9aa18c0a1a86eed020141585a3ad20555ad9993f..f283df62d14873113b39c4458047c785f833bbaa 100644
--- a/methods/momentbasedsimplifications.py
+++ b/methods/momentbasedsimplifications.py
@@ -4,53 +4,55 @@ All of these transformations operate on :class:`pystencils.AssignmentCollection`
 simplification hints, which are set by the MomentBasedLbMethod.
 """
 import sympy as sp
+
+from lbmpy.methods.abstractlbmethod import LbmCollisionRule
 from pystencils import Assignment
 from pystencils.sympyextensions import subs_additive, replace_second_order_products, extract_most_common_factor
 
 
-def replaceSecondOrderVelocityProducts(lbmCollisionEqs):
+def replace_second_order_velocity_products(cr: LbmCollisionRule):
     """
     Replaces mixed quadratic velocity terms like :math:`u_0 * u_1` by :math:`(u_0+u_1)^2 - u_0^2 - u_1^2`
     Required simplification hints:
         - velocity: sequence of velocity symbols
     """
-    sh = lbmCollisionEqs.simplification_hints
+    sh = cr.simplification_hints
     assert 'velocity' in sh, "Needs simplification hint 'velocity': Sequence of velocity symbols"
 
     result = []
     substitutions = []
     u = sh['velocity']
-    for i, s in enumerate(lbmCollisionEqs.main_assignments):
-        newRhs = replace_second_order_products(s.rhs, u, positive=None, replace_mixed=substitutions)
-        result.append(Assignment(s.lhs, newRhs))
-    res = lbmCollisionEqs.copy(result)
+    for i, s in enumerate(cr.main_assignments):
+        new_rhs = replace_second_order_products(s.rhs, u, positive=None, replace_mixed=substitutions)
+        result.append(Assignment(s.lhs, new_rhs))
+    res = cr.copy(result)
     res.subexpressions += substitutions
     return res
 
 
-def factorRelaxationRates(lbmCollisionEqs):
+def factor_relaxation_rates(cr: LbmCollisionRule):
     """
     Factors collision equations by relaxation rates.
     Required simplification hints:
-        - relaxationRates: Sequence of relaxation rates
+        - relaxation_rates: Sequence of relaxation rates
     """
-    sh = lbmCollisionEqs.simplification_hints
-    assert 'relaxationRates' in sh, "Needs simplification hint 'relaxationRates': Sequence of relaxation rates"
-    if len(sh['relaxationRates']) > 19:  # heuristics - for too many relaxation rates this simplification makes no sense
-        return lbmCollisionEqs
+    sh = cr.simplification_hints
+    assert 'relaxation_rates' in sh, "Needs simplification hint 'relaxation_rates': Sequence of relaxation rates"
+    if len(sh['relaxation_rates']) > 19:  # heuristics, works well if there is a small number of relaxation rates
+        return cr
 
-    relaxationRates = sp.Matrix(sh['relaxationRates']).atoms(sp.Symbol)
+    relaxation_rates = sp.Matrix(sh['relaxation_rates']).atoms(sp.Symbol)
 
     result = []
-    for s in lbmCollisionEqs.main_assignments:
-        newRhs = s.rhs
-        for rp in relaxationRates:
-            newRhs = newRhs.collect(rp)
-        result.append(Assignment(s.lhs, newRhs))
-    return lbmCollisionEqs.copy(result)
+    for s in cr.main_assignments:
+        new_rhs = s.rhs
+        for rp in relaxation_rates:
+            new_rhs = new_rhs.collect(rp)
+        result.append(Assignment(s.lhs, new_rhs))
+    return cr.copy(result)
 
 
-def factorDensityAfterFactoringRelaxationTimes(lbmCollisionEqs):
+def factor_density_after_factoring_relaxation_times(cr: LbmCollisionRule):
     """
     Tries to factor out the density. This only works if previously
     :func:`lbmpy.methods.momentbasedsimplifications.factorRelaxationTimes` was run.
@@ -59,48 +61,48 @@ def factorDensityAfterFactoringRelaxationTimes(lbmCollisionEqs):
 
     Required simplification hints:
         - density: density symbol which is factored out
-        - relaxationRates: set of symbolic relaxation rates in which the terms are assumed to be already factored
+        - relaxation_rates: set of symbolic relaxation rates in which the terms are assumed to be already factored
     """
-    sh = lbmCollisionEqs.simplification_hints
+    sh = cr.simplification_hints
     assert 'density' in sh, "Needs simplification hint 'density': Symbol for density"
-    assert 'relaxationRates' in sh, "Needs simplification hint 'relaxationRates': Set of symbolic relaxation rates"
+    assert 'relaxation_rates' in sh, "Needs simplification hint 'relaxation_rates': Set of symbolic relaxation rates"
 
-    relaxationRates = sp.Matrix(sh['relaxationRates']).atoms(sp.Symbol)
+    relaxation_rates = sp.Matrix(sh['relaxation_rates']).atoms(sp.Symbol)
     result = []
     rho = sh['density']
-    for s in lbmCollisionEqs.main_assignments:
-        newRhs = s.rhs
-        for rp in relaxationRates:
-            coeff = newRhs.coeff(rp)
-            newRhs = newRhs.subs(coeff, coeff.collect(rho))
-        result.append(Assignment(s.lhs, newRhs))
-    return lbmCollisionEqs.copy(result)
+    for s in cr.main_assignments:
+        new_rhs = s.rhs
+        for rp in relaxation_rates:
+            coeff = new_rhs.coeff(rp)
+            new_rhs = new_rhs.subs(coeff, coeff.collect(rho))
+        result.append(Assignment(s.lhs, new_rhs))
+    return cr.copy(result)
 
 
-def replaceDensityAndVelocity(lbmCollisionEqs):
+def replace_density_and_velocity(cr: LbmCollisionRule):
     """
     Looks for terms that can be replaced by the density or by one of the velocities
         Required simplification hints:
         - density: density symbol
         - velocity: sequence of velocity symbols
     """
-    sh = lbmCollisionEqs.simplification_hints
+    sh = cr.simplification_hints
     assert 'density' in sh, "Needs simplification hint 'density': Symbol for density"
     assert 'velocity' in sh, "Needs simplification hint 'velocity': Sequence of velocity symbols"
     rho = sh['density']
     u = sh['velocity']
 
-    substitutions = lbmCollisionEqs.new_filtered([rho] + list(u)).new_without_subexpressions().main_assignments
+    substitutions = cr.new_filtered([rho] + list(u)).new_without_subexpressions().main_assignments
     result = []
-    for s in lbmCollisionEqs.main_assignments:
-        newRhs = s.rhs
+    for s in cr.main_assignments:
+        new_rhs = s.rhs
         for replacement in substitutions:
-            newRhs = subs_additive(newRhs, replacement.lhs, replacement.rhs, required_match_replacement=0.5)
-        result.append(Assignment(s.lhs, newRhs))
-    return lbmCollisionEqs.copy(result)
+            new_rhs = subs_additive(new_rhs, replacement.lhs, replacement.rhs, required_match_replacement=0.5)
+        result.append(Assignment(s.lhs, new_rhs))
+    return cr.copy(result)
 
 
-def replaceCommonQuadraticAndConstantTerm(lbmCollisionEqs):
+def replace_common_quadratic_and_constant_term(cr: LbmCollisionRule):
     """
     A common quadratic term (f_eq_common) is extracted from the collision equation for center
     and substituted in all equations
@@ -108,127 +110,127 @@ def replaceCommonQuadraticAndConstantTerm(lbmCollisionEqs):
     Required simplification hints:
         - density: density symbol
         - velocity: sequence of velocity symbols
-        - relaxationRates: Sequence of relaxation rates
+        - relaxation_rates: Sequence of relaxation rates
         - stencil:
     """
-    sh = lbmCollisionEqs.simplification_hints
+    sh = cr.simplification_hints
     assert 'density' in sh, "Needs simplification hint 'density': Symbol for density"
     assert 'velocity' in sh, "Needs simplification hint 'velocity': Sequence of velocity symbols"
-    assert 'relaxationRates' in sh, "Needs simplification hint 'relaxationRates': Sequence of relaxation rates"
+    assert 'relaxation_rates' in sh, "Needs simplification hint 'relaxation_rates': Sequence of relaxation rates"
 
-    stencil = lbmCollisionEqs.method.stencil
+    stencil = cr.method.stencil
     assert sum([abs(e) for e in stencil[0]]) == 0, "Works only if first stencil entry is the center direction"
-    f_eq_common = __getCommonQuadraticAndConstantTerms(lbmCollisionEqs)
+    f_eq_common = __get_common_quadratic_and_constant_terms(cr)
     if f_eq_common is None:
-        return lbmCollisionEqs
+        return cr
 
     if len(f_eq_common.args) > 1:
         f_eq_common = Assignment(sp.Symbol('f_eq_common'), f_eq_common)
         result = []
-        for s in lbmCollisionEqs.main_assignments:
-            newRhs = subs_additive(s.rhs, f_eq_common.lhs, f_eq_common.rhs, required_match_replacement=0.5)
-            result.append(Assignment(s.lhs, newRhs))
-        res = lbmCollisionEqs.copy(result)
+        for s in cr.main_assignments:
+            new_rhs = subs_additive(s.rhs, f_eq_common.lhs, f_eq_common.rhs, required_match_replacement=0.5)
+            result.append(Assignment(s.lhs, new_rhs))
+        res = cr.copy(result)
         res.subexpressions.append(f_eq_common)
         return res
     else:
-        return lbmCollisionEqs
+        return cr
 
 
-def cseInOpposingDirections(lbmCollisionEqs):
+def cse_in_opposing_directions(cr: LbmCollisionRule):
     """
     Looks for common subexpressions in terms for opposing directions (e.g. north & south, top & bottom )
 
     Required simplification hints:
-        - relaxationRates: Sequence of relaxation rates
-        - postCollisionPdfSymbols: sequence of symbols
+        - relaxation_rates: Sequence of relaxation rates
+        - post_collision_pdf_symbols: sequence of symbols
     """
-    sh = lbmCollisionEqs.simplification_hints
-    assert 'relaxationRates' in sh, "Needs simplification hint 'relaxationRates': Sequence of relaxation rates"
+    sh = cr.simplification_hints
+    assert 'relaxation_rates' in sh, "Needs simplification hint 'relaxation_rates': Sequence of relaxation rates"
 
-    updateRules = lbmCollisionEqs.main_assignments
-    stencil = lbmCollisionEqs.method.stencil
-    relaxationRates = sp.Matrix(sh['relaxationRates']).atoms(sp.Symbol)
+    update_rules = cr.main_assignments
+    stencil = cr.method.stencil
+    relaxation_rates = sp.Matrix(sh['relaxation_rates']).atoms(sp.Symbol)
 
-    replacementSymbolGenerator = lbmCollisionEqs.subexpression_symbol_generator
+    replacement_symbol_generator = cr.subexpression_symbol_generator
 
-    directionToUpdateRule = {direction: updateRule for updateRule, direction in zip(updateRules, stencil)}
+    direction_to_update_rule = {direction: update_rule for update_rule, direction in zip(update_rules, stencil)}
     result = []
     substitutions = []
-    newCoefficientSubstitutions = dict()
-    for updateRule, direction in zip(updateRules, stencil):
-        if direction not in directionToUpdateRule:
+    new_coefficient_substitutions = dict()
+    for update_rule, direction in zip(update_rules, stencil):
+        if direction not in direction_to_update_rule:
             continue  # already handled the inverse direction
-        inverseDir = tuple([-i for i in direction])
-        inverseRule = directionToUpdateRule[inverseDir]
-        if inverseDir == direction:
-            result.append(updateRule)  # center is not modified
+        inverse_dir = tuple([-i for i in direction])
+        inverse_rule = direction_to_update_rule[inverse_dir]
+        if inverse_dir == direction:
+            result.append(update_rule)  # center is not modified
             continue
-        del directionToUpdateRule[inverseDir]
-        del directionToUpdateRule[direction]
+        del direction_to_update_rule[inverse_dir]
+        del direction_to_update_rule[direction]
 
-        updateRules = [updateRule, inverseRule]
+        update_rules = [update_rule, inverse_rule]
 
-        if len(relaxationRates) == 0:
-            foundSubexpressions, newTerms = sp.cse(updateRules, symbols=replacementSymbolGenerator,
-                                                   order='None', optimizations=[])
-            substitutions += [Assignment(f[0], f[1]) for f in foundSubexpressions]
+        if len(relaxation_rates) == 0:
+            found_subexpressions, new_terms = sp.cse(update_rules, symbols=replacement_symbol_generator,
+                                                     order='None', optimizations=[])
+            substitutions += [Assignment(f[0], f[1]) for f in found_subexpressions]
 
-            updateRules = newTerms
+            update_rules = new_terms
         else:
-            for relaxationRate in relaxationRates:
-                terms = [updateRule.rhs.coeff(relaxationRate) for updateRule in updateRules]
-                resultOfCommonFactor = [extract_most_common_factor(t) for t in terms]
-                commonFactors = [r[0] for r in resultOfCommonFactor]
-                termsWithoutFactor = [r[1] for r in resultOfCommonFactor]
-
-                if commonFactors[0] == commonFactors[1] and commonFactors[0] != 1:
-                    newCoefficient = commonFactors[0] * relaxationRate
-                    if newCoefficient not in newCoefficientSubstitutions:
-                        newCoefficientSubstitutions[newCoefficient] = next(replacementSymbolGenerator)
-                    newCoefficient = newCoefficientSubstitutions[newCoefficient]
-                    handledTerms = termsWithoutFactor
+            for relaxation_rate in relaxation_rates:
+                terms = [update_rule.rhs.coeff(relaxation_rate) for update_rule in update_rules]
+                result_of_common_factor = [extract_most_common_factor(t) for t in terms]
+                common_factors = [r[0] for r in result_of_common_factor]
+                terms_without_factor = [r[1] for r in result_of_common_factor]
+
+                if common_factors[0] == common_factors[1] and common_factors[0] != 1:
+                    new_coefficient = common_factors[0] * relaxation_rate
+                    if new_coefficient not in new_coefficient_substitutions:
+                        new_coefficient_substitutions[new_coefficient] = next(replacement_symbol_generator)
+                    new_coefficient = new_coefficient_substitutions[new_coefficient]
+                    handled_terms = terms_without_factor
                 else:
-                    newCoefficient = relaxationRate
-                    handledTerms = terms
+                    new_coefficient = relaxation_rate
+                    handled_terms = terms
 
-                foundSubexpressions, newTerms = sp.cse(handledTerms, symbols=replacementSymbolGenerator,
-                                                       order='None', optimizations=[])
-                substitutions += [Assignment(f[0], f[1]) for f in foundSubexpressions]
+                found_subexpressions, new_terms = sp.cse(handled_terms, symbols=replacement_symbol_generator,
+                                                         order='None', optimizations=[])
+                substitutions += [Assignment(f[0], f[1]) for f in found_subexpressions]
 
-                updateRules = [Assignment(ur.lhs, ur.rhs.subs(relaxationRate * oldTerm, newCoefficient * newTerm))
-                               for ur, newTerm, oldTerm in zip(updateRules, newTerms, terms)]
+                update_rules = [Assignment(ur.lhs, ur.rhs.subs(relaxation_rate * oldTerm, new_coefficient * newTerm))
+                                for ur, newTerm, oldTerm in zip(update_rules, new_terms, terms)]
 
-        result += updateRules
+        result += update_rules
 
-    for term, substitutedVar in newCoefficientSubstitutions.items():
+    for term, substitutedVar in new_coefficient_substitutions.items():
         substitutions.append(Assignment(substitutedVar, term))
 
-    result.sort(key=lambda e: lbmCollisionEqs.method.postCollisionPdfSymbols.index(e.lhs))
-    res = lbmCollisionEqs.copy(result)
+    result.sort(key=lambda e: cr.method.post_collision_pdf_symbols.index(e.lhs))
+    res = cr.copy(result)
     res.subexpressions += substitutions
     return res
 
 
 # -------------------------------------- Helper Functions --------------------------------------------------------------
 
-def __getCommonQuadraticAndConstantTerms(lbmCollisionEqs):
+def __get_common_quadratic_and_constant_terms(cr: LbmCollisionRule):
     """Determines a common subexpression useful for most LBM model often called f_eq_common.
     It contains the quadratic and constant terms of the center update rule."""
-    sh = lbmCollisionEqs.simplification_hints
-    stencil = lbmCollisionEqs.method.stencil
-    relaxationRates = sp.Matrix(sh['relaxationRates']).atoms(sp.Symbol)
+    sh = cr.simplification_hints
+    stencil = cr.method.stencil
+    relaxation_rates = sp.Matrix(sh['relaxation_rates']).atoms(sp.Symbol)
 
     dim = len(stencil[0])
 
-    pdfSymbols = lbmCollisionEqs.free_symbols - relaxationRates
+    pdf_symbols = cr.free_symbols - relaxation_rates
 
     center = tuple([0] * dim)
-    t = lbmCollisionEqs.main_assignments[stencil.index(center)].rhs
-    for rp in relaxationRates:
+    t = cr.main_assignments[stencil.index(center)].rhs
+    for rp in relaxation_rates:
         t = t.subs(rp, 1)
 
-    for fa in pdfSymbols:
+    for fa in pdf_symbols:
         t = t.subs(fa, 0)
 
     if 'forceTerms' in sh:
diff --git a/moments.py b/moments.py
index 69b2274455bcb6b0511672885f609cad4f6dfc0d..fca979bbd100c444223bb3efb21bf827ef35b8f5 100644
--- a/moments.py
+++ b/moments.py
@@ -52,87 +52,87 @@ T = TypeVar('T')
 # ------------------------------ Discrete (Exponent Tuples) ------------------------------------------------------------
 
 
-def momentMultiplicity(exponentTuple):
+def moment_multiplicity(exponent_tuple):
     """
     Returns number of permutations of the given moment tuple
 
     Example:
-    >>> momentMultiplicity((2,0,0))
+    >>> moment_multiplicity((2,0,0))
     3
-    >>> list(momentPermutations((2,0,0)))
+    >>> list(moment_permutations((2,0,0)))
     [(0, 0, 2), (0, 2, 0), (2, 0, 0)]
     """
-    c = Counter(exponentTuple)
-    result = math.factorial(len(exponentTuple))
+    c = Counter(exponent_tuple)
+    result = math.factorial(len(exponent_tuple))
     for d in c.values():
         result //= math.factorial(d)
     return result
 
 
-def pickRepresentativeMoments(moments):
+def pick_representative_moments(moments):
     """Picks the representative i.e. of each permutation group only one is kept"""
-    toRemove = []
+    to_remove = []
     for m in moments:
-        permutations = list(momentPermutations(m))
-        toRemove += permutations[1:]
-    return set(moments) - set(toRemove)
+        permutations = list(moment_permutations(m))
+        to_remove += permutations[1:]
+    return set(moments) - set(to_remove)
 
 
-def momentPermutations(exponentTuple):
+def moment_permutations(exponent_tuple):
     """Returns all (unique) permutations of the given tuple"""
-    return __unique_permutations(exponentTuple)
+    return __unique_permutations(exponent_tuple)
 
 
-def momentsOfOrder(order, dim=3, includePermutations=True):
+def moments_of_order(order, dim=3, include_permutations=True):
     """All tuples of length 'dim' which sum equals 'order'"""
-    for item in __fixed_sum_tuples(dim, order, ordered=not includePermutations):
+    for item in __fixed_sum_tuples(dim, order, ordered=not include_permutations):
         assert(len(item) == dim)
         assert(sum(item) == order)
         yield item
 
 
-def momentsUpToOrder(order, dim=3, includePermutations=True):
+def moments_up_to_order(order, dim=3, include_permutations=True):
     """All tuples of length 'dim' which sum is smaller than 'order' """
-    singleMomentIterators = [momentsOfOrder(o, dim, includePermutations) for o in range(order + 1)]
-    return tuple(itertools.chain(*singleMomentIterators))
+    single_moment_iterators = [moments_of_order(o, dim, include_permutations) for o in range(order + 1)]
+    return tuple(itertools.chain(*single_moment_iterators))
 
 
-def momentsUpToComponentOrder(order, dim=3):
+def moments_up_to_component_order(order, dim=3):
     """All tuples of length 'dim' where each entry is smaller or equal to 'order' """
     return tuple(itertools.product(*[range(order + 1)] * dim))
 
 
-def extendMomentsWithPermutations(exponentTuples):
+def extend_moments_with_permutations(exponent_tuples):
     """Returns all permutations of the given exponent tuples"""
-    allMoments = []
-    for i in exponentTuples:
-        allMoments += list(momentPermutations(i))
-    return __unique(allMoments)
+    all_moments = []
+    for i in exponent_tuples:
+        all_moments += list(moment_permutations(i))
+    return __unique(all_moments)
 
 
 # ------------------------------ Representation Conversions ------------------------------------------------------------
 
 
-def exponentToPolynomialRepresentation(exponentTuple):
+def exponent_to_polynomial_representation(exponent_tuple):
     """
     Converts an exponent tuple to corresponding polynomial representation
 
     Example:
-        >>> exponentToPolynomialRepresentation( (2,1,3) )
+        >>> exponent_to_polynomial_representation( (2,1,3) )
         x**2*y*z**3
     """
     poly = 1
-    for sym, tupleEntry in zip(MOMENT_SYMBOLS[:len(exponentTuple)], exponentTuple):
+    for sym, tupleEntry in zip(MOMENT_SYMBOLS[:len(exponent_tuple)], exponent_tuple):
         poly *= sym ** tupleEntry
     return poly
 
 
-def exponentsToPolynomialRepresentations(sequenceOfExponentTuples):
-    """Applies :func:`exponentToPolynomialRepresentation` to given sequence"""
-    return tuple([exponentToPolynomialRepresentation(t) for t in sequenceOfExponentTuples])
+def exponents_to_polynomial_representations(sequence_of_exponent_tuples):
+    """Applies :func:`exponent_to_polynomial_representation` to given sequence"""
+    return tuple([exponent_to_polynomial_representation(t) for t in sequence_of_exponent_tuples])
 
 
-def polynomialToExponentRepresentation(polynomial, dim=3):
+def polynomial_to_exponent_representation(polynomial, dim=3):
     """
     Converts a linear combination of moments in polynomial representation into exponent representation
 
@@ -140,61 +140,61 @@ def polynomialToExponentRepresentation(polynomial, dim=3):
 
     Example:
         >>> x , y, z = MOMENT_SYMBOLS
-        >>> set(polynomialToExponentRepresentation(1 + (42 * x**2 * y**2 * z) )) == {(42, (2, 2, 1)), (1, (0, 0, 0))}
+        >>> set(polynomial_to_exponent_representation(1 + (42 * x**2 * y**2 * z) )) == {(42, (2, 2, 1)), (1, (0, 0, 0))}
         True
     """
     assert dim <= 3
     x, y, z = MOMENT_SYMBOLS
     polynomial = polynomial.expand()
-    coeffExpTupleRepresentation = []
+    coeff_exp_tuple_representation = []
 
     summands = [polynomial] if polynomial.func != sp.Add else polynomial.args
     for expr in summands:
         if len(expr.atoms(sp.Symbol) - set(MOMENT_SYMBOLS)) > 0:
             raise ValueError("Invalid moment polynomial: " + str(expr))
         c, x_exp, y_exp, z_exp = sp.Wild('c'), sp.Wild('xexp'), sp.Wild('yexp'), sp.Wild('zc')
-        matchRes = expr.match(c * x**x_exp * y**y_exp * z**z_exp)
-        assert matchRes[x_exp].is_integer and matchRes[y_exp].is_integer and matchRes[z_exp].is_integer
-        expTuple = (int(matchRes[x_exp]), int(matchRes[y_exp]), int(matchRes[z_exp]),)
+        match_res = expr.match(c * x**x_exp * y**y_exp * z**z_exp)
+        assert match_res[x_exp].is_integer and match_res[y_exp].is_integer and match_res[z_exp].is_integer
+        exp_tuple = (int(match_res[x_exp]), int(match_res[y_exp]), int(match_res[z_exp]),)
         if dim < 3:
             for i in range(dim, 3):
-                assert expTuple[i] == 0, "Used symbols in polynomial are not representable in that dimension"
-            expTuple = expTuple[:dim]
-        coeffExpTupleRepresentation.append((matchRes[c], expTuple))
-    return coeffExpTupleRepresentation
+                assert exp_tuple[i] == 0, "Used symbols in polynomial are not representable in that dimension"
+            exp_tuple = exp_tuple[:dim]
+        coeff_exp_tuple_representation.append((match_res[c], exp_tuple))
+    return coeff_exp_tuple_representation
 
 
-def momentSortKey(moment):
+def moment_sort_key(moment):
     """Sort key function for moments to sort them by (in decreasing priority)
      order, number of occuring symbols, length of string representation, string representation"""
-    momStr = str(moment)
-    return getOrder(moment), len(moment.atoms(sp.Symbol)), len(momStr), momStr
+    mom_str = str(moment)
+    return get_order(moment), len(moment.atoms(sp.Symbol)), len(mom_str), mom_str
 
 
-def sortMomentsIntoGroupsOfSameOrder(moments):
+def sort_moments_into_groups_of_same_order(moments):
     """Returns a dictionary mapping the order (int) to a list of moments with that order."""
     result = defaultdict(list)
     for i, moment in enumerate(moments):
-        order = getOrder(moment)
+        order = get_order(moment)
         result[order].append(moment)
     return result
 
 # -------------------- Common Function working with exponent tuples and polynomial moments -----------------------------
 
 
-def isEven(moment):
+def is_even(moment):
     """
     A moment is considered even when under sign reversal nothing changes i.e. :math:`m(-x,-y,-z) = m(x,y,z)`
 
     For the exponent tuple representation that means that the exponent sum is even  e.g.
         >>> x , y, z = MOMENT_SYMBOLS
-        >>> isEven(x**2 * y**2)
+        >>> is_even(x**2 * y**2)
         True
-        >>> isEven(x**2 * y)
+        >>> is_even(x**2 * y)
         False
-        >>> isEven((1,0,0))
+        >>> is_even((1,0,0))
         False
-        >>> isEven(1)
+        >>> is_even(1)
         True
     """
     if type(moment) is tuple:
@@ -207,38 +207,38 @@ def isEven(moment):
         return sp.expand(moment - opposite) == 0
 
 
-def getMomentIndices(momentExponentTuple):
+def get_moment_indices(moment_exponent_tuple):
     """Returns indices for a given exponent tuple:
     
     Example:
-        >>> getMomentIndices((2,1,0))
+        >>> get_moment_indices((2,1,0))
         [0, 0, 1]
-        >>> getMomentIndices((0,0,3))
+        >>> get_moment_indices((0,0,3))
         [2, 2, 2]
     """
     result = []
-    for i, element in enumerate(momentExponentTuple):
+    for i, element in enumerate(moment_exponent_tuple):
         result += [i] * element
     return result
 
 
-def getExponentTupleFromIndices(momentIndices, dim):
+def get_exponent_tuple_from_indices(moment_indices, dim):
     result = [0] * dim
-    for i in momentIndices:
+    for i in moment_indices:
         result[i] += 1
     return tuple(result)
 
 
-def getOrder(moment):
+def get_order(moment):
     """Computes polynomial order of given moment.
 
     Examples:
         >>> x , y, z = MOMENT_SYMBOLS
-        >>> getOrder(x**2 * y + x)
+        >>> get_order(x**2 * y + x)
         3
-        >>> getOrder(z**4 * x**2)
+        >>> get_order(z**4 * x**2)
         6
-        >>> getOrder((2,1,0))
+        >>> get_order((2,1,0))
         3
     """
     if isinstance(moment, tuple):
@@ -250,7 +250,7 @@ def getOrder(moment):
     return sum([sp.degree(leading_coefficient, gen=m) for m in symbols_in_leading_coefficient])
 
 
-def nonAliasedMoment(moment_tuple: Sequence[int]) -> Tuple[int, ...]:
+def non_aliased_moment(moment_tuple: Sequence[int]) -> Tuple[int, ...]:
     """Takes a moment exponent tuple and returns the non-aliased version of it.
 
     For first neighborhood stencils, all moments with exponents 3, 5, 7... are equal to exponent 1,
@@ -258,9 +258,9 @@ def nonAliasedMoment(moment_tuple: Sequence[int]) -> Tuple[int, ...]:
     d ∈ {+1, 0, -1}. So for example d**5 is always the same as d**3 and d, and d**6 == d**4 == d**2
 
     Example:
-         >>> nonAliasedMoment((5, 4, 2))
+         >>> non_aliased_moment((5, 4, 2))
          (1, 2, 2)
-         >>> nonAliasedMoment((9, 1, 2))
+         >>> non_aliased_moment((9, 1, 2))
          (1, 1, 2)
     """
     moment = list(moment_tuple)
@@ -273,16 +273,18 @@ def nonAliasedMoment(moment_tuple: Sequence[int]) -> Tuple[int, ...]:
     return tuple(result)
 
 
-def isShearMoment(moment):
+def is_shear_moment(moment):
     """Shear moments in 3D are: x*y, x*z and y*z - in 2D its only x*y"""
     if type(moment) is tuple:
-        moment = exponentToPolynomialRepresentation(moment)
-    return moment in isShearMoment.shearMoments
-isShearMoment.shearMoments = set([c[0] * c[1] for c in itertools.combinations(MOMENT_SYMBOLS, 2)])
+        moment = exponent_to_polynomial_representation(moment)
+    return moment in is_shear_moment.shearMoments
+
+
+is_shear_moment.shearMoments = set([c[0] * c[1] for c in itertools.combinations(MOMENT_SYMBOLS, 2)])
 
 
 @memorycache(maxsize=512)
-def discreteMoment(function, moment, stencil):
+def discrete_moment(func, moment, stencil):
     """
     Computes discrete moment of given distribution function
 
@@ -292,13 +294,13 @@ def discreteMoment(function, moment, stencil):
     where :math:`p(d)` is the moment polynomial where :math:`x, y, z` have been replaced with the components of the
     stencil direction, and :math:`f_i` is the i'th entry in the passed function sequence
 
-    :param function: list of distribution functions for each direction
+    :param func: list of distribution functions for each direction
     :param moment: can either be a exponent tuple, or a sympy polynomial expression
     :param stencil: sequence of directions
     """
-    assert len(stencil) == len(function)
+    assert len(stencil) == len(func)
     res = 0
-    for factor, e in zip(function, stencil):
+    for factor, e in zip(func, stencil):
         if type(moment) is tuple:
             for vel, exponent in zip(e, moment):
                 factor *= vel ** exponent
@@ -312,7 +314,7 @@ def discreteMoment(function, moment, stencil):
     return res
 
 
-def momentMatrix(moments, stencil):
+def moment_matrix(moments, stencil):
     """
     Returns transformation matrix to moment space
 
@@ -336,7 +338,7 @@ def momentMatrix(moments, stencil):
     return sp.Matrix(len(moments), len(stencil), generator)
 
 
-def gramSchmidt(moments, stencil, weights=None):
+def gram_schmidt(moments, stencil, weights=None):
     """
     Computes orthogonal set of moments using the method by Gram-Schmidt
 
@@ -354,65 +356,110 @@ def gramSchmidt(moments, stencil, weights=None):
         weights = sp.diag(*weights)
 
     if type(moments[0]) is tuple:
-        moments = list(exponentsToPolynomialRepresentations(moments))
+        moments = list(exponents_to_polynomial_representations(moments))
     else:
         moments = list(copy(moments))
 
-    M = momentMatrix(moments, stencil).transpose()
-    columnsOfM = [M.col(i) for i in range(M.cols)]
-    orthogonalizedVectors = []
-    for i in range(len(columnsOfM)):
-        currentElement = columnsOfM[i]
+    pdfs_to_moments = moment_matrix(moments, stencil).transpose()
+    moment_matrix_columns = [pdfs_to_moments.col(i) for i in range(pdfs_to_moments.cols)]
+    orthogonalized_vectors = []
+    for i in range(len(moment_matrix_columns)):
+        current_element = moment_matrix_columns[i]
         for j in range(i):
-            prevElement = orthogonalizedVectors[j]
-            denom = prevElement.dot(weights * prevElement)
-            if denom == 0:
+            prev_element = orthogonalized_vectors[j]
+            denominator = prev_element.dot(weights * prev_element)
+            if denominator == 0:
                 raise ValueError("Not an independent set of vectors given: "
                                  "vector %d is dependent on previous vectors" % (i,))
-            overlap = currentElement.dot(weights * prevElement) / denom
-            currentElement -= overlap * prevElement
+            overlap = current_element.dot(weights * prev_element) / denominator
+            current_element -= overlap * prev_element
             moments[i] -= overlap * moments[j]
-        orthogonalizedVectors.append(currentElement)
+        orthogonalized_vectors.append(current_element)
 
     return moments
 
 
-def getDefaultMomentSetForStencil(stencil):
+def get_default_moment_set_for_stencil(stencil):
     """
     Returns a sequence of moments that are commonly used to construct a LBM equilibrium for the given stencil
     """
-    from lbmpy.stencils import getStencil, stencilsHaveSameEntries
+    from lbmpy.stencils import get_stencil, stencils_have_same_entries
 
-    toPoly = exponentsToPolynomialRepresentations
+    to_poly = exponents_to_polynomial_representations
 
-    if stencilsHaveSameEntries(stencil, getStencil("D2Q9")):
-        return sorted(toPoly(momentsUpToComponentOrder(2, dim=2)), key=momentSortKey)
+    if stencils_have_same_entries(stencil, get_stencil("D2Q9")):
+        return sorted(to_poly(moments_up_to_component_order(2, dim=2)), key=moment_sort_key)
 
-    all27Moments = momentsUpToComponentOrder(2, dim=3)
-    if stencilsHaveSameEntries(stencil, getStencil("D3Q27")):
-        return toPoly(all27Moments)
-    if stencilsHaveSameEntries(stencil, getStencil("D3Q19")):
-        nonMatchedMoments = [(1, 2, 2), (1, 1, 2), (2, 2, 2), (1, 1, 1)]
-        moments19 = set(all27Moments) - set(extendMomentsWithPermutations(nonMatchedMoments))
-        return sorted(toPoly(moments19), key=momentSortKey)
-    if stencilsHaveSameEntries(stencil, getStencil("D3Q15")):
+    all27_moments = moments_up_to_component_order(2, dim=3)
+    if stencils_have_same_entries(stencil, get_stencil("D3Q27")):
+        return to_poly(all27_moments)
+    if stencils_have_same_entries(stencil, get_stencil("D3Q19")):
+        non_matched_moments = [(1, 2, 2), (1, 1, 2), (2, 2, 2), (1, 1, 1)]
+        moments19 = set(all27_moments) - set(extend_moments_with_permutations(non_matched_moments))
+        return sorted(to_poly(moments19), key=moment_sort_key)
+    if stencils_have_same_entries(stencil, get_stencil("D3Q15")):
         x, y, z = MOMENT_SYMBOLS
-        nonMatchedMoments = [(1, 2, 0), (2, 2, 0), (1, 1, 2), (1, 2, 2), (2, 2, 2)]
-        additionalMoments = (6 * (x**2 * y**2 + x**2 * z**2 + y**2 * z**2),
-                             3 * (x * (y**2 + z**2)),
-                             3 * (y * (x**2 + z**2)),
-                             3 * (z * (x**2 + y**2)),
-                            )
-        toRemove = set(extendMomentsWithPermutations(nonMatchedMoments))
-        return sorted(toPoly(set(all27Moments) - toRemove) + additionalMoments, key=momentSortKey)
+        non_matched_moments = [(1, 2, 0), (2, 2, 0), (1, 1, 2), (1, 2, 2), (2, 2, 2)]
+        additional_moments = (6 * (x ** 2 * y ** 2 + x ** 2 * z ** 2 + y ** 2 * z ** 2),
+                              3 * (x * (y ** 2 + z ** 2)),
+                              3 * (y * (x ** 2 + z ** 2)),
+                              3 * (z * (x ** 2 + y ** 2)),
+                              )
+        to_remove = set(extend_moments_with_permutations(non_matched_moments))
+        return sorted(to_poly(set(all27_moments) - to_remove) + additional_moments, key=moment_sort_key)
 
     raise NotImplementedError("No default moment system available for this stencil - define matched moments yourself")
 
 
+def extract_monomials(sequence_of_polynomials, dim=3):
+    """
+    Returns a set of exponent tuples of all monomials contained in the given set of polynomials
+    :param sequence_of_polynomials: sequence of polynomials in the MOMENT_SYMBOLS
+    :param dim: length of returned exponent tuples
+
+    >>> x, y, z = MOMENT_SYMBOLS
+    >>> extract_monomials([x**2 + y**2 + y, y + y**2])
+    {(0, 2, 0), (0, 1, 0), (2, 0, 0)}
+    >>> extract_monomials([x**2 + y**2 + y, y + y**2], dim=2)
+    {(0, 1), (2, 0), (0, 2)}
+    """
+    monomials = set()
+    for polynomial in sequence_of_polynomials:
+        for factor, exponentTuple in polynomial_to_exponent_representation(polynomial):
+            monomials.add(exponentTuple[:dim])
+    return monomials
+
+
+def monomial_to_polynomial_transformation_matrix(monomials, polynomials):
+    """
+    Returns a transformation matrix from a monomial to a polynomial representation
+    :param monomials: sequence of exponent tuples
+    :param polynomials: sequence of polynomials in the MOMENT_SYMBOLS
+
+    >>> x, y, z = MOMENT_SYMBOLS
+    >>> polys = [7 * x**2 + 3 * x + 2 * y **2, \
+                 9 * x**2 - 5 * x]
+    >>> mons = list(extract_monomials(polys, dim=2))
+    >>> monomial_to_polynomial_transformation_matrix(mons, polys)
+    Matrix([
+    [7,  3, 2],
+    [9, -5, 0]])
+    """
+    dim = len(monomials[0])
+
+    result = sp.zeros(len(polynomials), len(monomials))
+    for polynomialIdx, polynomial in enumerate(polynomials):
+        for factor, exponent_tuple in polynomial_to_exponent_representation(polynomial):
+            exponent_tuple = exponent_tuple[:dim]
+            result[polynomialIdx, monomials.index(exponent_tuple)] = factor
+    return result
+
+
 # ---------------------------------- Visualization ---------------------------------------------------------------------
 
 
-def momentEqualityTable(stencil, discrete_equilibrium=None, continuous_equilibrium=None, maxOrder=4, truncateOrder=None):
+def moment_equality_table(stencil, discrete_equilibrium=None, continuous_equilibrium=None,
+                          max_order=4, truncate_order=None):
     """
     Creates a table showing which moments of a discrete stencil/equilibrium coincide with the
     corresponding continuous moments
@@ -421,28 +468,28 @@ def momentEqualityTable(stencil, discrete_equilibrium=None, continuous_equilibri
     :param discrete_equilibrium: list of sympy expr to compute discrete equilibrium for each direction, if left
                                 to default the standard discrete Maxwellian equilibrium is used
     :param continuous_equilibrium: continuous equilibrium, if left to default, the continuous Maxwellian is used
-    :param maxOrder: compare moments up to this order (number of rows in table)
-    :param truncateOrder: moments are considered equal if they match up to this order
+    :param max_order: compare moments up to this order (number of rows in table)
+    :param truncate_order: moments are considered equal if they match up to this order
     :return: Object to display in an Jupyter notebook
     """
     import ipy_table
-    from lbmpy.continuous_distribution_measures import continuousMoment
+    from lbmpy.continuous_distribution_measures import continuous_moment
 
     dim = len(stencil[0])
     u = sp.symbols(f"u_:{dim}")
     if discrete_equilibrium is None:
-        from lbmpy.maxwellian_equilibrium import discreteMaxwellianEquilibrium
-        discrete_equilibrium = discreteMaxwellianEquilibrium(stencil, c_s_sq=sp.Rational(1, 3), compressible=True,
-                                                             u=u, order=truncateOrder)
+        from lbmpy.maxwellian_equilibrium import discrete_maxwellian_equilibrium
+        discrete_equilibrium = discrete_maxwellian_equilibrium(stencil, c_s_sq=sp.Rational(1, 3), compressible=True,
+                                                               u=u, order=truncate_order)
     if continuous_equilibrium is None:
-        from lbmpy.maxwellian_equilibrium import continuousMaxwellianEquilibrium
-        continuous_equilibrium = continuousMaxwellianEquilibrium(dim=dim, u=u, c_s_sq=sp.Rational(1, 3))
+        from lbmpy.maxwellian_equilibrium import continuous_maxwellian_equilibrium
+        continuous_equilibrium = continuous_maxwellian_equilibrium(dim=dim, u=u, c_s_sq=sp.Rational(1, 3))
 
     table = []
     matched_moments = 0
     non_matched_moments = 0
 
-    moments_list = [list(momentsOfOrder(o, dim, includePermutations=False)) for o in range(maxOrder + 1)]
+    moments_list = [list(moments_of_order(o, dim, include_permutations=False)) for o in range(max_order + 1)]
 
     colors = dict()
     nr_of_columns = max([len(v) for v in moments_list]) + 1
@@ -455,12 +502,12 @@ def momentEqualityTable(stencil, discrete_equilibrium=None, continuous_equilibri
         row = [' '] * nr_of_columns
         row[0] = '%d' % (order,)
         for moment, colIdx in zip(moments, range(1, len(row))):
-            multiplicity = momentMultiplicity(moment)
-            dm = discreteMoment(discrete_equilibrium, moment, stencil)
-            cm = continuousMoment(continuous_equilibrium, moment, symbols=sp.symbols("v_0 v_1 v_2")[:dim])
+            multiplicity = moment_multiplicity(moment)
+            dm = discrete_moment(discrete_equilibrium, moment, stencil)
+            cm = continuous_moment(continuous_equilibrium, moment, symbols=sp.symbols("v_0 v_1 v_2")[:dim])
             difference = sp.simplify(dm - cm)
-            if truncateOrder:
-                difference = sp.simplify(remove_higher_order_terms(difference, symbols=u, order=truncateOrder))
+            if truncate_order:
+                difference = sp.simplify(remove_higher_order_terms(difference, symbols=u, order=truncate_order))
             if difference != 0:
                 colors[(order + 1, colIdx)] = 'Orange'
                 non_matched_moments += multiplicity
@@ -468,7 +515,7 @@ def momentEqualityTable(stencil, discrete_equilibrium=None, continuous_equilibri
                 colors[(order + 1, colIdx)] = 'lightGreen'
                 matched_moments += multiplicity
 
-            row[colIdx] = '%s  x %d' % (moment, momentMultiplicity(moment))
+            row[colIdx] = '%s  x %d' % (moment, moment_multiplicity(moment))
 
         table.append(row)
 
@@ -483,51 +530,51 @@ def momentEqualityTable(stencil, discrete_equilibrium=None, continuous_equilibri
     return table_display
 
 
-def momentEqualityTableByStencil(nameToStencilDict, moments, truncateOrder=None):
+def moment_equality_table_by_stencil(name_to_stencil_dict, moments, truncate_order=None):
     """
     Creates a table for display in IPython notebooks that shows which moments agree between continuous and
     discrete equilibrium, group by stencils
 
-    :param nameToStencilDict: dict from stencil name to stencil
+    :param name_to_stencil_dict: dict from stencil name to stencil
     :param moments: sequence of moments to compare - assumes that permutations have similar properties
                     so just one representative is shown labeled with its multiplicity
-    :param truncateOrder: compare up to this order
+    :param truncate_order: compare up to this order
     """
     import ipy_table
-    from lbmpy.maxwellian_equilibrium import discreteMaxwellianEquilibrium
-    from lbmpy.maxwellian_equilibrium import continuousMaxwellianEquilibrium
-    from lbmpy.continuous_distribution_measures import continuousMoment
+    from lbmpy.maxwellian_equilibrium import discrete_maxwellian_equilibrium
+    from lbmpy.maxwellian_equilibrium import continuous_maxwellian_equilibrium
+    from lbmpy.continuous_distribution_measures import continuous_moment
 
     stencil_names = []
     stencils = []
-    for key, value in nameToStencilDict.items():
+    for key, value in name_to_stencil_dict.items():
         stencil_names.append(key)
         stencils.append(value)
 
-    moments = list(pickRepresentativeMoments(moments))
+    moments = list(pick_representative_moments(moments))
 
     colors = {}
     for stencilIdx, stencil in enumerate(stencils):
         dim = len(stencil[0])
         u = sp.symbols(f"u_:{dim}")
-        discrete_equilibrium = discreteMaxwellianEquilibrium(stencil, c_s_sq=sp.Rational(1, 3), compressible=True,
-                                                             u=u, order=truncateOrder)
-        continuous_equilibrium = continuousMaxwellianEquilibrium(dim=dim, u=u, c_s_sq=sp.Rational(1, 3))
+        discrete_equilibrium = discrete_maxwellian_equilibrium(stencil, c_s_sq=sp.Rational(1, 3), compressible=True,
+                                                               u=u, order=truncate_order)
+        continuous_equilibrium = continuous_maxwellian_equilibrium(dim=dim, u=u, c_s_sq=sp.Rational(1, 3))
 
         for momentIdx, moment in enumerate(moments):
             moment = moment[:dim]
-            dm = discreteMoment(discrete_equilibrium, moment, stencil)
-            cm = continuousMoment(continuous_equilibrium, moment, symbols=sp.symbols("v_0 v_1 v_2")[:dim])
+            dm = discrete_moment(discrete_equilibrium, moment, stencil)
+            cm = continuous_moment(continuous_equilibrium, moment, symbols=sp.symbols("v_0 v_1 v_2")[:dim])
             difference = sp.simplify(dm - cm)
-            if truncateOrder:
-                difference = sp.simplify(remove_higher_order_terms(difference, symbols=u, order=truncateOrder))
+            if truncate_order:
+                difference = sp.simplify(remove_higher_order_terms(difference, symbols=u, order=truncate_order))
             colors[(momentIdx + 1, stencilIdx + 2)] = 'Orange' if difference != 0 else 'lightGreen'
 
     table = []
     header_row = [' ', '#'] + stencil_names
     table.append(header_row)
     for moment in moments:
-        row = [str(moment), str(momentMultiplicity(moment))] + [' '] * len(stencils)
+        row = [str(moment), str(moment_multiplicity(moment))] + [' '] * len(stencils)
         table.append(row)
 
     table_display = ipy_table.make_table(table)
@@ -538,50 +585,6 @@ def momentEqualityTableByStencil(nameToStencilDict, moments, truncateOrder=None)
     return table_display
 
 
-def extractMonomials(sequenceOfPolynomials, dim=3):
-    """
-    Returns a set of exponent tuples of all monomials contained in the given set of polynomials
-    :param sequenceOfPolynomials: sequence of polynomials in the MOMENT_SYMBOLS
-    :param dim: length of returned exponent tuples
-
-    >>> x, y, z = MOMENT_SYMBOLS
-    >>> extractMonomials([x**2 + y**2 + y, y + y**2])
-    {(0, 2, 0), (0, 1, 0), (2, 0, 0)}
-    >>> extractMonomials([x**2 + y**2 + y, y + y**2], dim=2)
-    {(0, 1), (2, 0), (0, 2)}
-    """
-    monomials = set()
-    for polynomial in sequenceOfPolynomials:
-        for factor, exponentTuple in polynomialToExponentRepresentation(polynomial):
-            monomials.add(exponentTuple[:dim])
-    return monomials
-
-
-def monomialToPolynomialTransformationMatrix(monomials, polynomials):
-    """
-    Returns a transformation matrix from a monomial to a polynomial representation
-    :param monomials: sequence of exponent tuples
-    :param polynomials: sequence of polynomials in the MOMENT_SYMBOLS
-
-    >>> x, y, z = MOMENT_SYMBOLS
-    >>> polys = [7 * x**2 + 3 * x + 2 * y **2, \
-                 9 * x**2 - 5 * x]
-    >>> mons = list(extractMonomials(polys, dim=2))
-    >>> monomialToPolynomialTransformationMatrix(mons, polys)
-    Matrix([
-    [7,  3, 2],
-    [9, -5, 0]])
-    """
-    dim = len(monomials[0])
-
-    result = sp.zeros(len(polynomials), len(monomials))
-    for polynomialIdx, polynomial in enumerate(polynomials):
-        for factor, exponentTuple in polynomialToExponentRepresentation(polynomial):
-            exponentTuple = exponentTuple[:dim]
-            result[polynomialIdx, monomials.index(exponentTuple)] = factor
-    return result
-
-
 # --------------------------------------- Internal Functions -----------------------------------------------------------
 
 def __unique(seq: Sequence[T]) -> List[T]:
@@ -669,4 +672,4 @@ def __fixed_sum_tuples(tuple_length: int, tuple_sum: int,
                 if ordered and current_list == sorted(current_list, reverse=True):
                     yield tuple(current_list)
 
-    return recursive_helper([0] * tuple_length, 0, tuple_sum)
\ No newline at end of file
+    return recursive_helper([0] * tuple_length, 0, tuple_sum)
diff --git a/parameterization.py b/parameterization.py
index e33d84259db42526e1ac349a3fe90f64adf7f809..aa43f280096837741018b37b9642b4691042ac41 100644
--- a/parameterization.py
+++ b/parameterization.py
@@ -1,7 +1,7 @@
 import ipywidgets.widgets as widgets
 from IPython.display import display
 from ipywidgets.widgets import FloatText, Label, VBox, HBox, Select, BoundedFloatText, Button
-from lbmpy.relaxationrates import relaxationRateFromLatticeViscosity, latticeViscosityFromRelaxationRate
+from lbmpy.relaxationrates import relaxation_rate_from_lattice_viscosity, lattice_viscosity_from_relaxation_rate
 
 
 class ScalingWidget:
@@ -9,145 +9,145 @@ class ScalingWidget:
         self.scalingType = Select(options=[r'diffusive (fixed relaxation rate)',
                                            r'acoustic (fixed dt)',
                                            r'fixed lattice velocity'])
-        self.physicalLength = FloatText(value=0.1)
-        self.cellsPerLength = FloatText(value=256.0)
-        self.maxPhysicalVelocity = FloatText(value=0.01)
-        self.dx = FloatText(value=self._getDx())
-        self.kinematicViscosity = BoundedFloatText(value=1.0, min=0, max=1e12)
+        self.physical_length = FloatText(value=0.1)
+        self.cells_per_length = FloatText(value=256.0)
+        self.max_physical_velocity = FloatText(value=0.01)
+        self.dx = FloatText(value=self._get_dx())
+        self.kinematic_viscosity = BoundedFloatText(value=1.0, min=0, max=1e12)
         self.omega = BoundedFloatText(min=0, max=2, value=1.9)
         self.dt = FloatText(value=0)
-        self.maxLatticeVelocity = FloatText(disabled=True)
+        self.max_lattice_velocity = FloatText(disabled=True)
         self.re = FloatText(disabled=True)
 
         self.processingUpdate = False
 
-        def makeLabel(text):
-            labelLayout = {'width': '200px'}
-            return Label(value=text, layout=labelLayout)
+        def make_label(text):
+            label_layout = {'width': '200px'}
+            return Label(value=text, layout=label_layout)
 
-        def makeButtons(inputWidget, inverse=False):
-            buttonLayout = {'width': '20px'}
+        def make_buttons(input_widget, inverse=False):
+            button_layout = {'width': '20px'}
             factor = 0.5 if inverse else 2.0
-            doubleBtn = Button(description="", button_style='warning', layout=buttonLayout)
-            halfBtn = Button(description="", button_style='success', layout=buttonLayout)
+            double_btn = Button(description="", button_style='warning', layout=button_layout)
+            half_btn = Button(description="", button_style='success', layout=button_layout)
 
-            def doubleValue(v):
-                inputWidget.value *= factor
+            def double_value(_):
+                input_widget.value *= factor
 
-            def halfValue(v):
-                inputWidget.value /= factor
+            def half_value(_):
+                input_widget.value /= factor
 
-            widgets.jslink((doubleBtn, 'disabled'), (inputWidget, 'disabled'))
-            widgets.jslink((halfBtn, 'disabled'), (inputWidget, 'disabled'))
-            doubleBtn.on_click(doubleValue)
-            halfBtn.on_click(halfValue)
-            return [halfBtn, doubleBtn]
+            widgets.jslink((double_btn, 'disabled'), (input_widget, 'disabled'))
+            widgets.jslink((half_btn, 'disabled'), (input_widget, 'disabled'))
+            double_btn.on_click(double_value)
+            half_btn.on_click(half_value)
+            return [half_btn, double_btn]
 
         self.form = VBox([
-            HBox([makeLabel(r'Scaling'), self.scalingType]),
-            HBox([makeLabel(r"Physical Length $[m]$"), self.physicalLength]),
-            HBox([makeLabel(r"Max. velocity $[m/s]$"), self.maxPhysicalVelocity]),
-            HBox([makeLabel(r"Cells per length"), self.cellsPerLength] + makeButtons(self.cellsPerLength, True)),
-            HBox([makeLabel(r"dx"), self.dx] + makeButtons(self.dx)),
-            HBox([makeLabel(r"Kinematic viscosity $10^{-6}[m^2/s]$"), self.kinematicViscosity]),
-            HBox([makeLabel(r"Relaxation rate $\omega$"), self.omega]),
-            HBox([makeLabel(r"dt"), self.dt] + makeButtons(self.dt)),
-            HBox([makeLabel(r"Max. lattice velocity"), self.maxLatticeVelocity]),
-            HBox([makeLabel(r"Re"), self.re]),
+            HBox([make_label(r'Scaling'), self.scalingType]),
+            HBox([make_label(r"Physical Length $[m]$"), self.physical_length]),
+            HBox([make_label(r"Max. velocity $[m/s]$"), self.max_physical_velocity]),
+            HBox([make_label(r"Cells per length"), self.cells_per_length] + make_buttons(self.cells_per_length, True)),
+            HBox([make_label(r"dx"), self.dx] + make_buttons(self.dx)),
+            HBox([make_label(r"Kinematic viscosity $10^{-6}[m^2/s]$"), self.kinematic_viscosity]),
+            HBox([make_label(r"Relaxation rate $\omega$"), self.omega]),
+            HBox([make_label(r"dt"), self.dt] + make_buttons(self.dt)),
+            HBox([make_label(r"Max. lattice velocity"), self.max_lattice_velocity]),
+            HBox([make_label(r"Re"), self.re]),
         ])
 
         # Change listeners
-        self.physicalLength.observe(self._on_physicalLength_change, names='value')
-        self.cellsPerLength.observe(self._on_cellsPerLength_change, names='value')
+        self.physical_length.observe(self._on_physical_length_change, names='value')
+        self.cells_per_length.observe(self._on_cells_per_length_change, names='value')
         self.dx.observe(self._on_dx_change, names='value')
-        self.physicalLength.observe(self._updateRe)
-        self.kinematicViscosity.observe(self._updateRe)
-        self.maxPhysicalVelocity.observe(self._updateRe)
+        self.physical_length.observe(self._update_re)
+        self.kinematic_viscosity.observe(self._update_re)
+        self.max_physical_velocity.observe(self._update_re)
 
-        for obj in [self.scalingType, self.kinematicViscosity, self.omega, self.dt, self.maxLatticeVelocity]:
-            obj.observe(self._updateFreeParameter, names='value')
+        for obj in [self.scalingType, self.kinematic_viscosity, self.omega, self.dt, self.max_lattice_velocity]:
+            obj.observe(self._update_free_parameter, names='value')
 
-        self._updateFreeParameter()
-        self._updateRe()
+        self._update_free_parameter()
+        self._update_re()
 
-    def _getDx(self):
-        return self.physicalLength.value / self.cellsPerLength.value
+    def _get_dx(self):
+        return self.physical_length.value / self.cells_per_length.value
 
-    def _updateDtFromRelaxationRateViscosityAndDx(self):
+    def _update_dt_from_relaxation_rate_viscosity_and_dx(self):
         if self.omega.value == 0:
             return 0
-        latticeViscosity = latticeViscosityFromRelaxationRate(self.omega.value)
-        self.dt.value = latticeViscosity / (self.kinematicViscosity.value * 1e-6) * self.dx.value ** 2
+        lattice_viscosity = lattice_viscosity_from_relaxation_rate(self.omega.value)
+        self.dt.value = lattice_viscosity / (self.kinematic_viscosity.value * 1e-6) * self.dx.value ** 2
 
-    def _updateDtFromDxAndLatticeVelocity(self):
-        if self.maxPhysicalVelocity.value == 0:
+    def _update_dt_from_dx_and_lattice_velocity(self):
+        if self.max_physical_velocity.value == 0:
             return
-        self.dt.value = self.maxLatticeVelocity.value / self.maxPhysicalVelocity.value * self.dx.value
+        self.dt.value = self.max_lattice_velocity.value / self.max_physical_velocity.value * self.dx.value
 
-    def _updateOmegaFromViscosityAndDtDx(self):
+    def _update_omega_from_viscosity_and_dt_dx(self):
         if self.dx.value == 0:
             return
-        latticeViscosity = self.kinematicViscosity.value * 1e-6 * self.dt.value / (self.dx.value ** 2)
-        self.omega.value = relaxationRateFromLatticeViscosity(latticeViscosity)
+        lattice_viscosity = self.kinematic_viscosity.value * 1e-6 * self.dt.value / (self.dx.value ** 2)
+        self.omega.value = relaxation_rate_from_lattice_viscosity(lattice_viscosity)
 
-    def _updateFreeParameter(self, change=None):
+    def _update_free_parameter(self, _=None):
         self.dt.disabled = True
         self.omega.disabled = True
-        self.maxLatticeVelocity.disabled = True
+        self.max_lattice_velocity.disabled = True
 
         if self.scalingType.value == r'diffusive (fixed relaxation rate)':
             self.omega.disabled = False
-            self._updateDtFromRelaxationRateViscosityAndDx()
-            self._updateLatticeVelocityFromDxDtAndPhysicalVelocity()
+            self._update_dt_from_relaxation_rate_viscosity_and_dx()
+            self._update_lattice_velocity_from_dx_dt_and_physical_velocity()
         elif self.scalingType.value == r'acoustic (fixed dt)':
-            self._updateOmegaFromViscosityAndDtDx()
-            self._updateDtFromDxAndLatticeVelocity()
-            self.maxLatticeVelocity.disabled = False
+            self._update_omega_from_viscosity_and_dt_dx()
+            self._update_dt_from_dx_and_lattice_velocity()
+            self.max_lattice_velocity.disabled = False
         elif self.scalingType.value == r'fixed lattice velocity':
-            self._updateOmegaFromViscosityAndDtDx()
+            self._update_omega_from_viscosity_and_dt_dx()
             self.dt.disabled = False
-            self._updateLatticeVelocityFromDxDtAndPhysicalVelocity()
+            self._update_lattice_velocity_from_dx_dt_and_physical_velocity()
         else:
             raise ValueError("Unknown Scaling Type")
 
-    def _updateLatticeVelocityFromDxDtAndPhysicalVelocity(self):
+    def _update_lattice_velocity_from_dx_dt_and_physical_velocity(self):
         if self.dx.value == 0:
             return
-        self.maxLatticeVelocity.value = self.dt.value / self.dx.value * self.maxPhysicalVelocity.value
+        self.max_lattice_velocity.value = self.dt.value / self.dx.value * self.max_physical_velocity.value
 
-    def _updateRe(self, change=None):
-        if self.kinematicViscosity.value == 0:
+    def _update_re(self, _=None):
+        if self.kinematic_viscosity.value == 0:
             return
-        L = self.physicalLength.value
-        u = self.maxPhysicalVelocity.value
-        nu = self.kinematicViscosity.value * 1e-6
+        L = self.physical_length.value
+        u = self.max_physical_velocity.value
+        nu = self.kinematic_viscosity.value * 1e-6
         self.re.value = round(L * u / nu, 7)
 
-    def _on_dx_change(self, change):
+    def _on_dx_change(self, _):
         if self.processingUpdate:
             return
         if self.dx.value == 0:
             return
         self.processingUpdate = True
-        self.cellsPerLength.value = self.physicalLength.value / self.dx.value
-        self._updateFreeParameter()
+        self.cells_per_length.value = self.physical_length.value / self.dx.value
+        self._update_free_parameter()
         self.processingUpdate = False
 
-    def _on_cellsPerLength_change(self, change):
+    def _on_cells_per_length_change(self, _):
         if self.processingUpdate:
             return
-        if self.cellsPerLength.value == 0:
+        if self.cells_per_length.value == 0:
             return
         self.processingUpdate = True
-        self.dx.value = self.physicalLength.value / self.cellsPerLength.value
-        self._updateFreeParameter()
+        self.dx.value = self.physical_length.value / self.cells_per_length.value
+        self._update_free_parameter()
         self.processingUpdate = False
 
-    def _on_physicalLength_change(self, change):
-        if self.cellsPerLength.value == 0:
+    def _on_physical_length_change(self, _):
+        if self.cells_per_length.value == 0:
             return
-        self.dx.value = self.physicalLength.value / self.cellsPerLength.value
-        self._updateFreeParameter()
+        self.dx.value = self.physical_length.value / self.cells_per_length.value
+        self._update_free_parameter()
 
     def show(self):
         from IPython.display import HTML
diff --git a/phasefield/analytical.py b/phasefield/analytical.py
index e4c7f391e650a3c25e4f2b0cccd14c87f5edcd69..4d0f9c8d954c8376dc40aaf128fcde879fbc02a1 100644
--- a/phasefield/analytical.py
+++ b/phasefield/analytical.py
@@ -1,15 +1,15 @@
 import sympy as sp
 from collections import defaultdict
 
-from pystencils.sympyextensions import multidimensional_sum as multiSum, normalize_product, prod
-from pystencils.derivative import functionalDerivative, expandUsingLinearity, Diff, fullDiffExpand
+from pystencils.sympyextensions import multidimensional_sum as multi_sum, normalize_product, prod
+from pystencils.derivative import functional_derivative, expand_using_linearity, Diff, full_diff_expand
 
 orderParameterSymbolName = "phi"
 surfaceTensionSymbolName = "tau"
-interfaceWidthSymbol = sp.Symbol("alpha")
+interface_width_symbol = sp.Symbol("alpha")
 
 
-def symmetricSymbolicSurfaceTension(i, j):
+def symmetric_symbolic_surface_tension(i, j):
     """Returns symbolic surface tension. The function is symmetric, i.e. interchanging i and j yields the same result.
     If both phase indices i and j are chosen equal, zero is returned"""
     if i == j:
@@ -18,69 +18,69 @@ def symmetricSymbolicSurfaceTension(i, j):
     return sp.Symbol("%s_%d_%d" % ((surfaceTensionSymbolName, ) + index))
 
 
-def symbolicOrderParameters(numSymbols):
-    return sp.symbols("%s_:%i" % (orderParameterSymbolName, numSymbols))
+def symbolic_order_parameters(num_symbols):
+    return sp.symbols("%s_:%i" % (orderParameterSymbolName, num_symbols))
 
 
-def freeEnergyFunction3Phases(orderParameters=None, interfaceWidth=interfaceWidthSymbol, transformed=True,
-                              includeBulk=True, includeInterface=True, expandDerivatives=True,
-                              kappa=sp.symbols("kappa_:3")):
-    kappaPrime = tuple(interfaceWidth**2 * k for k in kappa)
-    C = sp.symbols("C_:3")
+def free_energy_functional_3_phases(order_parameters=None, interface_width=interface_width_symbol, transformed=True,
+                                    include_bulk=True, include_interface=True, expand_derivatives=True,
+                                    kappa=sp.symbols("kappa_:3")):
+    kappa_prime = tuple(interface_width ** 2 * k for k in kappa)
+    c = sp.symbols("C_:3")
 
-    bulkFreeEnergy = sum(k * C_i ** 2 * (1 - C_i) ** 2 / 2 for k, C_i in zip(kappa, C))
-    surfaceFreeEnergy = sum(k * Diff(C_i) ** 2 / 2 for k, C_i in zip(kappaPrime, C))
+    bulk_free_energy = sum(k * C_i ** 2 * (1 - C_i) ** 2 / 2 for k, C_i in zip(kappa, c))
+    surface_free_energy = sum(k * Diff(C_i) ** 2 / 2 for k, C_i in zip(kappa_prime, c))
 
-    F = 0
-    if includeBulk:
-        F += bulkFreeEnergy
-    if includeInterface:
-        F += surfaceFreeEnergy
+    f = 0
+    if include_bulk:
+        f += bulk_free_energy
+    if include_interface:
+        f += surface_free_energy
 
     if not transformed:
-        return F
+        return f
 
-    if orderParameters:
-        rho, phi, psi = orderParameters
+    if order_parameters:
+        rho, phi, psi = order_parameters
     else:
         rho, phi, psi = sp.symbols("rho phi psi")
 
-    transformationMatrix = sp.Matrix([[1,  1, 1],
-                                      [1, -1, 0],
-                                      [0,  0, 1]])
-    rhoDef, phiDef, psiDef = transformationMatrix * sp.Matrix(C)
-    orderParamToConcentrationRelation = sp.solve([rhoDef - rho, phiDef - phi, psiDef - psi], C)
+    transformation_matrix = sp.Matrix([[1, 1, 1],
+                                       [1, -1, 0],
+                                       [0, 0, 1]])
+    rho_def, phi_def, psi_def = transformation_matrix * sp.Matrix(c)
+    order_param_to_concentration_relation = sp.solve([rho_def - rho, phi_def - phi, psi_def - psi], c)
 
-    F = F.subs(orderParamToConcentrationRelation)
-    if expandDerivatives:
-        F = expandUsingLinearity(F, functions=orderParameters)
+    f = f.subs(order_param_to_concentration_relation)
+    if expand_derivatives:
+        f = expand_using_linearity(f, functions=order_parameters)
 
-    return F, transformationMatrix
+    return f, transformation_matrix
 
 
-def freeEnergyFunctionalNPhasesPenaltyTerm(orderParameters, interfaceWidth=interfaceWidthSymbol, kappa=None,
-                                           penaltyTermFactor=0.01):
-    numPhases = len(orderParameters)
+def free_energy_functional_n_phases_penalty_term(order_parameters, interface_width=interface_width_symbol, kappa=None,
+                                                 penalty_term_factor=0.01):
+    num_phases = len(order_parameters)
     if kappa is None:
-        kappa = sp.symbols("kappa_:%d" % (numPhases,))
+        kappa = sp.symbols("kappa_:%d" % (num_phases,))
     if not hasattr(kappa, "__len__"):
-        kappa = [kappa] * numPhases
+        kappa = [kappa] * num_phases
 
     def f(x):
         return x ** 2 * (1 - x) ** 2
 
-    bulk = sum(f(c) * k / 2 for c, k in zip(orderParameters, kappa))
-    interface = sum(Diff(c) ** 2 / 2 * interfaceWidth ** 2 * k
-                    for c, k in zip(orderParameters, kappa))
+    bulk = sum(f(c) * k / 2 for c, k in zip(order_parameters, kappa))
+    interface = sum(Diff(c) ** 2 / 2 * interface_width ** 2 * k
+                    for c, k in zip(order_parameters, kappa))
 
-    bulkPenaltyTerm = (1 - sum(c for c in orderParameters)) ** 2
-    return bulk + interface + penaltyTermFactor * bulkPenaltyTerm
+    bulk_penalty_term = (1 - sum(c for c in order_parameters)) ** 2
+    return bulk + interface + penalty_term_factor * bulk_penalty_term
 
 
-def freeEnergyFunctionalNPhases(numPhases=None, surfaceTensions=symmetricSymbolicSurfaceTension,
-                                interfaceWidth=interfaceWidthSymbol, orderParameters=None,
-                                includeBulk=True, includeInterface=True, symbolicLambda=False,
-                                symbolicDependentVariable=False):
+def free_energy_functional_n_phases(num_phases=None, surface_tensions=symmetric_symbolic_surface_tension,
+                                    interface_width=interface_width_symbol, order_parameters=None,
+                                    include_bulk=True, include_interface=True, symbolic_lambda=False,
+                                    symbolic_dependent_variable=False):
     r"""
     Returns a symbolic expression for the free energy of a system with N phases and
     specified surface tensions. The total free energy is the sum of a bulk and an interface component.
@@ -100,26 +100,26 @@ def freeEnergyFunctionalNPhases(numPhases=None, surfaceTensions=symmetricSymboli
 
         f(c) = c^2( 1-c)^2
 
-    :param numPhases: number of phases, called N above
-    :param surfaceTensions: surface tension function, called with two phase indices (two integers)
-    :param interfaceWidth: called :math:`\eta` above, controls the interface width
-    :param orderParameters: explicitly
+    :param num_phases: number of phases, called N above
+    :param surface_tensions: surface tension function, called with two phase indices (two integers)
+    :param interface_width: called :math:`\eta` above, controls the interface width
+    :param order_parameters: explicitly
 
     Parameter useful for viewing / debugging the function
-    :param includeBulk: if false no bulk term is added
-    :param includeInterface:if false no interface contribution is added
-    :param symbolicLambda: surface energy coefficient is represented by symbol, not in expanded form
-    :param symbolicDependentVariable: last phase variable is defined as 1-otherPhaseVars, if this is set to True
+    :param include_bulk: if false no bulk term is added
+    :param include_interface:if false no interface contribution is added
+    :param symbolic_lambda: surface energy coefficient is represented by symbol, not in expanded form
+    :param symbolic_dependent_variable: last phase variable is defined as 1-otherPhaseVars, if this is set to True
                                       it is represented by phi_A for better readability
     """
-    assert not (numPhases is None and orderParameters is None)
-    if orderParameters is None:
-        phi = symbolicOrderParameters(numPhases-1)
+    assert not (num_phases is None and order_parameters is None)
+    if order_parameters is None:
+        phi = symbolic_order_parameters(num_phases - 1)
     else:
-        phi = orderParameters
-        numPhases = len(phi) + 1
+        phi = order_parameters
+        num_phases = len(phi) + 1
 
-    if not symbolicDependentVariable:
+    if not symbolic_dependent_variable:
         phi = tuple(phi) + (1 - sum(phi),)
     else:
         phi = tuple(phi) + (sp.Symbol("phi_D"), )
@@ -127,88 +127,89 @@ def freeEnergyFunctionalNPhases(numPhases=None, surfaceTensions=symmetricSymboli
     # Compared to handwritten notes we scale the interface width parameter here to obtain the correct
     # equations for the interface profile and the surface tensions i.e. to pass tests
     # test_analyticInterfaceSolution and test_surfaceTensionDerivation
-    interfaceWidth *= sp.sqrt(2)
+    interface_width *= sp.sqrt(2)
 
     def f(c):
         return c ** 2 * (1 - c) ** 2
 
-    def lambdaCoeff(k, l):
-        if symbolicLambda:
+    def lambda_coeff(k, l):
+        if symbolic_lambda:
             return sp.Symbol("Lambda_%d%d" % ((k, l) if k < l else (l, k)))
-        N = numPhases - 1
+        n = num_phases - 1
         if k == l:
-            assert surfaceTensions(l, l) == 0
-        return 3 / sp.sqrt(2) * interfaceWidth * (surfaceTensions(k, N) + surfaceTensions(l, N) - surfaceTensions(k, l))
+            assert surface_tensions(l, l) == 0
+        return 3 / sp.sqrt(2) * interface_width * (surface_tensions(k, n) +
+                                                   surface_tensions(l, n) - surface_tensions(k, l))
 
-    def bulkTerm(i, j):
-        return surfaceTensions(i, j) / 2 * (f(phi[i]) + f(phi[j]) - f(phi[i] + phi[j]))
+    def bulk_term(i, j):
+        return surface_tensions(i, j) / 2 * (f(phi[i]) + f(phi[j]) - f(phi[i] + phi[j]))
 
-    F_bulk = 3 / sp.sqrt(2) / interfaceWidth * sum(bulkTerm(i, j) for i, j in multiSum(2, numPhases) if i != j)
-    F_interface = sum(lambdaCoeff(i, j) / 2 * Diff(phi[i]) * Diff(phi[j]) for i, j in multiSum(2, numPhases-1))
+    f_bulk = 3 / sp.sqrt(2) / interface_width * sum(bulk_term(i, j) for i, j in multi_sum(2, num_phases) if i != j)
+    f_interface = sum(lambda_coeff(i, j) / 2 * Diff(phi[i]) * Diff(phi[j]) for i, j in multi_sum(2, num_phases - 1))
 
     result = 0
-    if includeBulk:
-        result += F_bulk
-    if includeInterface:
-        result += F_interface
+    if include_bulk:
+        result += f_bulk
+    if include_interface:
+        result += f_interface
     return result
 
 
-def separateIntoBulkAndInterface(freeEnergy):
+def separate_into_bulk_and_interface(free_energy):
     """Separates the bulk and interface parts of a free energy
 
-    >>> F = freeEnergyFunctionalNPhases(3)
-    >>> bulk, inter = separateIntoBulkAndInterface(F)
-    >>> assert sp.expand(bulk - freeEnergyFunctionalNPhases(3, includeInterface=False)) == 0
-    >>> assert sp.expand(inter - freeEnergyFunctionalNPhases(3, includeBulk=False)) == 0
+    >>> F = free_energy_functional_n_phases(3)
+    >>> bulk, inter = separate_into_bulk_and_interface(F)
+    >>> assert sp.expand(bulk - free_energy_functional_n_phases(3, include_interface=False)) == 0
+    >>> assert sp.expand(inter - free_energy_functional_n_phases(3, include_bulk=False)) == 0
     """
-    freeEnergy = freeEnergy.expand()
-    bulkPart = freeEnergy.subs({a: 0 for a in freeEnergy.atoms(Diff)})
-    interfacePart = freeEnergy - bulkPart
-    return bulkPart, interfacePart
+    free_energy = free_energy.expand()
+    bulk_part = free_energy.subs({a: 0 for a in free_energy.atoms(Diff)})
+    interface_part = free_energy - bulk_part
+    return bulk_part, interface_part
 
 
-def analyticInterfaceProfile(x, interfaceWidth=interfaceWidthSymbol):
+def analytic_interface_profile(x, interface_width=interface_width_symbol):
     """Analytic expression for a 1D interface normal to x with given interface width
 
     The following doctest shows that the returned analytical solution is indeed a solution of the ODE that we
     get from the condition :math:`\mu_0 = 0` (thermodynamic equilibrium) for a situation with only a single order
     parameter, i.e. at a transition between two phases.
     >>> numPhases = 4
-    >>> x, phi = sp.Symbol("x"), symbolicOrderParameters(numPhases-1)
-    >>> F = freeEnergyFunctionalNPhases(orderParameters=phi)
-    >>> mu = chemicalPotentialsFromFreeEnergy(F)
+    >>> x, phi = sp.Symbol("x"), symbolic_order_parameters(numPhases-1)
+    >>> F = free_energy_functional_n_phases(order_parameters=phi)
+    >>> mu = chemical_potentials_from_free_energy(F)
     >>> mu0 = mu[0].subs({p: 0 for p in phi[1:]})  # mu[0] as function of one order parameter only
-    >>> solution = analyticInterfaceProfile(x)
+    >>> solution = analytic_interface_profile(x)
     >>> solutionSubstitution = {phi[0]: solution, Diff(Diff(phi[0])): sp.diff(solution, x, x) }
     >>> sp.expand(mu0.subs(solutionSubstitution))  # inserting solution should solve the mu_0=0 equation
     0
     """
-    return (1 + sp.tanh(x / (2 * interfaceWidth))) / 2
+    return (1 + sp.tanh(x / (2 * interface_width))) / 2
 
 
-def chemicalPotentialsFromFreeEnergy(freeEnergy, orderParameters=None):
+def chemical_potentials_from_free_energy(free_energy, order_parameters=None):
     """Computes chemical potentials as functional derivative of free energy"""
-    syms = freeEnergy.atoms(sp.Symbol)
-    if orderParameters is None:
-        orderParameters = [s for s in syms if s.name.startswith(orderParameterSymbolName)]
-        orderParameters.sort(key=lambda e: e.name)
-        orderParameters = orderParameters[:-1]
-    constants = [s for s in syms if s not in orderParameters]
-    return sp.Matrix([expandUsingLinearity(functionalDerivative(freeEnergy, op),constants=constants)
-                      for op in orderParameters])
+    symbols = free_energy.atoms(sp.Symbol)
+    if order_parameters is None:
+        order_parameters = [s for s in symbols if s.name.startswith(orderParameterSymbolName)]
+        order_parameters.sort(key=lambda e: e.name)
+        order_parameters = order_parameters[:-1]
+    constants = [s for s in symbols if s not in order_parameters]
+    return sp.Matrix([expand_using_linearity(functional_derivative(free_energy, op), constants=constants)
+                      for op in order_parameters])
 
 
-def forceFromPhiAndMu(orderParameters, dim, mu=None):
+def force_from_phi_and_mu(order_parameters, dim, mu=None):
     if mu is None:
-        mu = sp.symbols("mu_:%d" % (len(orderParameters),))
+        mu = sp.symbols("mu_:%d" % (len(order_parameters),))
 
-    return sp.Matrix([sum(- c_i * Diff(mu_i, a) for c_i, mu_i in zip(orderParameters, mu))
+    return sp.Matrix([sum(- c_i * Diff(mu_i, a) for c_i, mu_i in zip(order_parameters, mu))
                       for a in range(dim)])
 
 
-def substituteLaplacianBySum(eq, dim):
-    """Substitutes abstract laplacian represented by ∂∂ by a sum over all dimensions
+def substitute_laplacian_by_sum(eq, dim):
+    """Substitutes abstract Laplacian represented by ∂∂ by a sum over all dimensions
     i.e. in case of 3D: ∂∂ is replaced by ∂0∂0 + ∂1∂1 + ∂2∂2
     :param eq: the term where the substitutions should be made
     :param dim: spatial dimension, in example above, 3
@@ -216,68 +217,68 @@ def substituteLaplacianBySum(eq, dim):
     functions = [d.args[0] for d in eq.atoms(Diff)]
     substitutions = {Diff(Diff(op)): sum(Diff(Diff(op, i), i) for i in range(dim))
                      for op in functions}
-    return fullDiffExpand(eq.subs(substitutions))
+    return full_diff_expand(eq.subs(substitutions))
 
 
-def coshIntegral(f, var):
+def cosh_integral(f, var):
     """Integrates a function f that has exactly one cosh term, from -oo to oo, by
     substituting a new helper variable for the cosh argument"""
-    coshTerm = list(f.atoms(sp.cosh))
-    assert len(coshTerm) == 1
+    cosh_term = list(f.atoms(sp.cosh))
+    assert len(cosh_term) == 1
     integral = sp.Integral(f, var)
-    transformedInt = integral.transform(coshTerm[0].args[0], sp.Symbol("u", real=True))
-    return sp.integrate(transformedInt.args[0], (transformedInt.args[1][0], -sp.oo, sp.oo))
+    transformed_int = integral.transform(cosh_term[0].args[0], sp.Symbol("u", real=True))
+    return sp.integrate(transformed_int.args[0], (transformed_int.args[1][0], -sp.oo, sp.oo))
 
 
-def symmetricTensorLinearization(dim):
-    nextIdx = 0
-    resultMap = {}
-    for idx in multiSum(2, dim):
+def symmetric_tensor_linearization(dim):
+    next_idx = 0
+    result_map = {}
+    for idx in multi_sum(2, dim):
         idx = tuple(sorted(idx))
-        if idx in resultMap:
+        if idx in result_map:
             continue
         else:
-            resultMap[idx] = nextIdx
-            nextIdx += 1
-    return resultMap
+            result_map[idx] = next_idx
+            next_idx += 1
+    return result_map
 
 # ----------------------------------------- Pressure Tensor ------------------------------------------------------------
 
 
-def extractGamma(freeEnergy, orderParameters):
+def extract_gamma(free_energy, order_parameters):
     """Extracts parameters before the gradient terms"""
     result = defaultdict(lambda: 0)
-    freeEnergy = freeEnergy.expand()
-    assert freeEnergy.func == sp.Add
-    for product in freeEnergy.args:
+    free_energy = free_energy.expand()
+    assert free_energy.func == sp.Add
+    for product in free_energy.args:
         product = normalize_product(product)
-        diffFactors = [e for e in product if e.func == Diff]
-        if len(diffFactors) == 0:
+        diff_factors = [e for e in product if e.func == Diff]
+        if len(diff_factors) == 0:
             continue
 
-        if len(diffFactors) != 2:
+        if len(diff_factors) != 2:
             raise ValueError("Could not new_filtered Λ because of term " + str(product))
 
-        indices = sorted([orderParameters.index(d.args[0]) for d in diffFactors])
+        indices = sorted([order_parameters.index(d.args[0]) for d in diff_factors])
         result[tuple(indices)] += prod(e for e in product if e.func != Diff)
-        if diffFactors[0] == diffFactors[1]:
+        if diff_factors[0] == diff_factors[1]:
             result[tuple(indices)] *= 2
     return result
 
 
-def pressureTensorBulkComponent(freeEnergy, orderParameters):
+def pressure_tensor_bulk_component(free_energy, order_parameters):
     """Diagonal component of pressure tensor in bulk"""
-    bulkFreeEnergy, _ = separateIntoBulkAndInterface(freeEnergy)
-    muBulk = chemicalPotentialsFromFreeEnergy(bulkFreeEnergy, orderParameters)
-    return sum(c_i * mu_i for c_i, mu_i in zip(orderParameters, muBulk)) - bulkFreeEnergy
+    bulk_free_energy, _ = separate_into_bulk_and_interface(free_energy)
+    mu_bulk = chemical_potentials_from_free_energy(bulk_free_energy, order_parameters)
+    return sum(c_i * mu_i for c_i, mu_i in zip(order_parameters, mu_bulk)) - bulk_free_energy
 
 
-def pressureTensorInterfaceComponent(freeEnergy, orderParameters, dim, a, b):
-    gamma = extractGamma(freeEnergy, orderParameters)
+def pressure_tensor_interface_component(free_energy, order_parameters, dim, a, b):
+    gamma = extract_gamma(free_energy, order_parameters)
     d = Diff
     result = 0
-    for i, c_i in enumerate(orderParameters):
-        for j, c_j in enumerate(orderParameters):
+    for i, c_i in enumerate(order_parameters):
+        for j, c_j in enumerate(order_parameters):
             t = d(c_i, a) * d(c_j, b) + d(c_i, b) * d(c_j, a)
             if a == b:
                 t -= sum(d(c_i, g) * d(c_j, g) for g in range(dim))
@@ -288,22 +289,22 @@ def pressureTensorInterfaceComponent(freeEnergy, orderParameters, dim, a, b):
     return result
 
 
-def pressureTensorFromFreeEnergy(freeEnergy, orderParameters, dim):
-    def getEntry(i, j):
-        pIf = pressureTensorInterfaceComponent(freeEnergy, orderParameters, dim, i, j)
-        pB = pressureTensorBulkComponent(freeEnergy, orderParameters) if i == j else 0
-        return sp.expand(pIf + pB)
+def pressure_tensor_from_free_energy(free_energy, order_parameters, dim):
+    def get_entry(i, j):
+        p_if = pressure_tensor_interface_component(free_energy, order_parameters, dim, i, j)
+        p_b = pressure_tensor_bulk_component(free_energy, order_parameters) if i == j else 0
+        return sp.expand(p_if + p_b)
 
-    return sp.Matrix(dim, dim, getEntry)
+    return sp.Matrix(dim, dim, get_entry)
 
 
-def forceFromPressureTensor(pressureTensor, functions=None):
-    assert len(pressureTensor.shape) == 2 and pressureTensor.shape[0] == pressureTensor.shape[1]
-    dim = pressureTensor.shape[0]
+def force_from_pressure_tensor(pressure_tensor, functions=None):
+    assert len(pressure_tensor.shape) == 2 and pressure_tensor.shape[0] == pressure_tensor.shape[1]
+    dim = pressure_tensor.shape[0]
 
-    def forceComponent(b):
-        r = -sum(Diff(pressureTensor[a, b], a) for a in range(dim))
-        r = fullDiffExpand(r, functions=functions)
+    def force_component(b):
+        r = -sum(Diff(pressure_tensor[a, b], a) for a in range(dim))
+        r = full_diff_expand(r, functions=functions)
         return r
 
-    return sp.Matrix([forceComponent(b) for b in range(dim)])
\ No newline at end of file
+    return sp.Matrix([force_component(b) for b in range(dim)])
diff --git a/phasefield/cahn_hilliard_lbm.py b/phasefield/cahn_hilliard_lbm.py
index 1d038c64a108115876ac2d3f7b248cb1ef57151e..6039420136e5bbb2966cd0da1916cc1f053b2418 100644
--- a/phasefield/cahn_hilliard_lbm.py
+++ b/phasefield/cahn_hilliard_lbm.py
@@ -1,25 +1,26 @@
 import sympy as sp
-from lbmpy.methods.creationfunctions import createFromEquilibrium
-from lbmpy.stencils import getStencil
+from lbmpy.methods.creationfunctions import create_from_equilibrium
+from lbmpy.stencils import get_stencil
 from pystencils.sympyextensions import kronecker_delta, multidimensional_sum
-from lbmpy.maxwellian_equilibrium import getWeights
+from lbmpy.maxwellian_equilibrium import get_weights
 
 
-def cahnHilliardLbmMethod(stencil, mu, relaxationRate=sp.Symbol("omega"), gamma=1):
-    """Returns LB equilibrium that solves the Cahn Hilliard equation
+def cahn_hilliard_lb_method(stencil, mu, relaxation_rate=sp.Symbol("omega"), gamma=1):
+    """Returns LB equilibrium that solves the Cahn Hilliard equation.
 
     ..math ::
 
         \partial_t \phi + \partial_i ( \phi v_i ) = M \nabla^2 \mu
-    
-    :param stencil: tuple of discrete directions
-    :param mu: symbolic expression (field access) for the chemical potential
-    :param relaxationRate: relaxation rate of method
-    :param gamma: tunable parameter affecting the second order equilibrium moment
+
+    Args:
+        stencil: tuple of discrete directions
+        mu: symbolic expression (field access) for the chemical potential
+        relaxation_rate: relaxation rate of method
+        gamma: tunable parameter affecting the second order equilibrium moment
     """
     if isinstance(stencil, str):
-        stencil = getStencil(stencil)
-    weights = getWeights(stencil, c_s_sq=sp.Rational(1, 3))
+        stencil = get_stencil(stencil)
+    weights = get_weights(stencil, c_s_sq=sp.Rational(1, 3))
 
     kd = kronecker_delta
 
@@ -40,5 +41,5 @@ def cahnHilliardLbmMethod(stencil, mu, relaxationRate=sp.Symbol("omega"), gamma=
 
     rho = sp.Symbol("rho")
     equilibrium[0] = rho - sp.expand(sum(equilibrium[1:]))
-    return createFromEquilibrium(stencil, tuple(equilibrium), relaxationRate, compressible=True)
+    return create_from_equilibrium(stencil, tuple(equilibrium), relaxation_rate, compressible=True)
 
diff --git a/phasefield/experiments1D.py b/phasefield/experiments1D.py
index fa46de2e53b7a2e4149783ad47fe2cf291195248..11b2489ebdefdabd38d18782139c03ab592bc28b 100644
--- a/phasefield/experiments1D.py
+++ b/phasefield/experiments1D.py
@@ -5,103 +5,108 @@ from lbmpy.chapman_enskog import Diff
 from pystencils import makeSlice
 
 
-def plotStatus(phaseFieldStep, fromX=None, toX=None):
+def plot_status(phase_field_step, from_x=None, to_x=None):
     import lbmpy.plot2d as plt
 
-    domainSize = phaseFieldStep.dataHandling.shape
-    assert len(domainSize) == 2 and domainSize[1] == 1, "Not a 1D scenario"
+    domain_size = phase_field_step.data_handling.shape
+    assert len(domain_size) == 2 and domain_size[1] == 1, "Not a 1D scenario"
 
-    dh = phaseFieldStep.dataHandling
+    dh = phase_field_step.data_handling
 
-    numPhases = phaseFieldStep.numOrderParameters
+    num_phases = phase_field_step.numOrderParameters
 
     plt.subplot(1, 3, 1)
     plt.title('φ')
-    phiName = phaseFieldStep.phiFieldName
-    for i in range(numPhases):
-        plt.plot(dh.gatherArray(phiName, makeSlice[fromX:toX, 0, i]), marker='x', label='φ_%d' % (i,))
+    phi_name = phase_field_step.phiFieldName
+    for i in range(num_phases):
+        plt.plot(dh.gather_array(phi_name, makeSlice[from_x:to_x, 0, i]), marker='x', label='φ_%d' % (i,))
     plt.legend()
 
     plt.subplot(1, 3, 2)
     plt.title("μ")
-    muName = phaseFieldStep.muFieldName
-    for i in range(numPhases):
-        plt.plot(dh.gatherArray(muName, makeSlice[fromX:toX, 0, i]), marker='x', label='μ_%d' % (i,));
+    mu_name = phase_field_step.muFieldName
+    for i in range(num_phases):
+        plt.plot(dh.gather_array(mu_name, makeSlice[from_x:to_x, 0, i]), marker='x', label='μ_%d' % (i,))
     plt.legend()
 
     plt.subplot(1, 3, 3)
     plt.title("Force and Velocity")
-    plt.plot(dh.gatherArray(phaseFieldStep.forceFieldName, makeSlice[fromX:toX, 0, 0]), label='F', marker='x')
-    plt.plot(dh.gatherArray(phaseFieldStep.velFieldName, makeSlice[fromX:toX, 0, 0]), label='u', marker='v')
+    plt.plot(dh.gather_array(phase_field_step.forceFieldName, makeSlice[from_x:to_x, 0, 0]), label='F', marker='x')
+    plt.plot(dh.gather_array(phase_field_step.velFieldName, makeSlice[from_x:to_x, 0, 0]), label='u', marker='v')
     plt.legend()
 
 
-def plotFreeEnergyBulkContours(freeEnergy, orderParameters, phase0=0, phase1=1,
-                               xRange=(-0.2, 1.2), yRange=(-0.2, 1.2), **kwargs):
+def plot_free_energy_bulk_contours(free_energy, order_parameters, phase0=0, phase1=1,
+                                   x_range=(-0.2, 1.2), y_range=(-0.2, 1.2), **kwargs):
     import lbmpy.plot2d as plt
 
-    x = np.linspace(xRange[0], xRange[1], 100)
-    y = np.linspace(yRange[0], yRange[1], 100)
+    x = np.linspace(x_range[0], x_range[1], 100)
+    y = np.linspace(y_range[0], y_range[1], 100)
     xg, yg = np.meshgrid(x, y)
-    substitutions = {op: 0 for i, op in enumerate(orderParameters) if i not in (phase0, phase1)}
-    substitutions.update({d: 0 for d in freeEnergy.atoms(Diff)})  # remove interface components of free energy
-    freeEnergyLambda = sp.lambdify([orderParameters[phase0], orderParameters[phase1]],
-                                   freeEnergy.subs(substitutions))
+    substitutions = {op: 0 for i, op in enumerate(order_parameters) if i not in (phase0, phase1)}
+    substitutions.update({d: 0 for d in free_energy.atoms(Diff)})  # remove interface components of free energy
+    free_energy_lambda = sp.lambdify([order_parameters[phase0], order_parameters[phase1]],
+                                     free_energy.subs(substitutions))
     if 'levels' not in kwargs:
         kwargs['levels'] = np.linspace(0, 1, 60)
-    plt.contour(x, y, freeEnergyLambda(xg, yg), **kwargs)
+    plt.contour(x, y, free_energy_lambda(xg, yg), **kwargs)
 
 
-def initSharpInterface(pfStep, phaseIdx, x1=None, x2=None, inverse=False):
-    domainSize = pfStep.dataHandling.shape
+def init_sharp_interface(pf_step, phase_idx, x1=None, x2=None, inverse=False):
+    domain_size = pf_step.data_handling.shape
     if x1 is None:
-        x1 = domainSize[0] // 4
+        x1 = domain_size[0] // 4
     if x2 is None:
         x2 = 3 * x1
 
-    if phaseIdx >= pfStep.numOrderParameters:
+    if phase_idx >= pf_step.numOrderParameters:
         return
 
-    for b in pfStep.dataHandling.iterate():
-        x = b.cellIndexArrays[0]
+    for b in pf_step.data_handling.iterate():
+        x = b.cell_index_arrays[0]
         mid = np.logical_and(x1 < x, x < x2)
 
-        phi = b[pfStep.phiFieldName]
+        phi = b[pf_step.phiFieldName]
         val1, val2 = (1, 0) if inverse else (0, 1)
 
-        phi[..., phaseIdx].fill(val1)
-        phi[mid, phaseIdx] = val2
+        phi[..., phase_idx].fill(val1)
+        phi[mid, phase_idx] = val2
 
-    pfStep.setPdfFieldsFromMacroscopicValues()
+    pf_step.set_pdf_fields_from_macroscopic_values()
 
 
-def tanhTest(pfStep, phase0, phase1, expectedInterfaceWidth=1, timeSteps=10000):
+def tanh_test(pf_step, phase0, phase1, expected_interface_width=1, time_steps=10000):
     """
     Initializes a sharp interface and checks if tanh-shaped profile is developing
-    :param pfStep: phase field scenario / step
-    :param phase0: index of first phase to initialize
-    :param phase1: index of second phase to initialize inversely
-    :param expectedInterfaceWidth: interface width parameter alpha that is used in analytical form
-    :param timeSteps: number of time steps run before evaluation
-    :return: deviation of simulated profile from analytical solution as average(abs(simulation-analytic))
+
+    Args:
+        pf_step: phase field scenario / step
+        phase0: index of first phase to initialize
+        phase1: index of second phase to initialize inversely
+        expected_interface_width: interface width parameter alpha that is used in analytical form
+        time_steps: number of time steps run before evaluation
+
+    Returns:
+        deviation of simulated profile from analytical solution as average(abs(simulation-analytic))
     """
     import lbmpy.plot2d as plt
-    from lbmpy.phasefield.analytical import analyticInterfaceProfile
-
-    domainSize = pfStep.dataHandling.shape
-    pfStep.reset()
-    pfStep.dataHandling.fill(pfStep.phiFieldName, 0)
-    initSharpInterface(pfStep, phaseIdx=phase0, inverse=False)
-    initSharpInterface(pfStep, phaseIdx=phase1, inverse=True)
-    pfStep.setPdfFieldsFromMacroscopicValues()
-    pfStep.run(timeSteps)
-
-    visWidth = 20
-    x = np.arange(visWidth) - (visWidth // 2)
-    analytic = np.array([analyticInterfaceProfile(x_i - 0.5, expectedInterfaceWidth) for x_i in x], dtype=np.float64)
-
-    stepLocation = domainSize[0] // 4
-    simulated = pfStep.phi[stepLocation - visWidth//2:stepLocation + visWidth//2, 0, phase0]
+    from lbmpy.phasefield.analytical import analytic_interface_profile
+
+    domain_size = pf_step.data_handling.shape
+    pf_step.reset()
+    pf_step.data_handling.fill(pf_step.phiFieldName, 0)
+    init_sharp_interface(pf_step, phase_idx=phase0, inverse=False)
+    init_sharp_interface(pf_step, phase_idx=phase1, inverse=True)
+    pf_step.set_pdf_fields_from_macroscopic_values()
+    pf_step.run(time_steps)
+
+    vis_width = 20
+    x = np.arange(vis_width) - (vis_width // 2)
+    analytic = np.array([analytic_interface_profile(x_i - 0.5, expected_interface_width) for x_i in x],
+                        dtype=np.float64)
+
+    step_location = domain_size[0] // 4
+    simulated = pf_step.phi[step_location - vis_width // 2:step_location + vis_width // 2, 0, phase0]
     plt.plot(analytic, label='analytic', marker='o')
     plt.plot(simulated, label='simulated', marker='x')
     plt.legend()
@@ -109,60 +114,64 @@ def tanhTest(pfStep, phase0, phase1, expectedInterfaceWidth=1, timeSteps=10000):
     return np.average(np.abs(simulated - analytic))
 
 
-def galileanInvarianceTest(pfStep, velocity=0.05, rounds=3, phase0=0, phase1=1,
-                           expectedInterfaceWidth=1, initTimeSteps=5000):
+def galilean_invariance_test(pf_step, velocity=0.05, rounds=3, phase0=0, phase1=1,
+                             expected_interface_width=1, init_time_steps=5000):
     """
     Moves interface at constant speed through periodic domain - check if momentum is conserved
-    :param pfStep: phase field scenario / step
-    :param velocity: constant velocity to move interface
-    :param rounds: how many times the interface should travel through the domain
-    :param phase0: index of first phase to initialize
-    :param phase1: index of second phase to initialize inversely
-    :param expectedInterfaceWidth: interface width parameter alpha that is used in analytical form
-    :param initTimeSteps: before velocity is set, this many time steps are run to let interface settle to tanh shape
-    :return: change in velocity
+
+    Args:
+        pf_step: phase field scenario / step
+        velocity: constant velocity to move interface
+        rounds: how many times the interface should travel through the domain
+        phase0: index of first phase to initialize
+        phase1: index of second phase to initialize inversely
+        expected_interface_width: interface width parameter alpha that is used in analytical form
+        init_time_steps: before velocity is set, this many time steps are run to let interface settle to tanh shape
+
+    Returns:
+        change in velocity
     """
     import lbmpy.plot2d as plt
-    from lbmpy.phasefield.analytical import analyticInterfaceProfile
+    from lbmpy.phasefield.analytical import analytic_interface_profile
 
-    domainSize = pfStep.dataHandling.shape
-    roundTimeSteps = int((domainSize[0]+0.25) / velocity)
+    domain_size = pf_step.data_handling.shape
+    round_time_steps = int((domain_size[0]+0.25) / velocity)
 
-    print("Velocity:", velocity, " Timesteps for round:", roundTimeSteps)
+    print("Velocity:", velocity, " Time steps for round:", round_time_steps)
 
-    pfStep.reset()
-    pfStep.dataHandling.fill(pfStep.phiFieldName, 0)
-    initSharpInterface(pfStep, phaseIdx=phase0, inverse=False)
-    initSharpInterface(pfStep, phaseIdx=phase1, inverse=True)
-    pfStep.setPdfFieldsFromMacroscopicValues()
+    pf_step.reset()
+    pf_step.data_handling.fill(pf_step.phiFieldName, 0)
+    init_sharp_interface(pf_step, phase_idx=phase0, inverse=False)
+    init_sharp_interface(pf_step, phase_idx=phase1, inverse=True)
+    pf_step.set_pdf_fields_from_macroscopic_values()
 
-    print("Running", initTimeSteps, "initial time steps")
-    pfStep.run(initTimeSteps)
-    pfStep.dataHandling.fill(pfStep.velFieldName, velocity, fValue=0)
-    pfStep.setPdfFieldsFromMacroscopicValues()
+    print("Running", init_time_steps, "initial time steps")
+    pf_step.run(init_time_steps)
+    pf_step.data_handling.fill(pf_step.velFieldName, velocity, value_idx=0)
+    pf_step.set_pdf_fields_from_macroscopic_values()
 
-    stepLocation = domainSize[0] // 4
-    visWidth = 20
+    step_location = domain_size[0] // 4
+    vis_width = 20
 
-    simulatedProfiles = []
+    simulated_profiles = []
 
-    def captureProfile():
-        simulated = pfStep.phi[stepLocation - visWidth // 2:stepLocation + visWidth // 2, 0, phase0].copy()
-        simulatedProfiles.append(simulated)
+    def capture_profile():
+        simulated = pf_step.phi[step_location - vis_width // 2:step_location + vis_width // 2, 0, phase0].copy()
+        simulated_profiles.append(simulated)
 
-    captureProfile()
-    for rt in range(rounds ):
+    capture_profile()
+    for rt in range(rounds):
         print("Running round %d/%d" % (rt+1, rounds))
-        pfStep.run(roundTimeSteps)
-        captureProfile()
+        pf_step.run(round_time_steps)
+        capture_profile()
 
-    x = np.arange(visWidth) - (visWidth // 2)
-    analytic = np.array([analyticInterfaceProfile(x_i - 0.5, expectedInterfaceWidth) for x_i in x], dtype=np.float64)
+    x = np.arange(vis_width) - (vis_width // 2)
+    ref = np.array([analytic_interface_profile(x_i - 0.5, expected_interface_width) for x_i in x], dtype=np.float64)
 
-    plt.plot(x, analytic, label='analytic', marker='o')
-    for i, profile in enumerate(simulatedProfiles):
+    plt.plot(x, ref, label='analytic', marker='o')
+    for i, profile in enumerate(simulated_profiles):
         plt.plot(x, profile, label="After %d rounds" % (i,))
 
     plt.legend()
 
-    return np.average(pfStep.velocity[:, 0, 0]) - velocity
+    return np.average(pf_step.velocity[:, 0, 0]) - velocity
diff --git a/phasefield/experiments2D.py b/phasefield/experiments2D.py
index 7b73c9f00cb43266e295a5459163c1f17e4b94e5..ef815dc5f8a4a514d2030a979a763c8ef3b6b3f1 100644
--- a/phasefield/experiments2D.py
+++ b/phasefield/experiments2D.py
@@ -1,26 +1,26 @@
 from lbmpy.boundaries import NoSlip
-from lbmpy.plot2d import phasePlot
+from lbmpy.plot2d import phase_plot
 from pystencils import makeSlice
 
 
-def dropsBetweenTwoPhase():
+def drops_between_two_phase():
     import lbmpy.plot2d as plt
     import sympy as sp
     from lbmpy.phasefield.phasefieldstep import PhaseFieldStep
-    from lbmpy.phasefield.analytical import freeEnergyFunctionalNPhasesPenaltyTerm
+    from lbmpy.phasefield.analytical import free_energy_functional_n_phases_penalty_term
     c = sp.symbols("c_:4")
-    F = freeEnergyFunctionalNPhasesPenaltyTerm(c, 1, [0.01, 0.02, 0.001, 0.02], 0.0001)
-    sc = PhaseFieldStep(F, c, domainSize=(2*200, 2*70), openMP=4, hydroDynamicRelaxationRate=1.9)
-    sc.setConcentration(makeSlice[:, 0.5:], [1, 0, 0, 0])
-    sc.setConcentration(makeSlice[:, :0.5], [0, 1, 0, 0])
-    sc.setConcentration(makeSlice[0.2:0.4, 0.3:0.7], [0, 0, 1, 0])
-    sc.setConcentration(makeSlice[0.7:0.8, 0.3:0.7], [0, 0, 0, 1])
-    sc.setPdfFieldsFromMacroscopicValues()
+    F = free_energy_functional_n_phases_penalty_term(c, 1, [0.01, 0.02, 0.001, 0.02], 0.0001)
+    sc = PhaseFieldStep(F, c, domain_size=(2 * 200, 2 * 70), openmp=4, hydro_dynamic_relaxation_rate=1.9)
+    sc.set_concentration(makeSlice[:, 0.5:], [1, 0, 0, 0])
+    sc.set_concentration(makeSlice[:, :0.5], [0, 1, 0, 0])
+    sc.set_concentration(makeSlice[0.2:0.4, 0.3:0.7], [0, 0, 1, 0])
+    sc.set_concentration(makeSlice[0.7:0.8, 0.3:0.7], [0, 0, 0, 1])
+    sc.set_pdf_fields_from_macroscopic_values()
 
     for i in range(500000):
         print("Step", i)
         plt.figure(figsize=(14, 7))
-        phasePlot(sc, makeSlice[:, 5:-5], linewidth=0.1)
+        phase_plot(sc, makeSlice[:, 5:-5], linewidth=0.1)
         plt.axis('off')
         plt.tight_layout()
         plt.savefig('step%03d.png' % (i,), bbox_inches='tight')
@@ -29,39 +29,35 @@ def dropsBetweenTwoPhase():
     plt.show()
 
 
-def fallingDrop():
+def falling_drop():
     import lbmpy.plot2d as plt
     import sympy as sp
     from lbmpy.phasefield.phasefieldstep import PhaseFieldStep
-    from lbmpy.phasefield.analytical import freeEnergyFunctionalNPhasesPenaltyTerm
+    from lbmpy.phasefield.analytical import free_energy_functional_n_phases_penalty_term
     c = sp.symbols("c_:3")
-    F = freeEnergyFunctionalNPhasesPenaltyTerm(c, 1, [0.001, 0.001, 0.0005])
+    F = free_energy_functional_n_phases_penalty_term(c, 1, [0.001, 0.001, 0.0005])
     gravity = -0.5e-5
-    sc = PhaseFieldStep(F, c, domainSize=(160, 200), openMP=4,
-                        hydroDynamicRelaxationRate=1.9,
-                        orderParameterForce={2: (0, gravity), 1: (0, 0)})
-    sc.setConcentration(makeSlice[:, 0.4:], [1, 0, 0])
-    sc.setConcentration(makeSlice[:, :0.4], [0, 1, 0])
-    sc.setConcentration(makeSlice[0.45:0.55, 0.8:0.9], [0, 0, 1])
-    sc.hydroLbmStep.boundaryHandling.setBoundary(NoSlip(), makeSlice[:, 0])
-    #sc.hydroLbmStep.boundaryHandling.setBoundary(NoSlip(), makeSlice[:, -1])
-
-    sc.setPdfFieldsFromMacroscopicValues()
+    sc = PhaseFieldStep(F, c, domain_size=(160, 200), openmp=4,
+                        hydro_dynamic_relaxation_rate=1.9,
+                        order_parameter_force={2: (0, gravity), 1: (0, 0)})
+    sc.set_concentration(makeSlice[:, 0.4:], [1, 0, 0])
+    sc.set_concentration(makeSlice[:, :0.4], [0, 1, 0])
+    sc.set_concentration(makeSlice[0.45:0.55, 0.8:0.9], [0, 0, 1])
+    sc.hydroLbmStep.boundary_handling.set_boundary(NoSlip(), makeSlice[:, 0])
+    #sc.hydroLbmStep.boundary_handling.set_boundary(NoSlip(), makeSlice[:, -1])
+
+    sc.set_pdf_fields_from_macroscopic_values()
     for i in range(650):
         print("Step", i)
         plt.figure(figsize=(14, 10))
         plt.subplot(1, 2, 1)
-        phasePlot(sc, makeSlice[:, 5:-15], linewidth=0.1)
+        phase_plot(sc, makeSlice[:, 5:-15], linewidth=0.1)
         plt.axis('off')
         plt.subplot(1, 2, 2)
-        plt.vectorField(sc.velocity[:, 5:-15, :])
+        plt.vector_field(sc.velocity[:, 5:-15, :])
         plt.axis('off')
         plt.tight_layout()
         plt.savefig('fallingDrop_boundary2_%05d.png' % (i,), bbox_inches='tight')
         plt.clf()
         sc.run(200)
     plt.show()
-
-
-if __name__ == '__main__':
-    fallingDrop()
diff --git a/phasefield/kerneleqs.py b/phasefield/kerneleqs.py
index 7b7184d30a5e22f1fb8866a36a915e5bb9bf97fc..415131672fe5bdaae4473cf651685f5361bc46c0 100644
--- a/phasefield/kerneleqs.py
+++ b/phasefield/kerneleqs.py
@@ -1,103 +1,103 @@
 import sympy as sp
 from pystencils import Assignment
 from pystencils.finitedifferences import Discretization2ndOrder
-from lbmpy.phasefield.analytical import chemicalPotentialsFromFreeEnergy, substituteLaplacianBySum, \
-    forceFromPhiAndMu, symmetricTensorLinearization, pressureTensorFromFreeEnergy, forceFromPressureTensor
+from lbmpy.phasefield.analytical import chemical_potentials_from_free_energy, substitute_laplacian_by_sum, \
+    force_from_phi_and_mu, symmetric_tensor_linearization, pressure_tensor_from_free_energy, force_from_pressure_tensor
 
 
 # ---------------------------------- Kernels to compute force ----------------------------------------------------------
 
 
-def muKernel(freeEnergy, orderParameters, phiField, muField, dx=1):
+def mu_kernel(free_energy, order_parameters, phi_field, mu_field, dx=1):
     """Reads from order parameter (phi) field and updates chemical potentials"""
-    assert phiField.spatialDimensions == muField.spatialDimensions
-    dim = phiField.spatialDimensions
-    chemicalPotential = chemicalPotentialsFromFreeEnergy(freeEnergy, orderParameters)
-    chemicalPotential = substituteLaplacianBySum(chemicalPotential, dim)
-    chemicalPotential = chemicalPotential.subs({op: phiField(i) for i, op in enumerate(orderParameters)})
+    assert phi_field.spatial_dimensions == mu_field.spatial_dimensions
+    dim = phi_field.spatial_dimensions
+    chemical_potential = chemical_potentials_from_free_energy(free_energy, order_parameters)
+    chemical_potential = substitute_laplacian_by_sum(chemical_potential, dim)
+    chemical_potential = chemical_potential.subs({op: phi_field(i) for i, op in enumerate(order_parameters)})
     discretize = Discretization2ndOrder(dx=dx)
-    return [Assignment(muField(i), discretize(mu_i)) for i, mu_i in enumerate(chemicalPotential)]
+    return [Assignment(mu_field(i), discretize(mu_i)) for i, mu_i in enumerate(chemical_potential)]
 
 
-def forceKernelUsingMu(forceField, phiField, muField, dx=1):
-    """Computes forces using precomputed chemical potential - needs muKernel first"""
-    assert muField.indexDimensions == 1
-    force = forceFromPhiAndMu(phiField.vecCenter, mu=muField.vecCenter, dim=muField.spatialDimensions)
+def force_kernel_using_mu(force_field, phi_field, mu_field, dx=1):
+    """Computes forces using precomputed chemical potential - needs mu_kernel first"""
+    assert mu_field.index_dimensions == 1
+    force = force_from_phi_and_mu(phi_field.center_vector, mu=mu_field.center_vector, dim=mu_field.spatial_dimensions)
     discretize = Discretization2ndOrder(dx=dx)
-    return [Assignment(forceField(i),
-                  discretize(f_i)).expand() for i, f_i in enumerate(force)]
+    return [Assignment(force_field(i),
+                       discretize(f_i)).expand() for i, f_i in enumerate(force)]
 
 
-def pressureTensorKernel(freeEnergy, orderParameters, phiField, pressureTensorField, dx=1):
-    dim = phiField.spatialDimensions
-    p = pressureTensorFromFreeEnergy(freeEnergy, orderParameters, dim)
-    p = p.subs({op: phiField(i) for i, op in enumerate(orderParameters)})
-    indexMap = symmetricTensorLinearization(dim)
+def pressure_tensor_kernel(free_energy, order_parameters, phi_field, pressure_tensor_field, dx=1):
+    dim = phi_field.spatial_dimensions
+    p = pressure_tensor_from_free_energy(free_energy, order_parameters, dim)
+    p = p.subs({op: phi_field(i) for i, op in enumerate(order_parameters)})
+    index_map = symmetric_tensor_linearization(dim)
     discretize = Discretization2ndOrder(dx=dx)
     eqs = []
-    for index, linIndex in indexMap.items():
-        eq = Assignment(pressureTensorField(linIndex), discretize(p[index]).expand())
+    for index, linIndex in index_map.items():
+        eq = Assignment(pressure_tensor_field(linIndex), discretize(p[index]).expand())
         eqs.append(eq)
     return eqs
 
 
-def forceKernelUsingPressureTensor(forceField, pressureTensorField, extraForce=None, dx=1):
-    dim = forceField.spatialDimensions
-    indexMap = symmetricTensorLinearization(dim)
+def force_kernel_using_pressure_tensor(force_field, pressure_tensor_field, extra_force=None, dx=1):
+    dim = force_field.spatial_dimensions
+    index_map = symmetric_tensor_linearization(dim)
 
-    p = sp.Matrix(dim, dim, lambda i, j: pressureTensorField(indexMap[i, j] if i < j else indexMap[j, i]))
-    f = forceFromPressureTensor(p)
-    if extraForce:
-        f += extraForce
+    p = sp.Matrix(dim, dim, lambda i, j: pressure_tensor_field(index_map[i, j] if i < j else index_map[j, i]))
+    f = force_from_pressure_tensor(p)
+    if extra_force:
+        f += extra_force
     discretize = Discretization2ndOrder(dx=dx)
-    return [Assignment(forceField(i), discretize(f_i).expand())
+    return [Assignment(force_field(i), discretize(f_i).expand())
             for i, f_i in enumerate(f)]
 
 
 # ---------------------------------- Cahn Hilliard with finite differences ---------------------------------------------
 
 
-def cahnHilliardFdEq(phaseIdx, phi, mu, velocity, mobility, dx, dt):
+def cahn_hilliard_fd_eq(phase_idx, phi, mu, velocity, mobility, dx, dt):
     from pystencils.finitedifferences import transient, advection, diffusion
-    cahnHilliard = transient(phi, phaseIdx) + advection(phi, velocity, phaseIdx) - diffusion(mu, mobility, phaseIdx)
-    return Discretization2ndOrder(dx, dt)(cahnHilliard)
+    cahn_hilliard = transient(phi, phase_idx) + advection(phi, velocity, phase_idx) - diffusion(mu, mobility, phase_idx)
+    return Discretization2ndOrder(dx, dt)(cahn_hilliard)
 
 
 class CahnHilliardFDStep:
-    def __init__(self, dataHandling, phiFieldName, muFieldName, velocityFieldName, name='ch_fd', target='cpu',
-                 dx=1, dt=1, mobilities=1, equationModifier=lambda eqs: eqs):
-        from pystencils import createKernel
-        self.dataHandling = dataHandling
+    def __init__(self, data_handling, phi_field_name, mu_field_name, velocity_field_name, name='ch_fd', target='cpu',
+                 dx=1, dt=1, mobilities=1, equation_modifier=lambda eqs: eqs):
+        from pystencils import create_kernel
+        self.dataHandling = data_handling
 
-        muField = self.dataHandling.fields[muFieldName]
-        velField = self.dataHandling.fields[velocityFieldName]
-        self.phiField = self.dataHandling.fields[phiFieldName]
-        self.tmpField = self.dataHandling.addArrayLike(name + '_tmp', phiFieldName, latexName='tmp')
+        mu_field = self.dataHandling.fields[mu_field_name]
+        vel_field = self.dataHandling.fields[velocity_field_name]
+        self.phi_field = self.dataHandling.fields[phi_field_name]
+        self.tmp_field = self.dataHandling.add_array_like(name + '_tmp', phi_field_name, latex_name='tmp')
 
-        numPhases = self.dataHandling.fSize(phiFieldName)
+        num_phases = self.dataHandling.values_per_cell(phi_field_name)
         if not hasattr(mobilities, '__len__'):
-            mobilities = [mobilities] * numPhases
-
-        updateEqs = []
-        for i in range(numPhases):
-            rhs = cahnHilliardFdEq(i, self.phiField, muField, velField, mobilities[i], dx, dt)
-            updateEqs.append(Assignment(self.tmpField(i), rhs))
-        self.updateEqs = updateEqs
-        self.updateEqs = equationModifier(updateEqs)
-        self.kernel = createKernel(self.updateEqs, target=target).compile()
-        self.sync = self.dataHandling.synchronizationFunction([phiFieldName, velocityFieldName, muFieldName],
-                                                              target=target)
-
-    def timeStep(self, **kwargs):
+            mobilities = [mobilities] * num_phases
+
+        update_eqs = []
+        for i in range(num_phases):
+            rhs = cahn_hilliard_fd_eq(i, self.phi_field, mu_field, vel_field, mobilities[i], dx, dt)
+            update_eqs.append(Assignment(self.tmp_field(i), rhs))
+        self.update_eqs = update_eqs
+        self.update_eqs = equation_modifier(update_eqs)
+        self.kernel = create_kernel(self.update_eqs, target=target).compile()
+        self.sync = self.dataHandling.synchronization_function([phi_field_name, velocity_field_name, mu_field_name],
+                                                               target=target)
+
+    def time_step(self, **kwargs):
         self.sync()
-        self.dataHandling.runKernel(self.kernel, **kwargs)
-        self.dataHandling.swap(self.phiField.name, self.tmpField.name)
+        self.dataHandling.run_kernel(self.kernel, **kwargs)
+        self.dataHandling.swap(self.phi_field.name, self.tmp_field.name)
 
-    def setPdfFieldsFromMacroscopicValues(self):
+    def set_pdf_fields_from_macroscopic_values(self):
         pass
 
-    def preRun(self):
+    def pre_run(self):
         pass
 
-    def postRun(self):
+    def post_run(self):
         pass
diff --git a/phasefield/phasefieldstep.py b/phasefield/phasefieldstep.py
index ae2aeb9782fa55b66af3f032367a59cfa292f280..7cfa190197e6a68498758c1cf4746db2312d1f81 100644
--- a/phasefield/phasefieldstep.py
+++ b/phasefield/phasefieldstep.py
@@ -2,13 +2,13 @@ import sympy as sp
 import numpy as np
 
 from lbmpy.lbstep import LatticeBoltzmannStep
-from lbmpy.phasefield.cahn_hilliard_lbm import cahnHilliardLbmMethod
-from lbmpy.phasefield.kerneleqs import muKernel, CahnHilliardFDStep, pressureTensorKernel, \
-    forceKernelUsingPressureTensor
-from pystencils import createKernel
-from lbmpy.phasefield.analytical import chemicalPotentialsFromFreeEnergy, symmetricTensorLinearization
+from lbmpy.phasefield.cahn_hilliard_lbm import cahn_hilliard_lb_method
+from lbmpy.phasefield.kerneleqs import mu_kernel, CahnHilliardFDStep, pressure_tensor_kernel, \
+    force_kernel_using_pressure_tensor
+from pystencils import create_kernel
+from lbmpy.phasefield.analytical import chemical_potentials_from_free_energy, symmetric_tensor_linearization
 from pystencils.boundaries.boundaryhandling import FlagInterface
-from pystencils.boundaries.inkernel import addNeumannBoundary
+from pystencils.boundaries.inkernel import add_neumann_boundary
 from pystencils.datahandling import SerialDataHandling
 from pystencils.assignment_collection.simplifications import sympy_cse_on_assignment_list
 from pystencils.slicing import makeSlice, SlicedGetter
@@ -16,267 +16,272 @@ from pystencils.slicing import makeSlice, SlicedGetter
 
 class PhaseFieldStep:
 
-    def __init__(self, freeEnergy, orderParameters, domainSize=None, dataHandling=None,
-                 name='pf', hydroLbmParameters={},
-                 hydroDynamicRelaxationRate=1.0, cahnHilliardRelaxationRates=1.0, densityOrderParameter=None,
-                 optimizationParams=None, kernelParams={}, dx=1, dt=1, solveCahnHilliardWithFiniteDifferences=False,
-                 orderParameterForce=None, concentrationToOrderParameters=None, orderParametersToConcentrations=None,
-                 activateHomogenousNeumannBoundaries=False):
+    def __init__(self, free_energy, order_parameters, domain_size=None, data_handling=None,
+                 name='pf', hydro_lbm_parameters={},
+                 hydro_dynamic_relaxation_rate=1.0, cahn_hilliard_relaxation_rates=1.0, density_order_parameter=None,
+                 optimization=None, kernel_params={}, dx=1, dt=1, solve_cahn_hilliard_with_finite_differences=False,
+                 order_parameter_force=None, concentration_to_order_parameters=None,
+                 order_parameters_to_concentrations=None, homogeneous_neumann_boundaries=False):
 
-        if optimizationParams is None:
-            optimizationParams = {'openMP': False, 'target': 'cpu'}
-        openMP, target = optimizationParams['openMP'], optimizationParams['target']
+        if optimization is None:
+            optimization = {'openmp': False, 'target': 'cpu'}
+        openmp, target = optimization['openmp'], optimization['target']
 
-        if dataHandling is None:
-            dataHandling = SerialDataHandling(domainSize, periodicity=True)
+        if data_handling is None:
+            data_handling = SerialDataHandling(domain_size, periodicity=True)
 
-        self.freeEnergy = freeEnergy
-        self.concentrationToOrderParameter = concentrationToOrderParameters
-        self.orderParametersToConcentrations = orderParametersToConcentrations
+        self.freeEnergy = free_energy
+        self.concentrationToOrderParameter = concentration_to_order_parameters
+        self.orderParametersToConcentrations = order_parameters_to_concentrations
 
-        self.chemicalPotentials = chemicalPotentialsFromFreeEnergy(freeEnergy, orderParameters)
+        self.chemicalPotentials = chemical_potentials_from_free_energy(free_energy, order_parameters)
 
         # ------------------ Adding arrays ---------------------
         gpu = target == 'gpu'
         self.gpu = gpu
-        self.numOrderParameters = len(orderParameters)
-        pressureTensorSize = len(symmetricTensorLinearization(dataHandling.dim))
-
-        self.phiFieldName = name + "_phi"
-        self.muFieldName = name + "_mu"
-        self.velFieldName = name + "_u"
-        self.forceFieldName = name + "_F"
-        self.pressureTensorFieldName = name + "_P"
-        self.dataHandling = dataHandling
-        self.phiField = dataHandling.addArray(self.phiFieldName, fSize=len(orderParameters), gpu=gpu, latexName='φ')
-        self.muField = dataHandling.addArray(self.muFieldName, fSize=len(orderParameters), gpu=gpu, latexName="μ")
-        self.velField = dataHandling.addArray(self.velFieldName, fSize=dataHandling.dim, gpu=gpu, latexName="u")
-        self.forceField = dataHandling.addArray(self.forceFieldName, fSize=dataHandling.dim, gpu=gpu, latexName="F")
-        self.pressureTensorField = dataHandling.addArray(self.pressureTensorFieldName,
-                                                         fSize=pressureTensorSize, latexName='P')
-        self.flagInterface = FlagInterface(dataHandling, 'flags')
+        self.num_order_parameters = len(order_parameters)
+        pressure_tensor_size = len(symmetric_tensor_linearization(data_handling.dim))
+
+        self.phi_field_name = name + "_phi"
+        self.mu_field_name = name + "_mu"
+        self.vel_field_name = name + "_u"
+        self.force_field_name = name + "_F"
+        self.pressure_tensor_field_name = name + "_P"
+        self.data_handling = data_handling
+
+        dh = self.data_handling
+        phi_size = len(order_parameters)
+        self.phi_field = dh.add_array(self.phi_field_name, values_per_cell=phi_size, gpu=gpu, latex_name='φ')
+        self.mu_field = dh.add_array(self.mu_field_name, values_per_cell=phi_size, gpu=gpu, latex_name="μ")
+        self.vel_field = dh.add_array(self.vel_field_name, values_per_cell=data_handling.dim, gpu=gpu, latex_name="u")
+        self.force_field = dh.add_array(self.force_field_name, values_per_cell=dh.dim, gpu=gpu, latex_name="F")
+        self.pressure_tensor_field = data_handling.add_array(self.pressure_tensor_field_name,
+                                                             values_per_cell=pressure_tensor_size, latex_name='P')
+        self.flagInterface = FlagInterface(data_handling, 'flags')
 
         # ------------------ Creating kernels ------------------
-        phi = tuple(self.phiField(i) for i in range(len(orderParameters)))
-        F = self.freeEnergy.subs({old: new for old, new in zip(orderParameters, phi)})
+        phi = tuple(self.phi_field(i) for i in range(len(order_parameters)))
+        F = self.freeEnergy.subs({old: new for old, new in zip(order_parameters, phi)})
 
-        if activateHomogenousNeumannBoundaries:
-            def applyNeumannBoundaries(eqs):
-                fields = [dataHandling.fields[self.phiFieldName],
-                          dataHandling.fields[self.pressureTensorFieldName],
+        if homogeneous_neumann_boundaries:
+            def apply_neumann_boundaries(eqs):
+                fields = [data_handling.fields[self.phi_field_name],
+                          data_handling.fields[self.pressure_tensor_field_name],
                           ]
-                flagField = dataHandling.fields[self.flagInterface.flagFieldName]
-                return addNeumannBoundary(eqs, fields, flagField, "neumannFlag", inverseFlag=False)
+                flag_field = data_handling.fields[self.flagInterface.flag_field_name]
+                return add_neumann_boundary(eqs, fields, flag_field, "neumannFlag", inverse_flag=False)
         else:
-            def applyNeumannBoundaries(eqs):
+            def apply_neumann_boundaries(eqs):
                 return eqs
 
         # μ and pressure tensor update
-        self.phiSync = dataHandling.synchronizationFunction([self.phiFieldName], target=target)
-        self.muEqs = muKernel(F, phi, self.phiField, self.muField, dx)
-        self.pressureTensorEqs = pressureTensorKernel(self.freeEnergy, orderParameters,
-                                                      self.phiField, self.pressureTensorField, dx)
-        muAndPressureTensorEqs = self.muEqs + self.pressureTensorEqs
-        muAndPressureTensorEqs = applyNeumannBoundaries(muAndPressureTensorEqs)
-        self.muAndPressureTensorKernel = createKernel(sympy_cse_on_assignment_list(muAndPressureTensorEqs),
-                                                      target=target, cpuOpenMP=openMP).compile()
+        self.phiSync = data_handling.synchronization_function([self.phi_field_name], target=target)
+        self.muEqs = mu_kernel(F, phi, self.phi_field, self.mu_field, dx)
+        self.pressureTensorEqs = pressure_tensor_kernel(self.freeEnergy, order_parameters,
+                                                        self.phi_field, self.pressure_tensor_field, dx)
+        mu_and_pressure_tensor_eqs = self.muEqs + self.pressureTensorEqs
+        mu_and_pressure_tensor_eqs = apply_neumann_boundaries(mu_and_pressure_tensor_eqs)
+        self.muAndPressureTensorKernel = create_kernel(sympy_cse_on_assignment_list(mu_and_pressure_tensor_eqs),
+                                                       target=target, cpu_openmp=openmp).compile()
 
         # F Kernel
-        extraForce = sp.Matrix([0] * self.dataHandling.dim)
-        if orderParameterForce is not None:
-            for orderParameterIdx, force in orderParameterForce.items():
-                extraForce += self.phiField(orderParameterIdx) * sp.Matrix(force)
-        self.forceEqs = forceKernelUsingPressureTensor(self.forceField, self.pressureTensorField, dx=dx,
-                                                       extraForce=extraForce)
-        self.forceFromPressureTensorKernel = createKernel(applyNeumannBoundaries(self.forceEqs),
-                                                          target=target, cpuOpenMP=openMP).compile()
-        self.pressureTensorSync = dataHandling.synchronizationFunction([self.pressureTensorFieldName], target=target)
+        extra_force = sp.Matrix([0] * self.data_handling.dim)
+        if order_parameter_force is not None:
+            for orderParameterIdx, force in order_parameter_force.items():
+                extra_force += self.phi_field(orderParameterIdx) * sp.Matrix(force)
+        self.forceEqs = force_kernel_using_pressure_tensor(self.force_field, self.pressure_tensor_field, dx=dx,
+                                                           extra_force=extra_force)
+        self.forceFromPressureTensorKernel = create_kernel(apply_neumann_boundaries(self.forceEqs),
+                                                           target=target, cpu_openmp=openmp).compile()
+        self.pressureTensorSync = data_handling.synchronization_function([self.pressure_tensor_field_name],
+                                                                         target=target)
 
         # Hydrodynamic LBM
-        if densityOrderParameter is not None:
-            densityIdx = orderParameters.index(densityOrderParameter)
-            hydroLbmParameters['computeDensityInEveryStep'] = True
-            hydroLbmParameters['densityDataName'] = self.phiFieldName
-            hydroLbmParameters['densityDataIndex'] = densityIdx
-
-        if 'optimizationParams' not in hydroLbmParameters:
-            hydroLbmParameters['optimizationParams'] = optimizationParams
+        if density_order_parameter is not None:
+            density_idx = order_parameters.index(density_order_parameter)
+            hydro_lbm_parameters['compute_density_in_every_step'] = True
+            hydro_lbm_parameters['density_data_name'] = self.phi_field_name
+            hydro_lbm_parameters['density_data_index'] = density_idx
+
+        if 'optimization' not in hydro_lbm_parameters:
+            hydro_lbm_parameters['optimization'] = optimization
         else:
-            hydroLbmParameters['optimizationParams'].update(optimizationParams)
+            hydro_lbm_parameters['optimization'].update(optimization)
 
-        self.hydroLbmStep = LatticeBoltzmannStep(dataHandling=dataHandling, name=name + '_hydroLBM',
-                                                 relaxationRate=hydroDynamicRelaxationRate,
-                                                 computeVelocityInEveryStep=True, force=self.forceField,
-                                                 velocityDataName=self.velFieldName, kernelParams=kernelParams,
-                                                 flagInterface=self.flagInterface,
-                                                 timeStepOrder='collideStream',
-                                                 **hydroLbmParameters)
+        self.hydroLbmStep = LatticeBoltzmannStep(data_handling=data_handling, name=name + '_hydroLBM',
+                                                 relaxation_rate=hydro_dynamic_relaxation_rate,
+                                                 compute_velocity_in_every_step=True, force=self.force_field,
+                                                 velocity_data_name=self.vel_field_name, kernel_params=kernel_params,
+                                                 flag_interface=self.flagInterface,
+                                                 time_step_order='collideStream',
+                                                 **hydro_lbm_parameters)
 
         # Cahn-Hilliard LBMs
-        if not hasattr(cahnHilliardRelaxationRates, '__len__'):
-            cahnHilliardRelaxationRates = [cahnHilliardRelaxationRates] * len(orderParameters)
+        if not hasattr(cahn_hilliard_relaxation_rates, '__len__'):
+            cahn_hilliard_relaxation_rates = [cahn_hilliard_relaxation_rates] * len(order_parameters)
 
         self.cahnHilliardSteps = []
 
-        if solveCahnHilliardWithFiniteDifferences:
-            if densityOrderParameter is not None:
-                raise NotImplementedError("densityOrderParameter not supported when "
+        if solve_cahn_hilliard_with_finite_differences:
+            if density_order_parameter is not None:
+                raise NotImplementedError("density_order_parameter not supported when "
                                           "CH is solved with finite differences")
-            chStep = CahnHilliardFDStep(self.dataHandling, self.phiFieldName, self.muFieldName, self.velFieldName,
-                                        target=target, dx=dx, dt=dt, mobilities=1,
-                                        equationModifier=applyNeumannBoundaries)
-            self.cahnHilliardSteps.append(chStep)
+            ch_step = CahnHilliardFDStep(self.data_handling, self.phi_field_name, self.mu_field_name,
+                                         self.vel_field_name, target=target, dx=dx, dt=dt, mobilities=1,
+                                         equation_modifier=apply_neumann_boundaries)
+            self.cahnHilliardSteps.append(ch_step)
         else:
-            for i, op in enumerate(orderParameters):
-                if op == densityOrderParameter:
+            for i, op in enumerate(order_parameters):
+                if op == density_order_parameter:
                     continue
 
-                chMethod = cahnHilliardLbmMethod(self.hydroLbmStep.method.stencil, self.muField(i),
-                                                 relaxationRate=cahnHilliardRelaxationRates[i])
-                chStep = LatticeBoltzmannStep(dataHandling=dataHandling, relaxationRate=1, lbMethod=chMethod,
-                                              velocityInputArrayName=self.velField.name,
-                                              densityDataName=self.phiField.name,
-                                              stencil='D3Q19' if self.dataHandling.dim == 3 else 'D2Q9',
-                                              computeDensityInEveryStep=True,
-                                              densityDataIndex=i,
-                                              flagInterface=self.hydroLbmStep.boundaryHandling.flagInterface,
-                                              name=name + "_chLbm_%d" % (i,),
-                                              optimizationParams=optimizationParams)
-                self.cahnHilliardSteps.append(chStep)
-
-        self.vtkWriter = self.dataHandling.vtkWriter(name, [self.phiFieldName, self.muFieldName, self.velFieldName,
-                                                            self.forceFieldName])
-
-        self.runHydroLbm = True
-        self.densityOrderParameter = densityOrderParameter
-        self.timeStepsRun = 0
+                ch_method = cahn_hilliard_lb_method(self.hydroLbmStep.method.stencil, self.mu_field(i),
+                                                    relaxation_rate=cahn_hilliard_relaxation_rates[i])
+                ch_step = LatticeBoltzmannStep(data_handling=data_handling, relaxation_rate=1, lb_method=ch_method,
+                                               velocity_input_array_name=self.vel_field.name,
+                                               density_data_name=self.phi_field.name,
+                                               stencil='D3Q19' if self.data_handling.dim == 3 else 'D2Q9',
+                                               compute_density_in_every_step=True,
+                                               density_data_index=i,
+                                               flag_interface=self.hydroLbmStep.boundary_handling.flag_interface,
+                                               name=name + "_chLbm_%d" % (i,),
+                                               optimization=optimization)
+                self.cahnHilliardSteps.append(ch_step)
+
+        self.vtk_writer = self.data_handling.create_vtk_writer(name, [self.phi_field_name, self.mu_field_name,
+                                                                      self.vel_field_name, self.force_field_name])
+
+        self.run_hydro_lbm = True
+        self.density_order_parameter = density_order_parameter
+        self.time_steps_run = 0
         self.reset()
 
         self.neumannFlag = 0
 
-    def writeVTK(self):
-        self.vtkWriter(self.timeStepsRun)
+    def write_vtk(self):
+        self.vtk_writer(self.time_steps_run)
 
     def reset(self):
         # Init φ and μ
-        self.dataHandling.fill(self.phiFieldName, 0.0)
-        self.dataHandling.fill(self.phiFieldName, 1.0 if self.densityOrderParameter is not None else 0.0, fValue=0)
-        self.dataHandling.fill(self.muFieldName, 0.0)
-        self.dataHandling.fill(self.forceFieldName, 0.0)
-        self.dataHandling.fill(self.velFieldName, 0.0)
-        self.setPdfFieldsFromMacroscopicValues()
-
-        self.timeStepsRun = 0
-
-    def setPdfFieldsFromMacroscopicValues(self):
-        self.hydroLbmStep.setPdfFieldsFromMacroscopicValues()
+        self.data_handling.fill(self.phi_field_name, 0.0)
+        self.data_handling.fill(self.phi_field_name, 1.0 if self.density_order_parameter is not None else 0.0,
+                                value_idx=0)
+        self.data_handling.fill(self.mu_field_name, 0.0)
+        self.data_handling.fill(self.force_field_name, 0.0)
+        self.data_handling.fill(self.vel_field_name, 0.0)
+        self.set_pdf_fields_from_macroscopic_values()
+
+        self.time_steps_run = 0
+
+    def set_pdf_fields_from_macroscopic_values(self):
+        self.hydroLbmStep.set_pdf_fields_from_macroscopic_values()
         for chStep in self.cahnHilliardSteps:
-            chStep.setPdfFieldsFromMacroscopicValues()
+            chStep.set_pdf_fields_from_macroscopic_values()
 
-    def preRun(self):
+    def pre_run(self):
         if self.gpu:
-            self.dataHandling.toGpu(self.phiFieldName)
-            self.dataHandling.toGpu(self.muFieldName)
-            self.dataHandling.toGpu(self.forceFieldName)
-        self.hydroLbmStep.preRun()
+            self.data_handling.to_gpu(self.phi_field_name)
+            self.data_handling.to_gpu(self.mu_field_name)
+            self.data_handling.to_gpu(self.force_field_name)
+        self.hydroLbmStep.pre_run()
         for chStep in self.cahnHilliardSteps:
-            chStep.preRun()
+            chStep.pre_run()
 
-    def postRun(self):
+    def post_run(self):
         if self.gpu:
-            self.dataHandling.toCpu(self.phiFieldName)
-            self.dataHandling.toCpu(self.muFieldName)
-            self.dataHandling.toCpu(self.forceFieldName)
-        if self.runHydroLbm:
-            self.hydroLbmStep.postRun()
+            self.data_handling.to_cpu(self.phi_field_name)
+            self.data_handling.to_cpu(self.mu_field_name)
+            self.data_handling.to_cpu(self.force_field_name)
+        if self.run_hydro_lbm:
+            self.hydroLbmStep.post_run()
         for chStep in self.cahnHilliardSteps:
-            chStep.postRun()
+            chStep.post_run()
 
-    def timeStep(self):
+    def time_step(self):
         neumannFlag = self.neumannFlag
-        #for b in self.dataHandling.iterate(sliceObj=makeSlice[:, 0]):
-        #    b[self.phiFieldName][..., 0] = 0.0
-        #    b[self.phiFieldName][..., 1] = 1.0
-        #for b in self.dataHandling.iterate(sliceObj=makeSlice[0, :]):
-        #    b[self.phiFieldName][..., 0] = 1.0
-        #    b[self.phiFieldName][..., 1] = 0.0
+        #for b in self.data_handling.iterate(sliceObj=makeSlice[:, 0]):
+        #    b[self.phi_field_name][..., 0] = 0.0
+        #    b[self.phi_field_name][..., 1] = 1.0
+        #for b in self.data_handling.iterate(sliceObj=makeSlice[0, :]):
+        #    b[self.phi_field_name][..., 0] = 1.0
+        #    b[self.phi_field_name][..., 1] = 0.0
 
         self.phiSync()
-        self.dataHandling.runKernel(self.muAndPressureTensorKernel, neumannFlag=neumannFlag)
+        self.data_handling.run_kernel(self.muAndPressureTensorKernel, neumannFlag=neumannFlag)
         self.pressureTensorSync()
-        self.dataHandling.runKernel(self.forceFromPressureTensorKernel, neumannFlag=neumannFlag)
+        self.data_handling.run_kernel(self.forceFromPressureTensorKernel, neumannFlag=neumannFlag)
 
-        if self.runHydroLbm:
-            self.hydroLbmStep.timeStep()
+        if self.run_hydro_lbm:
+            self.hydroLbmStep.time_step()
 
         for chLbm in self.cahnHilliardSteps:
-            #chLbm.timeStep(neumannFlag=neumannFlag)
-            chLbm.timeStep()
+            #chLbm.time_step(neumannFlag=neumannFlag)
+            chLbm.time_step()
 
-        self.timeStepsRun += 1
+        self.time_steps_run += 1
 
     @property
-    def boundaryHandling(self):
-        return self.hydroLbmStep.boundaryHandling
+    def boundary_handling(self):
+        return self.hydroLbmStep.boundary_handling
 
-    def setConcentration(self, sliceObj, concentration):
+    def set_concentration(self, slice_obj, concentration):
         if self.concentrationToOrderParameter is not None:
             phi = self.concentrationToOrderParameter(concentration)
         else:
             phi = np.array(concentration)
 
-        for b in self.dataHandling.iterate(sliceObj):
+        for b in self.data_handling.iterate(slice_obj):
             for i in range(phi.shape[-1]):
-                b[self.phiFieldName][..., i] = phi[i]
+                b[self.phi_field_name][..., i] = phi[i]
 
-    def setDensity(self, sliceObj, value):
-        for b in self.dataHandling.iterate(sliceObj):
-            for i in range(self.numOrderParameters):
-                b[self.hydroLbmStep.densityDataName].fill(value)
+    def set_density(self, slice_obj, value):
+        for b in self.data_handling.iterate(slice_obj):
+            for i in range(self.num_order_parameters):
+                b[self.hydroLbmStep.density_data_name].fill(value)
 
-    def run(self, timeSteps):
-        self.preRun()
-        for i in range(timeSteps):
-            self.timeStep()
-        self.postRun()
+    def run(self, time_steps):
+        self.pre_run()
+        for i in range(time_steps):
+            self.time_step()
+        self.post_run()
 
-    def _getSlice(self, dataName, sliceObj):
-        if sliceObj is None:
-            sliceObj = makeSlice[:, :] if self.dim == 2 else makeSlice[:, :, 0.5]
-        return self.dataHandling.gatherArray(dataName, sliceObj).squeeze()
+    def _get_slice(self, data_name, slice_obj):
+        if slice_obj is None:
+            slice_obj = makeSlice[:, :] if self.dim == 2 else makeSlice[:, :, 0.5]
+        return self.data_handling.gather_array(data_name, slice_obj).squeeze()
 
-    def phiSlice(self, sliceObj=None):
-        return self._getSlice(self.phiFieldName, sliceObj)
+    def phi_slice(self, slice_obj=None):
+        return self._get_slice(self.phi_field_name, slice_obj)
 
-    def concentrationSlice(self, sliceObj=None):
-        phi = self.phiSlice(sliceObj)
+    def concentration_slice(self, slice_obj=None):
+        phi = self.phi_slice(slice_obj)
         return phi if self.orderParametersToConcentrations is None else self.orderParametersToConcentrations(phi)
 
-    def muSlice(self, sliceObj=None):
-        return self._getSlice(self.muFieldName, sliceObj)
+    def mu_slice(self, slice_obj=None):
+        return self._get_slice(self.mu_field_name, slice_obj)
 
-    def velocitySlice(self, sliceObj=None):
-        return self._getSlice(self.velFieldName, sliceObj)
+    def velocity_slice(self, slice_obj=None):
+        return self._get_slice(self.vel_field_name, slice_obj)
 
-    def forceSlice(self, sliceObj=None):
-        return self._getSlice(self.forceFieldName, sliceObj)
+    def force_slice(self, slice_obj=None):
+        return self._get_slice(self.force_field_name, slice_obj)
 
     @property
     def phi(self):
-        return SlicedGetter(self.phiSlice)
+        return SlicedGetter(self.phi_slice)
 
     @property
     def concentration(self):
-        return SlicedGetter(self.concentrationSlice)
+        return SlicedGetter(self.concentration_slice)
 
     @property
     def mu(self):
-        return SlicedGetter(self.muSlice)
+        return SlicedGetter(self.mu_slice)
 
     @property
     def velocity(self):
-        return SlicedGetter(self.velocitySlice)
+        return SlicedGetter(self.velocity_slice)
 
     @property
     def force(self):
-        return SlicedGetter(self.forceSlice)
+        return SlicedGetter(self.force_slice)
diff --git a/phasefield/plot.py b/phasefield/plot.py
index 652943f9bb3435745a01e7a33951c3e625ee61fa..89817161390152c12b8ed04d2c53ba3a4531759d 100644
--- a/phasefield/plot.py
+++ b/phasefield/plot.py
@@ -1,15 +1,15 @@
 from lbmpy.plot2d import *
 
 
-def _drawAngles(ax, groupedPoints):
+def _draw_angles(ax, grouped_points):
     from matplotlib.lines import Line2D
     from matplotlib.text import Annotation
-    from lbmpy.phasefield.postprocessing import getAngle
+    from lbmpy.phasefield.postprocessing import get_angle
 
-    xData = [groupedPoints[1][0], groupedPoints[0][0], groupedPoints[2][0]]
-    yData = [groupedPoints[1][1], groupedPoints[0][1], groupedPoints[2][1]]
+    x_data = [grouped_points[1][0], grouped_points[0][0], grouped_points[2][0]]
+    y_data = [grouped_points[1][1], grouped_points[0][1], grouped_points[2][1]]
 
-    v = [p - groupedPoints[0] for p in groupedPoints[1:]]
+    v = [p - grouped_points[0] for p in grouped_points[1:]]
     v = [p / np.linalg.norm(p, ord=2) for p in v]
     direction = v[0] + v[1]
 
@@ -27,38 +27,37 @@ def _drawAngles(ax, groupedPoints):
     else:
         va = 'center'
 
-    textPos = groupedPoints[0] + 10 * direction
-    lines = Line2D(yData, xData, axes=ax, linewidth=3, color='k')
+    text_pos = grouped_points[0] + 10 * direction
+    lines = Line2D(y_data, x_data, axes=ax, linewidth=3, color='k')
     ax.add_line(lines)
 
-    angle = getAngle(*groupedPoints)
-    annotation = Annotation('%.1f°' % (angle,), (textPos[1], textPos[0]), axes=ax, fontsize=15, ha=ha, va=va)
+    angle = get_angle(*grouped_points)
+    annotation = Annotation('%.1f°' % (angle,), (text_pos[1], text_pos[0]), axes=ax, fontsize=15, ha=ha, va=va)
     ax.add_artist(annotation)
 
 
-def phaseIndices(phi, **kwargs):
-    singlePhaseArrays = [phi[..., i] for i in range(phi.shape[-1])]
-    lastPhase = 1 - sum(singlePhaseArrays)
-    singlePhaseArrays.append(lastPhase)
-    idxArray = np.array(singlePhaseArrays).argmax(axis=0)
-    return scalarField(idxArray, **kwargs)
+def phase_indices(phi, **kwargs):
+    single_phase_arrays = [phi[..., i] for i in range(phi.shape[-1])]
+    last_phase = 1 - sum(single_phase_arrays)
+    single_phase_arrays.append(last_phase)
+    idx_array = np.array(single_phase_arrays).argmax(axis=0)
+    return scalar_field(idx_array, **kwargs)
 
 
-def angles(phi0, phi1, phi2, branchingDistance=0.5, branchingPointFilter=3, onlyFirst=True):
-    from lbmpy.phasefield.postprocessing import getTriplePointInfos
+def angles(phi0, phi1, phi2, branching_distance=0.5, branching_point_filter=3, only_first=True):
+    from lbmpy.phasefield.postprocessing import get_triple_point_info
 
     levels = [0.5, ]
-    scalarFieldContour(phi0, levels=levels)
-    scalarFieldContour(phi1, levels=levels)
-    scalarFieldContour(phi2, levels=levels)
+    scalar_field_contour(phi0, levels=levels)
+    scalar_field_contour(phi1, levels=levels)
+    scalar_field_contour(phi2, levels=levels)
 
-    if onlyFirst:
-        angleInfo = getTriplePointInfos(phi0, phi1, phi2, branchingDistance, branchingPointFilter)
+    if only_first:
+        angle_info = get_triple_point_info(phi0, phi1, phi2, branching_distance, branching_point_filter)
     else:
-        angleInfo = getTriplePointInfos(phi0, phi1, phi2, branchingDistance, branchingPointFilter) +\
-                    getTriplePointInfos(phi1, phi0, phi2, branchingDistance, branchingPointFilter) +\
-                    getTriplePointInfos(phi2, phi1, phi0, branchingDistance, branchingPointFilter)
-
-    for points in angleInfo:
-        _drawAngles(gca(), points)
+        angle_info = get_triple_point_info(phi0, phi1, phi2, branching_distance, branching_point_filter) + \
+                     get_triple_point_info(phi1, phi0, phi2, branching_distance, branching_point_filter) + \
+                     get_triple_point_info(phi2, phi1, phi0, branching_distance, branching_point_filter)
 
+    for points in angle_info:
+        _draw_angles(gca(), points)
diff --git a/phasefield/postprocessing.py b/phasefield/postprocessing.py
index 269fee3e6556bddff05db8ac42628dda0722bed2..11520ab15d8df92383afe1d0be8913a192a9bd40 100644
--- a/phasefield/postprocessing.py
+++ b/phasefield/postprocessing.py
@@ -6,17 +6,17 @@ import scipy.spatial
 import warnings
 
 
-def getIsolines(dataset, level=0.5, refinementFactor=4):
+def get_isolines(dataset, level=0.5, refinement_factor=4):
     from matplotlib._contour import QuadContourGenerator
-    indexArrays = np.meshgrid(*[np.arange(s) for s in dataset.shape])
-    gen = QuadContourGenerator(*indexArrays, dataset, None, True, 0)
+    index_arrays = np.meshgrid(*[np.arange(s) for s in dataset.shape])
+    gen = QuadContourGenerator(*index_arrays, dataset, None, True, 0)
     result = gen.create_contour(level)
-    if refinementFactor > 1:
-        result = [Path(p).interpolated(refinementFactor).vertices for p in result]
+    if refinement_factor > 1:
+        result = [Path(p).interpolated(refinement_factor).vertices for p in result]
     return result
 
 
-def findJumpIndices(array, threshold=0, minLength=3):
+def find_jump_indices(array, threshold=0, min_length=3):
     jumps = []
     offset = 0
     while True:
@@ -26,32 +26,32 @@ def findJumpIndices(array, threshold=0, minLength=3):
             jump = np.argmax(array < threshold)
         if jump == 0:
             return jumps
-        if len(array) <= minLength + jump:
+        if len(array) <= min_length + jump:
             return jumps
         jumps.append(offset + jump)
-        offset += jump + minLength
+        offset += jump + min_length
 
-        array = array[jump + minLength:]
+        array = array[jump + min_length:]
 
 
-def findBranchingPoint(pathVertices1, pathVertices2, maxDistance=0.5, branchingPointFilter=3):
-    tree = scipy.spatial.KDTree(pathVertices1)
-    distances, indices = tree.query(pathVertices2, k=1, distance_upper_bound=maxDistance)
+def find_branching_point(path_vertices1, path_vertices2, max_distance=0.5, branching_point_filter=3):
+    tree = scipy.spatial.KDTree(path_vertices1)
+    distances, indices = tree.query(path_vertices2, k=1, distance_upper_bound=max_distance)
     distances[distances == np.inf] = -1
-    jumpIndices = findJumpIndices(distances, 0, branchingPointFilter)
-    return pathVertices2[jumpIndices]
+    jump_indices = find_jump_indices(distances, 0, branching_point_filter)
+    return path_vertices2[jump_indices]
 
 
-def findAllBranchingPoints(phaseField1, phaseField2, maxDistance=0.1, branchingPointFilter=3):
+def find_all_branching_points(phase_field1, phase_field2, max_distance=0.1, branching_point_filter=3):
     result = []
-    isoLines = [getIsolines(p, level=0.5, refinementFactor=16) for p in (phaseField1, phaseField2)]
-    for path1, path2 in itertools.product(*isoLines):
-        bbs = findBranchingPoint(path1, path2, maxDistance, branchingPointFilter)
+    iso_lines = [get_isolines(p, level=0.5, refinement_factor=16) for p in (phase_field1, phase_field2)]
+    for path1, path2 in itertools.product(*iso_lines):
+        bbs = find_branching_point(path1, path2, max_distance, branching_point_filter)
         result += list(bbs)
     return np.array(result)
 
 
-def findIntersections(pathVertices1, pathVertices2):
+def find_intersections(path_vertices1, path_vertices2):
     from numpy import where, dstack, diff, meshgrid
 
     with warnings.catch_warnings():
@@ -62,12 +62,12 @@ def findIntersections(pathVertices1, pathVertices2):
         aall = lambda abools: dstack(abools).all(axis=2)
         slope = lambda line: (lambda d: d[:, 1] / d[:, 0])(diff(line, axis=0))
 
-        x11, x21 = meshgrid(pathVertices1[:-1, 0], pathVertices2[:-1, 0])
-        x12, x22 = meshgrid(pathVertices1[1:, 0], pathVertices2[1:, 0])
-        y11, y21 = meshgrid(pathVertices1[:-1, 1], pathVertices2[:-1, 1])
-        y12, y22 = meshgrid(pathVertices1[1:, 1], pathVertices2[1:, 1])
+        x11, x21 = meshgrid(path_vertices1[:-1, 0], path_vertices2[:-1, 0])
+        x12, x22 = meshgrid(path_vertices1[1:, 0], path_vertices2[1:, 0])
+        y11, y21 = meshgrid(path_vertices1[:-1, 1], path_vertices2[:-1, 1])
+        y12, y22 = meshgrid(path_vertices1[1:, 1], path_vertices2[1:, 1])
 
-        m1, m2 = meshgrid(slope(pathVertices1), slope(pathVertices2))
+        m1, m2 = meshgrid(slope(path_vertices1), slope(path_vertices2))
         m1inv, m2inv = 1 / m1, 1 / m2
 
         yi = (m1 * (x21 - x11 - m2inv * y21) + y11) / (1 - m1 * m2inv)
@@ -81,44 +81,44 @@ def findIntersections(pathVertices1, pathVertices2):
         return xi[aall(xconds)], yi[aall(yconds)]
 
 
-def findAllIntersectionPoints(phaseField1, phaseField2):
-    isoLines = [getIsolines(p, level=1.0/3, refinementFactor=4)
-                for p in (phaseField1, phaseField2)]
+def find_all_intersection_points(phase_field1, phase_field2):
+    iso_lines = [get_isolines(p, level=1.0 / 3, refinement_factor=4)
+                 for p in (phase_field1, phase_field2)]
     result = []
-    for path1, path2 in itertools.product(*isoLines):
-        xArr, yArr = findIntersections(path1, path2)
-        if xArr is not None and yArr is not None:
-            for x, y in zip(xArr, yArr):
+    for path1, path2 in itertools.product(*iso_lines):
+        x_arr, y_arr = find_intersections(path1, path2)
+        if x_arr is not None and y_arr is not None:
+            for x, y in zip(x_arr, y_arr):
                 result.append(np.array([x, y]))
     return np.array(result)
 
 
-def groupPoints(triplePoints, outerPoints):
-    """For each triple points the two closest point in 'outerPoints' are searched. 
+def group_points(triple_points, outer_points):
+    """For each triple points the two closest point in 'outer_points' are searched.
     Returns list of tuples [ (triplePoints0, matchedPoint0, matchedPoint2), ... ]
     """
-    assert len(outerPoints) == 2 * len(triplePoints)
-    outerPoints = list(outerPoints)
+    assert len(outer_points) == 2 * len(triple_points)
+    outer_points = list(outer_points)
     result = []
-    for triplePoint in triplePoints:
-        outerPoints.sort(key=lambda p: np.sum((triplePoint - p) ** 2))
-        result.append([triplePoint, outerPoints.pop(0), outerPoints.pop(0)])
+    for triplePoint in triple_points:
+        outer_points.sort(key=lambda p: np.sum((triplePoint - p) ** 2))
+        result.append([triplePoint, outer_points.pop(0), outer_points.pop(0)])
     return result
 
 
-def getAngle(pMid, p1, p2):
+def get_angle(p_mid, p1, p2):
     """Returns angle in degree spanned by a midpoint and two outer points"""
-    v = [p - pMid for p in [p1, p2]]
+    v = [p - p_mid for p in [p1, p2]]
     v = [p / np.linalg.norm(p) for p in v]
-    scalarProd = np.sum(v[0] * v[1])
-    result = np.rad2deg(np.arccos(scalarProd))
+    scalar_prod = np.sum(v[0] * v[1])
+    result = np.rad2deg(np.arccos(scalar_prod))
     return result
 
 
-def getTriplePointInfos(phi0, phi1, phi2, branchingDistance=0.5, branchingPointFilter=3):
+def get_triple_point_info(phi0, phi1, phi2, branching_distance=0.5, branching_point_filter=3):
     """
 
-    :param branchingDistance: where the 1/2 contour lines  move apart farther than this value, the
+    :param branching_distance: where the 1/2 contour lines  move apart farther than this value, the
                               branching points are detected
     :return: list of 3-tuples that contain (triplePoint, branchingPoint1, branchingPoint2)
              the angle can be determined at the triple point 
@@ -127,11 +127,11 @@ def getTriplePointInfos(phi0, phi1, phi2, branchingDistance=0.5, branchingPointF
     # the angle at the triple points is measured with contour lines of level 1/2 at "branching points"
     # i.e. at points where the lines move away from each other
 
-    bb1 = findAllBranchingPoints(phi0, phi1, branchingDistance, branchingPointFilter)
-    bb2 = findAllBranchingPoints(phi0, phi2, branchingDistance, branchingPointFilter)
-    ip = findAllIntersectionPoints(phi0, phi1)
-    return groupPoints(ip, np.vstack([bb1, bb2]))
+    bb1 = find_all_branching_points(phi0, phi1, branching_distance, branching_point_filter)
+    bb2 = find_all_branching_points(phi0, phi2, branching_distance, branching_point_filter)
+    ip = find_all_intersection_points(phi0, phi1)
+    return group_points(ip, np.vstack([bb1, bb2]))
 
 
-def getAnglesOfPhase(phi0, phi1, phi2, branchingDistance=0.5, branchingPointFilter=3):
-    return [getAngle(*r) for r in getTriplePointInfos(phi0, phi1, phi2, branchingDistance, branchingPointFilter)]
+def get_angles_of_phase(phi0, phi1, phi2, branching_distance=0.5, branching_point_filter=3):
+    return [get_angle(*r) for r in get_triple_point_info(phi0, phi1, phi2, branching_distance, branching_point_filter)]
diff --git a/phasefield/scenarios.py b/phasefield/scenarios.py
index 1f7f4920b92b700d5320cac06cb6270d8e8b0846..cc372f56cb770819d78a5acd25dccdd684a9307e 100644
--- a/phasefield/scenarios.py
+++ b/phasefield/scenarios.py
@@ -1,62 +1,63 @@
 import sympy as sp
 import numpy as np
 from lbmpy.phasefield.phasefieldstep import PhaseFieldStep
-from lbmpy.phasefield.analytical import freeEnergyFunction3Phases, freeEnergyFunctionalNPhases, symbolicOrderParameters, \
-    freeEnergyFunctionalNPhasesPenaltyTerm
+from lbmpy.phasefield.analytical import free_energy_functional_3_phases, free_energy_functional_n_phases, symbolic_order_parameters, \
+    free_energy_functional_n_phases_penalty_term
 
 
-def createThreePhaseModel(alpha=1, kappa=(0.015, 0.015, 0.015), includeRho=True, **kwargs):
+def create_three_phase_model(alpha=1, kappa=(0.015, 0.015, 0.015), include_rho=True, **kwargs):
     parameters = {sp.Symbol("alpha"): alpha,
                   sp.Symbol("kappa_0"): kappa[0],
                   sp.Symbol("kappa_1"): kappa[1],
                   sp.Symbol("kappa_2"): kappa[2]}
-    if includeRho:
-        orderParameters = sp.symbols("rho phi psi")
-        freeEnergy, transformationMatrix = freeEnergyFunction3Phases(orderParameters)
-        freeEnergy = freeEnergy.subs(parameters)
-        M = np.array(transformationMatrix).astype(float)
-        Minv = np.array(transformationMatrix.inv()).astype(float)
-
-        def concentrationToOrderParameters(c):
-            phi = np.tensordot(c, M, axes=([-1], [1]))
+    if include_rho:
+        order_parameters = sp.symbols("rho phi psi")
+        free_energy, transformation_matrix = free_energy_functional_3_phases(order_parameters)
+        free_energy = free_energy.subs(parameters)
+        op_transformation = np.array(transformation_matrix).astype(float)
+        op_transformation_inv = np.array(transformation_matrix.inv()).astype(float)
+
+        def concentration_to_order_parameters(c):
+            phi = np.tensordot(c, op_transformation, axes=([-1], [1]))
             return phi
 
-        return PhaseFieldStep(freeEnergy, orderParameters, densityOrderParameter=orderParameters[0],
-                              concentrationToOrderParameters=concentrationToOrderParameters,
-                              orderParametersToConcentrations=lambda phi: np.tensordot(phi, Minv, axes=([-1], [1])),
+        return PhaseFieldStep(free_energy, order_parameters, density_order_parameter=order_parameters[0],
+                              concentration_to_order_parameters=concentration_to_order_parameters,
+                              order_parameters_to_concentrations=lambda phi: np.tensordot(phi, op_transformation_inv,
+                                                                                          axes=([-1], [1])),
                               **kwargs)
     else:
-        orderParameters = sp.symbols("phi psi")
-        freeEnergy, transformationMatrix = freeEnergyFunction3Phases((1,) + orderParameters)
-        freeEnergy = freeEnergy.subs(parameters)
-        M = transformationMatrix.copy()
-        M.row_del(0)  # rho is assumed to be 1 - is not required
-        M = np.array(M).astype(float)
-        reverse = transformationMatrix.inv() * sp.Matrix(sp.symbols("rho phi psi"))
-        MinvTrafo = sp.lambdify(sp.symbols("phi psi"), reverse.subs(sp.Symbol("rho"), 1))
-
-        def orderParametersToConcentrations(phi):
+        order_parameters = sp.symbols("phi psi")
+        free_energy, transformation_matrix = free_energy_functional_3_phases((1,) + order_parameters)
+        free_energy = free_energy.subs(parameters)
+        op_transformation = transformation_matrix.copy()
+        op_transformation.row_del(0)  # rho is assumed to be 1 - is not required
+        op_transformation = np.array(op_transformation).astype(float)
+        reverse = transformation_matrix.inv() * sp.Matrix(sp.symbols("rho phi psi"))
+        op_transformation_inv = sp.lambdify(sp.symbols("phi psi"), reverse.subs(sp.Symbol("rho"), 1))
+
+        def order_parameters_to_concentrations(phi):
             phi = np.array(phi)
-            transformed = MinvTrafo(phi[..., 0], phi[..., 1])
+            transformed = op_transformation_inv(phi[..., 0], phi[..., 1])
             return np.moveaxis(transformed[:, 0], 0, -1)
 
-        def concentrationToOrderParameters(c):
-            phi = np.tensordot(c, M, axes=([-1], [1]))
+        def concentration_to_order_parameters(c):
+            phi = np.tensordot(c, op_transformation, axes=([-1], [1]))
             return phi
 
-        return PhaseFieldStep(freeEnergy, orderParameters, densityOrderParameter=None,
-                              concentrationToOrderParameters=concentrationToOrderParameters,
-                              orderParametersToConcentrations=orderParametersToConcentrations,
+        return PhaseFieldStep(free_energy, order_parameters, density_order_parameter=None,
+                              concentration_to_order_parameters=concentration_to_order_parameters,
+                              order_parameters_to_concentrations=order_parameters_to_concentrations,
                               **kwargs)
 
 
-def createNPhaseModel(alpha=1, numPhases=4, surfaceTensions=lambda i, j: 0.005 if i != j else 0, **kwargs):
-    orderParameters = symbolicOrderParameters(numPhases-1)
-    freeEnergy = freeEnergyFunctionalNPhases(numPhases, surfaceTensions, alpha, orderParameters)
-    return PhaseFieldStep(freeEnergy, orderParameters, **kwargs)
+def create_n_phase_model(alpha=1, num_phases=4, surface_tensions=lambda i, j: 0.005 if i != j else 0, **kwargs):
+    order_parameters = symbolic_order_parameters(num_phases - 1)
+    free_energy = free_energy_functional_n_phases(num_phases, surface_tensions, alpha, order_parameters)
+    return PhaseFieldStep(free_energy, order_parameters, **kwargs)
 
 
-def createNPhaseModelPenaltyTerm(alpha=1, numPhases=4, kappa=0.015, penaltyTermFactor=0.01, **kwargs):
-    orderParameters = symbolicOrderParameters(numPhases)
-    freeEnergy = freeEnergyFunctionalNPhasesPenaltyTerm(orderParameters, alpha, kappa, penaltyTermFactor)
-    return PhaseFieldStep(freeEnergy, orderParameters, **kwargs)
+def create_n_phase_model_penalty_term(alpha=1, num_phases=4, kappa=0.015, penalty_term_factor=0.01, **kwargs):
+    order_parameters = symbolic_order_parameters(num_phases)
+    free_energy = free_energy_functional_n_phases_penalty_term(order_parameters, alpha, kappa, penalty_term_factor)
+    return PhaseFieldStep(free_energy, order_parameters, **kwargs)
diff --git a/plot2d.py b/plot2d.py
index 80333cf861e7bdc646afd78748a4be695247fda8..6b7945147d1cbf4527bfb20b8e41100bc7c250c9 100644
--- a/plot2d.py
+++ b/plot2d.py
@@ -1,77 +1,168 @@
 from itertools import cycle
+import matplotlib.patches as patches
 
 from pystencils import makeSlice
 from pystencils.plot2d import *
 
 
-def boundaryHandling(boundaryHandlingObj, indexExpr=None, boundaryNameToColor=None, showLegend=True):
+def boundary_handling(boundary_handling_obj, slice_obj=None, boundary_name_to_color=None, show_legend=True):
     """
     Shows boundary cells
 
-    :param boundaryHandlingObj: instance of :class:`lbmpy.boundaries.BoundaryHandling`
-    :param indexExpr: for 3D boundary handling a slice expression has to be passed here to define the plane that
+    :param boundary_handling_obj: instance of :class:`lbmpy.boundaries.BoundaryHandling`
+    :param slice_obj: for 3D boundary handling a slice expression has to be passed here to define the plane that
                       should be plotted
-    :param boundaryNameToColor: optional dictionary mapping boundary names to colors
-    :param showLegend: if True legend for color->boundary name is added
+    :param boundary_name_to_color: optional dictionary mapping boundary names to colors
+    :param show_legend: if True legend for color->boundary name is added
     """
     import matplotlib.pyplot as plt
 
-    boundaryHandlingObj.prepare()
+    boundary_handling_obj.prepare()
 
-    dh = boundaryHandlingObj.dataHandling
-    flagArr = dh.gatherArray(boundaryHandlingObj.flagArrayName, indexExpr, ghostLayers=True).squeeze()
-    if flagArr is None:
+    dh = boundary_handling_obj.data_handling
+    flag_arr = dh.gather_array(boundary_handling_obj.flag_array_name, slice_obj, ghost_layers=True).squeeze()
+    if flag_arr is None:
         return
 
-    if len(flagArr.shape) != 2 and indexExpr is None:
+    if len(flag_arr.shape) != 2 and slice_obj is None:
         raise ValueError("To plot a 3D boundary handling a slice has to be passed")
 
-    if boundaryNameToColor:
-        fixedColors = boundaryNameToColor
+    if boundary_name_to_color:
+        fixed_colors = boundary_name_to_color
     else:
-        fixedColors = {
+        fixed_colors = {
             'fluid': '#56b4e9',
             'NoSlip': '#999999',
             'UBB': '#d55e00',
             'FixedDensity': '#009e73',
         }
 
-    boundaryNames = []
-    flagValues = []
-    for name, flagName in sorted(boundaryHandlingObj.getBoundaryNameToFlagDict().items(), key=lambda l: l[1]):
-        boundaryNames.append(name)
-        flagValues.append(flagName)
-    defaultCycle = matplotlib.rcParams['axes.prop_cycle']
-    colorValues = [fixedColors[name] if name in fixedColors else cycle['color']
-                   for cycle, name in zip(defaultCycle, boundaryNames)]
-
-    cmap = matplotlib.colors.ListedColormap(colorValues)
-    bounds = np.array(flagValues, dtype=float) - 0.5
+    boundary_names = []
+    flag_values = []
+    for name, flagName in sorted(boundary_handling_obj.get_boundary_name_to_flag_dict().items(), key=lambda l: l[1]):
+        boundary_names.append(name)
+        flag_values.append(flagName)
+    default_cycle = matplotlib.rcParams['axes.prop_cycle']
+    color_values = [fixed_colors[name] if name in fixed_colors else c['color']
+                    for c, name in zip(default_cycle, boundary_names)]
+
+    colormap = matplotlib.colors.ListedColormap(color_values)
+    bounds = np.array(flag_values, dtype=float) - 0.5
     bounds = list(bounds) + [bounds[-1] + 1]
-    norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N)
+    norm = matplotlib.colors.BoundaryNorm(bounds, colormap.N)
 
-    flagArr = flagArr.swapaxes(0, 1)
-    plt.imshow(flagArr, interpolation='none', origin='lower',
-               cmap=cmap, norm=norm)
+    flag_arr = flag_arr.swapaxes(0, 1)
+    plt.imshow(flag_arr, interpolation='none', origin='lower',
+               cmap=colormap, norm=norm)
 
-    patches = [matplotlib.patches.Patch(color=color, label=name) for color, name in zip(colorValues, boundaryNames)]
+    path_list = [matplotlib.patches.Patch(color=color, label=name) for color, name in zip(color_values, boundary_names)]
     plt.axis('equal')
-    if showLegend:
-        plt.legend(handles=patches, bbox_to_anchor=(1.02, 0.5), loc=2, borderaxespad=0.)
+    if show_legend:
+        plt.legend(handles=path_list, bbox_to_anchor=(1.02, 0.5), loc=2, borderaxespad=0.)
 
-
-def phasePlot(phaseField, linewidth=1.0):
-    colors = ['#fe0002', '#00fe00', '#0000ff', '#ffa800', '#f600ff']
-    colorCycle = cycle(colors)
-
-    assert len(phaseField.shape) == 3
-
-    for i in range(phaseField.shape[-1]):
-        scalarFieldAlphaValue(phaseField[..., i], next(colorCycle), clip=True, interpolation='bilinear')
-    for i in range(phaseField.shape[-1]):
-        scalarFieldContour(phaseField[..., i], levels=[0.5], colors='k', linewidths=[linewidth])
-
-
-def phasePlotForStep(pfStep, sliceObj=makeSlice[:, :], **kwargs):
-    concentrations = pfStep.concentration[sliceObj]
-    phasePlot(concentrations, **kwargs)
+
+def phase_plot(phase_field, linewidth=1.0):
+    color_cycle = cycle(['#fe0002', '#00fe00', '#0000ff', '#ffa800', '#f600ff'])
+
+    assert len(phase_field.shape) == 3
+
+    for i in range(phase_field.shape[-1]):
+        scalar_field_alpha_value(phase_field[..., i], next(color_cycle), clip=True, interpolation='bilinear')
+    for i in range(phase_field.shape[-1]):
+        scalar_field_contour(phase_field[..., i], levels=[0.5], colors='k', linewidths=[linewidth])
+
+
+def phase_plot_for_step(phase_field_step, slice_obj=makeSlice[:, :], **kwargs):
+    concentrations = phase_field_step.concentration[slice_obj]
+    phase_plot(concentrations, **kwargs)
+
+
+class LbGrid:
+    """Visualizes a 2D LBM grid with matplotlib by drawing cells and pdf arrows"""
+
+    def __init__(self, x_cells, y_cells):
+        """Create a new grid with the given number of cells in x (horizontal) and y (vertical) direction"""
+
+        self._xCells = x_cells
+        self._yCells = y_cells
+
+        self._patches = []
+        for x in range(x_cells):
+            for y in range(y_cells):
+                self._patches.append(patches.Rectangle((x, y), 1.0, 1.0, fill=False, linewidth=3, color='#bbbbbb'))
+
+        self._cellBoundaries = dict()  # mapping cell to rectangle patch
+        self._arrows = dict()  # mapping (cell, direction) tuples to arrow patches
+
+    def add_cell_boundary(self, cell, **kwargs):
+        """Draws a rectangle around a single cell. Keyword arguments are passed to the matplotlib Rectangle patch"""
+        if 'fill' not in kwargs:
+            kwargs['fill'] = False
+        if 'linewidth' not in kwargs:
+            kwargs['linewidth'] = 3
+        if 'color' not in kwargs:
+            kwargs['color'] = '#bbbbbb'
+        self._cellBoundaries[cell] = patches.Rectangle(cell, 1.0, 1.0, **kwargs)
+
+    def add_cell_boundaries(self, **kwargs):
+        """Draws a rectangle around all cells. Keyword arguments are passed to the matplotlib Rectangle patch"""
+        for x in range(self._xCells):
+            for y in range(self._yCells):
+                self.add_cell_boundary((x, y), **kwargs)
+
+    def add_arrow(self, cell, arrow_position, arrow_direction, **kwargs):
+        """
+        Draws an arrow in a cell. If an arrow exists already at this position, it is replaced.
+
+        :param cell: cell coordinate as tuple (x,y)
+        :param arrow_position: each cell has 9 possible positions specified as tuple e.g. upper left (-1, 1)
+        :param arrow_direction: direction of the arrow as (x,y) tuple
+        :param kwargs: arguments passed directly to the FancyArrow patch of matplotlib
+        """
+        cell_midpoint = (0.5 + cell[0], 0.5 + cell[1])
+
+        if 'width' not in kwargs: kwargs['width'] = 0.005
+        if 'color' not in kwargs: kwargs['color'] = 'k'
+
+        if arrow_position == (0, 0):
+            del kwargs['width']
+            self._arrows[(cell, arrow_position)] = patches.Circle(cell_midpoint, radius=0.03, **kwargs)
+        else:
+            arrow_midpoint = (cell_midpoint[0] + arrow_position[0] * 0.25,
+                              cell_midpoint[1] + arrow_position[1] * 0.25)
+            length = 0.75
+            arrow_start = (arrow_midpoint[0] - arrow_direction[0] * 0.25 * length,
+                           arrow_midpoint[1] - arrow_direction[1] * 0.25 * length)
+
+            patch = patches.FancyArrow(arrow_start[0], arrow_start[1],
+                                       0.25 * length * arrow_direction[0],
+                                       0.25 * length * arrow_direction[1],
+                                       **kwargs)
+            self._arrows[(cell, arrow_position)] = patch
+
+    def fill_with_default_arrows(self, **kwargs):
+        """Fills the complete grid with the default pdf arrows"""
+        for x in range(self._xCells):
+            for y in range(self._yCells):
+                for dx in [-1, 0, 1]:
+                    for dy in [-1, 0, 1]:
+                        if 'color' not in kwargs: kwargs['color'] = '#bbbbbb'
+                        if 'width' not in kwargs: kwargs['width'] = 0.006
+
+                        self.add_arrow((x, y), (dx, dy), (dx, dy), **kwargs)
+
+    def draw(self, ax):
+        """Draw the grid into a given matplotlib axes object"""
+
+        for p in self._patches:
+            ax.add_patch(p)
+
+        for arrowPatch in self._arrows.values():
+            ax.add_patch(arrowPatch)
+
+        offset = 0.1
+        ax.set_xlim(-offset, self._xCells+offset)
+        ax.set_xlim(-offset, self._xCells + offset)
+        ax.set_ylim(-offset, self._yCells + offset)
+        ax.set_aspect('equal')
+        ax.set_axis_off()
diff --git a/postprocessing.py b/postprocessing.py
index 8488ba2a3605450ea6770b14980ccc7cd7766a03..6e7daf960172c652534c4e402c1401bc8174a400 100644
--- a/postprocessing.py
+++ b/postprocessing.py
@@ -1,22 +1,22 @@
 import numpy as np
 
 
-def vectorFieldInterpolator(vectorField):
+def vector_field_interpolator(vector_field):
     from scipy.interpolate import RegularGridInterpolator
-    coords = [np.arange(s) + 0.5 for s in  vectorField.shape[:-1]]
-    return RegularGridInterpolator(*coords, vectorField)
+    coordinates = [np.arange(s) + 0.5 for s in vector_field.shape[:-1]]
+    return RegularGridInterpolator(*coordinates, vector_field)
 
 
-def scalarFieldInterpolator(scalarField):
+def scalar_field_interpolator(scalar_field):
     from scipy.interpolate import RegularGridInterpolator
-    coords = [np.arange(s) + 0.5 for s in scalarField.shape]
-    return RegularGridInterpolator(coords, values=scalarField)
+    coordinates = [np.arange(s) + 0.5 for s in scalar_field.shape]
+    return RegularGridInterpolator(coordinates, values=scalar_field)
 
 
-def vorticity2D(velocityField):
-    assert len(velocityField.shape) == 3
-    assert velocityField.shape[2] == 2
-    grad_y_of_x = np.gradient(velocityField[:, :, 0], axis=1)
-    grad_x_of_y = np.gradient(velocityField[:, :, 1], axis=0)
+def vorticity_2d(velocity_field):
+    assert len(velocity_field.shape) == 3
+    assert velocity_field.shape[2] == 2
+    grad_y_of_x = np.gradient(velocity_field[:, :, 0], axis=1)
+    grad_x_of_y = np.gradient(velocity_field[:, :, 1], axis=0)
     return grad_x_of_y - grad_y_of_x
 
diff --git a/quadratic_equilibrium_construction.py b/quadratic_equilibrium_construction.py
index 56a2d9e9e7016e3ce1f312d5c06b856f6863c7bd..7124351ac386e0ce2b027cba746d96664fbdf824 100644
--- a/quadratic_equilibrium_construction.py
+++ b/quadratic_equilibrium_construction.py
@@ -6,11 +6,11 @@ Wolf-Gladrow, section 5.4
 import sympy as sp
 import numpy as np
 from pystencils.sympyextensions import scalar_product
-from lbmpy.moments import discreteMoment
-from lbmpy.maxwellian_equilibrium import compressibleToIncompressibleMomentValue
+from lbmpy.moments import discrete_moment
+from lbmpy.maxwellian_equilibrium import compressible_to_incompressible_moment_value
 
 
-def genericEquilibriumAnsatz(stencil, u=sp.symbols("u_:3")):
+def generic_equilibrium_ansatz(stencil, u=sp.symbols("u_:3")):
     """Returns a generic quadratic equilibrium with coefficients A, B, C, D according to 
     Wolf Gladrow Book equation (5.4.1) """
     dim = len(stencil[0])
@@ -20,24 +20,24 @@ def genericEquilibriumAnsatz(stencil, u=sp.symbols("u_:3")):
 
     for direction in stencil:
         speed = np.abs(direction).sum()
-        weight, linear, mixQuadratic, quadratic = getParameterSymbols(speed)
-        uTimesD = scalar_product(u, direction)
-        eq = weight + linear * uTimesD + mixQuadratic * uTimesD ** 2 + quadratic * scalar_product(u, u)
+        weight, linear, mix_quadratic, quadratic = get_parameter_symbols(speed)
+        u_times_d = scalar_product(u, direction)
+        eq = weight + linear * u_times_d + mix_quadratic * u_times_d ** 2 + quadratic * scalar_product(u, u)
         equilibrium.append(eq)
     return tuple(equilibrium)
 
 
-def genericEquilibriumAnsatzParameters(stencil):
-    degreesOfFreedom = set()
+def generic_equilibrium_ansatz_parameters(stencil):
+    degrees_of_freedom = set()
     for direction in stencil:
         speed = np.abs(direction).sum()
-        params = getParameterSymbols(speed)
-        degreesOfFreedom.update(params)
-    degreesOfFreedom.add(sp.Symbol("p"))
-    return sorted(list(degreesOfFreedom), key=lambda e: e.name)
+        params = get_parameter_symbols(speed)
+        degrees_of_freedom.update(params)
+    degrees_of_freedom.add(sp.Symbol("p"))
+    return sorted(list(degrees_of_freedom), key=lambda e: e.name)
 
 
-def matchGenericEquilibriumAnsatz(stencil, equilibrium, u=sp.symbols("u_:3")):
+def match_generic_equilibrium_ansatz(stencil, equilibrium, u=sp.symbols("u_:3")):
     """Given a quadratic equilibrium, the generic coefficients A,B,C,D are determined. 
     Returns a dict that maps these coefficients to their values. If the equilibrium does not have a
     generic quadratic form, a ValueError is raised"""
@@ -47,15 +47,15 @@ def matchGenericEquilibriumAnsatz(stencil, equilibrium, u=sp.symbols("u_:3")):
     result = dict()
     for direction, actualEquilibrium in zip(stencil, equilibrium):
         speed = np.abs(direction).sum()
-        A, B, C, D = getParameterSymbols(speed)
-        uTimesD = scalar_product(u, direction)
-        genericEquation = A + B * uTimesD + C * uTimesD ** 2 + D * scalar_product(u, u)
+        a, b, c, d = get_parameter_symbols(speed)
+        u_times_d = scalar_product(u, direction)
+        generic_equation = a + b * u_times_d + c * u_times_d ** 2 + d * scalar_product(u, u)
 
-        equations = sp.poly(actualEquilibrium - genericEquation, *u).coeffs()
-        solveRes = sp.solve(equations, [A, B, C, D])
-        if not solveRes:
+        equations = sp.poly(actualEquilibrium - generic_equation, *u).coeffs()
+        solve_res = sp.solve(equations, [a, b, c, d])
+        if not solve_res:
             raise ValueError("This equilibrium does not match the generic quadratic standard form")
-        for dof, value in solveRes.items():
+        for dof, value in solve_res.items():
             if dof in result and result[dof] != value:
                 raise ValueError("This equilibrium does not match the generic quadratic standard form")
             result[dof] = value
@@ -63,34 +63,34 @@ def matchGenericEquilibriumAnsatz(stencil, equilibrium, u=sp.symbols("u_:3")):
     return result
 
 
-def momentConstraintEquations(stencil, equilibrium, momentToValueDict, u=sp.symbols("u_:3")):
+def moment_constraint_equations(stencil, equilibrium, moment_to_value_dict, u=sp.symbols("u_:3")):
     """Returns a set of equations that have to be fulfilled for a generic equilibrium match moment conditions 
-    passed in momentToValueDict. This dict is expected to map moment tuples to values."""
+    passed in moment_to_value_dict. This dict is expected to map moment tuples to values."""
     dim = len(stencil[0])
     u = u[:dim]
     equilibrium = tuple(equilibrium)
-    constraintEquations = set()
-    for moment, desiredValue in momentToValueDict.items():
-        genericMoment = discreteMoment(equilibrium, moment, stencil)
-        equations = sp.poly(genericMoment - desiredValue, *u).coeffs()
-        constraintEquations.update(equations)
-    return list(constraintEquations)
+    constraint_equations = set()
+    for moment, desiredValue in moment_to_value_dict.items():
+        generic_moment = discrete_moment(equilibrium, moment, stencil)
+        equations = sp.poly(generic_moment - desiredValue, *u).coeffs()
+        constraint_equations.update(equations)
+    return list(constraint_equations)
 
 
-def hydrodynamicMomentValues(upToOrder=3, dim=3, compressible=True):
-    """Returns the values of moments that are required to approximate Navier Stokes (if upToOrder=3)"""
-    from lbmpy.maxwellian_equilibrium import getMomentsOfContinuousMaxwellianEquilibrium
-    from lbmpy.moments import momentsUpToOrder
+def hydrodynamic_moment_values(up_to_order=3, dim=3, compressible=True):
+    """Returns the values of moments that are required to approximate Navier Stokes (if up_to_order=3)"""
+    from lbmpy.maxwellian_equilibrium import get_moments_of_continuous_maxwellian_equilibrium
+    from lbmpy.moments import moments_up_to_order
 
-    moms = momentsUpToOrder(upToOrder, dim)
+    moms = moments_up_to_order(up_to_order, dim)
     c_s_sq = sp.Symbol("p") / sp.Symbol("rho")
-    momValues = getMomentsOfContinuousMaxwellianEquilibrium(moms, dim=dim, c_s_sq=c_s_sq, order=2)
+    moment_values = get_moments_of_continuous_maxwellian_equilibrium(moms, dim=dim, c_s_sq=c_s_sq, order=2)
     if not compressible:
-        momValues = [compressibleToIncompressibleMomentValue(m, sp.Symbol("rho"), sp.symbols("u_:3")[:dim])
-                     for m in momValues]
+        moment_values = [compressible_to_incompressible_moment_value(m, sp.Symbol("rho"), sp.symbols("u_:3")[:dim])
+                         for m in moment_values]
 
-    return {a: b.expand() for a, b in zip(moms, momValues)}
+    return {a: b.expand() for a, b in zip(moms, moment_values)}
 
 
-def getParameterSymbols(i):
+def get_parameter_symbols(i):
     return sp.symbols("A_%d B_%d C_%d D_%d" % (i, i, i, i))
diff --git a/relaxationrates.py b/relaxationrates.py
index faeb6ba234e9f47c683c36e2fad6f89c7705b315..7d8989621e98af62d75d428b43f92619a379651f 100644
--- a/relaxationrates.py
+++ b/relaxationrates.py
@@ -1,27 +1,25 @@
 import sympy as sp
-from lbmpy.moments import isShearMoment, getOrder
+from lbmpy.moments import is_shear_moment, get_order
 
 
-def relaxationRateFromLatticeViscosity(nu):
+def relaxation_rate_from_lattice_viscosity(nu):
     """Computes relaxation rate from lattice viscosity: :math:`\omega = \frac{1}{3\nu_L + \frac{1}{2}}`"""
     return 2 / (6 * nu + 1)
 
 
-def latticeViscosityFromRelaxationRate(omega):
+def lattice_viscosity_from_relaxation_rate(omega):
     """Computes lattice viscosity from relaxation rate: 
     :math:`\nu_L=\frac{1}{3}\left(\frac{1}{\omega}-\frac{1}{2}\right)`"""
     return (2 - omega) / (6 * omega)
 
 
-def relaxationRateFromMagicNumber(hydrodynamicRelaxationRate, magicNumber=sp.Rational(3, 16)):
-    """
-    Computes second TRT relaxation rate from magic number
-    """
-    omega = hydrodynamicRelaxationRate
-    return (4 - 2 * omega) / (4 * magicNumber * omega + 2 - omega)
+def relaxation_rate_from_magic_number(hydrodynamic_relaxation_rate, magic_number=sp.Rational(3, 16)):
+    """Computes second TRT relaxation rate from magic number."""
+    omega = hydrodynamic_relaxation_rate
+    return (4 - 2 * omega) / (4 * magic_number * omega + 2 - omega)
 
 
-def getShearRelaxationRate(method):
+def get_shear_relaxation_rate(method):
     """
     Assumes that all shear moments are relaxed with same rate - returns this rate
     Shear moments in 3D are: x*y, x*z and y*z - in 2D its only x*y
@@ -30,52 +28,55 @@ def getShearRelaxationRate(method):
     if hasattr(method, 'shearRelaxationRate'):
         return method.shearRelaxationRate
 
-    relaxationRates = set()
-    for moment, relaxInfo in method.relaxationInfoDict.items():
-        if isShearMoment(moment):
-            relaxationRates.add(relaxInfo.relaxationRate)
-    if len(relaxationRates) == 1:
-        return relaxationRates.pop()
+    relaxation_rates = set()
+    for moment, relaxInfo in method.relaxation_info_dict.items():
+        if is_shear_moment(moment):
+            relaxation_rates.add(relaxInfo.relaxation_rate)
+    if len(relaxation_rates) == 1:
+        return relaxation_rates.pop()
     else:
-        if len(relaxationRates) > 1:
-            raise ValueError("Shear moments are relaxed with different relaxation times: %s" % (relaxationRates,))
+        if len(relaxation_rates) > 1:
+            raise ValueError("Shear moments are relaxed with different relaxation times: %s" % (relaxation_rates,))
         else:
-            allRelaxationRates = set(v.relaxationRate for v in method.relaxationInfoDict.values())
-            if len(allRelaxationRates) == 1:
-                return list(allRelaxationRates)[0]
+            all_relaxation_rates = set(v.relaxation_rate for v in method.relaxation_info_dict.values())
+            if len(all_relaxation_rates) == 1:
+                return list(all_relaxation_rates)[0]
             raise NotImplementedError("Shear moments seem to be not relaxed separately - "
                                       "Can not determine their relaxation rate automatically")
 
 
-def relaxationRateScaling(omega, levelScaleFactor):
-    """
-    Computes adapted omega for refinement
-    :param omega: relaxation rate
-    :param levelScaleFactor: resolution of finer grid i.e. 2, 4, 8
-    :return: relaxation rate on refined grid
+def relaxation_rate_scaling(omega, level_scale_factor):
+    """Computes adapted omega for refinement.
+
+    Args:
+        omega: relaxation rate
+        level_scale_factor: resolution of finer grid i.e. 2, 4, 8
+
+    Returns:
+        relaxation rate on refined grid
     """
-    return omega / (omega / 2 + levelScaleFactor * (1 - omega / 2))
+    return omega / (omega / 2 + level_scale_factor * (1 - omega / 2))
 
 
-def defaultRelaxationRateNames():
-    nextIndex = [0]
+def default_relaxation_rate_names():
+    next_index = [0]
 
-    def result(momentList):
-        shearMomentInside = False
-        allConservedMoments = True
-        for m in momentList:
-            if isShearMoment(m):
-                shearMomentInside = True
-            if not (getOrder(m) == 0 or getOrder(m) == 1):
-                allConservedMoments = False
+    def result(moment_list):
+        shear_moment_inside = False
+        all_conserved_moments = True
+        for m in moment_list:
+            if is_shear_moment(m):
+                shear_moment_inside = True
+            if not (get_order(m) == 0 or get_order(m) == 1):
+                all_conserved_moments = False
 
-        if shearMomentInside:
+        if shear_moment_inside:
             return sp.Symbol("omega")
-        elif allConservedMoments:
+        elif all_conserved_moments:
             return 0
         else:
-            nextIndex[0] += 1
-            return sp.Symbol("omega_%d" % (nextIndex[0],))
+            next_index[0] += 1
+            return sp.Symbol("omega_%d" % (next_index[0],))
 
     return result
 
diff --git a/scenarios.py b/scenarios.py
index b47aa9ee3f0b0049d4bfc62b83cd16ce499df89b..8e13eddf813580e3f593cf4b42b9516fdf302226 100644
--- a/scenarios.py
+++ b/scenarios.py
@@ -5,144 +5,152 @@ Scenario setup
 This module contains functions to set up pre-defined scenarios like a lid-driven cavity or channel flows.
 It is a good starting point if you are new to lbmpy.
 
->>> scenario = createChannel(domainSize=(20, 10), force=1e-5,
-...                          method='srt', relaxationRate=1.9)
+>>> scenario = create_channel(domain_size=(20, 10), force=1e-5,
+...                          method='srt', relaxation_rate=1.9)
 >>> scenario.run(100)
 
 All scenarios can be modified, for example you can create a simple channel first, then place an object in it:
 
 >>> from lbmpy.boundaries import NoSlip
 >>> from pystencils.slicing import makeSlice
->>> flag = scenario.boundaryHandling.setBoundary(NoSlip(), makeSlice[0.3:0.4, 0.0:0.3])
+>>> flag = scenario.boundary_handling.set_boundary(NoSlip(), makeSlice[0.3:0.4, 0.0:0.3])
 
 
 
 Functions for scenario setup:
-----    -------------------------
+-----------------------------
 
 All of the following scenario creation functions take keyword arguments specifying which LBM method should be used
-and a ``optimizationParams`` dictionary, defining performance related options. These parameters are documented
-at :mod:`lbmpy.creationfunctions`. The only mandatory keyword parameter is ``relaxationRate``,
+and a ``optimization`` dictionary, defining performance related options. These parameters are documented
+at :mod:`lbmpy.creationfunctions`. The only mandatory keyword parameter is ``relaxation_rate``,
 that defines the viscosity of the fluid (valid values being between 0 and 2).
 """
 import numpy as np
-from lbmpy.geometry import setupChannelWalls, addParabolicVelocityInflow
+from lbmpy.geometry import setup_channel_walls, add_parabolic_velocity_inflow
 from lbmpy.lbstep import LatticeBoltzmannStep
-from pystencils.datahandling import createDataHandling
-from pystencils.slicing import sliceFromDirection
+from pystencils.datahandling import create_data_handling
+from pystencils.slicing import slice_from_direction
 from lbmpy.boundaries import NoSlip, UBB, FixedDensity
 
 
-def createFullyPeriodicFlow(initialVelocity, periodicityInKernel=False, lbmKernel=None,
-                            dataHandling=None, parallel=False, **kwargs):
-    """
-    Creates a fully periodic setup with prescribed velocity field
-
-    :param initialVelocity: numpy array that defines an initial velocity for each cell. The shape of this
-                            array determines the domain size.
-    :param periodicityInKernel: don't use boundary handling for periodicity, but directly generate the kernel periodic 
-    :param lbmKernel: a LBM function, which would otherwise automatically created
-    :param parallel: True for distributed memory parallelization with waLBerla
-    :param kwargs: other parameters are passed on to the method, see :mod:`lbmpy.creationfunctions`
-    :return: instance of :class:`Scenario`
+def create_fully_periodic_flow(initial_velocity, periodicity_in_kernel=False, lbm_kernel=None,
+                               data_handling=None, parallel=False, **kwargs):
+    """Creates a fully periodic setup with prescribed velocity field.
+
+    Args:
+        initial_velocity: numpy array that defines an initial velocity for each cell. The shape of this
+                         array determines the domain size.
+        periodicity_in_kernel: don't use boundary handling for periodicity, but directly generate the kernel periodic
+        lbm_kernel: a LBM function, which would otherwise automatically created
+        data_handling: data handling instance that is used to create the necessary fields. If a data handling is
+                       passed the periodicity and parallel arguments are ignored.
+        parallel: True for distributed memory parallelization with walberla
+        kwargs: other parameters are passed on to the method, see :mod:`lbmpy.creationfunctions`
+
+    Returns:
+        instance of :class:`Scenario`
     """
-    if 'optimizationParams' not in kwargs:
-        kwargs['optimizationParams'] = {}
+    if 'optimization' not in kwargs:
+        kwargs['optimization'] = {}
     else:
-        kwargs['optimizationParams'] = kwargs['optimizationParams'].copy()
-    domainSize = initialVelocity.shape[:-1]
-    if periodicityInKernel:
-        kwargs['optimizationParams']['builtinPeriodicity'] = (True, True, True)
-
-    if dataHandling is None:
-        dataHandling = createDataHandling(parallel, domainSize, periodicity=not periodicityInKernel,
-                                          defaultGhostLayers=1)
-    step = LatticeBoltzmannStep(dataHandling=dataHandling, name="periodicScenario", lbmKernel=lbmKernel, **kwargs)
-    for b in step.dataHandling.iterate(ghostLayers=False):
-        np.copyto(b[step.velocityDataName], initialVelocity[b.globalSlice])
-    step.setPdfFieldsFromMacroscopicValues()
+        kwargs['optimization'] = kwargs['optimization'].copy()
+    domain_size = initial_velocity.shape[:-1]
+    if periodicity_in_kernel:
+        kwargs['optimization']['builtin_periodicity'] = (True, True, True)
+
+    if data_handling is None:
+        data_handling = create_data_handling(parallel, domain_size, periodicity=not periodicity_in_kernel,
+                                             default_ghost_layers=1)
+    step = LatticeBoltzmannStep(data_handling=data_handling, name="periodicScenario", lbm_kernel=lbm_kernel, **kwargs)
+    for b in step.data_handling.iterate(ghost_layers=False):
+        np.copyto(b[step.velocity_data_name], initial_velocity[b.global_slice])
+    step.set_pdf_fields_from_macroscopic_values()
     return step
 
 
-def createLidDrivenCavity(domainSize=None, lidVelocity=0.005, lbmKernel=None, parallel=False,
-                          dataHandling=None, **kwargs):
-    """
-    Creates a lid driven cavity scenario
-
-    :param domainSize: tuple specifying the number of cells in each dimension
-    :param lidVelocity: x velocity of lid in lattice coordinates.
-    :param lbmKernel: a LBM function, which would otherwise automatically created
-    :param kwargs: other parameters are passed on to the method, see :mod:`lbmpy.creationfunctions`
-    :param parallel: True for distributed memory parallelization with waLBerla
-    :return: instance of :class:`Scenario`
+def create_lid_driven_cavity(domain_size=None, lid_velocity=0.005, lbm_kernel=None, parallel=False,
+                             data_handling=None, **kwargs):
+    """Creates a lid driven cavity scenario.
+
+    Args:
+        domain_size: tuple specifying the number of cells in each dimension
+        lid_velocity: x velocity of lid in lattice coordinates.
+        lbm_kernel: a LBM function, which would otherwise automatically created
+        kwargs: other parameters are passed on to the method, see :mod:`lbmpy.creationfunctions`
+        parallel: True for distributed memory parallelization with walberla
+        data_handling: see documentation of :func:`create_fully_periodic_flow`
+    Returns:
+        instance of :class:`Scenario`
     """
-    assert domainSize is not None or dataHandling is not None
-    if dataHandling is None:
-        dataHandling = createDataHandling(parallel, domainSize, periodicity=False, defaultGhostLayers=1)
-    step = LatticeBoltzmannStep(dataHandling=dataHandling, lbmKernel=lbmKernel, name="lidDrivenCavity", **kwargs)
+    assert domain_size is not None or data_handling is not None
+    if data_handling is None:
+        data_handling = create_data_handling(parallel, domain_size, periodicity=False, default_ghost_layers=1)
+    step = LatticeBoltzmannStep(data_handling=data_handling, lbm_kernel=lbm_kernel, name="lidDrivenCavity", **kwargs)
 
-    myUbb = UBB(velocity=[lidVelocity, 0, 0][:step.method.dim])
-    step.boundaryHandling.setBoundary(myUbb, sliceFromDirection('N', step.dim))
+    my_ubb = UBB(velocity=[lid_velocity, 0, 0][:step.method.dim])
+    step.boundary_handling.set_boundary(my_ubb, slice_from_direction('N', step.dim))
     for direction in ('W', 'E', 'S') if step.dim == 2 else ('W', 'E', 'S', 'T', 'B'):
-        step.boundaryHandling.setBoundary(NoSlip(), sliceFromDirection(direction, step.dim))
+        step.boundary_handling.set_boundary(NoSlip(), slice_from_direction(direction, step.dim))
 
     return step
 
 
-def createChannel(domainSize=None, force=None, pressureDifference=None, u_max=None, diameterCallback=None,
-                  duct=False, wallBoundary=NoSlip(), parallel=False, dataHandling=None, **kwargs):
-    """
-    Create a channel scenario (2D or 3D)
-    :param domainSize: size of the simulation domain. First coordinate is the flow direction.
+def create_channel(domain_size=None, force=None, pressure_difference=None, u_max=None, diameter_callback=None,
+                   duct=False, wall_boundary=NoSlip(), parallel=False, data_handling=None, **kwargs):
+    """Create a channel scenario (2D or 3D).
+    
+    :param domain_size: size of the simulation domain. First coordinate is the flow direction.
     
     The channel can be driven by one of the following methods. Please specify exactly one of the following parameters: 
     :param force: Periodic channel, driven by a body force. Pass force in flow direction in lattice units here.
-    :param pressureDifference: Inflow and outflow are fixed pressure conditions, with the given pressure difference. 
+    :param pressure_difference: Inflow and outflow are fixed pressure conditions, with the given pressure difference. 
     :param u_max: Parabolic velocity profile prescribed at inflow, pressure boundary =1.0 at outflow.
     
     Geometry parameters:
-    :param diameterCallback: optional callback for channel with varying diameters. Only valid if duct=False.
-                             The callback receives x coordinate array and domainSize and returns a
+    :param diameter_callback: optional callback for channel with varying diameters. Only valid if duct=False.
+                             The callback receives x coordinate array and domain_size and returns a
                              an array of diameters of the same shape
     :param duct: if true the channel has rectangular instead of circular cross section
-    :param wallBoundary: instance of boundary class that should be set at the channel walls
-    :param parallel: True for distributed memory parallelization with waLBerla
+    :param wall_boundary: instance of boundary class that should be set at the channel walls
+    :param parallel: True for distributed memory parallelization with walberla
+    :param data_handling: see documentation of :func:`create_fully_periodic_flow`
     :param kwargs: all other keyword parameters are passed directly to scenario class.
     """
-    assert domainSize is not None or dataHandling is not None
+    assert domain_size is not None or data_handling is not None
 
-    if [bool(p) for p in (force, pressureDifference, u_max)].count(True) != 1:
-        raise ValueError("Please specify exactly one of the parameters 'force', 'pressureDifference' or 'u_max'")
+    if [bool(p) for p in (force, pressure_difference, u_max)].count(True) != 1:
+        raise ValueError("Please specify exactly one of the parameters 'force', 'pressure_difference' or 'u_max'")
 
     periodicity = (True, False, False) if force else (False, False, False)
-    if dataHandling is None:
-        dim = len(domainSize)
+    if data_handling is None:
+        dim = len(domain_size)
         assert dim in (2, 3)
-        dataHandling = createDataHandling(parallel, domainSize, periodicity=periodicity[:dim], defaultGhostLayers=1)
+        data_handling = create_data_handling(parallel, domain_size, periodicity=periodicity[:dim],
+                                             default_ghost_layers=1)
 
-    dim = dataHandling.dim
+    dim = data_handling.dim
     if force:
         kwargs['force'] = tuple([force, 0, 0][:dim])
-        assert dataHandling.periodicity[0]
-        step = LatticeBoltzmannStep(dataHandling=dataHandling, name="forceDrivenChannel", **kwargs)
-    elif pressureDifference:
-        inflow = FixedDensity(1.0 + pressureDifference)
+        assert data_handling.periodicity[0]
+        step = LatticeBoltzmannStep(data_handling=data_handling, name="forceDrivenChannel", **kwargs)
+    elif pressure_difference:
+        inflow = FixedDensity(1.0 + pressure_difference)
         outflow = FixedDensity(1.0)
-        step = LatticeBoltzmannStep(dataHandling=dataHandling, name="pressureDrivenChannel", **kwargs)
-        step.boundaryHandling.setBoundary(inflow, sliceFromDirection('W', dim))
-        step.boundaryHandling.setBoundary(outflow, sliceFromDirection('E', dim))
+        step = LatticeBoltzmannStep(data_handling=data_handling, name="pressureDrivenChannel", **kwargs)
+        step.boundary_handling.set_boundary(inflow, slice_from_direction('W', dim))
+        step.boundary_handling.set_boundary(outflow, slice_from_direction('E', dim))
     elif u_max:
         if duct:
             raise NotImplementedError("Velocity inflow for duct flows not yet implemented")
-        step = LatticeBoltzmannStep(dataHandling=dataHandling, name="velocityDrivenChannel", **kwargs)
-        diameter = diameterCallback(np.array([0]), domainSize)[0] if diameterCallback else min(domainSize[1:])
-        addParabolicVelocityInflow(step.boundaryHandling, u_max, sliceFromDirection('W', dim),
-                                   velCoord=0, diameter=diameter)
+        step = LatticeBoltzmannStep(data_handling=data_handling, name="velocityDrivenChannel", **kwargs)
+        diameter = diameter_callback(np.array([0]), domain_size)[0] if diameter_callback else min(domain_size[1:])
+        add_parabolic_velocity_inflow(step.boundary_handling, u_max, slice_from_direction('W', dim),
+                                      vel_coord=0, diameter=diameter)
         outflow = FixedDensity(1.0)
-        step.boundaryHandling.setBoundary(outflow, sliceFromDirection('E', dim))
+        step.boundary_handling.set_boundary(outflow, slice_from_direction('E', dim))
     else:
         assert False
 
-    setupChannelWalls(step.boundaryHandling, diameterCallback, duct, wallBoundary)
+    setup_channel_walls(step.boundary_handling, diameter_callback, duct, wall_boundary)
     return step
 
diff --git a/simplificationfactory.py b/simplificationfactory.py
index 0948b7a6b3d34862f00b37b5429d1b7651349fa0..c8ef784c46f060e1da8e762c0a30e312f51761dd 100644
--- a/simplificationfactory.py
+++ b/simplificationfactory.py
@@ -1,44 +1,44 @@
 from functools import partial
 import sympy as sp
 
-from lbmpy.innerloopsplit import createLbmSplitGroups
+from lbmpy.innerloopsplit import create_lbm_split_groups
 from lbmpy.methods.cumulantbased import CumulantBasedLbMethod
 from pystencils.assignment_collection.simplifications import apply_to_all_assignments, \
     subexpression_substitution_in_main_assignments, sympy_cse, add_subexpressions_for_divisions
 
 
-def createSimplificationStrategy(lbmMethod, doCseInOpposingDirections=False, doOverallCse=False, splitInnerLoop=False):
+def create_simplification_strategy(lb_method, cse_pdfs=False, cse_global=False, split_inner_loop=False):
     from pystencils.assignment_collection import SimplificationStrategy
     from lbmpy.methods import MomentBasedLbMethod
-    from lbmpy.methods.momentbasedsimplifications import replaceSecondOrderVelocityProducts, \
-        factorDensityAfterFactoringRelaxationTimes, factorRelaxationRates, cseInOpposingDirections, \
-        replaceCommonQuadraticAndConstantTerm, replaceDensityAndVelocity
+    from lbmpy.methods.momentbasedsimplifications import replace_second_order_velocity_products, \
+        factor_density_after_factoring_relaxation_times, factor_relaxation_rates, cse_in_opposing_directions, \
+        replace_common_quadratic_and_constant_term, replace_density_and_velocity
 
     s = SimplificationStrategy()
 
     expand = partial(apply_to_all_assignments, operation=sp.expand)
     expand.__name__ = "expand"
 
-    if isinstance(lbmMethod, MomentBasedLbMethod):
+    if isinstance(lb_method, MomentBasedLbMethod):
         s.add(expand)
-        s.add(replaceSecondOrderVelocityProducts)
+        s.add(replace_second_order_velocity_products)
         s.add(expand)
-        s.add(factorRelaxationRates)
-        s.add(replaceDensityAndVelocity)
-        s.add(replaceCommonQuadraticAndConstantTerm)
-        s.add(factorDensityAfterFactoringRelaxationTimes)
+        s.add(factor_relaxation_rates)
+        s.add(replace_density_and_velocity)
+        s.add(replace_common_quadratic_and_constant_term)
+        s.add(factor_density_after_factoring_relaxation_times)
         s.add(subexpression_substitution_in_main_assignments)
-        if splitInnerLoop:
-            s.add(createLbmSplitGroups)
-    elif isinstance(lbmMethod, CumulantBasedLbMethod):
+        if split_inner_loop:
+            s.add(create_lbm_split_groups)
+    elif isinstance(lb_method, CumulantBasedLbMethod):
         s.add(expand)
-        s.add(factorRelaxationRates)
+        s.add(factor_relaxation_rates)
 
     s.add(add_subexpressions_for_divisions)
 
-    if doCseInOpposingDirections:
-        s.add(cseInOpposingDirections)
-    if doOverallCse:
+    if cse_pdfs:
+        s.add(cse_in_opposing_directions)
+    if cse_global:
         s.add(sympy_cse)
 
     return s
diff --git a/stencils.py b/stencils.py
index e73407cc906b5da151f497eb1268e29659e3cb9c..c663840d600654416406cece540b6d212d334ff3 100644
--- a/stencils.py
+++ b/stencils.py
@@ -1,7 +1,7 @@
 import sympy as sp
 
 
-def getStencil(name, ordering='walberla'):
+def get_stencil(name, ordering='walberla'):
     """
     Stencils are tuples of discrete velocities. They are commonly labeled in the 'DxQy' notation, where d is the
     dimension (length of the velocity tuples) and y is number of discrete velocities.
@@ -13,16 +13,16 @@ def getStencil(name, ordering='walberla'):
                      the literature.
     """
     try:
-        return getStencil.data[name.upper()][ordering.lower()]
+        return get_stencil.data[name.upper()][ordering.lower()]
     except KeyError:
-        errMsg = ""
-        for stencil, orderingNames in getStencil.data.items():
-            errMsg += "  %s: %s\n" % (stencil, ", ".join(orderingNames.keys()))
+        err_msg = ""
+        for stencil, orderingNames in get_stencil.data.items():
+            err_msg += "  %s: %s\n" % (stencil, ", ".join(orderingNames.keys()))
 
-        raise ValueError("No such stencil available. Available stencils: <stencilName>( <orderingNames> )\n" + errMsg)
+        raise ValueError("No such stencil available. Available stencils: <stencilName>( <orderingNames> )\n" + err_msg)
 
 
-getStencil.data = {
+get_stencil.data = {
     'D2Q9': {
         'walberla': ((0, 0),
                      (0, 1), (0, -1), (-1, 0), (1, 0),
@@ -37,19 +37,19 @@ getStencil.data = {
     'D3Q15': {
         'walberla':
             ((0, 0, 0),
-            (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
-            (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1), (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1)),
+             (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
+             (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1), (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1)),
         'premnath': ((0, 0, 0),
                      (1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1),
                      (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1),
                      (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1)),
     },
     'D3Q19': {
-        'walberla':((0, 0, 0),
-                    (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
-                    (-1, 1, 0), (1, 1, 0), (-1, -1, 0), (1, -1, 0),
-                    (0, 1, 1), (0, -1, 1), (-1, 0, 1), (1, 0, 1),
-                    (0, 1, -1), (0, -1, -1), (-1, 0, -1), (1, 0, -1)),
+        'walberla': ((0, 0, 0),
+                     (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
+                     (-1, 1, 0), (1, 1, 0), (-1, -1, 0), (1, -1, 0),
+                     (0, 1, 1), (0, -1, 1), (-1, 0, 1), (1, 0, 1),
+                     (0, 1, -1), (0, -1, -1), (-1, 0, -1), (1, 0, -1)),
         'braunschweig':  ((0, 0, 0),
                           (1, 0, 0), (-1, 0, 0),
                           (0, 1, 0), (0, -1, 0),
@@ -68,53 +68,54 @@ getStencil.data = {
     },
     'D3Q27': {
         'walberla': ((0, 0, 0),
-                  (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
-                  (-1, 1, 0), (1, 1, 0), (-1, -1, 0), (1, -1, 0),
-                  (0, 1, 1), (0, -1, 1), (-1, 0, 1), (1, 0, 1),
-                  (0, 1, -1), (0, -1, -1), (-1, 0, -1), (1, 0, -1),
-                  (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1), (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1)),
+                     (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1),
+                     (-1, 1, 0), (1, 1, 0), (-1, -1, 0), (1, -1, 0),
+                     (0, 1, 1), (0, -1, 1), (-1, 0, 1), (1, 0, 1),
+                     (0, 1, -1), (0, -1, -1), (-1, 0, -1), (1, 0, -1),
+                     (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1), (1, 1, -1), (-1, 1, -1), (1, -1, -1),
+                     (-1, -1, -1)),
         'premnath': ((0, 0, 0),
-                  (1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1),
-                  (1, 1, 0), (-1, 1, 0), (1, -1, 0), (-1, -1, 0),
-                  (1, 0, 1), (-1, 0, 1), (1, 0, -1), (-1, 0, -1),
-                  (0, 1, 1), (0, -1, 1), (0, 1, -1), (0, -1, -1),
-                  (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1),
-                  (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1))
+                     (1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1),
+                     (1, 1, 0), (-1, 1, 0), (1, -1, 0), (-1, -1, 0),
+                     (1, 0, 1), (-1, 0, 1), (1, 0, -1), (-1, 0, -1),
+                     (0, 1, 1), (0, -1, 1), (0, 1, -1), (0, -1, -1),
+                     (1, 1, 1), (-1, 1, 1), (1, -1, 1), (-1, -1, 1),
+                     (1, 1, -1), (-1, 1, -1), (1, -1, -1), (-1, -1, -1))
     }
 }
 
 
-def inverseDirection(direction):
+def inverse_direction(direction):
     """Returns inverse i.e. negative of given direction tuple"""
     return tuple([-i for i in direction])
 
 
-def isValidStencil(stencil, maxNeighborhood=None):
+def is_valid_stencil(stencil, max_neighborhood=None):
     """
     Tests if a nested sequence is a valid stencil i.e. all the inner sequences have the same length.
-    If maxNeighborhood is specified, it is also verified that the stencil does not contain any direction components
+    If max_neighborhood is specified, it is also verified that the stencil does not contain any direction components
     with absolute value greater than the maximal neighborhood.
     """
-    expectedDim = len(stencil[0])
+    expected_dim = len(stencil[0])
     for d in stencil:
-        if len(d) != expectedDim:
+        if len(d) != expected_dim:
             return False
-        if maxNeighborhood is not None:
+        if max_neighborhood is not None:
             for d_i in d:
-                if abs(d_i) > maxNeighborhood:
+                if abs(d_i) > max_neighborhood:
                     return False
     return True
 
 
-def isSymmetricStencil(stencil):
+def is_symmetric_stencil(stencil):
     """Tests for every direction d, that -d is also in the stencil"""
     for d in stencil:
-        if inverseDirection(d) not in stencil:
+        if inverse_direction(d) not in stencil:
             return False
     return True
 
 
-def stencilsHaveSameEntries(s1, s2):
+def stencils_have_same_entries(s1, s2):
     if len(s1) != len(s2):
         return False
     return len(set(s1) - set(s2)) == 0
@@ -122,10 +123,10 @@ def stencilsHaveSameEntries(s1, s2):
 
 # -------------------------------------- Visualization -----------------------------------------------------------------
 
-def visualizeStencil(stencil, **kwargs):
+def visualize_stencil(stencil, **kwargs):
     dim = len(stencil[0])
     if dim == 2:
-        visualizeStencil2D(stencil, **kwargs)
+        visualize_stencil_2d(stencil, **kwargs)
     else:
         slicing = False
         if 'slice' in kwargs:
@@ -133,12 +134,12 @@ def visualizeStencil(stencil, **kwargs):
             del kwargs['slice']
 
         if slicing:
-            visualizeStencil3DBySlicing(stencil, **kwargs)
+            visualize_stencil_3d_by_slicing(stencil, **kwargs)
         else:
-            visualizeStencil3D(stencil, **kwargs)
+            visualize_stencil_3d(stencil, **kwargs)
 
 
-def visualizeStencil2D(stencil, axes=None, figure=None, data=None, textsize='12', **kwargs):
+def visualize_stencil_2d(stencil, axes=None, figure=None, data=None, textsize='12', **kwargs):
     """
     Creates a matplotlib 2D plot of the stencil
 
@@ -162,17 +163,17 @@ def visualizeStencil2D(stencil, axes=None, figure=None, data=None, textsize='12'
     if data is None:
         data = list(range(len(stencil)))
 
-    for dir, annotation in zip(stencil, data):
-        assert len(dir) == 2, "Works only for 2D stencils"
+    for direction, annotation in zip(stencil, data):
+        assert len(direction) == 2, "Works only for 2D stencils"
 
-        if not(dir[0] == 0 and dir[1] == 0):
-            axes.arrow(0, 0, dir[0], dir[1], head_width=0.08, head_length=head_length, color='k')
+        if not(direction[0] == 0 and direction[1] == 0):
+            axes.arrow(0, 0, direction[0], direction[1], head_width=0.08, head_length=head_length, color='k')
 
         if isinstance(annotation, sp.Basic):
             annotation = "$" + sp.latex(annotation) + "$"
         else:
             annotation = str(annotation)
-        axes.text(dir[0]*text_offset, dir[1]*text_offset, annotation, verticalalignment='center', zorder=30,
+        axes.text(direction[0]*text_offset, direction[1]*text_offset, annotation, verticalalignment='center', zorder=30,
                   horizontalalignment='center',
                   size=textsize, bbox=dict(boxstyle=text_box_style, facecolor='#00b6eb', alpha=0.85, linewidth=0))
 
@@ -182,45 +183,44 @@ def visualizeStencil2D(stencil, axes=None, figure=None, data=None, textsize='12'
     axes.set_ylim([-text_offset * 1.1, text_offset * 1.1])
 
 
-def visualizeStencil3DBySlicing(stencil, sliceAxis=2, figure=None, data=None, **kwargs):
+def visualize_stencil_3d_by_slicing(stencil, slice_axis=2, figure=None, data=None, **kwargs):
     """
     Visualizes a 3D, first-neighborhood stencil by plotting 3 slices along a given axis
 
     :param stencil: stencil as sequence of directions
-    :param sliceAxis: 0, 1, or 2 indicating the axis to slice through
+    :param slice_axis: 0, 1, or 2 indicating the axis to slice through
     :param data: optional data to print as text besides the arrows
     :return:
     """
     import matplotlib.pyplot as plt
 
-    for dir in stencil:
-        for element in dir:
+    for d in stencil:
+        for element in d:
             assert element == -1 or element == 0 or element == 1, "This function can only first neighborhood stencils"
 
     if figure is None:
         figure = plt.gcf()
 
     axes = [figure.add_subplot(1, 3, i+1) for i in range(3)]
-    #f, axes = plt.subplots(1, 3)
-    splittedDirections = [[], [], []]
-    splittedData = [[], [], []]
-    axesNames = ['x', 'y', 'z']
+    splitted_directions = [[], [], []]
+    splitted_data = [[], [], []]
+    axes_names = ['x', 'y', 'z']
 
-    for i, dir in enumerate(stencil):
-        splitIdx = dir[sliceAxis] + 1
-        reducedDir = tuple([element for j, element in enumerate(dir) if j != sliceAxis])
-        splittedDirections[splitIdx].append(reducedDir)
-        splittedData[splitIdx].append(i if data is None else data[i])
+    for i, d in enumerate(stencil):
+        split_idx = d[slice_axis] + 1
+        reduced_dir = tuple([element for j, element in enumerate(d) if j != slice_axis])
+        splitted_directions[split_idx].append(reduced_dir)
+        splitted_data[split_idx].append(i if data is None else data[i])
 
     for i in range(3):
-        visualizeStencil2D(splittedDirections[i], axes=axes[i], data=splittedData[i], **kwargs)
+        visualize_stencil_2d(splitted_directions[i], axes=axes[i], data=splitted_data[i], **kwargs)
     for i in [-1, 0, 1]:
-        axes[i+1].set_title("Cut at %s=%d" % (axesNames[sliceAxis], i))
+        axes[i+1].set_title("Cut at %s=%d" % (axes_names[slice_axis], i))
 
 
-def visualizeStencil3D(stencil, figure=None, axes=None, data=None, textsize='8'):
+def visualize_stencil_3d(stencil, figure=None, axes=None, data=None, textsize='8'):
     """
-    Draws 3D stencil into a 3D coordinate system, parameters are similar to :func:`visualizeStencil2D`
+    Draws 3D stencil into a 3D coordinate system, parameters are similar to :func:`visualize_stencil_2d`
     If data is None, no labels are drawn. To draw the labels as in the 2D case, use ``data=list(range(len(stencil)))``
     """
     from matplotlib.patches import FancyArrowPatch
@@ -259,19 +259,19 @@ def visualizeStencil3D(stencil, figure=None, axes=None, data=None, textsize='8')
         if np.sum(np.abs(s - e)) == r[1] - r[0]:
             axes.plot3D(*zip(s, e), color="k", alpha=0.5)
 
-    for dir, annotation in zip(stencil, data):
-        assert len(dir) == 3, "Works only for 3D stencils"
-        if not(dir[0] == 0 and dir[1] == 0 and dir[2] == 0):
-            if dir[0] == 0:
+    for d, annotation in zip(stencil, data):
+        assert len(d) == 3, "Works only for 3D stencils"
+        if not(d[0] == 0 and d[1] == 0 and d[2] == 0):
+            if d[0] == 0:
                 color = '#348abd'
-            elif dir[1] == 0:
+            elif d[1] == 0:
                 color = '#fac364'
-            elif sum([abs(d) for d in dir]) == 2:
+            elif sum([abs(d) for d in d]) == 2:
                 color = '#95bd50'
             else:
                 color = '#808080'
 
-            a = Arrow3D([0, dir[0]], [0, dir[1]], [0, dir[2]], mutation_scale=20, lw=2, arrowstyle="-|>", color=color)
+            a = Arrow3D([0, d[0]], [0, d[1]], [0, d[2]], mutation_scale=20, lw=2, arrowstyle="-|>", color=color)
             axes.add_artist(a)
 
         if annotation:
@@ -280,7 +280,7 @@ def visualizeStencil3D(stencil, figure=None, axes=None, data=None, textsize='8')
             else:
                 annotation = str(annotation)
 
-            axes.text(dir[0]*text_offset, dir[1]*text_offset, dir[2]*text_offset,
+            axes.text(d[0]*text_offset, d[1]*text_offset, d[2]*text_offset,
                       annotation, verticalalignment='center', zorder=30,
                       size=textsize, bbox=dict(boxstyle=text_box_style, facecolor='#777777', alpha=0.6, linewidth=0))
 
@@ -288,4 +288,3 @@ def visualizeStencil3D(stencil, figure=None, axes=None, data=None, textsize='8')
     axes.set_ylim([-text_offset * 1.1, text_offset * 1.1])
     axes.set_zlim([-text_offset * 1.1, text_offset * 1.1])
     axes.set_axis_off()
-
diff --git a/turbulence_models.py b/turbulence_models.py
index 19f5a4ab3247d5a19c876ec00b379b8c02260fcf..e76b00e680f540ce6db2de6fa99f917d6b9d80e6 100644
--- a/turbulence_models.py
+++ b/turbulence_models.py
@@ -1,40 +1,42 @@
 import sympy as sp
 
 from pystencils import Assignment
-from lbmpy.relaxationrates import getShearRelaxationRate
+from lbmpy.relaxationrates import get_shear_relaxation_rate
 
 
-def secondOrderMomentTensor(functionValues, stencil):
+def second_order_moment_tensor(function_values, stencil):
     """Returns (D x D) Matrix of second order moments of the given function where D is the dimension"""
-    assert len(functionValues) == len(stencil)
+    assert len(function_values) == len(stencil)
     dim = len(stencil[0])
-    return sp.Matrix(dim, dim, lambda i, j: sum(c[i] * c[j] * f for f, c in zip(functionValues, stencil)))
+    return sp.Matrix(dim, dim, lambda i, j: sum(c[i] * c[j] * f for f, c in zip(function_values, stencil)))
 
 
-def frobeniusNorm(matrix, factor=1):
+def frobenius_norm(matrix, factor=1):
     """Computes the Frobenius norm of a matrix defined as the square root of the sum of squared matrix elements
     The optional factor is added inside the square root"""
     return sp.sqrt(sum(i * i for i in matrix) * factor)
 
 
-def addSmagorinskyModel(collisionRule, smagorinskyConstant, omegaOutputField=None):
-    method = collisionRule.method
-    omega_s = getShearRelaxationRate(method)
-    fNeq = sp.Matrix(method.preCollisionPdfSymbols) - method.getEquilibriumTerms()
+def add_smagorinsky_model(collision_rule, smagorinsky_constant, omega_output_field=None):
+    method = collision_rule.method
+    omega_s = get_shear_relaxation_rate(method)
+    f_neq = sp.Matrix(method.pre_collision_pdf_symbols) - method.get_equilibrium_terms()
 
     tau_0 = sp.Symbol("tau_0_")
-    secondOrderNeqMoments = sp.Symbol("Pi")
-    rho = method.zerothOrderEquilibriumMomentSymbol if method.conservedQuantityComputation.compressible else 1
-    adaptedOmega = sp.Symbol("smagorinskyOmega")
+    second_order_neq_moments = sp.Symbol("Pi")
+    rho = method.zeroth_order_equilibrium_moment_symbol if method.conserved_quantity_computation.compressible else 1
+    adapted_omega = sp.Symbol("smagorinskyOmega")
 
     # for derivation see notebook demo_custom_LES_model.pynb
     eqs = [Assignment(tau_0, 1 / omega_s),
-           Assignment(secondOrderNeqMoments, frobeniusNorm(secondOrderMomentTensor(fNeq, method.stencil), factor=2) / rho),
-           Assignment(adaptedOmega, 2 / (tau_0 + sp.sqrt(18 * smagorinskyConstant**2 * secondOrderNeqMoments + tau_0**2)))]
-    collisionRule.subexpressions += eqs
-    collisionRule.topological_sort(sort_subexpressions=True, sort_main_assignments=False)
+           Assignment(second_order_neq_moments,
+                      frobenius_norm(second_order_moment_tensor(f_neq, method.stencil), factor=2) / rho),
+           Assignment(adapted_omega,
+                      2 / (tau_0 + sp.sqrt(18 * smagorinsky_constant ** 2 * second_order_neq_moments + tau_0 ** 2)))]
+    collision_rule.subexpressions += eqs
+    collision_rule.topological_sort(sort_subexpressions=True, sort_main_assignments=False)
 
-    if omegaOutputField:
-        collisionRule.main_assignments.append(Assignment(omegaOutputField.center, adaptedOmega))
+    if omega_output_field:
+        collision_rule.main_assignments.append(Assignment(omega_output_field.center, adapted_omega))
 
-    return collisionRule
+    return collision_rule
diff --git a/updatekernels.py b/updatekernels.py
index 3ce41df8d1a2991faf7524af94118800127a235e..46f9241fe53b2f8b7c0714718e1efb3a6ce3929b 100644
--- a/updatekernels.py
+++ b/updatekernels.py
@@ -3,7 +3,7 @@ import sympy as sp
 
 from pystencils import Field, Assignment
 from pystencils.assignment_collection.assignment_collection import AssignmentCollection
-from pystencils.field import createNumpyArrayWithLayout, layoutStringToTuple
+from pystencils.field import create_numpy_array_with_layout, layout_string_to_tuple
 from pystencils.sympyextensions import fast_subs
 from lbmpy.methods.abstractlbmethod import LbmCollisionRule
 from lbmpy.fieldaccess import StreamPullTwoFieldsAccessor, PeriodicTwoFieldsAccessor, CollideOnlyInplaceAccessor
@@ -12,165 +12,170 @@ from lbmpy.fieldaccess import StreamPullTwoFieldsAccessor, PeriodicTwoFieldsAcce
 # -------------------------------------------- LBM Kernel Creation -----------------------------------------------------
 
 
-def createLBMKernel(collisionRule, inputField, outputField, accessor):
-    """
-    Replaces the pre- and post collision symbols in the collision rule by field accesses.
-
-    :param collisionRule:  instance of LbmCollisionRule, defining the collision step
-    :param inputField: field used for reading pdf values
-    :param outputField: field used for writing pdf values (may be the same as input field for certain accessors)
-    :param accessor: instance of PdfFieldAccessor, defining where to read and write values
-                     to create e.g. a fused stream-collide kernel
-    :return: LbmCollisionRule where pre- and post collision symbols have been replaced
+def create_lbm_kernel(collision_rule, input_field, output_field, accessor):
+    """Replaces the pre- and post collision symbols in the collision rule by field accesses.
+
+    Args:
+        collision_rule:  instance of LbmCollisionRule, defining the collision step
+        input_field: field used for reading pdf values
+        output_field: field used for writing pdf values (may be the same as input field for certain accessors)
+        accessor: instance of PdfFieldAccessor, defining where to read and write values
+                  to create e.g. a fused stream-collide kernel
+
+    Returns:
+        LbmCollisionRule where pre- and post collision symbols have been replaced
     """
-    method = collisionRule.method
-    preCollisionSymbols = method.preCollisionPdfSymbols
-    postCollisionSymbols = method.postCollisionPdfSymbols
+    method = collision_rule.method
+    pre_collision_symbols = method.pre_collision_pdf_symbols
+    post_collision_symbols = method.post_collision_pdf_symbols
     substitutions = {}
 
-    inputAccesses = accessor.read(inputField, method.stencil)
-    outputAccesses = accessor.write(outputField, method.stencil)
+    input_accesses = accessor.read(input_field, method.stencil)
+    output_accesses = accessor.write(output_field, method.stencil)
 
-    for (idx, offset), inputAccess, outputAccess in zip(enumerate(method.stencil), inputAccesses, outputAccesses):
-        substitutions[preCollisionSymbols[idx]] = inputAccess
-        substitutions[postCollisionSymbols[idx]] = outputAccess
+    for (idx, offset), inputAccess, outputAccess in zip(enumerate(method.stencil), input_accesses, output_accesses):
+        substitutions[pre_collision_symbols[idx]] = inputAccess
+        substitutions[post_collision_symbols[idx]] = outputAccess
 
-    result = collisionRule.new_with_substitutions(substitutions)
+    result = collision_rule.new_with_substitutions(substitutions)
 
-    if 'splitGroups' in result.simplification_hints:
-        newSplitGroups = []
-        for splitGroup in result.simplification_hints['splitGroups']:
-            newSplitGroups.append([fast_subs(e, substitutions) for e in splitGroup])
-        result.simplification_hints['splitGroups'] = newSplitGroups
+    if 'split_groups' in result.simplification_hints:
+        new_split_groups = []
+        for splitGroup in result.simplification_hints['split_groups']:
+            new_split_groups.append([fast_subs(e, substitutions) for e in splitGroup])
+        result.simplification_hints['split_groups'] = new_split_groups
 
     return result
 
 
-def createStreamPullCollideKernel(collisionRule, numpyField=None, srcFieldName="src", dstFieldName="dst",
-                                  genericLayout='numpy', genericFieldType=np.float64,
-                                  builtinPeriodicity=(False, False, False)):
+def create_stream_pull_collide_kernel(collision_rule, numpy_arr=None, src_field_name="src", dst_field_name="dst",
+                                      generic_layout='numpy', generic_field_type=np.float64,
+                                      builtin_periodicity=(False, False, False)):
+    """Implements a stream-pull scheme, where values are read from source and written to destination field.
+
+    Args:
+        collision_rule: a collision rule created by lbm method
+        numpy_arr: optional numpy field for PDFs. Used to create a kernel of fixed loop bounds and strides
+                    if None, a generic kernel is created
+        src_field_name: name of the pdf source field
+        dst_field_name: name of the pdf destination field
+        generic_layout: if no numpy_arr is given to determine the layout, a variable sized field with the given
+                       generic_layout is used
+        generic_field_type: if no numpy_arr is given, this data type is used for the fields
+        builtin_periodicity: periodicity that should be built into the kernel
+
+    Returns:
+        lbm update rule, where generic pdf references are replaced by field accesses
     """
-    Implements a stream-pull scheme, where values are read from source and written to destination field
-    :param collisionRule: a collision rule created by lbm method
-    :param numpyField: optional numpy field for PDFs. Used to create a kernel of fixed loop bounds and strides
-                       if None, a generic kernel is created
-    :param srcFieldName: name of the pdf source field
-    :param dstFieldName: name of the pdf destination field
-    :param genericLayout: if no numpyField is given to determine the layout, a variable sized field with the given
-                          genericLayout is used
-    :param genericFieldType: if no numpyField is given, this data type is used for the fields
-    :param builtinPeriodicity: periodicity that should be built into the kernel
-    :return: lbm update rule, where generic pdf references are replaced by field accesses
-    """
-    dim = collisionRule.method.dim
-    if numpyField is not None:
-        assert len(numpyField.shape) == dim + 1, "Field dimension mismatch: dimension is %s, should be %d" % \
-                                                 (len(numpyField.shape), dim + 1)
-
-    if numpyField is None:
-        src = Field.createGeneric(srcFieldName, dim, indexDimensions=1, layout=genericLayout, dtype=genericFieldType)
-        dst = Field.createGeneric(dstFieldName, dim, indexDimensions=1, layout=genericLayout, dtype=genericFieldType)
+    dim = collision_rule.method.dim
+    if numpy_arr is not None:
+        assert len(numpy_arr.shape) == dim + 1, "Field dimension mismatch: dimension is %s, should be %d" % \
+                                                (len(numpy_arr.shape), dim + 1)
+
+    if numpy_arr is None:
+        src = Field.create_generic(src_field_name, dim, index_dimensions=1, layout=generic_layout, dtype=generic_field_type)
+        dst = Field.create_generic(dst_field_name, dim, index_dimensions=1, layout=generic_layout, dtype=generic_field_type)
     else:
-        src = Field.createFromNumpyArray(srcFieldName, numpyField, indexDimensions=1)
-        dst = Field.createFromNumpyArray(dstFieldName, numpyField, indexDimensions=1)
+        src = Field.create_from_numpy_array(src_field_name, numpy_arr, index_dimensions=1)
+        dst = Field.create_from_numpy_array(dst_field_name, numpy_arr, index_dimensions=1)
 
     accessor = StreamPullTwoFieldsAccessor
 
-    if any(builtinPeriodicity):
-        accessor = PeriodicTwoFieldsAccessor(builtinPeriodicity, ghostLayers=1)
-    return createLBMKernel(collisionRule, src, dst, accessor)
+    if any(builtin_periodicity):
+        accessor = PeriodicTwoFieldsAccessor(builtin_periodicity, ghost_layers=1)
+    return create_lbm_kernel(collision_rule, src, dst, accessor)
 
 
-def createCollideOnlyKernel(collisionRule, numpyField=None, fieldName="src",
-                            genericLayout='numpy', genericFieldType=np.float64):
-    """
-    Implements a collision only (no neighbor access) LBM kernel.
-    For parameters see function ``createStreamPullCollideKernel``
+def create_collide_only_kernel(collision_rule, numpy_arr=None, field_name="src",
+                               generic_layout='numpy', generic_field_type=np.float64):
+    """Implements a collision only (no neighbor access) LBM kernel.
+
+    For parameters see function ``create_stream_pull_collide_kernel``
     """
-    dim = collisionRule.method.dim
-    if numpyField is not None:
-        assert len(numpyField.shape) == dim + 1, "Field dimension mismatch: dimension is %s, should be %d" % \
-                                                 (len(numpyField.shape), dim + 1)
+    dim = collision_rule.method.dim
+    if numpy_arr is not None:
+        assert len(numpy_arr.shape) == dim + 1, "Field dimension mismatch: dimension is %s, should be %d" % \
+                                                (len(numpy_arr.shape), dim + 1)
 
-    if numpyField is None:
-        field = Field.createGeneric(fieldName, dim, indexDimensions=1, layout=genericLayout, dtype=genericFieldType)
+    if numpy_arr is None:
+        field = Field.create_generic(field_name, dim, index_dimensions=1, layout=generic_layout, dtype=generic_field_type)
     else:
-        field = Field.createFromNumpyArray(fieldName, numpyField, indexDimensions=1)
+        field = Field.create_from_numpy_array(field_name, numpy_arr, index_dimensions=1)
 
-    return createLBMKernel(collisionRule, field, field, CollideOnlyInplaceAccessor)
+    return create_lbm_kernel(collision_rule, field, field, CollideOnlyInplaceAccessor)
 
 
-def createStreamPullOnlyKernel(stencil, numpyField=None, srcFieldName="src", dstFieldName="dst",
-                               genericLayout='numpy', genericFieldType=np.float64):
-    """
-    Creates a stream-pull kernel, without collision
-    For parameters see function ``createStreamPullCollideKernel``
+def create_stream_pull_only_kernel(stencil, numpy_arr=None, src_field_name="src", dst_field_name="dst",
+                                   generic_layout='numpy', generic_field_type=np.float64):
+    """Creates a stream-pull kernel, without collision.
+
+    For parameters see function ``create_stream_pull_collide_kernel``
     """
 
     dim = len(stencil[0])
-    if numpyField is None:
-        src = Field.createGeneric(srcFieldName, dim, indexDimensions=1, layout=genericLayout, dtype=genericFieldType)
-        dst = Field.createGeneric(dstFieldName, dim, indexDimensions=1, layout=genericLayout, dtype=genericFieldType)
+    if numpy_arr is None:
+        src = Field.create_generic(src_field_name, dim, index_dimensions=1,
+                                   layout=generic_layout, dtype=generic_field_type)
+        dst = Field.create_generic(dst_field_name, dim, index_dimensions=1,
+                                   layout=generic_layout, dtype=generic_field_type)
     else:
-        src = Field.createFromNumpyArray(srcFieldName, numpyField, indexDimensions=1)
-        dst = Field.createFromNumpyArray(dstFieldName, numpyField, indexDimensions=1)
+        src = Field.create_from_numpy_array(src_field_name, numpy_arr, index_dimensions=1)
+        dst = Field.create_from_numpy_array(dst_field_name, numpy_arr, index_dimensions=1)
 
     accessor = StreamPullTwoFieldsAccessor()
-    eqs = [Assignment(a, b) for a, b in zip(accessor.write(dst, stencil), accessor.read(src, stencil))
-           if Assignment(a, b) != True]
+    eqs = [Assignment(a, b) for a, b in zip(accessor.write(dst, stencil), accessor.read(src, stencil))]
     return AssignmentCollection(eqs, [])
 
 
-def createStreamPullWithOutputKernel(lbMethod, srcField, dstField, output):
-    stencil = lbMethod.stencil
-    cqc = lbMethod.conservedQuantityComputation
+def create_stream_pull_with_output_kernel(lb_method, src_field, dst_field, output):
+    stencil = lb_method.stencil
+    cqc = lb_method.conserved_quantity_computation
     streamed = sp.symbols("streamed_:%d" % (len(stencil),))
     accessor = StreamPullTwoFieldsAccessor()
-    streamEqs = [Assignment(a, b) for a, b in zip(streamed, accessor.read(srcField, stencil))
-                 if Assignment(a, b) != True]
-    outputEqCollection = cqc.outputEquationsFromPdfs(streamed, output)
-    writeEqs = [Assignment(a, b) for a, b in zip(accessor.write(dstField, stencil), streamed)]
+    stream_assignments = [Assignment(a, b) for a, b in zip(streamed, accessor.read(src_field, stencil))]
+    output_eq_collection = cqc.output_equations_from_pdfs(streamed, output)
+    write_eqs = [Assignment(a, b) for a, b in zip(accessor.write(dst_field, stencil), streamed)]
 
-    subExprs = streamEqs + outputEqCollection.subexpressions
-    mainEqs = outputEqCollection.main_assignments + writeEqs
-    return LbmCollisionRule(lbMethod, mainEqs, subExprs, simplification_hints=outputEqCollection.simplification_hints)
+    subexpressions = stream_assignments + output_eq_collection.subexpressions
+    main_eqs = output_eq_collection.main_assignments + write_eqs
+    return LbmCollisionRule(lb_method, main_eqs, subexpressions,
+                            simplification_hints=output_eq_collection.simplification_hints)
 
 # ---------------------------------- Pdf array creation for various layouts --------------------------------------------
 
 
-def createPdfArray(size, numDirections, ghostLayers=1, layout='fzyx'):
-    """
-    Creates an empty numpy array for a pdf field with the specified memory layout.
+def create_pdf_array(size, num_directions, ghost_layers=1, layout='fzyx'):
+    """Creates an empty numpy array for a pdf field with the specified memory layout.
 
     Examples:
-        >>> createPdfArray((3, 4, 5), 9, layout='zyxf', ghostLayers=0).shape
+        >>> create_pdf_array((3, 4, 5), 9, layout='zyxf', ghost_layers=0).shape
         (3, 4, 5, 9)
-        >>> createPdfArray((3, 4, 5), 9, layout='zyxf', ghostLayers=0).strides
+        >>> create_pdf_array((3, 4, 5), 9, layout='zyxf', ghost_layers=0).strides
         (72, 216, 864, 8)
-        >>> createPdfArray((3, 4), 9, layout='zyxf', ghostLayers=1).shape
+        >>> create_pdf_array((3, 4), 9, layout='zyxf', ghost_layers=1).shape
         (5, 6, 9)
-        >>> createPdfArray((3, 4), 9, layout='zyxf', ghostLayers=1).strides
+        >>> create_pdf_array((3, 4), 9, layout='zyxf', ghost_layers=1).strides
         (72, 360, 8)
     """
-    sizeWithGl = [s + 2 * ghostLayers for s in size]
+    size_with_gl = [s + 2 * ghost_layers for s in size]
     dim = len(size)
     if isinstance(layout, str):
-        layout = layoutStringToTuple(layout, dim+1)
-    return createNumpyArrayWithLayout(sizeWithGl + [numDirections], layout)
+        layout = layout_string_to_tuple(layout, dim + 1)
+    return create_numpy_array_with_layout(size_with_gl + [num_directions], layout)
 
 
 # ------------------------------------------- Add output fields to kernel ----------------------------------------------
 
 
-def addOutputFieldForConservedQuantities(collisionRule, conservedQuantitiesToOutputFieldDict):
-    method = collisionRule.method
-    cqc = method.conservedQuantityComputation.outputEquationsFromPdfs(method.preCollisionPdfSymbols,
-                                                                      conservedQuantitiesToOutputFieldDict)
-    return collisionRule.new_merged(cqc)
+def add_output_field_for_conserved_quantities(collision_rule, conserved_quantities_to_output_field_dict):
+    method = collision_rule.method
+    cqc = method.conserved_quantity_computation.output_equations_from_pdfs(method.pre_collision_pdf_symbols,
+                                                                           conserved_quantities_to_output_field_dict)
+    return collision_rule.new_merged(cqc)
 
 
-def writeQuantitiesToField(collisionRule, symbols, outputField):
+def write_quantities_to_field(collision_rule, symbols, output_field):
     if not hasattr(symbols, "__len__"):
         symbols = [symbols]
-    eqs = [Assignment(outputField(i), s) for i, s in enumerate(symbols)]
-    return collisionRule.copy(collisionRule.main_assignments + eqs)
+    eqs = [Assignment(output_field(i), s) for i, s in enumerate(symbols)]
+    return collision_rule.copy(collision_rule.main_assignments + eqs)