acoular 24.3__py3-none-any.whl → 24.5__py3-none-any.whl

acoular/tests/test_traj_beamformer_results.py

@@ -1,164 +0,0 @@
-import unittest
-
-from os.path import join
-
-import numpy as np
-
-from acoular import config
-config.global_caching = 'none'
-
-from acoular import WNoiseGenerator, MovingPointSource, WriteH5, Trajectory, MicGeom,\
-    RectGrid, MaskedTimeSamples, SteeringVector, TimeAverage, BeamformerTimeSqTraj, BeamformerTimeTraj,\
-    BeamformerCleantTraj, BeamformerCleantSqTraj, BeamformerTime, BeamformerTimeSq,\
-    BeamformerCleant, BeamformerCleantSq
-
-# if this flag is set to True, new time data will be simulated and
-WRITE_NEW_REFERENCE_DATA = False
-# new beamformer results are generated for comparison during testing. Should always be False. Only set to
-# true, if it is necessary to recalculate the data, due to wanted changes of the Beamformers (or MovingPointSource).
-
-# Parameters
-FNAME = join('reference_data','beamformer_traj_time_data.h5')
-SFREQ = 6000
-SPEED = 10  # km/h
-SEED = 1
-D = .5
-SOURCE_POS = (0.0, 0.0, D)
-passby_dist = .5  # distance that the source is passing in front of array
-CONV_AMP = True
-
-# create linear mic geom
-MGEOM = MicGeom()
-N = 5
-L = .5
-MGEOM.mpos_tot = np.zeros((3, N), dtype=np.float64)
-win = np.sin(np.arange(N)*np.pi/(N-1))
-b = 0.4
-MGEOM.mpos_tot[0] = np.linspace(-L, L, N)*(1-b)/(win*b+1-b)
-
-# Monopole Trajectory
-t_passby = passby_dist/SPEED/3.6
-nsamples = int(t_passby*SFREQ)
-TRAJ = Trajectory()  # source center
-TRAJ.points[0] = (-passby_dist/2 + SOURCE_POS[0], SOURCE_POS[1], SOURCE_POS[2])
-TRAJ.points[t_passby] = (+passby_dist/2, SOURCE_POS[1], SOURCE_POS[2])
-
-
-def create_test_time_data(nsamples):
-    """
-    creates test data for a single moving monopole emitting white noise
-    
-    Parameters
-    ----------
-    speed : float
-        source velocity in m/s.
-
-    Returns
-    -------
-    None.
-
-    """
-    n1 = WNoiseGenerator(sample_freq=SFREQ, numsamples=nsamples, seed=SEED)
-    p1 = MovingPointSource(signal=n1, mics=MGEOM,
-                           trajectory=TRAJ, conv_amp=CONV_AMP)
-    wh5 = WriteH5(source=p1, name=FNAME)
-    print(50*"#")
-    print(f"create {FNAME} ...")
-    print(f"num samples: {nsamples}, pass-by time: {t_passby}s")
-    print(50*"#")
-    wh5.save()
-
-def get_beamformer_traj_result(Beamformer, num=32):
-    """
-    returns the result for a given Beamformer class
-    
-    Parameters
-    ----------
-    Beamformer : cls
-        trajectory beamformer.
-    num : int, optional
-        number of samples to return. The default is 32.
-
-    Returns
-    -------
-    array
-        first block returned by the trajectory beamformers result() function.
-
-    """
-    ## with moving grid
-    ts = MaskedTimeSamples(name=FNAME)
-    gMoving = RectGrid(x_min=-.1, x_max=.1, y_min=0, y_max=0, z=0,
-                       increment=.1)
-    stMoving = SteeringVector(grid=gMoving, mics=MGEOM)
-    bt = Beamformer(source=ts, trajectory=TRAJ, steer=stMoving)
-    if hasattr(bt,'n_iter'):
-        bt.n_iter = 2
-    return next(bt.result(num)).astype(np.float32)
-
-def get_beamformer_time_result(Beamformer, num=32):
-    """
-    returns the result for a given time Beamformer class
-    
-    Parameters
-    ----------
-    Beamformer : cls
-        time beamformer.
-    num : int, optional
-        number of samples to return. The default is 32.
-
-    Returns
-    -------
-    array
-        first block returned by the time beamformers result() function.
-
-    """
-    ## with moving grid
-    ts = MaskedTimeSamples(name=FNAME)
-    gfixed = RectGrid(x_min=-.1, x_max=.1, y_min=0, y_max=0, z=D,
-                       increment=.1)
-    stfixed = SteeringVector(grid=gfixed, mics=MGEOM)
-    bt = Beamformer(source=ts,steer=stfixed)
-    if hasattr(bt,'n_iter'):
-        bt.n_iter = 2
-    return next(bt.result(num)).astype(np.float32)
-
-class BeamformerTimeTest(unittest.TestCase):
-    """
-    A simple test case that varifies that the results of trajectory beamformers 
-    and fixed focus beamformers in time domain are not changing across different
-    versions of code.
-    """
-
-    traj_beamformers = [BeamformerTimeTraj, BeamformerTimeSqTraj,
-                        BeamformerCleantTraj, BeamformerCleantSqTraj]
-
-    time_beamformers = [BeamformerTime, BeamformerTimeSq,
-                        BeamformerCleant, BeamformerCleantSq]
-    
-    def test_beamformer_traj_result(self):
-        """compare results of trajectory beamformers against previous
-        results from .h5 file"""
-        for beamformer in self.traj_beamformers:
-            with self.subTest(beamformer.__name__):
-                name = join('reference_data',f'{beamformer.__name__}.npy')
-                actual_data = get_beamformer_traj_result(beamformer)
-                if WRITE_NEW_REFERENCE_DATA:
-                    np.save(name,actual_data)
-                ref_data = np.load(name)
-                np.testing.assert_allclose(actual_data, ref_data, rtol=5e-5, atol=5e-6)
-
-    def test_beamformer_time_result(self):
-        """compare results of time beamformers with fixed focus against previous
-        results from .h5 file"""
-        for beamformer in self.time_beamformers:
-            with self.subTest(beamformer.__name__):
-                name = join('reference_data',f'{beamformer.__name__}.npy')
-                actual_data = get_beamformer_time_result(beamformer)
-                if WRITE_NEW_REFERENCE_DATA:
-                    np.save(name,actual_data)
-                ref_data = np.load(name)
-                np.testing.assert_allclose(actual_data, ref_data, rtol=5e-5, atol=5e-6)
-
-    
-if __name__ == '__main__':
-    unittest.main()

acoular/tests/unsupported/SpeedComparison/cythonBeamformer.pyx

@@ -1,237 +0,0 @@
-import numpy as np
-cimport numpy as np
-
-from libc.math cimport exp as c_exp
-from libc.math cimport sin as c_sin
-from libc.math cimport cos as c_cos
-
-from cython.parallel import prange, parallel
-from cython import boundscheck, wraparound, nonecheck, cdivision
-from cpython cimport array
-import array
-
-#ZUM PARALLELISIEREN MIT CYTHON
-#1.  Inplace Operatoren ("+=", etc) kommen hier eine besondere Bedeutung zu.
-#2.  Bei Cython-Version 0.25.2 gibt es einen Bug beim Zuweisen von numpy-Arrays:
-#    Wenn ein Vektor zuerst vollgeschrieben und im späteren Verlauf der Methode 
-#    wieder ausgelesen wird, wurden nicht die korrekten Werte ausgelesen.
-#    Wurde der Vektor/Matrix allerdings nur einmalig geschrieben und dann returned,
-#    war alles okay. Ist im Code unten nochmal am Bsp. "beamformerCython" beschrieben.
-#    Dieses Problem tritt nur auf, falls der Code über prange parallelisiert wird.
-#    Außerdem tritt der Fehler nicht immer auf. Liegt vllt an unausgereifter Ausnutzung
-#    der gesharedten Caches.
-#3.  Welche Variablen Thread-private und welche geshared werden sollen, entscheidet
-#    Cython selbst.
-#4.  Beim Beamformer (s.u.) hat das parallelisieren mit 'prange' zu erheblichen Einbußen in
-#    der Laufzeit geführt (ca 5x LANGSAMER). Es gibt allerdings einfache BSPs
-#    ("c_arrayOpenMP", "c_array", s.u.), bei denen mit gleichen Compiler-Optionen 
-#    wie beim Beamformer durch die Parallelisierung mit 'prange' erhebliche 
-#    Laufzeitverbesserungen erreicht werden.
-#5.  Es muss ein setup-File mit den Kompilieroptionen erstellt werden. In diesem 
-#    Fall ist dies "setupCythonOpenMP.py". Danach wird über die Konsole mit dem
-#    Befehl "python setupCythonOpenMP.py build_ext --inplace" kompiliert.
-
-
-
-
-#==============================================================================
-# # Das Ganze wird fuer effizientes indexing gebraucht...
-DTYPEComplex = np.complex128
-DTYPEReal = np.float
-ctypedef np.complex128_t DTYPEComplex_t
-ctypedef np.float_t DTYPEReal_t
-#==============================================================================
-
-# Die Dekoratoren sollen nochmals Schnelligkeit bringen.
-@nonecheck(False)
-@boundscheck(False)
-@wraparound(False)
-@cdivision(True)
-def beamformerCython(np.ndarray[DTYPEComplex_t, ndim=3] csm, np.ndarray[DTYPEReal_t] r0, np.ndarray[DTYPEReal_t, ndim=2] rm, np.ndarray[DTYPEComplex_t] kj):
-#def beamformerCython(complex[:,:,:] csm, double[:] r0, double[:,:] rm, complex[:] kj):  # Standard Methodenkopf (laut Doku etwas langsamer)
-    """ Dies ist eine Implementierung der Methode 'r_beamfull_inverse' der 
-    mit scipy.weave erzeugten 'beamformer.so'. Benutzt Parallelisierung via 
-    cythons 'prange' und Kompilierung mit OpenMP.
-    """
-    cdef int nFreqs = csm.shape[0]
-    cdef int nGridPoints = len(r0)
-    cdef int nMics = csm.shape[1]
-    
-    cdef double[:,:] beamformOutput = np.zeros([nFreqs, nGridPoints], dtype=DTYPEReal)
-    cdef complex[:] steerVec = np.zeros([nMics], dtype=DTYPEComplex)
-
-    cdef int cntFreqs, cntGrid, cntMics, cntMics2, cntMics1
-    cdef double r01, kjj, rm1, temp1, rs, temp3
-    cdef complex temp2
-#    cdef float temp3  # Das hat erstmal nicht auf Anhieb geklappt, deshalb ist temp3 noch double
-    
-    for cntFreqs in range(nFreqs):
-        kjj = kj[cntFreqs].imag
-        
-        
-        
-        
-        
-        with nogil, parallel():
-        
-            
-            # Mit Chef drüber reden.
-            
-            
-            
-            
-            for cntGrid in prange(nGridPoints, schedule='static'):  # Parallelisierung
-                r01 = r0[cntGrid]
-                rs = r01 ** 2
-                temp1 = 0.0
-                for cntFreqs in range(nFreqs):
-                    kjj = kj[cntFreqs].imag
-                    for cntGrid in range(nGridPoints):
-                        rs = 0
-                        r01 = r0[cntGrid]
-                        for cntMics in range(nMics):
-                            rm1 = rm[cntGrid, cntMics]
-                            rs += 1.0 / (rm1 ** 2)
-                            temp3 = (kjj * (rm1 - r01))
-                            steerVec[cntMics] = (c_cos(temp3) - 1j * c_sin(temp3)) * rm1
-                        rs = r01 ** 2
-                        
-                        temp1 = 0.0
-                        for cntMics in range(nMics): 
-                            temp2 = 0.0
-                            for cntMics2 in range(cntMics):
-                                temp2 = temp2 + csm[cntFreqs, cntMics2, cntMics] * steerVec[cntMics2]  # Falls nicht mit prange gearbeitet wird, kann man "+= etc" wie sonst benutzen
-                            temp1 = temp1 + 2 * (temp2 * steerVec[cntMics].conjugate()).real
-                            temp1 = temp1 + (csm[cntFreqs, cntMics, cntMics] * (steerVec[cntMics]).conjugate() * steerVec[cntMics]).real
-                        beamformOutput[cntFreqs, cntGrid] = (temp1 / rs)        
-    return beamformOutput
-
-@boundscheck(False)
-@wraparound(False)
-@nonecheck(False)
-@cdivision(True)
-def beamformerCythonNOTparallel(np.ndarray[DTYPEComplex_t, ndim=3] csm, np.ndarray[DTYPEReal_t] r0, np.ndarray[DTYPEReal_t, ndim=2] rm, np.ndarray[DTYPEComplex_t] kj):
-    """ Dies ist eine Implementierung der Methode 'r_beamfull_inverse' der 
-    mit scipy.weave erzeugten 'beamformer.so', OHNE Parallelisierung.
-    """
-    cdef int nFreqs = csm.shape[0]
-    cdef int nGridPoints = len(r0)
-    cdef int nMics = csm.shape[1]
-    
-    cdef double[:,:] beamformOutput = np.zeros([nFreqs, nGridPoints], dtype=DTYPEReal)
-    cdef complex[:] steerVec = np.zeros([nMics], dtype=DTYPEComplex)
-    
-    cdef int cntFreqs, cntGrid, cntMics, cntMics2
-    cdef double rs, r01, kjj, rm1, temp1, temp3
-    cdef complex temp2
-#    cdef float temp3
-    
-    for cntFreqs in range(nFreqs):
-        kjj = kj[cntFreqs].imag
-        for cntGrid in range(nGridPoints):
-            rs = 0
-            r01 = r0[cntGrid]
-            for cntMics in range(nMics):
-                rm1 = rm[cntGrid, cntMics]
-                rs += 1.0 / (rm1 ** 2)
-                temp3 = (kjj * (rm1 - r01))
-                steerVec[cntMics] = (c_cos(temp3) - 1j * c_sin(temp3)) * rm1
-            rs = r01 ** 2
-            
-            temp1 = 0.0
-            for cntMics in range(nMics): 
-                temp2 = 0.0
-                for cntMics2 in range(cntMics):
-                    temp2 += csm[cntFreqs, cntMics2, cntMics] * steerVec[cntMics2]  # Falls nicht mit prange gearbeitet wird, kann man "+= etc" wie sonst benutzen
-                temp1 += 2 * (temp2 * steerVec[cntMics].conjugate()).real
-                temp1 += (csm[cntFreqs, cntMics, cntMics] * (steerVec[cntMics]).conjugate() * steerVec[cntMics]).real
-            beamformOutput[cntFreqs, cntGrid] = (temp1 / rs)          
-    return beamformOutput
-
-@nonecheck(False)
-@boundscheck(False)
-@wraparound(False)
-@cdivision(True)
-def beamformerCythonCorrectButSlow(np.ndarray[DTYPEComplex_t, ndim=3] csm, np.ndarray[DTYPEReal_t] r0, np.ndarray[DTYPEReal_t, ndim=2] rm, np.ndarray[DTYPEComplex_t] kj):
-#def beamformerCython(complex[:,:,:] csm, double[:] r0, double[:,:] rm, complex[:] kj):  # Standard Methodenkopf (laut Doku etwas langsamer)
-    """ Dies ist eine Implementierung der Methode 'r_beamfull_inverse' der 
-    mit scipy.weave erzeugten 'beamformer.so'. Benutzt Parallelisierung via 
-    cythons 'prange' und Kompilierung mit OpenMP.
-    """
-    cdef int nFreqs = csm.shape[0]
-    cdef int nGridPoints = len(r0)
-    cdef int nMics = csm.shape[1]
-    
-    cdef double[:,:] beamformOutput = np.zeros([nFreqs, nGridPoints], dtype=DTYPEReal)
-
-    cdef int cntFreqs, cntGrid, cntMics, cntMics2, cntMics1
-    cdef double r01, kjj, rm1, temp1, rs, temp3
-    cdef complex temp2, steerVec1, steerVec
-#    cdef float temp3
-    
-    for cntFreqs in range(nFreqs):
-        kjj = kj[cntFreqs].imag
-        for cntGrid in prange(nGridPoints, nogil=True, schedule='static'):  # Parallelisierung
-            r01 = r0[cntGrid]
-            rs = r01 ** 2
-            
-            # Im ursprünglichen Code wurde hier erstmal in einer Schleife 
-            # ueber die Mics der Steering-Vektor erstellt und später verarbeitet. 
-            # Cython verhaut aber beim späteren Auslesen dieses Vektors, falls 
-            # mit prange parallelisiert wird (siehe 2. im Kommentar ganz oben).
-            # Deshalb wurde hier der Code ein wenig geändert (Wirkung bleibt aber erhalten, 
-            # allerdings werdfen redundante Operationen ausgeführt -->langsamer)
-            # Siehe Methode "beamformerCythonNOTparallel" für den ursprünglichen Code.
-            
-            temp1 = 0.0
-            for cntMics in range(nMics): 
-                temp2 = 0.0
-                rm1 = rm[cntGrid, cntMics]
-                temp3 = (kjj * (rm1 - r01))
-                steerVec = (c_cos(temp3) - 1j * c_sin(temp3)) * rm1
-                
-                for cntMics2 in range(cntMics):
-                    rm1 = rm[cntGrid, cntMics2]
-                    temp3 = (kjj * (rm1 - r01))
-                    steerVec1 = (c_cos(temp3) - 1j * c_sin(temp3)) * rm1
-                    temp2 = temp2 + csm[cntFreqs, cntMics2, cntMics] * steerVec1
-                temp1 = temp1 + 2 * (temp2 * steerVec.conjugate()).real
-                temp1 = temp1 + (csm[cntFreqs, cntMics, cntMics] * steerVec.conjugate() * steerVec).real
-            beamformOutput[cntFreqs, cntGrid] = (temp1 / rs)  # Hier gibt es keine Schwierigkeiten bzgl des Stichpkts 2. von oben. Nur falls "beamformOutput" nochmal in derselben Methode ausgelesen werden sollte.
-    return beamformOutput
-
-
-#==============================================================================
-# BSP, FÜR DIE DIE PARALLELISIERUNG MIT PRANGE LAUFZEITVERBESSERUNGEN BRINGT:
-#---------------------------------------------------------------------------
-#
-# Die nachfolgenden 2 Fkt. machen das gleiche. Allerdings ist "c_arrayOpenMP" mit 'prange' parallelisiert.
-# Macht man von ausserhalb einen Laufzeitvergleich, ist zu erkennen, dass das
-# Parallelisieren hier tatsächlich was bringt (bei mir ungefähr 2x schneller).
-@boundscheck(False)
-@wraparound(False)
-@nonecheck(False)
-def c_array(double[:] X):
-    cdef int N = X.shape[0]
-    cdef double[:] Y = np.zeros(N)
-    cdef int i
-    for i in range(N):  # NICHT parallelisiert
-        if X[i] > 0.5:
-            Y[i] = c_exp(X[i])
-        else:
-            Y[i] = 0
-    return Y
-
-@boundscheck(False)
-@wraparound(False)
-@nonecheck(False)
-def c_arrayOpenMP(double[:] X):
-    cdef int N = X.shape[0]
-    cdef double[:] Y = np.zeros(N)
-    cdef int i
-    for i in prange(N, nogil=True):  # parallelisiert
-        if X[i] > 0.5:
-            Y[i] = c_exp(X[i])
-        else:
-            Y[i] = 0
-    return Y

acoular/tests/unsupported/SpeedComparison/mainForCython.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Jul  6 16:16:03 2017
-
-@author: tomgensch
-"""
-#import os
-#print(os.path.dirname(os.path.realpath(__file__)))
-
-import numpy as np
-from cythonBeamformer import beamformerCython, beamformerCythonNOTparallel
-
-nMics = 32
-nGridPoints = 100
-nFreqs = 10
-
-csm = np.random.rand(nFreqs, nMics, nMics) + 1j*np.random.rand(nFreqs, nMics, nMics)
-for cntFreqs in range(nFreqs):
-    csm[cntFreqs, :, :] += csm[cntFreqs, :, :].T.conj()  # zu Hermitischer Matrix machen
-r0 = np.random.rand(nGridPoints) #abstand aufpunkte-arraymittelpunkt
-rm = np.random.rand(nGridPoints, nMics) #abstand aufpunkte-arraymikrofone
-kj = np.zeros(nFreqs) + 1j*np.random.rand(nFreqs) # 
-
-
-#csm = np.ones((nFreqs, nMics, nMics), 'D')
-#r0 = np.ones(nGridPoints) * .2
-#rm = np.array([[.2, .3]])#rm = np.ones((nGridPoints, nMics)) * .24
-#kj = np.zeros(nFreqs) + 1j
-
-
-print('Sequentiel')
-outputWithoutMP = beamformerCythonNOTparallel(csm, r0, rm, kj)
-
-print('Parallel')
-outputMP = beamformerCython(csm, r0, rm, kj)
-
-outputMit = np.array(outputMP)
-outputOhne = np.array(outputWithoutMP)
-
-
-
-
-#==============================================================================
-# Bei Intel gibt es mit dem setuo-file aus der Doku keine probleme.
-# Die differenz zwischen den methoden und der referenz ist dann 0 (also wirklich 0, nicht e-12)
-# Allerdings ist parallel viel lamngsamer!
-#==============================================================================
-
-
-
-
-
-#e1Mit = np.array(e1MP)
-#e1Ohne = np.array(e1OhneMP)
-
-
-## Referenz
-beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-e1 = np.zeros((nMics), np.complex128)
-
-for cntFreqs in xrange(nFreqs):  # laeuft z.Z. nur einmal durch
-    kjj = kj[cntFreqs].imag   ### könnte man vielleicht reinnehmen um unten nicht immer den realteilnehmen zu müssen
-    for cntGrid in xrange(nGridPoints):
-        rs = 0
-        r01 = r0[cntGrid]
-        
-        # Erzeugen der Steering-Vectoren
-        for cntMics in xrange(nMics):
-            rm1 = rm[cntGrid, cntMics]
-            rs += 1.0 / (rm1**2)
-            temp3 = (kjj * (rm1 - r01))  # der Float bewirkt die Abweichung vom Originalergebnis um ca 10^-8
-            e1[cntMics] = (np.cos(temp3) - 1j * np.sin(temp3)) * rm1
-        rs = r01 ** 2
-        
-        # Berechnen der Matrix multiplikation
-        temp1 = 0.0
-        for cntMics in xrange(nMics):
-            temp2 = 0.0
-            for cntMics2 in xrange(cntMics):
-                temp2 += csm[cntFreqs, cntMics2, cntMics] * e1[cntMics2]  # nicht ganz sicher ob richtig
-            temp1 += 2 * (temp2 * e1[cntMics].conjugate()).real
-            temp1 += (csm[cntFreqs, cntMics, cntMics] * np.conjugate(e1[cntMics]) * e1[cntMics]).real
-        
-        beamformOutput[cntFreqs, cntGrid] = (temp1 / rs).real
-    
-
-#diffE1MitOpenMP = max(abs(e1 - e1Mit))
-#diffE1OhneOpenMP = max(abs(e1 - e1Ohne))
-##diffE1BothCythonMethods = max([abs(e1Mit[cnt] - e1Ohne[cnt]) for cnt in range(len(e1Ohne))])
-#diffE1BothCythonMethods = np.amax(abs(e1Mit - e1Ohne), axis=0)
-#diffE1BothCythonMethods = np.amax(diffE1BothCythonMethods, axis=0)
-
-diffOutputBothMethods = np.amax(abs(outputMit - outputOhne), axis=0)
-diffOutputBothMethods = np.amax(abs(diffOutputBothMethods), axis=0)
-
-diffOutputOpenMP = np.amax(abs(outputMit - beamformOutput), axis=0)
-diffOutputOpenMP = np.amax(abs(diffOutputOpenMP), axis=0)
-
-diffOutputWithoutOpenMP = np.amax(abs(outputOhne - beamformOutput), axis=0)
-diffOutputWithoutOpenMP = np.amax(abs(diffOutputWithoutOpenMP), axis=0)
-
-print(diffOutputBothMethods)

acoular/tests/unsupported/SpeedComparison/mainForParallelJit.py

@@ -1,143 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Jul 20 14:06:46 2017
-
-@author: tomgensch
-
-This script was for getting to know the mechanisms of the new prange function
-of jit (numba version 0.34). As it turns out the automatic parallelization is
-as faulty as in cython (same errors).
-"""
-
-import numpy as np
-from numba import njit, float64, complex128, prange
-
-nMics = 4
-nGridPoints = 5
-nFreqs = 1
-
-csm = np.random.rand(nFreqs, nMics, nMics) + 1j*np.random.rand(nFreqs, nMics, nMics)
-for cntFreqs in range(nFreqs):
-    csm[cntFreqs, :, :] += csm[cntFreqs, :, :].T.conj()  # zu Hermitischer Matrix machen
-r0 = np.random.rand(nGridPoints) #abstand aufpunkte-arraymittelpunkt
-rm = np.random.rand(nGridPoints, nMics) #abstand aufpunkte-arraymikrofone
-kj = np.zeros(nFreqs) + 1j*np.random.rand(nFreqs) 
-
-@njit(float64[:,:](complex128[:,:,:], float64[:], float64[:,:], complex128[:]), parallel=True)
-def loops_NumbaJit_parallelSlow(csm, r0, rm, kj):
-    nFreqs = csm.shape[0]
-    nGridPoints = len(r0)
-    nMics = csm.shape[1]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-    
-    for cntFreqs in xrange(nFreqs):
-        kjj = kj[cntFreqs].imag
-        for cntGrid in prange(nGridPoints):
-            r01 = r0[cntGrid]
-            rs = r01 ** 2
-            
-            temp1 = 0.0
-            for cntMics in xrange(nMics): 
-                temp2 = 0.0
-                rm1 = rm[cntGrid, cntMics]
-                temp3 = np.float32(kjj * (rm1 - r01))
-                steerVec = (np.cos(temp3) - 1j * np.sin(temp3)) * rm1
-                
-                for cntMics2 in xrange(cntMics):
-                    rm1 = rm[cntGrid, cntMics2]
-                    temp3 = np.float32(kjj * (rm1 - r01))
-                    steerVec1 = (np.cos(temp3) - 1j * np.sin(temp3)) * rm1
-                    temp2 += csm[cntFreqs, cntMics2, cntMics] * steerVec1
-                temp1 += 2 * (temp2 * steerVec.conjugate()).real
-                temp1 += (csm[cntFreqs, cntMics, cntMics] * steerVec.conjugate() * steerVec).real
-            
-            beamformOutput[cntFreqs, cntGrid] = (temp1 / rs).real
-    return beamformOutput
-
-@njit(float64[:,:](complex128[:,:,:], float64[:], float64[:,:], complex128[:]), parallel=True)
-def loops_NumbaJit_parallelFast(csm, r0, rm, kj):
-    """ This method implements the prange over the Gridpoints, which is a direct
-    implementation of the currently used c++ methods created with scipy.wave.
-    
-    Very strange: Just like with Cython, this implementation (prange over Gridpoints)
-    produces wrong results. If one doesn't parallelize -> everything is good 
-    (just like with Cython). Maybe Cython and Numba.jit use the same interpreter 
-    to generate OpenMP-parallelizable code.
-    
-    BUT: If one uncomments the 'steerVec' declaration in the prange-loop over the
-    gridpoints an error occurs. After commenting the line again and executing
-    the script once more, THE BEAMFORMER-RESULTS ARE CORRECT (for repeated tries). 
-    Funny enough the method is now twice as slow in comparison to the 
-    'wrong version' (before invoking the error).
-    """
-    # init
-    nFreqs = csm.shape[0]
-    nGridPoints = len(r0)
-    nMics = csm.shape[1]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-    steerVec = np.zeros((nMics), np.complex128)
-    
-    for cntFreqs in xrange(nFreqs):
-        kjj = kj[cntFreqs].imag
-        for cntGrid in prange(nGridPoints):
-#            steerVec = np.zeros((nMics), np.complex128)  # This is the line that has to be uncommented (see this methods documentation comment)
-            rs = 0
-            r01 = r0[cntGrid]
-            
-            for cntMics in xrange(nMics):
-                rm1 = rm[cntGrid, cntMics]
-                rs += 1.0 / (rm1**2)
-                temp3 = np.float32(kjj * (rm1 - r01))
-                steerVec[cntMics] = (np.cos(temp3) - 1j * np.sin(temp3)) * rm1
-            rs = r01 ** 2
-            
-            temp1 = 0.0
-            for cntMics in xrange(nMics):
-                temp2 = 0.0
-                for cntMics2 in xrange(cntMics):
-                    temp2 = temp2 + csm[cntFreqs, cntMics2, cntMics] * steerVec[cntMics2]
-                temp1 = temp1 + 2 * (temp2 * steerVec[cntMics].conjugate()).real
-                temp1 = temp1 + (csm[cntFreqs, cntMics, cntMics] * np.conjugate(steerVec[cntMics]) * steerVec[cntMics]).real
-            
-            beamformOutput[cntFreqs, cntGrid] = (temp1 / rs).real
-    return beamformOutput
-
-beamformOutputFast = loops_NumbaJit_parallelFast(csm, r0, rm, kj)
-beamformOutputSlow = loops_NumbaJit_parallelSlow(csm, r0, rm, kj)
-
-#%% Referenz
-beamformOutputRef = np.zeros((nFreqs, nGridPoints), np.float64)
-e1 = np.zeros((nMics), np.complex128)
-
-for cntFreqs in xrange(nFreqs):
-    kjj = kj[cntFreqs].imag
-    for cntGrid in xrange(nGridPoints):
-        rs = 0
-        r01 = r0[cntGrid]
-        
-        for cntMics in xrange(nMics):
-            rm1 = rm[cntGrid, cntMics]
-            rs += 1.0 / (rm1**2)
-            temp3 = np.float32(kjj * (rm1 - r01)) 
-            e1[cntMics] = (np.cos(temp3) - 1j * np.sin(temp3)) * rm1
-        rs = r01 ** 2
-        
-        temp1 = 0.0
-        for cntMics in xrange(nMics):
-            temp2 = 0.0
-            for cntMics2 in xrange(cntMics):
-                temp2 += csm[cntFreqs, cntMics2, cntMics] * e1[cntMics2]
-            temp1 += 2 * (temp2 * e1[cntMics].conjugate()).real
-            temp1 += (csm[cntFreqs, cntMics, cntMics] * np.conjugate(e1[cntMics]) * e1[cntMics]).real
-        
-        beamformOutputRef[cntFreqs, cntGrid] = (temp1 / rs).real
-
-diffFast = np.amax(abs(beamformOutputFast - beamformOutputRef), axis=0)
-diffFast= np.amax(abs(diffFast), axis=0)
-
-diffSlow = np.amax(abs(beamformOutputSlow - beamformOutputRef), axis=0)
-diffSlow= np.amax(abs(diffSlow), axis=0)
-
-print(diffFast)
-print(diffSlow)