pydvma 0.9.7__tar.gz

pydvma-0.9.7/LICENSE

@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Tore Butlin
+Contributors: Tore Butlin, Jim Woodhouse, Areeg Emarah, En Yi Tee, Theo Brown, Rick Lupton
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pydvma-0.9.7/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.1
+Name: pydvma
+Version: 0.9.7
+Home-page: https://github.com/torebutlin/pydvma
+Author: Tore Butlin
+Author-email: tb267@cam.ac.uk
+License: BSD 3-Clause License
+License-File: LICENSE
+
+# pydvma
+
+A Python package for dynamics and vibration measurements and analysis.
+
+
+## About pydvma
+
+This is a modular library for data measurement and analysis in the context of dynamics and vibration, for use in student laboratory experiments as well as for research projects, developed at Cambridge University Engineering Department.
+
+A high-level interface allows straightforward application for common use-cases and a low-level interface provides more control when needed.
+
+The aim is for a library that is simple to use and simple to maintain. It is not a full-featured GUI, but when used in conjunction with Jupyter Notebooks it is intended to provide the best of both worlds: interactive tools for common tasks and a command line interface for customisation.
+
+
+## Getting started
+
+### Installation
+
+The logger is recommended for use with Python 3.10.
+
+```
+pip install pydvma
+```
+
+If you would like soundcard acquisition then also install sounddevice:
+```
+pip install sounddevice
+```
+
+Or clone this repository and install using:
+```
+python setup.py install
+```
+
+Alternatively you can use the environment yml file provided:
+```
+conda env -name logger create -f logger.yml
+conda activate logger
+```
+
+### Running the logger
+
+To get started, open the file:
+```
+pydvma_template.ipynb
+```
+
+or within a Jupyter Notebook or Python console:
+```python
+%gui qt
+import pydvma as dvma
+settings = dvma.MySettings()
+osc = dvma.Oscilloscope(settings)
+logger = dvma.Logger(settings)
+```
+
+## Roadmap
+
+At present the library has basic functionality for:
+
+- logging data using soundcards or National Instrument DAQs (requires NiDAQmx to be installed from NI, windows only)
+- logging with pre-trigger for impulse response measurements
+- logging with pc generated output (soundcard and NIDAQ)
+- computing frequency domain data
+- computing transfer function data
+- computing sonograms/spectrograms
+- basic modal analysis tools (mode-fitting)
+- saving and plotting data
+- export to Matlab
+- interactive tools for standard acquisition and analysis
+- oscilloscope view of input signals
+
+The plan is to include the following functionality:
+
+- wider support for import/export
+- more advanced modal analysis tools (e.g. global fitting)
+- extend the range of hardware that can be accessed from this library
+
+
+## Contributer guidelines
+
+Contributions to this project are welcomed, keeping in mind the project aims above:
+
+- If you find a bug, please report using GitHub's issue tracker
+
+- For bug-fixes and refinements: please feel free to clone the repository, make edits and create a pull request with a clear description of changes made.
+
+- If you would like to make a more significant contribution or change, then please be in contact to outline your suggestion.
+
+Please see the documentation for details of the code structure and templates for anticipated applications.
+<!-- pip install git+https://github.com/torebutlin/pydvma.git -->
+<!-- pip install git+https://github.com/js2597/pydvma.git -->

pydvma-0.9.7/README.md

@@ -0,0 +1,92 @@
+# pydvma
+
+A Python package for dynamics and vibration measurements and analysis.
+
+
+## About pydvma
+
+This is a modular library for data measurement and analysis in the context of dynamics and vibration, for use in student laboratory experiments as well as for research projects, developed at Cambridge University Engineering Department.
+
+A high-level interface allows straightforward application for common use-cases and a low-level interface provides more control when needed.
+
+The aim is for a library that is simple to use and simple to maintain. It is not a full-featured GUI, but when used in conjunction with Jupyter Notebooks it is intended to provide the best of both worlds: interactive tools for common tasks and a command line interface for customisation.
+
+
+## Getting started
+
+### Installation
+
+The logger is recommended for use with Python 3.10.
+
+```
+pip install pydvma
+```
+
+If you would like soundcard acquisition then also install sounddevice:
+```
+pip install sounddevice
+```
+
+Or clone this repository and install using:
+```
+python setup.py install
+```
+
+Alternatively you can use the environment yml file provided:
+```
+conda env -name logger create -f logger.yml
+conda activate logger
+```
+
+### Running the logger
+
+To get started, open the file:
+```
+pydvma_template.ipynb
+```
+
+or within a Jupyter Notebook or Python console:
+```python
+%gui qt
+import pydvma as dvma
+settings = dvma.MySettings()
+osc = dvma.Oscilloscope(settings)
+logger = dvma.Logger(settings)
+```
+
+## Roadmap
+
+At present the library has basic functionality for:
+
+- logging data using soundcards or National Instrument DAQs (requires NiDAQmx to be installed from NI, windows only)
+- logging with pre-trigger for impulse response measurements
+- logging with pc generated output (soundcard and NIDAQ)
+- computing frequency domain data
+- computing transfer function data
+- computing sonograms/spectrograms
+- basic modal analysis tools (mode-fitting)
+- saving and plotting data
+- export to Matlab
+- interactive tools for standard acquisition and analysis
+- oscilloscope view of input signals
+
+The plan is to include the following functionality:
+
+- wider support for import/export
+- more advanced modal analysis tools (e.g. global fitting)
+- extend the range of hardware that can be accessed from this library
+
+
+## Contributer guidelines
+
+Contributions to this project are welcomed, keeping in mind the project aims above:
+
+- If you find a bug, please report using GitHub's issue tracker
+
+- For bug-fixes and refinements: please feel free to clone the repository, make edits and create a pull request with a clear description of changes made.
+
+- If you would like to make a more significant contribution or change, then please be in contact to outline your suggestion.
+
+Please see the documentation for details of the code structure and templates for anticipated applications.
+<!-- pip install git+https://github.com/torebutlin/pydvma.git -->
+<!-- pip install git+https://github.com/js2597/pydvma.git -->

pydvma-0.9.7/pydvma/__init__.py

@@ -0,0 +1,16 @@
+from .gui import Logger, Oscilloscope
+from .options import MySettings, Output_Signal_Settings ,set_plot_colours
+from .file import load_data, save_data, save_fig, export_to_matlab_jwlogger, export_to_matlab, export_to_csv
+# from .oscilloscope import Oscilloscope
+from .acquisition import log_data, output_signal, signal_generator, stream_snapshot
+from .datastructure import DataSet, TimeData, FreqData, CrossSpecData, TfData, SonoData, MetaData, ModalData, update_dataset
+from .testdata import create_test_impulse_data, create_test_impulse_ensemble, create_test_noise_data
+from .plotting import PlotData
+from .analysis import calculate_fft, calculate_cross_spectrum_matrix, calculate_cross_spectra_averaged, clean_impulse
+from .analysis import calculate_tf, calculate_tf_averaged, multiply_by_power_of_iw, best_match, calculate_sonogram
+from .streams import Recorder, Recorder_NI, start_stream, REC, setup_output_NI, setup_output_soundcard, list_available_devices, get_devices_NI, get_devices_soundcard
+from .modal import modal_fit_single_channel, modal_fit_all_channels
+# import faulthandler
+# faulthandler.enable()
+# from .gui_tk_test import Logger
+

pydvma-0.9.7/pydvma/acquisition.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 27 17:08:42 2018
+
+@author: tb267
+"""
+
+from . import datastructure
+from . import streams
+
+import numpy as np
+import scipy.signal as signal
+import scipy.stats as stats
+import datetime
+import time
+
+MESSAGE = ''
+
+#%% Main data acquisition function
+def log_data(settings,test_name=None,rec=None, output=None):
+    '''
+    Logs data according to settings and returns DataSet class
+    '''
+    global MESSAGE
+    
+    if rec is None:
+        streams.start_stream(settings)
+        rec = streams.REC
+        
+    
+    streams.REC.trigger_detected = False
+    
+    # Stream is slightly longer than settings.stored_time, so need to add delay
+    # from initialisation to allow stream to fill up and prevent zeros at start
+    # of logged data.
+    time.sleep(2*settings.chunk_size/settings.fs)
+    t = datetime.datetime.now()
+    timestring = '_'+str(t.year)+'_'+str(t.month)+'_'+str(t.day)+'_at_'+str(t.hour)+'_'+str(t.minute)+'_'+str(t.second)
+    
+    if settings.pretrig_samples == None:
+
+        MESSAGE = 'Logging data for {} seconds.\n'.format(settings.stored_time)
+        print(MESSAGE)
+        
+        
+        # basic way to control logging time: won't be precise time from calling function
+        # also won't be exactly synced to output signal
+        if output is not None:
+            s = output_signal(settings,output)
+            # rec.write(output.astype('float32'))
+        
+        if (settings.device_driver == 'nidaq') or (output is None): # nidaq output is nonblocking, but soundcard is blocking
+            time.sleep(settings.stored_time)
+        
+            
+        # make copy of data
+        stored_time_data_copy = np.copy(streams.REC.stored_time_data)
+        number_samples = int(streams.REC.settings.stored_time * streams.REC.settings.fs)
+        
+        stored_time_data_copy = stored_time_data_copy[-number_samples:,:]
+        MESSAGE += 'Logging complete.\n'
+        print(MESSAGE)
+
+        if output is not None:
+            if settings.output_device_driver == 'soundcard':
+                s.stop()
+                s.close()
+            if settings.output_device_driver == 'nidaq':
+                s.WaitUntilTaskDone(settings.stored_time+5)
+                s.StopTask()
+        
+
+        
+    else:
+        streams.REC.__init__(settings) # zeros buffers so looks for trigger in fresh data
+        streams.REC.trigger_detected = False # somehow this can be true even after previous call
+        streams.REC.trigger_first_detected_message = True
+        
+        MESSAGE = 'Waiting for trigger on channel {}.\n'.format(settings.pretrig_channel)
+        print(MESSAGE)
+        
+        start_output_flag = True
+        t0 = time.time()
+        while (time.time()-t0 < settings.pretrig_timeout) and not streams.REC.trigger_detected:
+            if (output is not None) and (start_output_flag == True): # start output within loop, but only once!
+                time.sleep(1)
+                MESSAGE = 'Starting output signal.\n'
+                print(MESSAGE)
+                s = output_signal(settings,output)
+                # rec.write(output.astype('float32'))
+                start_output_flag = False
+
+            time.sleep(0.2)
+        if (time.time()-t0 > settings.pretrig_timeout):
+            MESSAGE = 'Trigger not detected within timeout of {} seconds.\n'.format(settings.pretrig_timeout)
+            print(MESSAGE)
+        
+        # make copy of data
+        stored_time_data_copy = np.copy(streams.REC.stored_time_data)
+        trigger_check = stored_time_data_copy[(settings.chunk_size):(2*settings.chunk_size),settings.pretrig_channel]
+        detected_sample = settings.chunk_size + np.where(np.abs(trigger_check) > settings.pretrig_threshold)[0][0]
+        number_samples = int(settings.stored_time * settings.fs)
+        start_index = detected_sample - settings.pretrig_samples
+        end_index   = start_index + number_samples
+        streams.REC.trigger_detected = False # don't start stream again until sorted out trigger detection
+        
+        stored_time_data_copy = stored_time_data_copy[start_index:end_index,:]
+        
+        MESSAGE = 'Logging complete.\n'
+        print(MESSAGE)
+
+        if output is not None:
+            if settings.output_device_driver == 'soundcard':
+                s.stop()
+                s.close()
+            if settings.output_device_driver == 'nidaq':
+                s.WaitUntilTaskDone(settings.stored_time+5)
+                s.StopTask()
+        
+    # make into dataset
+    fs = settings.fs
+    n_samp = len(stored_time_data_copy[:,0])
+    dt = 1/fs
+    t_samp = n_samp*dt
+    time_axis = np.linspace(0,(n_samp-1)/n_samp * settings.stored_time,n_samp)
+    
+    if (output is not None) and (settings.use_output_as_ch0 == True):
+        stored_output = np.zeros((n_samp,len(output[0,:])))
+        n_start = settings.pretrig_samples
+        if n_start is None:
+            n_start = 0
+        n_end = np.copy(n_samp)
+        if len(output[:,0]) >= (n_end-n_start):
+            stored_output[n_start:n_end,:] = output[:n_end-n_start,:]
+        elif len(output[:,0]) < (n_end-n_start):
+            stored_output[n_start:len(output[:,0])+n_start,:] = output[:,:]
+            
+        stored_time_data_copy = np.concatenate((stored_output,stored_time_data_copy),axis=1)
+    
+    timedata = datastructure.TimeData(time_axis,stored_time_data_copy,settings,timestamp=t,timestring=timestring,test_name=test_name)
+    
+    
+    dataset  = datastructure.DataSet()
+    dataset.add_to_dataset(timedata)
+    
+    # check for clipping
+    if np.any(np.abs(stored_time_data_copy) > 0.95):
+        MESSAGE += 'WARNING: Data may be clipped'
+        print(MESSAGE)
+    
+    
+    return dataset
+    
+
+
+#def log_data_with_output(settings, output,test_name=None, rec=None):
+#
+    
+    # # call log_data function
+    # dataset = log_data(settings, test_name, rec)
+    
+    # # call output_signal function
+    # output_signal(settings,output)
+    
+    # return dataset
+    
+
+
+def output_signal(settings,output):
+    # setup NI / audio stream
+    if settings.output_device_driver == 'soundcard':
+        s = streams.setup_output_soundcard(settings)
+        data = output.astype('float32')
+        s.write(data)
+        return s
+        
+    elif settings.output_device_driver == 'nidaq':
+        sh = np.shape(output)
+        T = sh[0]/settings.fs
+        s = streams.setup_output_NI(settings,output)
+        s.StartTask()
+        return s
+    else:
+        print('device_driver not recognised')
+        return None
+        
+    # send to device
+
+
+def signal_generator(settings,sig='gaussian',T=1,amplitude=0.1,f=None,selected_channels='all'):
+    """
+    Creates a signal ready for output to a chosen device
+    """
+    global MESSAGE
+    if selected_channels == 'all':
+        selected_channels = np.arange(0,settings.output_channels)
+       
+    # initiate variables
+    t = np.arange(0,T,1/settings.output_fs)
+    N_per_channel = np.size(t)
+    y = np.zeros((N_per_channel,settings.output_channels))
+    win = np.ones((N_per_channel,1))
+    T_ramp = np.min([T/10,0.1])
+    N_ramp = int(T_ramp*settings.output_fs)
+    win[0:N_ramp,0] = 0.5*(1-np.cos(np.arange(0,N_ramp)/N_ramp*np.pi))
+    win[-N_ramp:,0] = 0.5*(1+np.cos(np.arange(0,N_ramp)/N_ramp*np.pi))
+    
+    limit = 1 # generate signals normalised with amplitudes 0-1
+    
+    # Create sig. Note 'sig' is choice of signal, while 'signal' is scipy.signal
+    if sig == 'gaussian':
+        y[:,selected_channels] = np.random.randn(N_per_channel,np.size(selected_channels))
+        
+        
+        
+#        if settings.output_device_driver == 'soundcard':
+#            limit = 1
+#        elif settings.output_device_driver == 'nidaq':
+#            limit = settings.VmaxNI
+             
+                
+        y[:,selected_channels] = stats.truncnorm.rvs(-limit/amplitude, limit/amplitude, loc=0,scale=amplitude, size=(N_per_channel,np.size(selected_channels)))
+        if f is not None:
+            b,a = signal.butter(3,f,btype='bandpass',fs=settings.output_fs)
+            y = signal.filtfilt(b,a,y,axis=0,padtype=None)
+            y = amplitude * y / np.sqrt(np.mean(y**2))
+            if np.max(np.abs(y)) > limit:
+                y = limit * y / np.max(np.abs(y))
+                MESSAGE = 'Actual rms output after scaling to avoid clipping is {0:1.3f}'.format(np.sqrt(np.mean(y**2)))
+            else:
+                MESSAGE = 'Actual rms output is {0:1.3f}'.format(np.sqrt(np.mean(y**2)))
+                
+            
+#            N_exceed_lim = np.sum(y>limit)+np.sum(y<-limit)
+#            fraction_clipped = N_exceed_lim/np.size(y)
+#            y[y>limit] = limit
+#            y[y<-limit] = -limit
+#            if fraction_clipped > 0:
+#                print('{} out of {} samples exceeded output voltage limit of device and have been clipped'.format(N_exceed_lim,np.size(y)))
+#            if fraction_clipped > 0.01:
+#                print('{0:1.1f} percent of samples exceed output voltage limit of device'.format(fraction_clipped*100))
+                
+    elif sig == 'uniform':
+        y[:,selected_channels] = np.random.uniform(low=-amplitude,high=amplitude,size=(N_per_channel,np.size(selected_channels)))
+        if f is not None:
+            b,a = signal.butter(3,f,btype='bandpass',fs=settings.output_fs)
+            y = signal.filtfilt(b,a,y,axis=0,padtype=None)
+            y = amplitude * y / np.sqrt(np.mean(y**2))
+    elif sig == 'sweep':
+        if f is None:
+            f = [0,settings.output_fs/2]
+        
+        for ch in selected_channels:
+            y[:,ch] = amplitude*signal.chirp(t,f[0],T,f[1])
+    else:
+        print('signal type must be one of {''gaussian'',''uniform'',''sweep''}')
+        y = np.zeros((N_per_channel,settings.output_channels))
+    
+    y = win * y
+    
+    # final correction to ensure all signals limited to 0-1
+    if np.max(np.abs(y)) > limit:
+        y = limit * y / np.max(np.abs(y))
+        MESSAGE = 'Actual rms output after scaling to avoid clipping is {0:1.3f}'.format(np.sqrt(np.mean(y**2)))
+        
+    return t,y
+
+
+def stream_snapshot(rec):
+    
+    time_data_copy = np.copy(streams.REC.osc_time_data)
+    time_axis_copy = np.copy(streams.REC.osc_time_axis)
+    
+    t = datetime.datetime.now()
+    timestring = '_'+str(t.year)+'_'+str(t.month)+'_'+str(t.day)+'_at_'+str(t.hour)+'_'+str(t.minute)+'_'+str(t.second)    
+
+    time_data = datastructure.TimeData(time_axis_copy,time_data_copy,streams.REC.settings,timestamp=t,timestring=timestring,test_name='stream_snapshot')
+    
+    
+    return time_data