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

acoular/tests/unsupported/SpeedComparison/vglOptimierungR_BEAM_OS.py

@@ -1,231 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-
-"""
-import time as tm
-
-import numpy as np
-from numba import guvectorize, complex128, float64
-
-import sharedFunctions as shFncs
-from beamformer import r_beamfull_os_classic, r_beamdiag_os_classic  # The benchmark (created with scipy.weave)
-#from beamformer_withoutMP import r_beamfull_inverse_withoutMP  # also created with scipy.weave, but WITHOUT using multiple cores via OpenMP
-
-
-#%% NUMBA - GUVECTORIZE
-def csmBeamformer(csm, r0, rm, kj):
-    """ Benchmark for comparison of correctness.
-    """
-    nFreqs = csm.shape[0]
-    nGridPoints = r0.shape[0]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.complex128)
-    for cntFreqs in xrange(nFreqs):
-        for cntGrid in xrange(nGridPoints):
-            steeringVector = np.exp(-1j * np.float32(kj[cntFreqs].imag * (rm[cntGrid, :] - r0[cntGrid])))
-            # correct
-            result = np.dot(steeringVector, csm[cntFreqs, :, :])
-            beamformOutput[cntFreqs, cntGrid] = np.vdot(steeringVector, result)  
-            
-            # incorrect
-#            result = np.dot(csm[cntFreqs, :, :], steeringVector)
-#            beamformOutput[cntFreqs, cntGrid] = np.vdot(steeringVector, result)
-    return beamformOutput.real / nMics**2
-
-
-def correctResult(r0, rm, kj, eigVal, eigVec):
-    nFreqs, nGridPoints, nMics = kj.shape[0], rm.shape[0], rm.shape[1]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-    for cntFreqs in xrange(nFreqs):
-        for cntGrid in xrange(nGridPoints):
-            steeringVector = np.exp(-1j * np.float32(kj[cntFreqs].imag * (rm[cntGrid, :] - r0[cntGrid])))
-            result = 0.0
-            for cntEWs in range(eigVal.shape[1]):
-#                spectralCSM = np.outer(eigVec[cntFreqs, :, cntEWs], eigVec[cntFreqs, :, cntEWs].conj())
-#                result += np.inner(np.inner(steeringVector.conj(), spectralCSM), steeringVector) * eigVal[cntFreqs, cntEWs]
-#            beamformOutput[cntFreqs, cntGrid] = result
-                result += np.vdot(eigVec[cntFreqs, :, cntEWs], steeringVector.conj()) * eigVal[cntFreqs, cntEWs] * eigVec[cntFreqs, :, cntEWs]
-            beamformOutput[cntFreqs, cntGrid] = np.dot(steeringVector, result)
-    return beamformOutput.real / nMics**2
-
-def loops_NumbaGuvectorizeOverGrid(r0, rm, kj, eigVal, eigVec):
-    nFreqs, nGridPoints, nMics = kj.shape[0], rm.shape[0], rm.shape[1]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-    for cntFreqs in xrange(nFreqs):
-        result = np.zeros(nGridPoints, np.float64)
-        loops_Core(eigVal[cntFreqs, :], eigVec[cntFreqs, :, :], r0, rm, kj[cntFreqs].imag, nMics, result)
-        beamformOutput[cntFreqs, :] = result
-    return beamformOutput
-
-@guvectorize([(float64[:], complex128[:,:], float64[:], float64[:], float64[:], float64[:], float64[:])], 
-              '(e),(m,e),(),(m),(),()->()', nopython=True, target='parallel')
-def loops_Core(eigVal, eigVec, distGridToArrayCenter, distGridToAllMics, 
-                                                             waveNumber, nMicsForNormalization, result):
-    # init
-    nMics = distGridToAllMics.shape[0]
-    steerVec = np.zeros((nMics), np.complex128)
-
-    # building steering vector: in order to save some operaions -> some normalization steps are applied after mat-vec-multipl.
-    for cntMics in xrange(nMics):
-        temp = np.float32(waveNumber[0] * (distGridToAllMics[cntMics] - distGridToArrayCenter[0]))
-        steerVec[cntMics] = (np.cos(temp) - 1j * np.sin(temp))
-    
-    # performing matrix-vector-multiplication via spectral decomposition of the hermitian CSM-Matrix
-    temp1 = 0.0
-    for cntEigVal in range(len(eigVal)):
-        temp2 = 0.0
-        for cntMics in range(nMics):  # Algebraic multiplicity = Geometric multiplicity for any hermitian matrix
-            temp2 += eigVec[cntMics, cntEigVal] * steerVec[cntMics]
-        temp1 += (temp2 * temp2.conjugate() * eigVal[cntEigVal]).real
-    result[0] = temp1 / nMicsForNormalization[0] ** 2
-
-
-def loopsCascade_NumbaGuvectorizeOverGrid(r0, rm, kj, eigVal, eigVec):
-    nFreqs, nGridPoints, nMics = kj.shape[0], rm.shape[0], rm.shape[1]
-    beamformOutput = np.zeros((nFreqs, nGridPoints), np.float64)
-    for cntFreqs in xrange(nFreqs):
-        result = np.zeros(nGridPoints, np.float64)
-        loopsCascade_Core(eigVal[cntFreqs, :], eigVec[cntFreqs, :, :], r0, rm, kj[cntFreqs].imag, nMics, result)
-        beamformOutput[cntFreqs, :] = result
-    return beamformOutput
-
-@guvectorize([(float64[:], complex128[:,:], float64[:], float64[:], float64[:], float64[:], float64[:])], 
-              '(e),(m,e),(),(m),(),()->()', nopython=True, target='parallel')
-def loopsCascade_Core(eigVal, eigVec, distGridToArrayCenter, distGridToAllMics, 
-                                                             waveNumber, nMicsForNormalization, result):
-    # init
-    nMics = distGridToAllMics.shape[0]
-    steerVec = np.zeros((nMics), np.complex128)
-
-    # building steering vector: in order to save some operaions -> some normalization steps are applied after mat-vec-multipl.
-    for cntMics in xrange(nMics):
-        temp = np.float32(waveNumber[0] * (distGridToAllMics[cntMics] - distGridToArrayCenter[0]))
-        steerVec[cntMics] = (np.cos(temp) - 1j * np.sin(temp))
-    
-    # performing matrix-vector-multiplication via spectral decomposition of the hermitian CSM-Matrix
-    temp1 = 0.0
-    for cntEigVal in range(len(eigVal)):
-        temp2 = np.dot(eigVec[:, cntEigVal], steerVec)
-        temp1 += (temp2 * temp2.conjugate() * eigVal[cntEigVal]).real
-    result[0] = temp1 / nMicsForNormalization[0] ** 2
-#%%  MAIN
-listOfMics = [64, 100, 250, 500, 700, 1000]
-listGridPoints = [100, 5000, 10000]  # Standard value: 12000  # The number of gridpoints doesn't seeme to have to great of an influence
-nTrials = 10
-listOfNFreqs = [10000]
-
-#==============================================================================
-# The benchmark function 'r_beamfull_inverse' 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 = [csmBeamformer, correctResult, r_beamfull_os_classic]  # full csm
-#funcsToTrial = [csmBeamformer, correctResult, r_beamdiag_os_classic]  # removed diagonal of csm
-funcsToTrial = [loopsCascade_NumbaGuvectorizeOverGrid, loops_NumbaGuvectorizeOverGrid, r_beamfull_os_classic] 
-removeDiagOfCSM = False
-
-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*'-')
-            
-            # Inputs for the beamformer methods:
-            # At the moment the beamformer-methods are called once per 
-            # frequency (CSM is a Matrix, no 3rd-order-tensor)
-            # For easier camparability we build the CSM as a 3rd-order-tensor) instead
-            csm = np.random.rand(nFreqs, nMics, nMics) + 1j*np.random.rand(nFreqs, nMics, nMics)  # cross spectral matrix
-            for cntFreqs in range(nFreqs):
-                csm[cntFreqs, :, :] += csm[cntFreqs, :, :].T.conj()  # make CSM hermetical
-            e = np.random.rand(nMics) + 1j*np.random.rand(nMics)  # has no usage
-            h = np.zeros((nFreqs, nGridPoints))  # results are stored here, if function has no return value
-            r0 = np.random.rand(nGridPoints)  # distance between gridpoints and middle of array
-            rm = np.random.rand(nGridPoints, nMics)  # distance between gridpoints and all mics in the array
-            kj = np.zeros(nFreqs) + 1j*np.random.rand(nFreqs) # complex wavenumber 
-            eigVal, eigVec = np.linalg.eigh(csm)
-            indLow = 5  # 5
-            indHigh = 10# 10
-            
-            # remove diagonal of csm
-            if removeDiagOfCSM:
-                for cntMics in range(nMics):
-                    csm[cntFreqs, cntMics, cntMics] = 0
-                eigValDiag, eigVecDiag = np.linalg.eigh(csm)
-                refFunc = 'r_beamdiag_os_classic'
-                resultReference = correctResult(r0, rm, kj, eigValDiag[:, indLow : indHigh], eigVecDiag[:, :, indLow : indHigh])  # For relative/absolute error
-            else:
-                refFunc = 'r_beamfull_os_classic'
-                resultReference = correctResult(r0, rm, kj, eigVal[:, indLow : indHigh], eigVec[:, :, indLow : indHigh])  # For relative/absolute error
-            
-            nameOfFuncsToTrial = map(lambda x: x.__name__, funcsToTrial)
-            nameOfFuncsForError = [funcName for funcName in nameOfFuncsToTrial if funcName != refFunc]
-            maxRelativeDeviation = np.zeros((len(funcsToTrial), nTrials))
-            maxAbsoluteDeviation = np.zeros((len(funcsToTrial), nTrials))
-            timeConsumption = [[] for _ in range(len(funcsToTrial))]
-            indOfBaselineFnc = nameOfFuncsToTrial.index(refFunc)
-            
-            # Testing
-            print(10*'-' + 'Testing of functions' + 10*'-')
-            cntFunc = 0
-            for func in funcsToTrial:
-                print(func.__name__)
-                for cntTrials in xrange(nTrials):
-                    h = np.zeros((nFreqs, nGridPoints))
-                    if func.__name__ == refFunc:
-                        t0 = tm.time()
-                        func(e, h, r0, rm, kj, eigVal, eigVec, indLow, indHigh)
-                        t1 = tm.time()
-                        result = h / nMics**2
-                    elif func.__name__ == 'correctResult' and removeDiagOfCSM:
-                        t0 = tm.time()
-                        output = func(r0, rm, kj, eigValDiag[:, indLow : indHigh], eigVecDiag[:, :, indLow : indHigh])
-                        t1 = tm.time()
-                        result = output
-                    elif func.__name__ == 'csmBeamformer':
-                        t0 = tm.time()
-                        output = func(csm, r0, rm, kj)
-                        t1 = tm.time()
-                        result = output
-                    else:
-                        t0 = tm.time()
-                        output = func(r0, rm, kj, eigVal[:, indLow : indHigh], eigVec[:, :, indLow : indHigh])
-                        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(abs(relativeDiffBetweenNewCodeAndRef), axis=1), axis=0)  # relative error in inf-norm
-                    maxAbsoluteDeviation[cntFunc, cntTrials] = np.amax(np.amax(abs(result - resultReference), axis=1), 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/Beamformer/cascadingSums/' + 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
-
-#==============================================================================
-#The Following use of the numba decorators could lead to less code (as a function 
-#body could be used more often) but is also slower, which is why it wasn't used
-#in this comparison.
-# signature = complex128[:,:](complex128[:,:,:], float64[:], float64[:,:])
-# numbaOptimizedFunction= jit(signature, nopython=True)(plainPythonFunction.py_func)
-#==============================================================================

acoular/tests/unsupported/SpeedComparison/whatsFastestWayFor_absASquared.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-"""
-Created on Fri Sep 15 11:24:36 2017
-
-@author: tomgensch
-"""
-
-import numba as nb
-import time as tm
-
-@nb.njit
-def absASquared(N):
-    a = 42.0 + 87.0j
-    for cnt in xrange(N):
-        peter = abs(a) * abs(a)
-    return peter
-@nb.njit
-def aTimesAConj(N):
-    a = 42.0 + 87.0j
-    for cnt in xrange(N):
-        peter = (a * a.conjugate()).real
-    return peter
-@nb.njit
-def realSquaredPlusImagSquared(N):
-    a = 42.0 + 87.0j
-    for cnt in xrange(N):
-        peter = a.real * a.real + a.imag * a.imag
-    return peter
-
-N = 3000000000
-t0 = tm.time()
-erg1 = absASquared(N)
-timeAbsASquared = tm.time() - t0
-
-t0 = tm.time()
-erg2 = aTimesAConj(N)
-timeATimesAConj = tm.time() - t0
-
-t0 = tm.time()
-erg3 = realSquaredPlusImagSquared(N)
-timeRealSquaredPlusImagSquared = tm.time() - t0
-
-faktorAbsSquareVstimeRealSquaredPlusImagSquared = timeAbsASquared / timeRealSquaredPlusImagSquared
-faktortimeATimesAConjVstimeRealSquaredPlusImagSquared = timeATimesAConj / timeRealSquaredPlusImagSquared
-
-print('abs(a)**2 / (a.real**2 + a.imag**2): %s' %(faktorAbsSquareVstimeRealSquaredPlusImagSquared))
-print('a*a.conj / (a.real**2 + a.imag**2): %s' %(faktortimeATimesAConjVstimeRealSquaredPlusImagSquared))

acoular/tests/unsupported/functionalBeamformer.py

@@ -1,123 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Example 6 for acoular library
-
-demonstrates different steering vectors in acoular,
-and CSM diagonal removal 
-with same setup as in example 1
-
-uses measured data in file example_data.h5
-calibration in file example_calib.xml
-microphone geometry in array_56.xml (part of acoular)
-
-
-Copyright (c) 2006-2017 The Acoular developers.
-All rights reserved.
-"""
-from __future__ import print_function
-
-# imports from acoular
-import acoular
-from acoular import L_p, Calib, MicGeom, EigSpectra, \
-RectGrid, BeamformerBase, BeamformerEig, BeamformerOrth, BeamformerCleansc, \
-MaskedTimeSamples, BeamformerDamas, BeamformerFunctional
-
-# other imports
-from os import path
-from pylab import figure, subplot, imshow, show, colorbar, title, suptitle
-
-# files
-datafile = 'example_data.h5'
-calibfile = 'example_calib.xml'
-micgeofile = path.join( path.split(acoular.__file__)[0],'xml','array_56.xml')
-
-#octave band of interest
-cfreq = 4000
-
-#===============================================================================
-# first, we define the time samples using the MaskedTimeSamples class
-# alternatively we could use the TimeSamples class that provides no masking
-# of channels and samples
-#===============================================================================
-t1 = MaskedTimeSamples(name=datafile)
-t1.start = 0 # first sample, default
-t1.stop = 16000 # last valid sample = 15999
-invalid = [1,7] # list of invalid channels (unwanted microphones etc.)
-t1.invalid_channels = invalid 
-
-#===============================================================================
-# calibration is usually needed and can be set directly at the TimeSamples 
-# object (preferred) or for frequency domain processing at the PowerSpectra 
-# object (for backwards compatibility)
-#===============================================================================
-t1.calib = Calib(from_file=calibfile)
-
-#===============================================================================
-# the microphone geometry must have the same number of valid channels as the
-# TimeSamples object has
-#===============================================================================
-m = MicGeom(from_file=micgeofile)
-m.invalid_channels = invalid
-
-#===============================================================================
-# the grid for the beamforming map; a RectGrid3D class is also available
-# (the example grid is very coarse)
-#===============================================================================
-g = RectGrid(x_min=-0.6, x_max=-0.0, y_min=-0.3, y_max=0.3, z=0.68,
-             increment=0.05)
-
-#===============================================================================
-# for frequency domain methods, this provides the cross spectral matrix and its
-# eigenvalues and eigenvectors, if only the matrix is needed then class 
-# PowerSpectra can be used instead
-#===============================================================================
-f = EigSpectra(time_data=t1, 
-               window='Hanning', overlap='50%', block_size=128, #FFT-parameters
-               ind_low=7, ind_high=15) #to save computational effort, only
-               # frequencies with index 1-30 are used
-
-
-#===============================================================================
-# beamformers in frequency domain
-#===============================================================================
-bb = BeamformerBase(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04)
-bd = BeamformerDamas(beamformer=bb, n_iter=100)
-be = BeamformerEig(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04, n=54)
-bo = BeamformerOrth(beamformer=be, eva_list=list(range(38,54)))
-bs = BeamformerCleansc(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04)
-bf = BeamformerFunctional(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04, gamma = 60)
-
-#===============================================================================
-# plot result maps for different beamformers in frequency domain
-#===============================================================================
-
-
-
-fi = 1 #no of figure
-for r_diag in (True,False):
-    figure(fi)
-    suptitle('Old Implementation | R_diag=' + str(r_diag))
-    fi +=1 
-    bb.r_diag = r_diag
-    be.r_diag = r_diag
-    bs.r_diag = r_diag
-    bf.r_diag = r_diag
-    i1 = 1 #no of subplot
-    for steer in ('true level', 'true location', 'classic', 'inverse'):     
-        bb.steer = steer
-        be.steer = steer
-        bs.steer = steer
-        bf.steer = steer
-        for b in (bb, bd, bo, bs, bf):
-            subplot(4,5,i1)
-            i1 += 1
-            map = b.synthetic(cfreq,1)
-            mx = L_p(map.max())
-            imshow(L_p(map.T), vmax=mx, vmin=mx-15, 
-                   interpolation='nearest', extent=g.extend())
-            print(b.steer)
-            colorbar()
-            title(b.__class__.__name__,fontsize='small')
-
-
-show()

acoular/tests/unsupported/precisionTest.py

@@ -1,153 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Example 6 for acoular library
-
-demonstrates different steering vectors in acoular,
-and CSM diagonal removal 
-with same setup as in example 1
-
-uses measured data in file example_data.h5
-calibration in file example_calib.xml
-microphone geometry in array_56.xml (part of acoular)
-
-
-Copyright (c) 2006-2017 The Acoular developers.
-All rights reserved.
-"""
-from __future__ import print_function
-
-# imports from acoular
-import acoular
-from acoular import L_p, Calib, MicGeom, EigSpectra, \
-RectGrid, BeamformerBase, BeamformerEig, BeamformerOrth, BeamformerCleansc, \
-MaskedTimeSamples, BeamformerDamas, BeamformerFunctional, PointSpreadFunction, BeamformerClean, BeamformerDamasPlus
-
-# other imports
-from os import path
-from pylab import figure, subplot, imshow, show, colorbar, title, suptitle
-
-# files
-datafile = 'example_data.h5'
-calibfile = 'example_calib.xml'
-micgeofile = path.join( path.split(acoular.__file__)[0],'xml','array_56.xml')
-
-#octave band of interest
-cfreq = 4000
-
-#===============================================================================
-# first, we define the time samples using the MaskedTimeSamples class
-# alternatively we could use the TimeSamples class that provides no masking
-# of channels and samples
-#===============================================================================
-t1 = MaskedTimeSamples(name=datafile)
-t1.start = 0 # first sample, default
-t1.stop = 16000 # last valid sample = 15999
-invalid = [1,7] # list of invalid channels (unwanted microphones etc.)
-t1.invalid_channels = invalid 
-
-#===============================================================================
-# calibration is usually needed and can be set directly at the TimeSamples 
-# object (preferred) or for frequency domain processing at the PowerSpectra 
-# object (for backwards compatibility)
-#===============================================================================
-t1.calib = Calib(from_file=calibfile)
-
-#===============================================================================
-# the microphone geometry must have the same number of valid channels as the
-# TimeSamples object has
-#===============================================================================
-m = MicGeom(from_file=micgeofile)
-m.invalid_channels = invalid
-
-#===============================================================================
-# the grid for the beamforming map; a RectGrid3D class is also available
-# (the example grid is very coarse)
-#===============================================================================
-g = RectGrid(x_min=-0.6, x_max=-0.0, y_min=-0.3, y_max=0.3, z=0.68,
-             increment=0.05)
-
-#===============================================================================
-# for frequency domain methods, this provides the cross spectral matrix and its
-# eigenvalues and eigenvectors, if only the matrix is needed then class 
-# PowerSpectra can be used instead
-#===============================================================================
-f = EigSpectra(time_data=t1, 
-               window='Hanning', overlap='50%', block_size=128, #FFT-parameters
-               ind_low=7, ind_high=15, precision='complex128') #to save computational effort, only
-               # frequencies with index 1-30 are used
-csm = f.csm[:]
-eva = f.eva[:]
-
-f32 = EigSpectra(time_data=t1, 
-               window='Hanning', overlap='50%', block_size=128, #FFT-parameters
-               ind_low=7, ind_high=15, precision='complex64') #to save computational effort, only
-csm32 = f32.csm[:]
-eva32 = f32.eva[:]
-
-psf32 = PointSpreadFunction(grid=g, mpos=m, c=346.04, precision='float32')
-psf32Res = psf32.psf[:]
-
-psf64 = PointSpreadFunction(grid=g, mpos=m, c=346.04, precision='float64')
-psf64Res = psf64.psf[:]
-
-bb32 = BeamformerBase(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04, precision='float32')
-bb32Res = bb32.synthetic(cfreq,1)
-
-bb64 = BeamformerBase(freq_data=f, grid=g, mpos=m, r_diag=True, c=346.04, precision='float64')
-bb64Res = bb64.synthetic(cfreq,1)
-
-bf = BeamformerFunctional(freq_data=f, grid=g, mpos=m, r_diag=False, c=346.04, gamma = 60, precision='float32')
-bfRes = bf.synthetic(cfreq,1)
-
-# 32 Bit PSF precision
-bd3232 = BeamformerDamas(beamformer=bb32, n_iter=100, psf_precision='float32')
-bd3232Res = bd3232.synthetic(cfreq,1)
-bc3232 = BeamformerClean(beamformer=bb32, psf_precision='float32')
-bc3232Res = bc3232.synthetic(cfreq,1)
-bdp3232 = BeamformerDamasPlus(beamformer=bb32, n_iter=100, psf_precision='float32')
-bdp3232Res  = bdp3232.synthetic(cfreq,1)
-
-#64 Bit
-bd3264 = BeamformerDamas(beamformer=bb32, n_iter=100, psf_precision='float64')
-bd3264Res = bd3264.synthetic(cfreq,1)
-bc3264 = BeamformerClean(beamformer=bb32, psf_precision='float64')
-bc3264Res = bc3264.synthetic(cfreq,1)
-bdp3264 = BeamformerDamasPlus(beamformer=bb32, n_iter=100, psf_precision='float64')
-bdp3264Res  = bdp3264.synthetic(cfreq,1)
-
-# 32 Bit PSF precision
-bd6432 = BeamformerDamas(beamformer=bb64, n_iter=100, psf_precision='float32')
-bd6432Res = bd6432.synthetic(cfreq,1)
-bc6432 = BeamformerClean(beamformer=bb64, psf_precision='float32')
-bc6432Res = bc6432.synthetic(cfreq,1)
-bdp6432 = BeamformerDamasPlus(beamformer=bb64, n_iter=100, psf_precision='float32')
-bdp6432Res  = bdp6432.synthetic(cfreq,1)
-
-#64 Bit
-bd6464 = BeamformerDamas(beamformer=bb64, n_iter=100, psf_precision='float64')
-bd6464Res = bd6464.synthetic(cfreq,1)
-bc6464 = BeamformerClean(beamformer=bb64, psf_precision='float64')
-bc6464Res = bc6464.synthetic(cfreq,1)
-bdp6464 = BeamformerDamasPlus(beamformer=bb64, n_iter=100, psf_precision='float64')
-bdp6464Res  = bdp6464.synthetic(cfreq,1)
-
-
-
-#===============================================================================
-# plot result maps for different beamformers in frequency domain
-#===============================================================================
-i1 = 1
-for b in (bb32, bd3232, bc3232, bdp3232, bd3264, bc3264, bdp3264,
-          bb64, bd6432, bc6432, bdp6432, bd6464, bc6464, bdp6464):
-    subplot(2, 7, i1)
-    i1 += 1
-    res = b.synthetic(cfreq,1)
-    mx = L_p(res.max())
-    imshow(L_p(res.T), vmax=mx, vmin=mx-15, 
-           interpolation='nearest', extent=g.extend())
-    print(b.steer)
-    colorbar()
-    title(b.__class__.__name__ + b.precision,fontsize='small')
-
-
-show()