pystencils_tests/benchmark/iacaMarks.h

-/*
-* Copyright (2008-2009) Intel Corporation All Rights Reserved. 
-* The source code contained or described herein and all documents 
-* related to the source code ("Material") are owned by Intel Corporation 
-* or its suppliers or licensors. Title to the Material remains with 
-* Intel Corporation or its suppliers and licensors. The Material 
-* contains trade secrets and proprietary and confidential information 
-* of Intel or its suppliers and licensors. The Material is protected 
-* by worldwide copyright and trade secret laws and treaty provisions. 
-* No part of the Material may be used, copied, reproduced, modified, 
-* published, uploaded, posted, transmitted, distributed, or disclosed 
-* in any way without Intel(R)s prior express written permission.
-*
-* No license under any patent, copyright, trade secret or other 
-* intellectual property right is granted to or conferred upon you by 
-* disclosure or delivery of the Materials, either expressly, by implication,
-* inducement, estoppel or otherwise. Any license under such intellectual 
-* property rights must be express and approved by Intel in writing.
-*/
-
-#if defined (__GNUC__) 
-#define IACA_SSC_MARK( MARK_ID )						\
-__asm__ __volatile__ (									\
-					  "\n\t  movl $"#MARK_ID", %%ebx"	\
-					  "\n\t  .byte 0x64, 0x67, 0x90"	\
-					  : : : "memory" );
-
-#else
-#define IACA_SSC_MARK(x) {__asm  mov ebx, x\
-	__asm  _emit 0x64 \
-	__asm  _emit 0x67 \
-	__asm  _emit 0x90 }
-#endif
-
-#define IACA_START {IACA_SSC_MARK(111)}
-#define IACA_END {IACA_SSC_MARK(222)}
-
-#ifdef _WIN64
-#include <intrin.h>
-#define IACA_VC64_START __writegsbyte(111, 111);
-#define IACA_VC64_END   __writegsbyte(222, 222);
-#endif
-
-/**************** asm *****************
-;START_MARKER
-mov ebx, 111
-db 0x64, 0x67, 0x90
-
-;END_MARKER
-mov ebx, 222
-db 0x64, 0x67, 0x90
-
-**************************************/

pystencils_tests/benchmark/main.c

-#include "iacaMarks.h"
-
-int main(int argc, char * argv[]){
-	int a = 0;
-	for(int i = 0; i < argc+100000; i++){
-		IACA_START
-		a += i;
-	}
-	IACA_END
-	return a;
-}

pystencils_tests/kerncraft_inputs/2d-5pt.c

-double a[30][50][3];
-double b[30][50][3];
-double s;
-
-for(int j=1; j<30-1; ++j)
-    for(int i=1; i<50-1; ++i)
-        b[j][i] = ( a[j][i-1] + a[j][i+1]
-                  + a[j-1][i] + a[j+1][i]) * s;

pystencils_tests/kerncraft_inputs/3d-7pt.c

-double a[M][N][N];
-double b[M][N][N];
-double s;
-
-for(int k=1; k<M-1; ++k)
-    for(int j=1; j<N-1; ++j)
-        for(int i=1; i<N-1; ++i)
-            b[k][j][i] = ( a[k][j][i-1] + a[k][j][i+1]
-                         + a[k][j-1][i] + a[k][j+1][i]
-                         + a[k-1][j][i] + a[k+1][j][i]) * s;

pystencils_tests/kerncraft_inputs/default_machine_file.yaml

-kerncraft version: 0.7.3
-clock: 2.7 GHz
-cores per socket: 8
-cores per NUMA domain: 8
-NUMA domains per socket: 1
-model type: Intel Core SandyBridge EP processor
-model name: Intel(R) Xeon(R) CPU E5-2680 0 @ 2.70GHz
-sockets: 2
-threads per core: 2
-cacheline size: 64 B
-compiler:
-    !!omap
-    - icc: -O3 -xAVX -fno-alias -qopenmp
-    - clang: -O3 -march=corei7-avx -mtune=corei7-avx -D_POSIX_C_SOURCE=200112L -fopenmp
-    - gcc: -O3 -march=corei7-avx -D_POSIX_C_SOURCE=200112L -fopenmp
-micro-architecture: SNB
-FLOPs per cycle:
-    SP: {total: 16, ADD: 8, MUL: 8}
-    DP: {total: 8, ADD: 4, MUL: 4}
-overlapping model:
-    ports: ["0", "0DV", "1", "2", "3", "4", "5"]
-    performance counter metric:
-        Max(UOPS_DISPATCHED_PORT_PORT_0:PMC[0-3],
-            UOPS_DISPATCHED_PORT_PORT_1:PMC[0-3],
-            UOPS_DISPATCHED_PORT_PORT_4:PMC[0-3],
-            UOPS_DISPATCHED_PORT_PORT_5:PMC[0-3])
-non-overlapping model:
-    ports: ["2D", "3D"]
-    performance counter metric: T_OL + T_L1L2 + T_L2L3 + T_L3MEM
-write-allocate: True
-memory hierarchy:
-    - level: L1
-      cache per group: {
-         'sets': 64, 'ways': 8, 'cl_size': 64, # 32 kB
-         'replacement_policy': 'LRU',
-         'write_allocate': True, 'write_back': True,
-         'load_from': 'L2', 'store_to': 'L2'}
-      cores per group: 1
-      threads per group: 2
-      groups: 16
-      performance counter metrics:
-          accesses: MEM_UOPS_RETIRED_LOADS:PMC[0-3]
-          misses: L1D_REPLACEMENT:PMC[0-3]
-          evicts: L1D_M_EVICT:PMC[0-3]
-    - level: L2
-      cache per group: {
-         'sets': 512, 'ways': 8, 'cl_size': 64, # 256 kB
-         'replacement_policy': 'LRU',
-         'write_allocate': True, 'write_back': True,
-         'load_from': 'L3', 'store_to': 'L3'}
-      cores per group: 1
-      threads per group: 2
-      groups: 16
-      non-overlap upstream throughput: [32 B/cy, 'half-duplex']
-      performance counter metrics:
-          accesses: L1D_REPLACEMENT:PMC[0-3]
-          misses: L2_LINES_IN_ALL:PMC[0-3]
-          evicts: L2_TRANS_L2_WB:PMC[0-3]
-    - level: L3
-      cache per group: {
-         'sets': 20480, 'ways': 16, 'cl_size': 64, # 20 MB
-         'replacement_policy': 'LRU',
-         'write_allocate': True, 'write_back': True}
-      cores per group: 8
-      threads per group: 16
-      groups: 2
-      non-overlap upstream throughput: [32 B/cy, 'half-duplex']
-      performance counter metrics:
-          accesses: L2_LINES_IN_ALL:PMC[0-3]
-          misses: (CAS_COUNT_RD:MBOX0C[01] + CAS_COUNT_RD:MBOX1C[01] +
-                   CAS_COUNT_RD:MBOX2C[01] + CAS_COUNT_RD:MBOX3C[01])
-          evicts: (CAS_COUNT_WR:MBOX0C[01] + CAS_COUNT_WR:MBOX1C[01] +
-                   CAS_COUNT_WR:MBOX2C[01] + CAS_COUNT_WR:MBOX3C[01])
-    - level: MEM
-      cores per group: 8
-      non-overlap upstream throughput: ['full socket memory bandwidth', 'half-duplex']
-      size per group: null
-      threads per group: 16
-benchmarks:
-  kernels:
-    copy:
-      FLOPs per iteration: 0
-      read streams: {bytes: 8.00 B, streams: 1}
-      read+write streams: {bytes: 0.00 B, streams: 0}
-      write streams: {bytes: 8.00 B, streams: 1}
-    daxpy:
-      FLOPs per iteration: 2
-      read streams: {bytes: 16.00 B, streams: 2}
-      read+write streams: {bytes: 8.00 B, streams: 1}
-      write streams: {bytes: 8.00 B, streams: 1}
-    load:
-      FLOPs per iteration: 0
-      read streams: {bytes: 8.00 B, streams: 1}
-      read+write streams: {bytes: 0.00 B, streams: 0}
-      write streams: {bytes: 0.00 B, streams: 0}
-    triad:
-      FLOPs per iteration: 2
-      read streams: {bytes: 24.00 B, streams: 3}
-      read+write streams: {bytes: 0.00 B, streams: 0}
-      write streams: {bytes: 8.00 B, streams: 1}
-    update:
-      FLOPs per iteration: 0
-      read streams: {bytes: 8.00 B, streams: 1}
-      read+write streams: {bytes: 8.00 B, streams: 1}
-      write streams: {bytes: 8.00 B, streams: 1}
-  measurements:
-    L1:
-      1:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [81.98 GB/s, 163.75 GB/s, 245.62 GB/s, 327.69 GB/s, 409.41 GB/s, 489.83
-              GB/s, 571.67 GB/s, 653.50 GB/s]
-          daxpy: [71.55 GB/s, 143.01 GB/s, 214.86 GB/s, 286.26 GB/s, 355.60 GB/s,
-            426.71 GB/s, 497.45 GB/s, 568.97 GB/s]
-          load: [61.92 GB/s, 122.79 GB/s, 183.01 GB/s, 244.30 GB/s, 306.76 GB/s, 368.46
-              GB/s, 427.41 GB/s, 490.88 GB/s]
-          triad: [81.61 GB/s, 163.25 GB/s, 244.92 GB/s, 326.65 GB/s, 406.69 GB/s,
-            487.76 GB/s, 569.10 GB/s, 650.39 GB/s]
-          update: [84.03 GB/s, 168.02 GB/s, 252.10 GB/s, 335.94 GB/s, 419.90 GB/s,
-            503.88 GB/s, 587.86 GB/s, 671.88 GB/s]
-        size per core: [16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB,
-          16.00 kB, 16.00 kB]
-        size per thread: [16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00
-            kB, 16.00 kB, 16.00 kB]
-        threads: [1, 2, 3, 4, 5, 6, 7, 8]
-        threads per core: 1
-        total size: [16.00 kB, 32.00 kB, 48.00 kB, 64.00 kB, 80.00 kB, 96.00 kB, 112.00
-            kB, 128.00 kB]
-      2:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [79.53 GB/s, 158.70 GB/s, 238.20 GB/s, 317.62 GB/s, 397.09 GB/s, 476.33
-              GB/s, 555.69 GB/s, 634.96 GB/s]
-          daxpy: [70.94 GB/s, 141.90 GB/s, 212.97 GB/s, 283.91 GB/s, 354.93 GB/s,
-            425.85 GB/s, 496.74 GB/s, 567.40 GB/s]
-          load: [57.01 GB/s, 114.11 GB/s, 171.11 GB/s, 228.13 GB/s, 285.15 GB/s, 342.11
-              GB/s, 399.11 GB/s, 456.11 GB/s]
-          triad: [79.48 GB/s, 159.03 GB/s, 238.53 GB/s, 318.04 GB/s, 392.11 GB/s,
-            477.10 GB/s, 538.36 GB/s, 636.02 GB/s]
-          update: [82.75 GB/s, 165.55 GB/s, 248.50 GB/s, 331.32 GB/s, 414.06 GB/s,
-            496.82 GB/s, 579.83 GB/s, 662.36 GB/s]
-        size per core: [16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB, 16.00 kB,
-          16.00 kB, 16.00 kB]
-        size per thread: [8.00 kB, 8.00 kB, 8.00 kB, 8.00 kB, 8.00 kB, 8.00 kB, 8.00
-            kB, 8.00 kB]
-        threads: [2, 4, 6, 8, 10, 12, 14, 16]
-        threads per core: 2
-        total size: [16.00 kB, 32.00 kB, 48.00 kB, 64.00 kB, 80.00 kB, 96.00 kB, 112.00
-            kB, 128.00 kB]
-    L2:
-      1:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [41.28 GB/s, 81.96 GB/s, 120.28 GB/s, 160.70 GB/s, 203.22 GB/s, 239.97
-              GB/s, 271.13 GB/s, 307.01 GB/s]
-          daxpy: [48.85 GB/s, 98.62 GB/s, 143.29 GB/s, 197.76 GB/s, 230.58 GB/s, 284.98
-              GB/s, 334.22 GB/s, 385.72 GB/s]
-          load: [38.51 GB/s, 76.67 GB/s, 114.73 GB/s, 152.90 GB/s, 188.69 GB/s, 223.64
-              GB/s, 265.21 GB/s, 289.41 GB/s]
-          triad: [40.92 GB/s, 83.49 GB/s, 124.48 GB/s, 165.24 GB/s, 206.74 GB/s, 237.90
-              GB/s, 274.96 GB/s, 329.09 GB/s]
-          update: [50.37 GB/s, 100.05 GB/s, 145.43 GB/s, 196.82 GB/s, 244.07 GB/s,
-            301.62 GB/s, 336.88 GB/s, 403.78 GB/s]
-        size per core: [128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00
-            kB, 128.00 kB, 128.00 kB]
-        size per thread: [128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00
-            kB, 128.00 kB, 128.00 kB]
-        threads: [1, 2, 3, 4, 5, 6, 7, 8]
-        threads per core: 1
-        total size: [128.00 kB, 256.00 kB, 384.00 kB, 512.00 kB, 640.00 kB, 768.00
-            kB, 0.90 MB, 1.02 MB]
-      2:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [42.17 GB/s, 83.47 GB/s, 124.57 GB/s, 163.78 GB/s, 202.56 GB/s, 242.80
-              GB/s, 276.95 GB/s, 311.36 GB/s]
-          daxpy: [50.87 GB/s, 98.72 GB/s, 152.12 GB/s, 193.48 GB/s, 251.36 GB/s, 301.72
-              GB/s, 352.55 GB/s, 365.28 GB/s]
-          load: [39.62 GB/s, 79.03 GB/s, 118.03 GB/s, 157.85 GB/s, 196.48 GB/s, 237.44
-              GB/s, 276.81 GB/s, 309.71 GB/s]
-          triad: [44.80 GB/s, 88.35 GB/s, 125.13 GB/s, 169.94 GB/s, 209.60 GB/s, 260.15
-              GB/s, 300.75 GB/s, 333.08 GB/s]
-          update: [49.80 GB/s, 100.70 GB/s, 150.56 GB/s, 196.44 GB/s, 251.90 GB/s,
-            280.93 GB/s, 352.74 GB/s, 399.27 GB/s]
-        size per core: [128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00 kB, 128.00
-            kB, 128.00 kB, 128.00 kB]
-        size per thread: [64.00 kB, 64.00 kB, 64.00 kB, 64.00 kB, 64.00 kB, 64.00
-            kB, 64.00 kB, 64.00 kB]
-        threads: [2, 4, 6, 8, 10, 12, 14, 16]
-        threads per core: 2
-        total size: [128.00 kB, 256.00 kB, 384.00 kB, 512.00 kB, 640.00 kB, 768.00
-            kB, 0.90 MB, 1.02 MB]
-    L3:
-      1:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [23.21 GB/s, 46.01 GB/s, 67.96 GB/s, 90.17 GB/s, 111.47 GB/s, 133.14
-              GB/s, 153.84 GB/s, 174.92 GB/s]
-          daxpy: [30.35 GB/s, 60.32 GB/s, 90.00 GB/s, 119.71 GB/s, 148.87 GB/s, 178.39
-              GB/s, 207.10 GB/s, 236.25 GB/s]
-          load: [23.35 GB/s, 46.52 GB/s, 69.57 GB/s, 92.60 GB/s, 115.77 GB/s, 138.89
-              GB/s, 161.82 GB/s, 184.11 GB/s]
-          triad: [25.18 GB/s, 50.08 GB/s, 74.33 GB/s, 98.78 GB/s, 122.66 GB/s, 146.78
-              GB/s, 170.52 GB/s, 194.47 GB/s]
-          update: [32.67 GB/s, 64.65 GB/s, 95.98 GB/s, 127.29 GB/s, 157.67 GB/s, 188.22
-              GB/s, 217.41 GB/s, 246.99 GB/s]
-        size per core: [1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25
-            MB, 1.25 MB]
-        size per thread: [1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25
-            MB, 1.25 MB]
-        threads: [1, 2, 3, 4, 5, 6, 7, 8]
-        threads per core: 1
-        total size: [1.25 MB, 2.50 MB, 3.75 MB, 5.00 MB, 6.25 MB, 7.50 MB, 8.75 MB,
-          10.00 MB]
-      2:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [23.83 GB/s, 47.25 GB/s, 69.84 GB/s, 92.61 GB/s, 114.31 GB/s, 136.48
-              GB/s, 157.55 GB/s, 178.99 GB/s]
-          daxpy: [31.52 GB/s, 62.72 GB/s, 93.43 GB/s, 124.29 GB/s, 154.55 GB/s, 185.18
-              GB/s, 215.10 GB/s, 245.24 GB/s]
-          load: [27.63 GB/s, 54.93 GB/s, 81.57 GB/s, 108.63 GB/s, 134.91 GB/s, 161.72
-              GB/s, 188.15 GB/s, 214.94 GB/s]
-          triad: [25.90 GB/s, 51.76 GB/s, 76.73 GB/s, 102.29 GB/s, 126.17 GB/s, 152.10
-              GB/s, 176.71 GB/s, 200.64 GB/s]
-          update: [34.10 GB/s, 67.67 GB/s, 100.62 GB/s, 133.50 GB/s, 165.61 GB/s,
-            197.74 GB/s, 228.73 GB/s, 259.05 GB/s]
-        size per core: [1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25 MB, 1.25
-            MB, 1.25 MB]
-        size per thread: [625.00 kB, 625.00 kB, 625.00 kB, 625.00 kB, 625.00 kB, 625.00
-            kB, 625.00 kB, 625.00 kB]
-        threads: [2, 4, 6, 8, 10, 12, 14, 16]
-        threads per core: 2
-        total size: [1.25 MB, 2.50 MB, 3.75 MB, 5.00 MB, 6.25 MB, 7.50 MB, 8.75 MB,
-          10.00 MB]
-    MEM:
-      1:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [11.60 GB/s, 21.29 GB/s, 25.94 GB/s, 27.28 GB/s, 27.47 GB/s, 27.36
-              GB/s, 27.21 GB/s, 27.12 GB/s]
-          daxpy: [17.33 GB/s, 31.89 GB/s, 38.65 GB/s, 40.50 GB/s, 40.81 GB/s, 40.62
-              GB/s, 40.59 GB/s, 40.26 GB/s]
-          load: [12.01 GB/s, 23.04 GB/s, 32.79 GB/s, 40.21 GB/s, 43.39 GB/s, 44.14
-              GB/s, 44.42 GB/s, 44.40 GB/s]
-          triad: [12.73 GB/s, 24.27 GB/s, 30.43 GB/s, 31.46 GB/s, 31.77 GB/s, 31.74
-              GB/s, 31.65 GB/s, 31.52 GB/s]
-          update: [18.91 GB/s, 32.43 GB/s, 37.28 GB/s, 39.98 GB/s, 40.99 GB/s, 40.92
-              GB/s, 40.61 GB/s, 40.34 GB/s]
-        size per core: [40.00 MB, 20.00 MB, 13.33 MB, 10.00 MB, 8.00 MB, 6.67 MB,
-          5.71 MB, 5.00 MB]
-        size per thread: [40.00 MB, 20.00 MB, 13.33 MB, 10.00 MB, 8.00 MB, 6.67 MB,
-          5.71 MB, 5.00 MB]
-        threads: [1, 2, 3, 4, 5, 6, 7, 8]
-        threads per core: 1
-        total size: [40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB]
-      2:
-        cores: [1, 2, 3, 4, 5, 6, 7, 8]
-        results:
-          copy: [10.92 GB/s, 20.62 GB/s, 25.34 GB/s, 26.22 GB/s, 26.32 GB/s, 26.31
-              GB/s, 26.22 GB/s, 26.16 GB/s]
-          daxpy: [17.15 GB/s, 31.96 GB/s, 38.12 GB/s, 39.19 GB/s, 39.38 GB/s, 39.16
-              GB/s, 39.06 GB/s, 38.87 GB/s]
-          load: [13.49 GB/s, 25.92 GB/s, 36.16 GB/s, 41.56 GB/s, 43.34 GB/s, 43.40
-              GB/s, 43.01 GB/s, 42.66 GB/s]
-          triad: [12.38 GB/s, 23.17 GB/s, 28.69 GB/s, 29.98 GB/s, 30.50 GB/s, 30.59
-              GB/s, 30.75 GB/s, 30.70 GB/s]
-          update: [19.67 GB/s, 34.93 GB/s, 39.93 GB/s, 40.79 GB/s, 40.43 GB/s, 40.03
-              GB/s, 39.62 GB/s, 39.33 GB/s]
-        size per core: [40.00 MB, 20.00 MB, 13.33 MB, 10.00 MB, 8.00 MB, 6.67 MB,
-          5.71 MB, 5.00 MB]
-        size per thread: [20.00 MB, 10.00 MB, 6.67 MB, 5.00 MB, 4.00 MB, 3.33 MB,
-          2.86 MB, 2.50 MB]
-        threads: [2, 4, 6, 8, 10, 12, 14, 16]
-        threads per core: 2
-        total size: [40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB, 40.00 MB]
-

pystencils_tests/test_address_of.py

-"""
-Test of pystencils.data_types.address_of
-"""
-
-import pystencils
-from pystencils.data_types import PointerType, address_of, cast_func
-from pystencils.simp.simplifications import sympy_cse
-
-
-def test_address_of():
-    x, y = pystencils.fields('x,y: int64[2d]')
-    s = pystencils.TypedSymbol('s', PointerType('int64'))
-
-    assignments = pystencils.AssignmentCollection({
-        s: address_of(x[0, 0]),
-        y[0, 0]: cast_func(s, 'int64')
-    }, {})
-
-    ast = pystencils.create_kernel(assignments)
-    code = pystencils.show_code(ast)
-    print(code)
-
-    assignments = pystencils.AssignmentCollection({
-        y[0, 0]: cast_func(address_of(x[0, 0]), 'int64')
-    }, {})
-
-    ast = pystencils.create_kernel(assignments)
-    code = pystencils.show_code(ast)
-    print(code)
-
-
-def test_address_of_with_cse():
-    x, y = pystencils.fields('x,y: int64[2d]')
-
-    assignments = pystencils.AssignmentCollection({
-        y[0, 0]: cast_func(address_of(x[0, 0]), 'int64'),
-        x[0, 0]: cast_func(address_of(x[0, 0]), 'int64') + 1
-    }, {})
-
-    ast = pystencils.create_kernel(assignments)
-    code = pystencils.show_code(ast)
-    assignments_cse = sympy_cse(assignments)
-
-    ast = pystencils.create_kernel(assignments_cse)
-    code = pystencils.show_code(ast)
-    print(code)

pystencils_tests/test_assignment_collection.py

-import sympy as sp
-
-from pystencils import Assignment, AssignmentCollection
-from pystencils.simp.assignment_collection import SymbolGen
-
-
-def test_assignment_collection():
-    x, y, z, t = sp.symbols("x y z t")
-    symbol_gen = SymbolGen("a")
-
-    ac = AssignmentCollection([Assignment(z, x + y)],
-                              [], subexpression_symbol_generator=symbol_gen)
-
-    lhs = ac.add_subexpression(t)
-    assert lhs == sp.Symbol("a_0")
-    ac.subexpressions.append(Assignment(t, 3))
-    ac.topological_sort(sort_main_assignments=False, sort_subexpressions=True)
-    assert ac.subexpressions[0].lhs == t
-
-    assert ac.new_with_inserted_subexpression(sp.Symbol("not_defined")) == ac
-    ac_inserted = ac.new_with_inserted_subexpression(t)
-    ac_inserted2 = ac.new_without_subexpressions({lhs})
-    assert all(a == b for a, b in zip(ac_inserted.all_assignments, ac_inserted2.all_assignments))
-
-    print(ac_inserted)
-    assert ac_inserted.subexpressions[0] == Assignment(lhs, 3)
-
-    assert 'a_0' in str(ac_inserted)
-    assert '<table' in ac_inserted._repr_html_()

pystencils_tests/test_basic_usage_llvm.ipynb

-%% Cell type:markdown id: tags:
-
-# pystencils - LLVM generation
-The generation of LLVM code is simliar but not identical as seen with the C++ version. For the generation itself a python module ``llvmlite`` is used. This module provides the necessary support and bindings for LLVM. In order to generate from the AST to llvm, the AST needs to be transformed to support type conversions. This is the biggest difference to the C++ version. C++ doesn't need that since the language itself handles the casts.
-
-In this example a simple weighted Jacobi kernel is generated, so the focus remains on the part of LLVM generation.
-
-%% Cell type:code id: tags:
-
-``` python
-import sympy as sp
-import numpy as np
-import ctypes
-from pystencils import Field, Assignment
-from pystencils import create_kernel
-from pystencils.display_utils import to_dot
-
-sp.init_printing()
-```
-
-%% Cell type:markdown id: tags:
-
-The numpy arrays (with inital values) create *Field*s for the update Rule. Later those arrays are used for the computation itself.
-
-%% Cell type:code id: tags:
-
-``` python
-src_arr = np.zeros((30, 20))
-src_arr[0,:] = 1.0
-src_arr[:,0] = 1.0
-dst_arr = src_arr.copy()
-
-src_field = Field.create_from_numpy_array('src', src_arr)
-dst_field = Field.create_from_numpy_array('dst', dst_arr)
-```
-
-%% Cell type:markdown id: tags:
-
-Using the *Field* objects and the additional *Symbol* $\omega$ for the weight the update rule is specified as a *sympy* equation.
-
-%% Cell type:code id: tags:
-
-``` python
-omega = sp.symbols("omega")
-update_rule = Assignment(dst_field[0,0], omega * (src_field[0,1] + src_field[0,-1] + src_field[1,0] + src_field[-1,0]) / 4
-                   + (1.-omega)*src_field[0,0])
-update_rule
-```
-
-%% Output
-
-
-                                ω⋅(src_E + src_N + src_S + src_W)
-    dst_C := src_C⋅(-ω + 1.0) + ─────────────────────────────────
-                                                4
-
-%% Cell type:markdown id: tags:
-
-With this update rule an abstract syntax tree (AST) can be created. This AST can be used to print the LLVM code. The creation follows the same routines as the C++ version does. However at the end there are two more steps. In order to generate LLVM, type casting and pointer arithmetic had to be introduced (which C++ does for you).
-
-%% Cell type:code id: tags:
-
-``` python
-ast = create_kernel([update_rule], target='llvm')
-print(str(ast))
-```
-
-%% Output
-
-    KernelFunction kernel([<double * RESTRICT fd_dst>, <double * RESTRICT const fd_src>, <double omega>])
-    	Block for(ctr_0=1; ctr_0<29; ctr_0+=1)
-    		Block fd_dst_C ← pointer_arithmetic_func(fd_dst, 20*ctr_0)
-    		fd_src_C ← pointer_arithmetic_func(fd_src, 20*ctr_0)
-    		fd_src_E ← pointer_arithmetic_func(fd_src, 20*ctr_0 + 20)
-    		fd_src_W ← pointer_arithmetic_func(fd_src, 20*ctr_0 - 20)
-    		for(ctr_1=1; ctr_1<19; ctr_1+=1)
-    			Block fd_dst_C[ctr_1] ← omega*(fd_src_C[ctr_1 + 1] + fd_src_C[ctr_1 - 1] + fd_src_E[ctr_1] + fd_src_W[ctr_1])/4 + (omega*cast_func(-1, double) + 1.0)*fd_src_C[ctr_1]
-    
-    
-    
-
-%% Cell type:markdown id: tags:
-
-It is possible to examine the AST further.
-
-%% Cell type:code id: tags:
-
-``` python
-to_dot(ast)
-```
-
-%% Output
-
-
-    <graphviz.files.Source at 0x7f2d14f276a0>
-
-%% Cell type:markdown id: tags:
-
-With transformed AST it is now possible to generate and compile the AST into LLVM. Notice that unlike in C++ version, no files are writen to the hard drive (although it is possible).
-
-There are multiple ways how to generate and compile the AST. The most simple one is simillar to the C++ version. Using the ``compile()`` function of the generated AST
-
-You can also manually create a python function with ``make_python_function``.
-
-Another option is obtaining the jit itself with ``generate_and_jit``.
-The function ``generate_and_jit`` first generates and the compiles the AST.
-
-If even more controll is needed, it is possible to use the functions ``generateLLVM`` and ``compileLLVM`` to achieve the same. For further controll, instead of calling ``compileLLVM`` the jit object itself can be created and its necessary functions for the compilation have to be run manually (``parse``, (``optimize``,) ``compile``)
-
-%% Cell type:code id: tags:
-
-``` python
-kernel = ast.compile()
-
-#kernel = make_python_function(ast)
-
-# Or alternativally
-#jit = generate_and_jit(ast)
-# Call: jit('kernel', src_arr, dst_arr)
-```
-
-%% Cell type:markdown id: tags:
-
-The compiled function(s) can be used now. Either call the function (with arguments, if not given before) or call the jit object with the function's name and its arguments. Here, numpy arrays are automatically adjusted with ctypes.
-
-The functions and arguments can be read as well.
-
-**All of the information the jit object has comes from the module which was parsed. If you parse a second module and don't run the compilation step, the module and the compiled code are not the same anymore, thus leading to false information**
-
-%% Cell type:code id: tags:
-
-``` python
-#jit.print_functions()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-for i in range(100):
-    kernel(src=src_arr, dst=dst_arr, omega=2/3)
-    src_arr, dst_arr = dst_arr, src_arr
-
-```
-
-%% Cell type:markdown id: tags:
-
-The output is drawn with matplotlib.
-
-%% Cell type:code id: tags:
-
-``` python
-import matplotlib.pyplot as plt
-from matplotlib import cm
-fig = plt.figure()
-ax = fig.add_subplot(111)
-ax.imshow(dst_arr, cmap=cm.jet)
-plt.show()
-```
-
-%% Output
-
-
-%% Cell type:code id: tags:
-
-``` python
-```

pystencils_tests/test_conditional_vec.py

-import numpy as np
-import sympy as sp
-
-import pystencils as ps
-from pystencils.astnodes import Block, Conditional
-from pystencils.cpu.vectorization import vec_all, vec_any
-
-
-def test_vec_any():
-    data_arr = np.zeros((15, 15))
-
-    data_arr[3:9, 2:7] = 1.0
-    data = ps.fields("data: double[2D]", data=data_arr)
-
-    c = [
-        ps.Assignment(sp.Symbol("t1"), vec_any(data.center() > 0.0)),
-        Conditional(vec_any(data.center() > 0.0), Block([
-            ps.Assignment(data.center(), 2.0)
-        ]))
-    ]
-    ast = ps.create_kernel(c, target='cpu',
-                           cpu_vectorize_info={'instruction_set': 'avx'})
-    kernel = ast.compile()
-    kernel(data=data_arr)
-    np.testing.assert_equal(data_arr[3:9, 0:8], 2.0)
-
-
-def test_vec_all():
-    data_arr = np.zeros((15, 15))
-
-    data_arr[3:9, 2:7] = 1.0
-    data = ps.fields("data: double[2D]", data=data_arr)
-
-    c = [
-        Conditional(vec_all(data.center() > 0.0), Block([
-            ps.Assignment(data.center(), 2.0)
-        ]))
-    ]
-    ast = ps.create_kernel(c, target='cpu',
-                           cpu_vectorize_info={'instruction_set': 'avx'})
-    kernel = ast.compile()
-    before = data_arr.copy()
-    kernel(data=data_arr)
-    np.testing.assert_equal(data_arr, before)
-
-
-def test_boolean_before_loop():
-    t1, t2 = sp.symbols('t1, t2')
-    f_arr = np.ones((10, 10))
-    g_arr = np.zeros_like(f_arr)
-    f, g = ps.fields("f, g : double[2D]", f=f_arr, g=g_arr)
-
-    a = [
-        ps.Assignment(t1, t2 > 0),
-        ps.Assignment(g[0, 0],
-                      sp.Piecewise((f[0, 0], t1), (42, True)))
-    ]
-    ast = ps.create_kernel(a, cpu_vectorize_info={'instruction_set': 'avx'})
-    kernel = ast.compile()
-    kernel(f=f_arr, g=g_arr, t2=1.0)
-    print(g)
-    np.testing.assert_array_equal(g_arr, 1.0)
-    kernel(f=f_arr, g=g_arr, t2=-1.0)
-    np.testing.assert_array_equal(g_arr, 42.0)

pystencils_tests/test_cuda_known_functions.py

-import sympy
-
-import pystencils
-from pystencils.astnodes import get_dummy_symbol
-from pystencils.backends.cuda_backend import CudaSympyPrinter
-from pystencils.data_types import address_of
-
-
-def test_cuda_known_functions():
-    printer = CudaSympyPrinter()
-    print(printer.known_functions)
-
-    x, y = pystencils.fields('x,y: float32 [2d]')
-
-    assignments = pystencils.AssignmentCollection({
-        get_dummy_symbol(): sympy.Function('atomicAdd')(address_of(y.center()), 2),
-        y.center():  sympy.Function('rsqrtf')(x[0, 0])
-    })
-
-    ast = pystencils.create_kernel(assignments, 'gpu')
-    print(pystencils.show_code(ast))
-    kernel = ast.compile()
-    assert(kernel is not None)
-
-
-def test_cuda_but_not_c():
-    x, y = pystencils.fields('x,y: float32 [2d]')
-
-    assignments = pystencils.AssignmentCollection({
-        get_dummy_symbol(): sympy.Function('atomicAdd')(address_of(y.center()), 2),
-        y.center():  sympy.Function('rsqrtf')(x[0, 0])
-    })
-
-    ast = pystencils.create_kernel(assignments, 'cpu')
-    code = str(pystencils.show_code(ast))
-    assert "Not supported" in code
-
-
-def test_cuda_unknown():
-    x, y = pystencils.fields('x,y: float32 [2d]')
-
-    assignments = pystencils.AssignmentCollection({
-        get_dummy_symbol(): sympy.Function('wtf')(address_of(y.center()), 2),
-    })
-
-    ast = pystencils.create_kernel(assignments, 'gpu')
-    code = str(pystencils.show_code(ast))
-    print(code)
-    assert "Not supported in CUDA" in code

pystencils_tests/test_datahandling_parallel.py

-import numpy as np
-import waLBerla as wlb
-
-from pystencils.datahandling.parallel_datahandling import ParallelDataHandling
-from pystencils_tests.test_datahandling import (
-    access_and_gather, kernel_execution_jacobi, reduction, synchronization, vtk_output)
-
-
-def test_access_and_gather():
-    block_size = (4, 7, 1)
-    num_blocks = (3, 2, 1)
-    cells = tuple(a * b for a, b in zip(block_size, num_blocks))
-    blocks = wlb.createUniformBlockGrid(blocks=num_blocks, cellsPerBlock=block_size, oneBlockPerProcess=False,
-                                        periodic=(1, 1, 1))
-    dh = ParallelDataHandling(blocks, default_ghost_layers=2)
-    access_and_gather(dh, cells)
-    synchronization(dh, test_gpu=False)
-    if hasattr(wlb, 'cuda'):
-        synchronization(dh, test_gpu=True)
-
-
-def test_gpu():
-    if not hasattr(wlb, 'cuda'):
-        print("Skip GPU tests because walberla was built without CUDA")
-        return
-
-    block_size = (4, 7, 1)
-    num_blocks = (3, 2, 1)
-    blocks = wlb.createUniformBlockGrid(blocks=num_blocks, cellsPerBlock=block_size, oneBlockPerProcess=False)
-    dh = ParallelDataHandling(blocks, default_ghost_layers=2)
-    dh.add_array('v', values_per_cell=3, dtype=np.int64, ghost_layers=2, gpu=True)
-
-    for b in dh.iterate():
-        b['v'].fill(42)
-    dh.all_to_gpu()
-    for b in dh.iterate():
-        b['v'].fill(0)
-    dh.to_cpu('v')
-    for b in dh.iterate():
-        np.testing.assert_equal(b['v'], 42)
-
-
-def test_kernel():
-
-    for gpu in (True, False):
-        if gpu and not hasattr(wlb, 'cuda'):
-            print("Skipping CUDA tests because walberla was built without GPU support")
-            continue
-
-        # 3D
-        blocks = wlb.createUniformBlockGrid(blocks=(3, 2, 4), cellsPerBlock=(3, 2, 5), oneBlockPerProcess=False)
-        dh = ParallelDataHandling(blocks)
-        kernel_execution_jacobi(dh, test_gpu=gpu)
-        reduction(dh)
-
-        # 2D
-        blocks = wlb.createUniformBlockGrid(blocks=(3, 2, 1), cellsPerBlock=(3, 2, 1), oneBlockPerProcess=False)
-        dh = ParallelDataHandling(blocks, dim=2)
-        kernel_execution_jacobi(dh, test_gpu=gpu)
-        reduction(dh)
-
-
-def test_vtk_output():
-    blocks = wlb.createUniformBlockGrid(blocks=(3, 2, 4), cellsPerBlock=(3, 2, 5), oneBlockPerProcess=False)
-    dh = ParallelDataHandling(blocks)
-    vtk_output(dh)

pystencils_tests/test_destructuring_field_class.py

-import sympy
-
-import pystencils
-from pystencils.astnodes import DestructuringBindingsForFieldClass
-from pystencils.kernelparameters import FieldPointerSymbol, FieldShapeSymbol, FieldStrideSymbol
-
-
-def test_destructuring_field_class():
-    z, x, y = pystencils.fields("z, y, x: [2d]")
-
-    normal_assignments = pystencils.AssignmentCollection([pystencils.Assignment(
-        z[0, 0], x[0, 0] * sympy.log(x[0, 0] * y[0, 0]))], [])
-
-    ast = pystencils.create_kernel(normal_assignments, target='gpu')
-    print(pystencils.show_code(ast))
-
-    ast.body = DestructuringBindingsForFieldClass(ast.body)
-    print(pystencils.show_code(ast))
-    ast.compile()
-
-
-class DestructuringEmojiClass(DestructuringBindingsForFieldClass):
-    CLASS_TO_MEMBER_DICT = {
-        FieldPointerSymbol: "🥶",
-        FieldShapeSymbol: "😳_%i",
-        FieldStrideSymbol: "🥵_%i"
-    }
-    CLASS_NAME_TEMPLATE = "🤯<{dtype}, {ndim}>"
-
-    def __init__(self, node):
-        super().__init__(node)
-        self.headers = []
-
-
-def test_destructuring_alternative_field_class():
-    z, x, y = pystencils.fields("z, y, x: [2d]")
-
-    normal_assignments = pystencils.AssignmentCollection([pystencils.Assignment(
-        z[0, 0], x[0, 0] * sympy.log(x[0, 0] * y[0, 0]))], [])
-
-    ast = pystencils.create_kernel(normal_assignments, target='gpu')
-    ast.body = DestructuringEmojiClass(ast.body)
-    print(pystencils.show_code(ast))

pystencils_tests/test_fd_derivation.ipynb

-%% Cell type:code id: tags:
-
-``` python
-from pystencils.session import *
-from pystencils.fd.derivation import *
-```
-
-%% Cell type:markdown id: tags:
-
-# 2D standard stencils
-
-%% Cell type:code id: tags:
-
-``` python
-stencil = [(-1, 0), (1, 0), (0, -1), (0, 1), (0, 0)]
-standard_2d_00 = FiniteDifferenceStencilDerivation((0,0), stencil)
-f = ps.fields("f: [2D]")
-standard_2d_00_res = standard_2d_00.get_stencil()
-res = standard_2d_00_res.apply(f.center)
-expected = f[-1, 0] - 2 * f[0, 0] + f[1, 0]
-assert res == expected
-```
-
-%% Cell type:code id: tags:
-
-``` python
-assert standard_2d_00_res.accuracy == 2
-assert not standard_2d_00_res.is_isotropic
-standard_2d_00_res
-```
-
-%% Output
-
-    Finite difference stencil of accuracy 2, isotropic error: False
-
-%% Cell type:code id: tags:
-
-``` python
-standard_2d_00.get_stencil().as_matrix()
-```
-
-%% Output
-
-    ---------------------------------------------------------------------------
-    AttributeError                            Traceback (most recent call last)
-    <ipython-input-4-ea41cd8e50a0> in <module>
-    ----> 1 standard_2d_00.get_stencil().as_matrix()
-
-    ~/pystencils/pystencils/pystencils/fd/derivation.py in as_matrix(self)
-        185                 for direction, weight in zip(self.stencil, self.weights):
-        186                     result[max_offset - direction[1], max_offset + direction[0]] = weight
-    --> 187                 result.tomatrix().tomatrix()
-        188                 print("test")
-        189             if dim == 3:
-    ~/anaconda3/envs/pystencils/lib/python3.7/site-packages/sympy/matrices/matrices.py in __getattr__(self, attr)
-       2139         else:
-       2140             raise AttributeError(
-    -> 2141                 "%s has no attribute %s." % (self.__class__.__name__, attr))
-       2142
-       2143     def __len__(self):
-    AttributeError: MutableDenseMatrix has no attribute tomatrix.
-
-%% Cell type:markdown id: tags:
-
-# 2D isotropic stencils
-
-## second x-derivative
-
-%% Cell type:code id: tags:
-
-``` python
-stencil = [(i, j) for i in (-1, 0, 1) for j in (-1, 0, 1)]
-isotropic_2d_00 = FiniteDifferenceStencilDerivation((0,0), stencil)
-isotropic_2d_00_res = isotropic_2d_00.get_stencil(isotropic=True)
-assert isotropic_2d_00_res.is_isotropic
-assert isotropic_2d_00_res.accuracy == 2
-isotropic_2d_00_res
-```
-
-%% Cell type:code id: tags:
-
-``` python
-isotropic_2d_00_res.as_matrix()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-plt.figure(figsize=(2,2))
-isotropic_2d_00_res.visualize()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-expected_result = sp.Matrix([[1, -2, 1], [10, -20, 10], [1, -2, 1]]) / 12
-assert expected_result == isotropic_2d_00_res.as_matrix()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-type(isotropic_2d_00_res.as_matrix())
-```
-
-%% Cell type:code id: tags:
-
-``` python
-type(expected_result)
-```
-
-%% Cell type:markdown id: tags:
-
-## Isotropic laplacian
-
-%% Cell type:code id: tags:
-
-``` python
-isotropic_2d_11 = FiniteDifferenceStencilDerivation((1,1), stencil)
-isotropic_2d_11_res = isotropic_2d_11.get_stencil(isotropic=True)
-iso_laplacian = isotropic_2d_00_res.as_matrix() + isotropic_2d_11_res.as_matrix()
-iso_laplacian
-```
-
-%% Cell type:code id: tags:
-
-``` python
-expected_result = sp.Matrix([[1, 4, 1], [4, -20, 4], [1, 4, 1]]) / 6
-assert iso_laplacian == expected_result
-```

pystencils_tests/test_field.py

-import numpy as np
-import pytest
-import sympy as sp
-
-import pystencils as ps
-from pystencils.field import Field, FieldType
-from pystencils.field import layout_string_to_tuple
-
-
-def test_field_basic():
-    f = Field.create_generic('f', spatial_dimensions=2)
-    assert FieldType.is_generic(f)
-    assert f['E'] == f[1, 0]
-    assert f['N'] == f[0, 1]
-    assert '_' in f.center._latex('dummy')
-
-    f = Field.create_fixed_size('f', (10, 10), strides=(80, 8), dtype=np.float64)
-    assert f.spatial_strides == (10, 1)
-    assert f.index_strides == ()
-    assert f.center_vector == sp.Matrix([f.center])
-
-    f = Field.create_fixed_size('f', (8, 8, 2, 2), index_dimensions=2)
-    assert f.center_vector == sp.Matrix([[f(0, 0), f(0, 1)],
-                                         [f(1, 0), f(1, 1)]])
-    field_access = f[1, 1]
-    assert field_access.nr_of_coordinates == 2
-    assert field_access.offset_name == 'NE'
-    neighbor = field_access.neighbor(coord_id=0, offset=-2)
-    assert neighbor.offsets == (-1, 1)
-    assert '_' in neighbor._latex('dummy')
-
-    f = Field.create_generic('f', spatial_dimensions=5, index_dimensions=2)
-    field_access = f[1, -1, 2, -3, 0](1, 0)
-    assert field_access.offsets == (1, -1, 2, -3, 0)
-    assert field_access.index == (1, 0)
-
-
-def test_error_handling():
-    struct_dtype = np.dtype([('a', np.int32), ('b', np.float64), ('c', np.uint32)])
-    Field.create_generic('f', spatial_dimensions=2, index_dimensions=0, dtype=struct_dtype)
-    with pytest.raises(ValueError) as e:
-        Field.create_generic('f', spatial_dimensions=2, index_dimensions=1, dtype=struct_dtype)
-    assert 'index dimension' in str(e.value)
-
-    arr = np.array([[1, 2.0, 3], [1, 2.0, 3]], dtype=struct_dtype)
-    Field.create_from_numpy_array('f', arr, index_dimensions=0)
-    with pytest.raises(ValueError) as e:
-        Field.create_from_numpy_array('f', arr, index_dimensions=1)
-    assert 'Structured arrays' in str(e.value)
-
-    arr = np.zeros([3, 3, 3])
-    Field.create_from_numpy_array('f', arr, index_dimensions=2)
-    with pytest.raises(ValueError) as e:
-        Field.create_from_numpy_array('f', arr, index_dimensions=3)
-    assert 'Too many' in str(e.value)
-
-    Field.create_fixed_size('f', (3, 2, 4), index_dimensions=0, dtype=struct_dtype, layout='reverse_numpy')
-    with pytest.raises(ValueError) as e:
-        Field.create_fixed_size('f', (3, 2, 4), index_dimensions=1, dtype=struct_dtype, layout='reverse_numpy')
-    assert 'Structured arrays' in str(e.value)
-
-    f = Field.create_fixed_size('f', (10, 10))
-    with pytest.raises(ValueError) as e:
-        f[1]
-    assert 'Wrong number of spatial indices' in str(e.value)
-
-    f = Field.create_generic('f', spatial_dimensions=2, index_shape=(3,))
-    with pytest.raises(ValueError) as e:
-        f(3)
-    assert 'out of bounds' in str(e.value)
-
-    f = Field.create_fixed_size('f', (10, 10, 3, 4), index_dimensions=2)
-    with pytest.raises(ValueError) as e:
-        f(3, 0)
-    assert 'out of bounds' in str(e.value)
-
-    with pytest.raises(ValueError) as e:
-        f(1, 0)(1, 0)
-    assert 'Indexing an already indexed' in str(e.value)
-
-    with pytest.raises(ValueError) as e:
-        f(1)
-    assert 'Wrong number of indices' in str(e.value)
-
-    with pytest.raises(ValueError) as e:
-        Field.create_generic('f', spatial_dimensions=2, layout='wrong')
-    assert 'Unknown layout descriptor' in str(e.value)
-
-    assert layout_string_to_tuple('fzyx', dim=4) == (3, 2, 1, 0)
-    with pytest.raises(ValueError) as e:
-        layout_string_to_tuple('wrong', dim=4)
-    assert 'Unknown layout descriptor' in str(e.value)
-
-
-def test_decorator_scoping():
-    dst = ps.fields('dst : double[2D]')
-
-    def f1():
-        a = sp.Symbol("a")
-
-        def f2():
-            b = sp.Symbol("b")
-
-            @ps.kernel
-            def decorated_func():
-                dst[0, 0] @= a + b
-
-            return decorated_func
-
-        return f2
-
-    assert f1()(), ps.Assignment(dst[0, 0], sp.Symbol("a") + sp.Symbol("b"))
-
-
-def test_string_creation():
-    x, y, z = ps.fields('  x(4),    y(3,5) z : double[  3,  47]')
-    assert x.index_shape == (4,)
-    assert y.index_shape == (3, 5)
-    assert z.spatial_shape == (3, 47)

pystencils_tests/test_indexed_kernels.py

-import numpy as np
-
-from pystencils import Assignment, Field
-from pystencils.cpu import create_indexed_kernel, make_python_function
-
-
-def test_indexed_kernel():
-    arr = np.zeros((3, 4))
-    dtype = np.dtype([('x', int), ('y', int), ('value', arr.dtype)])
-    index_arr = np.zeros((3,), dtype=dtype)
-    index_arr[0] = (0, 2, 3.0)
-    index_arr[1] = (1, 3, 42.0)
-    index_arr[2] = (2, 1, 5.0)
-
-    indexed_field = Field.create_from_numpy_array('index', index_arr)
-    normal_field = Field.create_from_numpy_array('f', arr)
-    update_rule = Assignment(normal_field[0, 0], indexed_field('value'))
-    ast = create_indexed_kernel([update_rule], [indexed_field])
-    kernel = make_python_function(ast)
-    kernel(f=arr, index=index_arr)
-    for i in range(index_arr.shape[0]):
-        np.testing.assert_allclose(arr[index_arr[i]['x'], index_arr[i]['y']], index_arr[i]['value'], atol=1e-13)
-
-
-def test_indexed_cuda_kernel():
-    try:
-        import pycuda
-    except ImportError:
-        pycuda = None
-
-    if pycuda:
-        from pystencils.gpucuda import make_python_function
-        import pycuda.gpuarray as gpuarray
-        from pystencils.gpucuda.kernelcreation import created_indexed_cuda_kernel
-
-        arr = np.zeros((3, 4))
-        dtype = np.dtype([('x', int), ('y', int), ('value', arr.dtype)])
-        index_arr = np.zeros((3,), dtype=dtype)
-        index_arr[0] = (0, 2, 3.0)
-        index_arr[1] = (1, 3, 42.0)
-        index_arr[2] = (2, 1, 5.0)
-
-        indexed_field = Field.create_from_numpy_array('index', index_arr)
-        normal_field = Field.create_from_numpy_array('f', arr)
-        update_rule = Assignment(normal_field[0, 0], indexed_field('value'))
-        ast = created_indexed_cuda_kernel([update_rule], [indexed_field])
-        kernel = make_python_function(ast)
-
-        gpu_arr = gpuarray.to_gpu(arr)
-        gpu_index_arr = gpuarray.to_gpu(index_arr)
-        kernel(f=gpu_arr, index=gpu_index_arr)
-        gpu_arr.get(arr)
-        for i in range(index_arr.shape[0]):
-            np.testing.assert_allclose(arr[index_arr[i]['x'], index_arr[i]['y']], index_arr[i]['value'], atol=1e-13)
-    else:
-        print("Did not run test on GPU since no pycuda is available")

pystencils_tests/test_jacobi_llvm.py

-import numpy as np
-
-from pystencils import Assignment, Field
-from pystencils.llvm import create_kernel, make_python_function
-from pystencils.llvm.llvmjit import generate_and_jit
-
-
-def test_jacobi_fixed_field_size():
-    size = (30, 20)
-
-    src_field_llvm = np.random.rand(*size)
-    src_field_py = np.copy(src_field_llvm)
-    dst_field_llvm = np.zeros(size)
-    dst_field_py = np.zeros(size)
-
-    f = Field.create_from_numpy_array("f", src_field_llvm)
-    d = Field.create_from_numpy_array("d", dst_field_llvm)
-
-    jacobi = Assignment(d[0, 0], (f[1, 0] + f[-1, 0] + f[0, 1] + f[0, -1]) / 4)
-    ast = create_kernel([jacobi])
-
-    for x in range(1, size[0] - 1):
-        for y in range(1, size[1] - 1):
-            dst_field_py[x, y] = 0.25 * (src_field_py[x - 1, y] + src_field_py[x + 1, y] +
-                                         src_field_py[x, y - 1] + src_field_py[x, y + 1])
-
-    jit = generate_and_jit(ast)
-    jit('kernel', dst_field_llvm, src_field_llvm)
-    error = np.sum(np.abs(dst_field_py - dst_field_llvm))
-    np.testing.assert_almost_equal(error, 0.0)
-
-
-def test_jacobi_variable_field_size():
-    size = (3, 3, 3)
-    f = Field.create_generic("f", 3)
-    d = Field.create_generic("d", 3)
-    jacobi = Assignment(d[0, 0, 0], (f[1, 0, 0] + f[-1, 0, 0] + f[0, 1, 0] + f[0, -1, 0]) / 4)
-    ast = create_kernel([jacobi])
-
-    src_field_llvm = np.random.rand(*size)
-    src_field_py = np.copy(src_field_llvm)
-    dst_field_llvm = np.zeros(size)
-    dst_field_py = np.zeros(size)
-
-    for x in range(1, size[0] - 1):
-        for y in range(1, size[1] - 1):
-            for z in range(1, size[2] - 1):
-                dst_field_py[x, y, z] = 0.25 * (src_field_py[x - 1, y, z] + src_field_py[x + 1, y, z] +
-                                                src_field_py[x, y - 1, z] + src_field_py[x, y + 1, z])
-
-    kernel = make_python_function(ast, {'f': src_field_llvm, 'd': dst_field_llvm})
-    kernel()
-    error = np.sum(np.abs(dst_field_py - dst_field_llvm))
-    np.testing.assert_almost_equal(error, 0.0)

pystencils_tests/test_kerncraft_coupling.py

-import os
-
-import numpy as np
-import pytest
-import sympy as sp
-import kerncraft
-
-from pystencils import Assignment, Field
-from pystencils.cpu import create_kernel
-from pystencils.kerncraft_coupling import KerncraftParameters, PyStencilsKerncraftKernel
-from pystencils.kerncraft_coupling.generate_benchmark import generate_benchmark
-
-SCRIPT_FOLDER = os.path.dirname(os.path.realpath(__file__))
-INPUT_FOLDER = os.path.join(SCRIPT_FOLDER, "kerncraft_inputs")
-
-
-@pytest.mark.kernkraft
-def test_compilation():
-    machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
-
-    kernel_file_path = os.path.join(INPUT_FOLDER, "2d-5pt.c")
-    with open(kernel_file_path) as kernel_file:
-        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
-        reference_kernel.as_code('likwid')
-
-    size = [30, 50, 3]
-    arr = np.zeros(size)
-    a = Field.create_from_numpy_array('a', arr, index_dimensions=1)
-    b = Field.create_from_numpy_array('b', arr, index_dimensions=1)
-    s = sp.Symbol("s")
-    rhs = a[0, -1](0) + a[0, 1] + a[-1, 0] + a[1, 0]
-    update_rule = Assignment(b[0, 0], s * rhs)
-    ast = create_kernel([update_rule])
-    mine = generate_benchmark(ast, likwid=False)
-    print(mine)
-
-
-@pytest.mark.kernkraft
-def analysis(kernel, model='ecmdata'):
-    machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
-    if model == 'ecmdata':
-        model = kerncraft.models.ECMData(kernel, machine, KerncraftParameters())
-    elif model == 'ecm':
-        model = kerncraft.models.ECM(kernel, machine, KerncraftParameters())
-        # model.analyze()
-        # model.plot()
-    elif model == 'benchmark':
-        model = kerncraft.models.Benchmark(kernel, machine, KerncraftParameters())
-    else:
-        model = kerncraft.models.ECM(kernel, machine, KerncraftParameters())
-    model.analyze()
-    return model
-
-
-@pytest.mark.kernkraft
-def test_3d_7pt_iaca():
-    # Make sure you use the intel compiler
-    size = [20, 200, 200]
-    kernel_file_path = os.path.join(INPUT_FOLDER, "3d-7pt.c")
-    machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
-    with open(kernel_file_path) as kernel_file:
-        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
-    reference_kernel.set_constant('M', size[0])
-    reference_kernel.set_constant('N', size[1])
-    assert size[1] == size[2]
-    analysis(reference_kernel, model='ecm')
-
-    arr = np.zeros(size)
-    a = Field.create_from_numpy_array('a', arr, index_dimensions=0)
-    b = Field.create_from_numpy_array('b', arr, index_dimensions=0)
-    s = sp.Symbol("s")
-    rhs = a[0, -1, 0] + a[0, 1, 0] + a[-1, 0, 0] + a[1, 0, 0] + a[0, 0, -1] + a[0, 0, 1]
-
-    update_rule = Assignment(b[0, 0, 0], s * rhs)
-    ast = create_kernel([update_rule])
-    k = PyStencilsKerncraftKernel(ast, machine)
-    analysis(k, model='ecm')
-    assert reference_kernel._flops == k._flops
-    # assert reference.results['cl throughput'] == analysis.results['cl throughput']
-
-
-@pytest.mark.kernkraft
-def test_2d_5pt():
-    size = [30, 50, 3]
-    kernel_file_path = os.path.join(INPUT_FOLDER, "2d-5pt.c")
-    with open(kernel_file_path) as kernel_file:
-        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
-    reference = analysis(reference_kernel)
-
-    arr = np.zeros(size)
-    a = Field.create_from_numpy_array('a', arr, index_dimensions=1)
-    b = Field.create_from_numpy_array('b', arr, index_dimensions=1)
-    s = sp.Symbol("s")
-    rhs = a[0, -1](0) + a[0, 1] + a[-1, 0] + a[1, 0]
-    update_rule = Assignment(b[0, 0], s * rhs)
-    ast = create_kernel([update_rule])
-    k = PyStencilsKerncraftKernel(ast)
-    result = analysis(k)
-
-    for e1, e2 in zip(reference.results['cycles'], result.results['cycles']):
-        assert e1 == e2
-
-
-@pytest.mark.kernkraft
-def test_3d_7pt():
-    size = [30, 50, 50]
-    kernel_file_path = os.path.join(INPUT_FOLDER, "3d-7pt.c")
-    with open(kernel_file_path) as kernel_file:
-        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
-    reference_kernel.set_constant('M', size[0])
-    reference_kernel.set_constant('N', size[1])
-    assert size[1] == size[2]
-    reference = analysis(reference_kernel)
-
-    arr = np.zeros(size)
-    a = Field.create_from_numpy_array('a', arr, index_dimensions=0)
-    b = Field.create_from_numpy_array('b', arr, index_dimensions=0)
-    s = sp.Symbol("s")
-    rhs = a[0, -1, 0] + a[0, 1, 0] + a[-1, 0, 0] + a[1, 0, 0] + a[0, 0, -1] + a[0, 0, 1]
-
-    update_rule = Assignment(b[0, 0, 0], s * rhs)
-    ast = create_kernel([update_rule])
-    k = PyStencilsKerncraftKernel(ast)
-    result = analysis(k)
-
-    for e1, e2 in zip(reference.results['cycles'], result.results['cycles']):
-        assert e1 == e2

pystencils_tests/test_opencl.py

-import numpy as np
-import pytest
-import sympy as sp
-
-import pystencils
-from pystencils.backends.cuda_backend import CudaBackend
-from pystencils.backends.opencl_backend import OpenClBackend
-from pystencils.opencl.opencljit import make_python_function
-
-try:
-    import pyopencl as cl
-    HAS_OPENCL = True
-except Exception:
-    HAS_OPENCL = False
-
-
-def test_print_opencl():
-    z, y, x = pystencils.fields("z, y, x: [2d]")
-
-    assignments = pystencils.AssignmentCollection({
-        z[0, 0]: x[0, 0] * sp.log(x[0, 0] * y[0, 0])
-    })
-
-    print(assignments)
-
-    ast = pystencils.create_kernel(assignments, target='gpu')
-
-    print(ast)
-
-    code = pystencils.show_code(ast, custom_backend=CudaBackend())
-    print(code)
-
-    opencl_code = pystencils.show_code(ast, custom_backend=OpenClBackend())
-    print(opencl_code)
-
-    assert "__global double * RESTRICT const _data_x" in str(opencl_code)
-    assert "__global double * RESTRICT" in str(opencl_code)
-    assert "get_local_id(0)" in str(opencl_code)
-
-
-@pytest.mark.skipif(not HAS_OPENCL, reason="Test requires pyopencl")
-def test_opencl_jit_fixed_size():
-    z, y, x = pystencils.fields("z, y, x: [20,30]")
-
-    assignments = pystencils.AssignmentCollection({
-        z[0, 0]: x[0, 0] * sp.log(x[0, 0] * y[0, 0])
-    })
-
-    print(assignments)
-
-    ast = pystencils.create_kernel(assignments, target='gpu')
-
-    print(ast)
-
-    code = pystencils.show_code(ast, custom_backend=CudaBackend())
-    print(code)
-    opencl_code = pystencils.show_code(ast, custom_backend=OpenClBackend())
-    print(opencl_code)
-
-    cuda_kernel = ast.compile()
-    assert cuda_kernel is not None
-
-    import pycuda.gpuarray as gpuarray
-
-    x_cpu = np.random.rand(20, 30)
-    y_cpu = np.random.rand(20, 30)
-    z_cpu = np.random.rand(20, 30)
-
-    x = gpuarray.to_gpu(x_cpu)
-    y = gpuarray.to_gpu(y_cpu)
-    z = gpuarray.to_gpu(z_cpu)
-    cuda_kernel(x=x, y=y, z=z)
-
-    result_cuda = z.get()
-
-    import pyopencl.array as array
-    ctx = cl.create_some_context(0)
-    queue = cl.CommandQueue(ctx)
-
-    x = array.to_device(queue, x_cpu)
-    y = array.to_device(queue, y_cpu)
-    z = array.to_device(queue, z_cpu)
-
-    opencl_kernel = make_python_function(ast, queue, ctx)
-    assert opencl_kernel is not None
-    opencl_kernel(x=x, y=y, z=z)
-
-    result_opencl = z.get(queue)
-
-    assert np.allclose(result_cuda, result_opencl)
-
-
-@pytest.mark.skipif(not HAS_OPENCL, reason="Test requires pyopencl")
-def test_opencl_jit():
-    z, y, x = pystencils.fields("z, y, x: [2d]")
-
-    assignments = pystencils.AssignmentCollection({
-        z[0, 0]: x[0, 0] * sp.log(x[0, 0] * y[0, 0])
-    })
-
-    print(assignments)
-
-    ast = pystencils.create_kernel(assignments, target='gpu')
-
-    print(ast)
-
-    code = pystencils.show_code(ast, custom_backend=CudaBackend())
-    print(code)
-    opencl_code = pystencils.show_code(ast, custom_backend=OpenClBackend())
-    print(opencl_code)
-
-    cuda_kernel = ast.compile()
-    assert cuda_kernel is not None
-
-    import pycuda.gpuarray as gpuarray
-
-    x_cpu = np.random.rand(20, 30)
-    y_cpu = np.random.rand(20, 30)
-    z_cpu = np.random.rand(20, 30)
-
-    x = gpuarray.to_gpu(x_cpu)
-    y = gpuarray.to_gpu(y_cpu)
-    z = gpuarray.to_gpu(z_cpu)
-    cuda_kernel(x=x, y=y, z=z)
-
-    result_cuda = z.get()
-
-    import pyopencl.array as array
-    ctx = cl.create_some_context(0)
-    queue = cl.CommandQueue(ctx)
-
-    x = array.to_device(queue, x_cpu)
-    y = array.to_device(queue, y_cpu)
-    z = array.to_device(queue, z_cpu)
-
-    opencl_kernel = make_python_function(ast, queue, ctx)
-    assert opencl_kernel is not None
-    opencl_kernel(x=x, y=y, z=z)
-
-    result_opencl = z.get(queue)
-
-    assert np.allclose(result_cuda, result_opencl)
-
-
-@pytest.mark.skipif(not HAS_OPENCL, reason="Test requires pyopencl")
-def test_opencl_jit_with_parameter():
-    z, y, x = pystencils.fields("z, y, x: [2d]")
-
-    a = sp.Symbol('a')
-    assignments = pystencils.AssignmentCollection({
-        z[0, 0]: x[0, 0] * sp.log(x[0, 0] * y[0, 0]) + a
-    })
-
-    print(assignments)
-
-    ast = pystencils.create_kernel(assignments, target='gpu')
-
-    print(ast)
-
-    code = pystencils.show_code(ast, custom_backend=CudaBackend())
-    print(code)
-    opencl_code = pystencils.show_code(ast, custom_backend=OpenClBackend())
-    print(opencl_code)
-
-    cuda_kernel = ast.compile()
-    assert cuda_kernel is not None
-
-    import pycuda.gpuarray as gpuarray
-
-    x_cpu = np.random.rand(20, 30)
-    y_cpu = np.random.rand(20, 30)
-    z_cpu = np.random.rand(20, 30)
-
-    x = gpuarray.to_gpu(x_cpu)
-    y = gpuarray.to_gpu(y_cpu)
-    z = gpuarray.to_gpu(z_cpu)
-    cuda_kernel(x=x, y=y, z=z, a=5.)
-
-    result_cuda = z.get()
-
-    import pyopencl.array as array
-    ctx = cl.create_some_context(0)
-    queue = cl.CommandQueue(ctx)
-
-    x = array.to_device(queue, x_cpu)
-    y = array.to_device(queue, y_cpu)
-    z = array.to_device(queue, z_cpu)
-
-    opencl_kernel = make_python_function(ast, queue, ctx)
-    assert opencl_kernel is not None
-    opencl_kernel(x=x, y=y, z=z, a=5.)
-
-    result_opencl = z.get(queue)
-
-    assert np.allclose(result_cuda, result_opencl)
-
-
-if __name__ == '__main__':
-    test_opencl_jit()

pystencils_tests/test_phasefield_dentritic_3D.ipynb

-%% Cell type:code id: tags:
-
-``` python
-from pystencils.session import *
-sp.init_printing()
-frac = sp.Rational
-```
-
-%% Cell type:markdown id: tags:
-
-# Phase-field simulation of dentritic solidification in 3D
-
-This notebook tests the model presented in the dentritic growth tutorial in 3D.
-
-%% Cell type:code id: tags:
-
-``` python
-target = 'gpu'
-gpu = target == 'gpu'
-domain_size = (25, 25, 25) if 'is_test_run' in globals() else (300, 300, 300)
-
-dh = ps.create_data_handling(domain_size=domain_size, periodicity=True, default_target=target)
-φ_field = dh.add_array('phi', latex_name='φ')
-φ_delta_field = dh.add_array('phidelta', latex_name='φ_D')
-t_field = dh.add_array('T')
-```
-
-%% Cell type:code id: tags:
-
-``` python
-ε, m, δ, j, θzero, α, γ, Teq, κ, τ = sp.symbols("ε m δ j θ_0 α γ T_eq κ τ")
-εb = sp.Symbol("\\bar{\\epsilon}")
-discretize = ps.fd.Discretization2ndOrder(dx=0.03, dt=1e-5)
-
-φ = φ_field.center
-T = t_field.center
-d = ps.fd.Diff
-
-def f(φ, m):
-    return φ**4 / 4 - (frac(1, 2) - m/3) * φ**3 + (frac(1,4)-m/2)*φ**2
-
-
-
-bulk_free_energy_density = f(φ, m)
-interface_free_energy_density = ε ** 2 / 2 * (d(φ, 0) ** 2 + d(φ, 1) ** 2 + d(φ, 2) ** 2)
-```
-
-%% Cell type:markdown id: tags:
-
-Here comes the major change, that has to be made for the 3D model: $\epsilon$ depends on the interface normal, which can not be computed simply as atan() as in the 2D case
-
-%% Cell type:code id: tags:
-
-``` python
-n = sp.Matrix([d(φ, i) for i in range(3)])
-nLen = sp.sqrt(sum(n_i**2 for n_i in n))
-n = n / nLen
-nVal = sum(n_i**4 for n_i in n)
-σ = δ * nVal
-
-εVal = εb * (1 + σ)
-εVal
-```
-
-%% Output
-
-    $\displaystyle \bar{\epsilon} \left(δ \left(\frac{{\partial_{0} {{φ}_{(0,0,0)}}}^{4}}{\left({\partial_{0} {{φ}_{(0,0,0)}}}^{2} + {\partial_{1} {{φ}_{(0,0,0)}}}^{2} + {\partial_{2} {{φ}_{(0,0,0)}}}^{2}\right)^{2}} + \frac{{\partial_{1} {{φ}_{(0,0,0)}}}^{4}}{\left({\partial_{0} {{φ}_{(0,0,0)}}}^{2} + {\partial_{1} {{φ}_{(0,0,0)}}}^{2} + {\partial_{2} {{φ}_{(0,0,0)}}}^{2}\right)^{2}} + \frac{{\partial_{2} {{φ}_{(0,0,0)}}}^{4}}{\left({\partial_{0} {{φ}_{(0,0,0)}}}^{2} + {\partial_{1} {{φ}_{(0,0,0)}}}^{2} + {\partial_{2} {{φ}_{(0,0,0)}}}^{2}\right)^{2}}\right) + 1\right)$
-                   ⎛  ⎛                            4
-                   ⎜  ⎜                 D(φ[0,0,0])
-    \bar{\epsilon}⋅⎜δ⋅⎜───────────────────────────────────────────── + ───────────
-                   ⎜  ⎜                                            2
-                   ⎜  ⎜⎛           2              2              2⎞    ⎛
-                   ⎝  ⎝⎝D(φ[0,0,0])  + D(φ[0,0,0])  + D(φ[0,0,0]) ⎠    ⎝D(φ[0,0,0]
-    
-                     4                                               4
-          D(φ[0,0,0])                                     D(φ[0,0,0])
-    ────────────────────────────────── + ─────────────────────────────────────────
-                                     2
-     2              2              2⎞    ⎛           2              2
-    )  + D(φ[0,0,0])  + D(φ[0,0,0]) ⎠    ⎝D(φ[0,0,0])  + D(φ[0,0,0])  + D(φ[0,0,0]
-    
-        ⎞    ⎞
-        ⎟    ⎟
-    ────⎟ + 1⎟
-       2⎟    ⎟
-     2⎞ ⎟    ⎟
-    ) ⎠ ⎠    ⎠
-
-%% Cell type:code id: tags:
-
-``` python
-def m_func(temperature):
-    return (α / sp.pi) * sp.atan(γ * (Teq - temperature))
-```
-
-%% Cell type:code id: tags:
-
-``` python
-substitutions = {m: m_func(T),
-                 ε: εVal}
-
-fe_i = interface_free_energy_density.subs(substitutions)
-fe_b = bulk_free_energy_density.subs(substitutions)
-
-μ_if = ps.fd.expand_diff_full(ps.fd.functional_derivative(fe_i, φ), functions=[φ])
-μ_b = ps.fd.expand_diff_full(ps.fd.functional_derivative(fe_b, φ), functions=[φ])
-```
-
-%% Cell type:code id: tags:
-
-``` python
-dF_dφ = μ_b + sp.Piecewise((μ_if, nLen**2 > 1e-10), (0, True))
-```
-
-%% Cell type:code id: tags:
-
-``` python
-parameters = {
-    τ: 0.0003,
-    κ: 1.8,
-    εb: 0.01,
-    δ: 0.3,
-    γ: 10,
-    j: 6,
-    α: 0.9,
-    Teq: 1.0,
-    θzero: 0.2,
-    sp.pi: sp.pi.evalf()
-}
-parameters
-```
-
-%% Output
-
-
-    $\displaystyle \left\{ \pi : 3.14159265358979, \  T_{eq} : 1.0, \  \bar{\epsilon} : 0.01, \  j : 6, \  α : 0.9, \  γ : 10, \  δ : 0.3, \  θ_{0} : 0.2, \  κ : 1.8, \  τ : 0.0003\right\}$
-    {π: 3.14159265358979, T_eq: 1.0, \bar{\epsilon}: 0.01, j: 6, α: 0.9, γ: 10, δ:
-     0.3, θ₀: 0.2, κ: 1.8, τ: 0.0003}
-
-%% Cell type:code id: tags:
-
-``` python
-dφ_dt = - dF_dφ / τ
-assignments = [
-    ps.Assignment(φ_delta_field.center, discretize(dφ_dt.subs(parameters))),
-]
-φEqs = ps.simp.sympy_cse_on_assignment_list(assignments)
-φEqs.append(ps.Assignment(φ, discretize(ps.fd.transient(φ) - φ_delta_field.center)))
-
-
-temperatureEvolution = -ps.fd.transient(T) + ps.fd.diffusion(T, 1) + κ * φ_delta_field.center
-temperatureEqs = [
-    ps.Assignment(T, discretize(temperatureEvolution.subs(parameters)))
-]
-```
-
-%% Cell type:code id: tags:
-
-``` python
-temperatureEqs
-```
-
-%% Output
-
-    $\displaystyle \left[ {{T}_{(0,0,0)}} \leftarrow 0.0111111111111111 {{T}_{(-1,0,0)}} + 0.0111111111111111 {{T}_{(0,-1,0)}} + 0.0111111111111111 {{T}_{(0,0,-1)}} + 0.933333333333333 {{T}_{(0,0,0)}} + 0.0111111111111111 {{T}_{(0,0,1)}} + 0.0111111111111111 {{T}_{(0,1,0)}} + 0.0111111111111111 {{T}_{(1,0,0)}} + 1.8 \cdot 10^{-5} {{φ_D}_{(0,0,0)}}\right]$
-    [T_C := 0.0111111111111111⋅T_W + 0.0111111111111111⋅T_S + 0.0111111111111111⋅T
-    _B + 0.933333333333333⋅T_C + 0.0111111111111111⋅T_T + 0.0111111111111111⋅T_N +
-     0.0111111111111111⋅T_E + 1.8e-5⋅phidelta_C]
-
-%% Cell type:code id: tags:
-
-``` python
-φ_kernel = ps.create_kernel(φEqs, cpu_openmp=4, target=target).compile()
-temperatureKernel = ps.create_kernel(temperatureEqs, cpu_openmp=4, target=target).compile()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-def time_loop(steps):
-    φ_sync = dh.synchronization_function(['phi'], target=target)
-    temperature_sync = dh.synchronization_function(['T'], target=target)
-    dh.all_to_gpu()
-    for t in range(steps):
-        φ_sync()
-        dh.run_kernel(φ_kernel)
-        temperature_sync()
-        dh.run_kernel(temperatureKernel)
-    dh.all_to_cpu()
-
-
-def init(nucleus_size=np.sqrt(5)):
-    for b in dh.iterate():
-        x, y, z = b.cell_index_arrays
-        x, y, z = x - b.shape[0] // 2, y - b.shape[1] // 2, z - b.shape[2] // 2
-        b['phi'].fill(0)
-        b['phi'][(x ** 2 + y ** 2 + z ** 2) < nucleus_size ** 2] = 1.0
-        b['T'].fill(0.0)
-
-
-def plot(slice_obj=ps.make_slice[:, :, 0.5]):
-    plt.subplot(1, 3, 1)
-    plt.scalar_field(dh.gather_array('phi', slice_obj).squeeze())
-    plt.title("φ")
-    plt.colorbar()
-    plt.subplot(1, 3, 2)
-    plt.title("T")
-    plt.scalar_field(dh.gather_array('T', slice_obj).squeeze())
-    plt.colorbar()
-    plt.subplot(1, 3, 3)
-    plt.title("∂φ")
-    plt.scalar_field(dh.gather_array('phidelta', slice_obj).squeeze())
-    plt.colorbar()
-```
-
-%% Cell type:code id: tags:
-
-``` python
-init()
-plot()
-print(dh)
-```
-
-%% Output
-
-        Name|      Inner (min/max)|     WithGl (min/max)
-    ----------------------------------------------------
-           T|            (  0,  0)|            (  0,  0)
-         phi|            (  0,  1)|            (  0,  1)
-    phidelta|            (  0,  0)|            (  0,  0)
-    
-
-
-
-%% Cell type:code id: tags:
-
-``` python
-if 'is_test_run' in globals():
-    time_loop(2)
-    assert np.isfinite(dh.max('phi'))
-    assert np.isfinite(dh.max('T'))
-    assert np.isfinite(dh.max('phidelta'))
-else:
-    from time import perf_counter
-    vtk_writer = dh.create_vtk_writer('dentritic_growth_large', ['phi'])
-    last = perf_counter()
-    for i in range(300):
-        time_loop(100)
-        vtk_writer(i)
-        print("Step ", i, perf_counter() - last, dh.max('phi'))
-        last = perf_counter()
-```

pystencils_tests/test_print_unsupported_node.py

-# -*- coding: utf-8 -*-
-#
-# Copyright © 2019 Stephan Seitz <stephan.seitz@fau.de>
-#
-# Distributed under terms of the GPLv3 license.
-
-"""
-
-"""
-import pytest
-
-import pystencils
-from pystencils.backends.cbackend import CBackend
-
-
-class UnsupportedNode(pystencils.astnodes.Node):
-
-    def __init__(self):
-        super().__init__()
-
-
-def test_print_unsupported_node():
-    with pytest.raises(NotImplementedError, match='CBackend does not support node of type UnsupportedNode'):
-        CBackend()(UnsupportedNode())