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

acoular/tests/unsupported/SpeedComparison/setupCythonOpenMP.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Setup- Datei fuer Paralleles Cython (benutzt OpemMP).
-Siehe "http://cython.readthedocs.io/en/latest/src/userguide/parallelism.html"
-"""
-
-from distutils.core import setup
-from distutils.extension import Extension
-from Cython.Build import cythonize
-
-#==============================================================================
-## Laut Cython Doku "http://cython.readthedocs.io/en/latest/src/userguide/parallelism.html#Compiling" muss dieser Code noch rein
-ext_modules = [
-      Extension(
-          "cythonBeamformer",
-          ["cythonBeamformer.pyx"],
-          extra_compile_args=['-fopenmp'],
-          extra_link_args=['-fopenmp'],
-      )
- ]
-setup(
-     name='cythonBeamformer',
-     ext_modules=cythonize(ext_modules),
- )
-#==============================================================================
-
-
-#==============================================================================
-## Compiler optionen von Acoular
-#ext_modules = [
-#       Extension(
-#           "cythonBeamformer",
-#           ["cythonBeamformer.pyx"],
-#           extra_compile_args=['-O3','-ffast-math','-msse3', \
-#        '-Wno-write-strings', '-fopenmp'],
-#           extra_link_args=['-lgomp'],
-#       )
-#  ]
-#setup(
-#      name='cythonBeamformer',
-#      ext_modules=cythonize(ext_modules),
-#  )
-#==============================================================================
-
-
-#==============================================================================
-## Compiler optionen nach "http://nealhughes.net/parallelcomp2/"
-# ext_modules=[
-#     Extension("cythonBeamformer",
-#               ["cythonBeamformer.pyx"],
-#               libraries=["m"],
-#               extra_compile_args = ["-O3", "-ffast-math", "-march=native", "-fopenmp" ],
-#               extra_link_args=['-fopenmp']
-#               ) 
-# ]
-# 
-# setup( 
-#   name = "cythonBeamformer",
-#   cmdclass = {"build_ext": build_ext},
-#   ext_modules = ext_modules
-# )
-#==============================================================================

acoular/tests/unsupported/SpeedComparison/sharedFunctions.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Created on Wed May 24 11:09:29 2017
-
-@author: tomgensch
-"""
-from cPickle import dump, load
-import matplotlib.pylab as plt
-import numpy as np
-import glob
-
-
-def savingTimeConsumption(fileName, saveTuple):
-    """ Saves all data in 'saveTuple' into 'fileName.sav'. 
-    The First entry of the tuple has to be a String, explaining the structure of 
-    the tuple."""
-    fi = open(fileName + '.sav', 'w')
-    dump(saveTuple, fi, -1)
-    fi.close()
-    return 0
-
-
-def readingInSAVES(fileName):
-    """ Reads in the Data saved with 'savingTimeConsumption'. """
-    fi = open(fileName, 'r')
-    data = load(fi)
-    fi.close()
-    helpText = data[0]
-    returnData = data[1:]
-    return helpText, returnData
-
-
-def plottingTimeConsumptions(titleString, trialedFuncs, timesToPlot):
-    """ titleString...String to be displayed in Title
-    trialedFuncs...list of the strings of the trialed functions
-    timesToPlot...dim [numberTrials, numberFunctions]
-    """
-#    plt.figure()
-    for cnt in range(len(trialedFuncs)):
-        if 'vectorized' in trialedFuncs[cnt]:
-            lineStyle = '--'
-        elif 'faverage' in trialedFuncs[cnt]:
-            lineStyle = '--'
-        else:
-            lineStyle = '-'
-        plt.semilogy(timesToPlot[cnt], label=trialedFuncs[cnt], linestyle=lineStyle, marker='o')
-    plt.xticks(range(len(timesToPlot[1])))
-    plt.xlabel('trials [1]')
-    plt.ylabel('Time per Trial [s]')
-    plt.grid(which='major')
-    plt.grid(which='minor', linestyle='--')
-    plt.title(titleString)
-    yMin, yMax = plt.ylim()
-    newYMin = 10 ** np.floor(np.log10(yMin))
-    plt.ylim(newYMin, yMax)
-    plt.legend(bbox_to_anchor=(1.01, 1), loc=2, borderaxespad=0.)
-    plt.show()
-
-
-def plottingOfOvernightTestcasesBeamformer(fileName):
-    helpText, daten = readingInSAVES(fileName)
-    
-    stringForLegend = []
-    hFig = plt.figure()
-    hAxesRelErr = hFig.add_subplot(3,2,5)
-    hAxesRelErr.set_ylabel('relative Error - infNorm')
-    hAxesRelErr.set_xlabel('trials [1]')
-    
-    hAxesAbsErr = hFig.add_subplot(3,2,6)
-    hAxesAbsErr.set_ylabel('absolute Error - infNorm')
-    hAxesAbsErr.set_xlabel('trials [1]')
-    
-    numberMethods = len(daten[0])
-    numberTrials = len(daten[1][0, :])
-    trials = np.arange(numberTrials)
-    
-    # For barplot
-    withPerTrial = 0.75
-    widthBar = withPerTrial / numberMethods
-    offsetOfXAxes = withPerTrial / 2 - widthBar
-
-    # plotting error
-    for cnt in xrange(numberMethods):
-        stringForLegend.append(daten[0][cnt] + ' | Time=%1.2f' %(daten[6][cnt]))  # For time consumption
-        hAxesRelErr.bar(trials + cnt * widthBar - offsetOfXAxes, daten[1][cnt, :], widthBar, label=daten[0][cnt])  # relative error
-        hAxesAbsErr.bar(trials + cnt * widthBar - offsetOfXAxes, daten[7][cnt, :], widthBar, label=daten[0][cnt])  # absolute error
-    hAxesAbsErr.legend()
-    hAxesAbsErr.set_yscale('log')
-    hAxesAbsErr.set_xticks(trials)
-    
-    hAxesRelErr.set_yscale('log')
-    hAxesRelErr.set_xticks(trials)
-    
-    # plotting time consumption
-    titelString = 'Performance Comparison, nMics = %s, nGridPoints = %s, nFreqs = %s.'\
-                '\n With time consumption factor in relation to the \noriginal r_beamfull_inverse'\
-                ' in the legend'\
-                '\n If a method works with manually spawn threads: nThreads = %s.'%(daten[3], daten[4], daten[5], daten[8])
-    plt.subplot(3,3,(1,5))
-    plottingTimeConsumptions(titelString, stringForLegend, daten[2])
-    hFig.canvas.set_window_title(fileName)
-
-
-def plottingTimeConsumptionOverSpecificOrdinate(dirName, ordinate='nMics'):
-    listOfFiles = glob.glob(dirName + '/*.sav')
-    helpText, daten = readingInSAVES(listOfFiles[0])
-    arrayOrdinate = np.zeros(len(listOfFiles))
-    arrayTimeConsump = np.zeros((len(listOfFiles), len(daten[6])))
-    cnt = 0
-    for currentfile in listOfFiles:
-        helpText, daten = readingInSAVES(currentfile)
-        if ordinate == 'nMics':
-            arrayOrdinate[cnt] = daten[3]
-        arrayTimeConsump[cnt, :] = daten[6]
-        cnt += 1
-    indSorted = np.argsort(arrayOrdinate)
-    plt.semilogy(arrayOrdinate[indSorted], arrayTimeConsump[indSorted, :], marker='o')#, label=trialedFuncs[cnt], linestyle=lineStyle, marker='o')
-    plt.legend(daten[0])
-    plt.grid(which='major')
-    plt.grid(which='minor', linestyle='--')
-    plt.xlabel(ordinate)
-    plt.ylabel('Mean of Time per Trial [s] (normalized to faverage)')
-    plt.title('Mean of TimeConsumption over ' + ordinate + '\n asd')
-    plt.xticks(arrayOrdinate)
-        
-
-def plottingOfOvernightTestcasesOnFAVERAGE(fileName):
-    helpText, daten = readingInSAVES(fileName)
-    titleString = 'NUMBA - using "faverage"\n' \
-        'nAverages=%s,  nFreqbins=%s,  nMics=%s,  nTest=%s' % (daten[2], daten[3], daten[4], daten[5])
-    plottingTimeConsumptions(titleString, daten[0], daten[1])
-
-
-def plotAllAvailableTestCases(dirName):
-    listOfFiles = glob.glob(dirName + '/*.sav')
-    for currentfile in listOfFiles:
-        try:
-            plottingOfOvernightTestcasesBeamformer(currentfile)
-        except:
-            print('Could not plot Testcase:' + currentfile)
-
-def saveAllCurrentlyOpenedFigures():
-    for cntFig in plt.get_fignums():
-        saveNameForPNGHelp = plt.figure(cntFig).canvas.get_window_title()
-        saveNameForPNG = saveNameForPNGHelp.replace('.sav', '.png')
-        plt.savefig(saveNameForPNG)
-
-#plottingTimeConsumptionOverSpecificOrdinate('Sicherung_DurchgelaufeneTests/faverage/InfluenceOfMics/')
-#plottingOfOvernightTestcasesBeamformer('Sicherung_DurchgelaufeneTests/.sav')
-#plotAllAvailableTestCases('Sicherung_DurchgelaufeneTests/damasSolver/')
-#plottingOfOvernightTestcasesBeamformer('Peter.sav')
-#saveAllCurrentlyOpenedFigures()

acoular/tests/unsupported/SpeedComparison/vglOptimierungFAverage.py

@@ -1,204 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-"""
-import time as tm
-import gc
-
-import numpy as np
-from numba import njit, guvectorize, complex128, void, prange
-
-import sharedFunctions as shFncs
-from beamformer import faverage  # The benchmark (created with scipy.weave)
-from beamformer_withoutMP import faverage_OhneMP
-
-#%% Numba - njit
-@njit(complex128[:,:,:](complex128[:,:,:], complex128[:,:]))
-def loops_Njit(csm, SpecAllChn):
-    nFreqs = csm.shape[0]
-    nMics = csm.shape[1]
-    for cntFreq in range(nFreqs):
-        for cntRow in range(nMics):
-            temp = np.conj(SpecAllChn[cntFreq, cntRow])
-            for cntColumn in range(nMics):
-                csm[cntFreq, cntRow, cntColumn] += temp * SpecAllChn[cntFreq, cntColumn]
-    return csm
-
-@njit(complex128[:,:,:](complex128[:,:,:], complex128[:,:]), parallel=True)
-def loops_Njit_Parallel(csm, SpecAllChn):
-    nFreqs = csm.shape[0]
-    nMics = csm.shape[1]
-    for cntFreq in range(nFreqs):
-        for cntRow in range(nMics):
-            temp = np.conj(SpecAllChn[cntFreq, cntRow])
-            for cntColumn in range(nMics):
-                csm[cntFreq, cntRow, cntColumn] += temp * SpecAllChn[cntFreq, cntColumn]
-    return csm
-
-@njit(complex128[:,:,:](complex128[:,:,:], complex128[:,:]), parallel=True)
-def loops_Njit_Parallel_Prange(csm, SpecAllChn):
-    nFreqs = csm.shape[0]
-    nMics = csm.shape[1]
-    for cntFreq in range(nFreqs):
-        for cntRow in prange(nMics):
-            temp = np.conj(SpecAllChn[cntFreq, cntRow])
-            for cntColumn in range(nMics):
-                csm[cntFreq, cntRow, cntColumn] += temp * SpecAllChn[cntFreq, cntColumn]
-    return csm
-
-#%% create CSM via complex transpose of lower triangular matrix
-@njit(complex128[:,:,:](complex128[:,:,:], complex128[:,:]))
-def loopsComplexTranspose_Numpy(csm, SpecAllChn):
-    nFreqs = csm.shape[0]
-    for cntFreq in range(nFreqs):
-        csm[cntFreq, :, :] += np.outer(np.conj(SpecAllChn[cntFreq, :]), SpecAllChn[cntFreq, :])
-    return csm
-
-@njit(complex128[:,:,:](complex128[:,:,:], complex128[:,:]))
-def loopsOnlyTriangularMatrix_Njit(csm, SpecAllChn):
-    """ one could only build the lower triangular csm and then, after averaging
-    over all the ensenbles creating the whole csm by complex transposing.
-    One could maybe use sparse CSR/CSC matrices (even though the CSM is not too big, so advantages are maybe small.)
-    """
-    nFreqs = csm.shape[0]
-    nMics = csm.shape[1]
-    for cntFreq in range(nFreqs):
-        for cntRow in range(nMics):
-            temp = np.conj(SpecAllChn[cntFreq, cntRow])
-            for cntColumn in range(cntRow):  # only half of the operations in respect to 'loops_Njit'
-                csm[cntFreq, cntRow, cntColumn] += temp * SpecAllChn[cntFreq, cntColumn]
-    return csm
-
-#%% Numba - guvectorize
-
-# =============================================================================
-# I don't think that parallelizing over the mics is in this case feasible.
-# At least i can't think of a way to abstract the faverage procedure on one level below.
-# It is however feasible to parallelize over the frequencies
-# =============================================================================
-
-@guvectorize([void(complex128[:,:], complex128[:], complex128[:,:])], '(m,m),(m)->(m,m)',
-              nopython=True, target='cpu')
-def loops_GuvectorizeOverFreqs_singleThreadedCPU(csm, SpecAllChn, result):
-    nMics = csm.shape[0]
-    for cntRow in range(nMics):
-        temp = np.conj(SpecAllChn[cntRow])
-        for cntColumn in range(nMics):
-            result[cntRow, cntColumn] = csm[cntRow, cntColumn] + temp * SpecAllChn[cntColumn]
-
-@guvectorize([void(complex128[:,:], complex128[:], complex128[:,:])], '(m,m),(m)->(m,m)',
-              nopython=True, target='parallel')
-def loops_GuvectorizeOverFreqs_multiThreadedCPU(csm, SpecAllChn, result):
-    nMics = csm.shape[0]
-    for cntRow in range(nMics):
-        temp = np.conj(SpecAllChn[cntRow])
-        for cntColumn in range(nMics):
-            result[cntRow, cntColumn] = csm[cntRow, cntColumn] + temp * SpecAllChn[cntColumn]
-
-@guvectorize([void(complex128[:,:], complex128[:], complex128[:,:])], '(m,m),(m)->(m,m)',
-              nopython=True, target='cpu')
-def loopsOnlyTriangularMatrix_GuvectorizeOverFreqs_singleThreadedCPU(csm, SpecAllChn, result):
-    nMics = csm.shape[0]
-    for cntRow in range(nMics):
-        temp = np.conj(SpecAllChn[cntRow])
-        for cntColumn in range(cntRow):
-            result[cntRow, cntColumn] = csm[cntRow, cntColumn] + temp * SpecAllChn[cntColumn]
-
-@guvectorize([void(complex128[:,:], complex128[:], complex128[:,:])], '(m,m),(m)->(m,m)',
-              nopython=True, target='parallel')
-def loopsOnlyTriangularMatrix_GuvectorizeOverFreqs_multiThreadedCPU(csm, SpecAllChn, result):
-    nMics = csm.shape[0]
-    for cntRow in range(nMics):
-        temp = np.conj(SpecAllChn[cntRow])
-        for cntColumn in range(cntRow):
-            result[cntRow, cntColumn] = csm[cntRow, cntColumn] + temp * SpecAllChn[cntColumn]
-
-#%%  MAIN
-listOfMics = [500, 700, 1000]  # default: 64
-listOfNFreqs = [2**cnt for cnt in range(4, 11)]  # default: 2048
-nTrials = 10
-
-
-#==============================================================================
-# The benchmark function 'faverage' and also other implementations of
-# the beamformer create a lot of overhead, which influences the computational
-# effort of the succeding function. This is mostly the case, if concurrent
-# calculations are done (multiple cores). So often the first trial of a new
-# function takes some time longer than the other trials.
-#==============================================================================
-
-#funcsToTrial = [loopsComplexTranspose_Numpy, loops_Njit, loops_Njit_Parallel, loops_Njit_Parallel_Prange,
-#                loopsOnlyTriangularMatrix_Njit, loops_GuvectorizeOverFreqs_singleThreadedCPU,
-#                loops_GuvectorizeOverFreqs_multiThreadedCPU,
-#                loopsOnlyTriangularMatrix_GuvectorizeOverFreqs_singleThreadedCPU,
-#                loopsOnlyTriangularMatrix_GuvectorizeOverFreqs_multiThreadedCPU,
-#                faverage_OhneMP, faverage]
-funcsToTrial = [loopsOnlyTriangularMatrix_Njit, faverage]
-
-for nMics in listOfMics:
-    for nFreqs in listOfNFreqs:
-        # Init
-        print(10*'-' + 'New Test configuration: nMics=%s, nFreqs=%s' %(nMics, nFreqs) + 10*'-')
-        print(10*'-' + 'Creation of inputInputs' + 10*'-')
-
-        csm = np.zeros((nFreqs, nMics, nMics), np.complex128)
-        spectrumInput = np.random.rand(nFreqs, nMics) + \
-                1j*np.random.rand(nFreqs, nMics)
-
-        nameOfFuncsToTrial = map(lambda x: x.__name__, funcsToTrial)
-        nameOfFuncsForError = [funcName for funcName in nameOfFuncsToTrial if funcName != 'faverage']
-        maxRelativeDeviation = np.zeros((len(funcsToTrial), nTrials))
-        maxAbsoluteDeviation = np.zeros((len(funcsToTrial), nTrials))
-        timeConsumption = [[] for _ in range(len(funcsToTrial))]
-        indOfBaselineFnc = nameOfFuncsToTrial.index('faverage')
-
-        print(10*'-' + 'Onetime calculation of "faverage" for error reference' + 10*'-')
-        faverage(csm, spectrumInput)
-        resultReference = csm  # For relative/absolute error
-        gc.collect()
-
-        # Testing
-        print(10*'-' + 'Testing of functions' + 10*'-')
-        cntFunc = 0
-        for func in funcsToTrial:
-            print(func.__name__)
-            for cntTrials in xrange(nTrials):
-                csm = np.zeros((nFreqs, nMics, nMics), np.complex128)
-                resultHelp = np.zeros((nFreqs, nMics, nMics), np.complex128)
-                if func.__name__ == 'faverage' or func.__name__ == 'faverage_OhneMP':
-                    t0 = tm.time()
-                    func(csm, spectrumInput)
-                    t1 = tm.time()
-                    result = csm
-                elif func.__name__ == 'loops_GuvectorizeOverFreqs':
-                    t0 = tm.time()
-                    func(csm, spectrumInput, resultHelp)
-                    t1 = tm.time()
-                    result = resultHelp
-                else:
-                    t0 = tm.time()
-                    output = func(csm, spectrumInput)
-                    t1 = tm.time()
-                    result = output
-                timeConsumption[cntFunc].append(t1 - t0)
-                relativeDiffBetweenNewCodeAndRef = (result - resultReference) / (result + resultReference) * 2  # error in relation to the resulting value
-                maxRelativeDeviation[cntFunc, cntTrials] = np.amax(np.amax(np.amax(abs(relativeDiffBetweenNewCodeAndRef), axis=0), axis=0), axis=0) + 10.0**-20  # relative error in inf-norm
-                maxAbsoluteDeviation[cntFunc, cntTrials] = np.amax(np.amax(np.amax(abs(result - resultReference), axis=0), axis=0), axis=0) + 10.0**-20  # absolute error in inf-norm
-            cntFunc += 1
-        factorTimeConsump = [np.mean(timeConsumption[cnt]) for cnt in range(0, len(funcsToTrial))] \
-                            / np.mean(timeConsumption[indOfBaselineFnc])
-
-        # Save the current test-config as .sav
-        helpString = 'The order of the variables is: \n nameOfFuncsToTrial \n maxRelativeDeviation'\
-                '\n timeConsumption [nFuncs, nTrials] \n nMics \n nGridPoints \n nFreqs '\
-                '\n Factor of time consumption (in relation to the original .cpp) \n maxAbsoluteDeviation \n nThreadsGlobal'
-        saveTupel = (helpString, nameOfFuncsToTrial, maxRelativeDeviation, timeConsumption,
-                     nMics, 0, nFreqs, factorTimeConsump, maxAbsoluteDeviation, 0)
-        stringParameters = 'faverage_TestcasesTimeConsumption_nMics%s_nFreqs%s_nTrials%s' %(nMics, nFreqs, nTrials)
-
-#        stringSaveName = 'Peter'
-        stringSaveName = 'Sicherung_DurchgelaufeneTests/faverage/' + stringParameters
-
-        shFncs.savingTimeConsumption(stringSaveName, saveTupel)  # saving as "stringSaveName.sav"
-#        shFncs.plottingOfOvernightTestcasesBeamformer(stringSaveName + '.sav')  # plot of the current test-config
-

acoular/tests/unsupported/SpeedComparison/vglOptimierungGaussSeidel.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Checking various implementations of the damas solver
-
-
-Versions used in this script:
-numba=0.34.0
-python=2.7.13
-"""
-import time as tm
-import threading
-import gc
-
-import numpy as np
-import numba as nb
-
-import sharedFunctions as shFncs
-from beamformer import gseidel1  # The benchmark (created with scipy.weave)
-#from beamformer_withoutMP import r_beamfull_inverse_OhneMP  # also created with scipy.weave, but WITHOUT using multiple cores via OpenMP
-
-@nb.njit(nb.float32[:](nb.float32[:,:], nb.float32[:], nb.float32[:], nb.int64), cache=True)
-def njit_pure(A, dirtyMap, damasSolution, nIterations):
-    nGridPoints = len(dirtyMap)
-    for cntIter in xrange(nIterations):
-        for cntGrid in xrange(nGridPoints):
-            solHelp = np.float32(0)
-            for cntGridHelp in xrange(cntGrid):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            for cntGridHelp in xrange(cntGrid + 1, nGridPoints):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            solHelp = dirtyMap[cntGrid] - solHelp
-            if solHelp > 0.0:
-                damasSolution[cntGrid] = solHelp
-            else:
-                damasSolution[cntGrid] = 0.0
-    return damasSolution
-
-@nb.njit(nb.float32[:](nb.float32[:,:], nb.float32[:], nb.float32[:], nb.int64), parallel=True)
-def njit_parallel(A, dirtyMap, damasSolution, nIterations):
-    nGridPoints = len(dirtyMap)
-    for cntIter in xrange(nIterations):
-        for cntGrid in xrange(nGridPoints):
-            solHelp = np.float32(0)
-            for cntGridHelp in xrange(cntGrid):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            for cntGridHelp in xrange(cntGrid + 1, nGridPoints):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            solHelp = dirtyMap[cntGrid] - solHelp
-            if solHelp > 0.0:
-                damasSolution[cntGrid] = solHelp
-            else:
-                damasSolution[cntGrid] = 0.0
-    return damasSolution
-
-@nb.guvectorize([(nb.float32[:,:], nb.float32[:], nb.int64, nb.float32[:])], '(g,g),(g),()->(g)', cache=True)
-def guvectorizeOverFreqs(A, dirtyMap, nIterations, damasSolution):
-    nGridPoints = len(dirtyMap)
-    for cntIter in xrange(nIterations):
-        for cntGrid in xrange(nGridPoints):
-            solHelp = np.float32(0)
-            for cntGridHelp in xrange(cntGrid):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            for cntGridHelp in xrange(cntGrid + 1, nGridPoints):
-                solHelp += A[cntGrid, cntGridHelp] * damasSolution[cntGridHelp]
-            solHelp = dirtyMap[cntGrid] - solHelp
-            if solHelp > 0.0:
-                damasSolution[cntGrid] = solHelp
-            else:
-                damasSolution[cntGrid] = 0.0
-
-
-def njit_multiThreading(A, dirtyMap, damasSolution, nIterations):
-    nGridPoints = len(dirtyMap)
-    for cntIter in xrange(nIterations):
-        for cntGrid in xrange(nGridPoints):
-            sumHelp = np.zeros((2), np.float32)
-            threadLowerSum = threading.Thread(target=njit_coreSum, args=(A[cntGrid, :], damasSolution, 0, cntGrid, sumHelp, 0))
-            threadUpperSum = threading.Thread(target=njit_coreSum, args=(A[cntGrid, :], damasSolution, cntGrid+1, nGridPoints, sumHelp, 1))
-            threadLowerSum.start()
-            threadUpperSum.start()
-            threadLowerSum.join()
-            threadUpperSum.join()
-            solHelp = np.float32(dirtyMap[cntGrid] - (sumHelp[0] + sumHelp[1]))
-            if solHelp > 0.0:
-                damasSolution[cntGrid] = solHelp
-            else:
-                damasSolution[cntGrid] = 0.0
-    return damasSolution
-@nb.njit(nb.void(nb.float32[:], nb.float32[:], nb.int64, nb.int64, nb.float32[:], nb.int64), cache=True, nogil=True)
-def njit_coreSum(A, damasSolution, start, stop, result, indRes):
-    for cntGridHelp in xrange(start, stop):
-        result[indRes] += A[cntGridHelp] * damasSolution[cntGridHelp]
-
-#%%  MAIN
-listOfMics = [0] # not really needed
-listGridPoints = [500, 1000, 2000, 5000, 10000]  # Standard value: 12000  # The number of gridpoints doesn't seeme to have to great of an influence
-nTrials = 10
-nIterations = 10
-listOfNFreqs = [20]
-
-funcsToTrial = [njit_pure, njit_parallel, guvectorizeOverFreqs, njit_multiThreading, gseidel1]
-for nMics in listOfMics:
-    for nGridPoints in listGridPoints:
-        for nFreqs in listOfNFreqs:
-            # Init
-            print(10*'-' + 'New Test configuration: nMics=%s, nGridPoints=%s, nFreqs=%s' %(nMics, nGridPoints, nFreqs) + 10*'-')
-            print(10*'-' + 'Creation of inputInputs' + 10*'-')
-            
-            A = np.float32(np.random.rand(1, nGridPoints, nGridPoints))  #A = np.float32(np.ones((1, nGridPoints, nGridPoints)))
-#            for cntFreqs in range(nFreqs):
-#                A[cntFreqs, :, :] += A[cntFreqs, :, :].T.conj()
-            dirtyMap = np.float32(np.random.rand(1, nGridPoints))  #dirtyMap = np.float32(np.ones((1, nGridPoints)))
-            damasSolution = np.zeros((nGridPoints), np.float32)
-            
-            # create nFreqs times the same matrix for comparing reasons
-            A = np.tile(A, [nFreqs, 1, 1])
-            dirtyMap = np.tile(dirtyMap, [nFreqs, 1])
-            
-            nameOfFuncsToTrial = map(lambda x: x.__name__, funcsToTrial)
-            nameOfFuncsForError = [funcName for funcName in nameOfFuncsToTrial if funcName != 'gseidel1']
-            maxRelativeDeviation = np.zeros((len(funcsToTrial), nTrials))
-            maxAbsoluteDeviation = np.zeros((len(funcsToTrial), nTrials))
-            timeConsumption = [[] for _ in range(len(funcsToTrial))]
-            indOfBaselineFnc = nameOfFuncsToTrial.index('gseidel1')
-            
-            print(10*'-' + 'Onetime calculation of error reference' + 10*'-')
-            gseidel1(A[0,:,:], dirtyMap[0,:], damasSolution, nIterations)
-            resultReference = damasSolution  # For relative/absolute error
-            gc.collect()
-            
-            # Testing
-            print(10*'-' + 'Testing of functions' + 10*'-')
-            cntFunc = 0
-            for func in funcsToTrial:
-                print(func.__name__)
-                for cntTrials in xrange(nTrials):
-                    damasSolution = np.zeros((1, nGridPoints), np.float32)
-                    damasSolution = np.tile(damasSolution, [nFreqs, 1])
-                    if func.__name__ == 'guvectorizeOverFreqs':
-                        t0 = tm.time()
-                        func(A, dirtyMap, nIterations, damasSolution)
-                        t1 = tm.time()
-                        result = damasSolution[0, :]
-                    elif func.__name__ == 'gseidel1':
-                        t0 = tm.time()
-                        for cntFreqsHelp in xrange(nFreqs):
-                            func(A[cntFreqsHelp,:,:], dirtyMap[cntFreqsHelp,:], damasSolution[cntFreqsHelp,:], nIterations)
-                        t1 = tm.time()
-                        result = damasSolution[0, :]
-                    else:
-                        t0 = tm.time()
-                        for cntFreqsHelp in xrange(nFreqs):
-                            output = func(A[cntFreqsHelp,:,:], dirtyMap[cntFreqsHelp,:], damasSolution[cntFreqsHelp,:], nIterations)
-                        t1 = tm.time()
-                        result = output
-                    timeConsumption[cntFunc].append(t1 - t0)
-                    relativeDiffBetweenNewCodeAndRef = (result - resultReference) / (result + resultReference) * 2  # error in relation to the resulting value
-                    maxRelativeDeviation[cntFunc, cntTrials] = np.amax(abs(relativeDiffBetweenNewCodeAndRef), axis=0)  # relative error in inf-norm
-                    maxAbsoluteDeviation[cntFunc, cntTrials] = np.amax(abs(result - resultReference), axis=0)  # absolute error in inf-norm
-                cntFunc += 1
-            factorTimeConsump = [np.mean(timeConsumption[cnt]) for cnt in range(0, len(funcsToTrial))] \
-                                / np.mean(timeConsumption[indOfBaselineFnc])
-            
-            # Save the current test-config as .sav
-            helpString = 'The order of the variables is: \n nameOfFuncsToTrial \n maxRelativeDeviation'\
-                '\n timeConsumption [nFuncs, nTrials] \n nMics \n nGridPoints \n nFreqs '\
-                '\n Factor of time consumption (in relation to the original .cpp) \n maxAbsoluteDeviation \n nThreadsGlobal'
-            saveTupel = (helpString, nameOfFuncsToTrial, maxRelativeDeviation, timeConsumption, 
-                         nMics, nGridPoints, nFreqs, factorTimeConsump, maxAbsoluteDeviation, 0)
-            stringParameters = 'OvernightTestcasesBeamformer_nMics%s_nGridPoints%s_nFreqs%s_nTrials%s' %(nMics, nGridPoints, nFreqs, nTrials)
-            
-#            stringSaveName = 'Peter'
-            stringSaveName = 'Sicherung_DurchgelaufeneTests/damasSolver/' + stringParameters
-#            stringSaveName = 'Sicherung_DurchgelaufeneTests/Beamformer/AllImportantMethods/' + stringParameters
-#            stringSaveName = 'Sicherung_DurchgelaufeneTests/Beamformer/EinflussGridpoints/AMDFX6100/' + stringParameters
-#            stringSaveName = 'Sicherung_DurchgelaufeneTests/Beamformer/JitPrange/' + stringParameters
-#            stringSaveName = 'Sicherung_DurchgelaufeneTests/Beamformer/Multithreading_02Threads/' + stringParameters
-
-            shFncs.savingTimeConsumption(stringSaveName, saveTupel)  # saving as "stringSaveName.sav"
-            
-#            shFncs.plottingOfOvernightTestcasesBeamformer(stringSaveName + '.sav')  # plot of the current test-config