- assignment collection
- sympyextensions

- added documentation
- PEP8 renaming

- Previously sympy.Eq was used to represent assignments. However Eq
  represents equality not assignment. This means that sometimes sympy
  "simplified" an equation like a = a  to True,
-> replaced sp.Eq by pystencils.Assignment everywhere
- renamed EquationCollection to AssignmentCollection

- switched to google style docstrings
- removed dead code
- started to annotate types

for fields without index dimensions the indices (0,) and () have been
treated equivalently, but did not compare equal

- notebooks are considered in coverage analysis now
   -> custom notebook runner plugin adapted
- added images for documentation

- shortened the longest running tests, moved some configurations
  to longrun

Modified the gitlab-ci for benchmarking purposes
Created a new Dockerfile for benchmarking purposes, which includes the
intel compiler.
Docker file now has likwid installed as well.
Created a machine file for the benchmarking machine.
Kerncraft updated and fixed.

TODOs:
    - cleanup of the yaml files
    - Test the Skylake machine file and kerncraft_coupling for correct
      behaviour

-> one place to switch between cpu and gpu

label -> target
ceIdx -> superscript

- merged finite difference functions into one function
- put derivative operators from lbmpy into pystencils

- in-kernel Neumann boundaries
- flag-interface for boundary handling makes one flag field multiple
  boundary handlings possible
- generator: support for bitwise logical operators

- splitted existing LBM boundary handling into two parts:
    -> generic part , that is used for FD as well and moved it to pystencils
    -> LBM specific part - remained in lbmpy

- bugfixes

- step class for LB phasefield generic enough to work with 3-phase and
  N-phase models
- cahn hilliard can either be solved by LBM or by finite differences
- 3 phase model can be solved with rho phase or without

- now an lbMethod or updateRule can be passed in directly
- made method/update rule/ast function independent i.e. no function
  uses the same parameters as on of the others

- 3 phase model works now with step sytem

- plotting
- calculation of force on boundary
- vtk outpu

- previously all objects where cached by id()
- for waLBerla simulations in each time step a new np.array view
  is created from the waLBerla field. Each of these views has a
  different id -> caching did not work for waLBerla setups
- changed hash for numpy arrays: instead of id, a tuple of
  (dataPtr, strides, shapes) is used as hash input

- Step working for serial CPU scenarios

- scaling interface width eta instead of surface tensions tau to correct
  interface profile & surface tensions

João Victor Tozatti Risso authored 7 years ago and Martin Bauer committed 7 years ago

Concept: Generate code involving the (un)packing of fields (from)to linear
(1D) arrays, i.e. (de)serialization of the field values for buffered
communication.

A linear index is generated for the buffer, by inferring the strides and
variables of the loops over fields in the AST. In the CPU, this information is
obtained through the makeLoopOverDomain function, in
pystencils/transformations/transformations.py. On CUDA, the strides of
the fields (excluding buffers) are combined with the indexing variables to infer
the indexing of the buffer.

What is supported:
    - code generation for both CPU and GPU
    - (un)packing of fields with all the memory layouts supported by
    pystencils
    - (un)packing slices of fields (from)into the buffer
    - (un)packing subsets of cell values from the fields (from)into the buffer

Limitations:

- assumes that only one buffer and one field are being operated within
each kernel, however multiple equations involving the buffer and the
field are supported.

- (un)packing multiple cell values (from)into the buffer is supported,
however it is limited to the fields with indexDimensions=1. The same
applies to (un)packing subset of cell values of each cell.

Changes in this commit:

- add the FieldType enumeration to pystencils/field.py, to mark fields
of various types. This is replaces and is a generalization of the
isIndexedField boolean flag of the Field class. For now, the types
supported are: generic, indexed and buffer fields.

- add the fieldType property to the Field class, which indicates the
type of the field. Modifications were also performed to the member
functions of the Field class to add this property.

- add resolveBufferAccesses function, which replaces the fields marked
as buffers with the actual field access in the AST traversal.

Miscelaneous changes:

- add blockDim and gridDim variables as CUDA indexing variables.