Serialization and deserialization and unified plot class

Co-Authored-By: fuerbringer <[email protected]>

Author: corrooli

.gitignore

@@ -3,3 +3,4 @@ venv/
 .idea/
 *.wav
 *.wave
+*.xz

common/plotter.py

@@ -0,0 +1,95 @@
+from common.serializer import Serializer
+import matplotlib.pyplot as plt
+import numpy as np
+
+class Plotter():
+
+    def __init__(self, verbose=False):
+        self.sim_params = None
+        self.partitions = None
+        self.verbose=verbose
+
+    def set_data_from_file(self, file_name):
+        serializer = Serializer(compressed=True)
+        (sim_params, partitions) = serializer.read(file_name)
+        self.sim_params = sim_params
+        self.partitions = partitions
+        
+    def set_data_from_simulation(self, sim_params, partitions):
+        self.sim_params = sim_params
+        self.partitions = partitions
+
+
+    def plot_1D(self):
+        # TODO Implement
+        pass
+
+
+    def plot_2D(self):
+        
+        partition_1 = self.partitions[0]
+        partition_2 = self.partitions[1]
+        partition_3 = self.partitions[2]
+        
+
+        room_dims = np.linspace(0., partition_1.dimensions[0], len(partition_1.pressure_field_results[0]))
+        ytop = np.max(partition_1.pressure_field_results)
+        ybtm = np.min(partition_1.pressure_field_results)
+
+        fig = plt.figure(figsize=plt.figaspect(0.5))
+        ax_1 = fig.add_subplot(2, 2, 1)
+        ax_2 = fig.add_subplot(2, 2, 2)
+        ax_3 = fig.add_subplot(2, 2, 4)
+
+        # TODO Make plots dynamic (just if we can make time at some point)
+
+        temp_X_1 = np.linspace(0, partition_1.space_divisions_x, partition_1.space_divisions_x)
+        temp_Y_1 = np.linspace(0, partition_1.space_divisions_y, partition_1.space_divisions_y)
+        X_1, Y_1 = np.meshgrid(temp_X_1, temp_Y_1)
+
+        temp_X_2 = np.linspace(0, partition_2.space_divisions_x, partition_2.space_divisions_x)
+        temp_Y_2 = np.linspace(0, partition_2.space_divisions_y, partition_2.space_divisions_y)
+        X_2, Y_2 = np.meshgrid(temp_X_2, temp_Y_2)
+
+        temp_X_3 = np.linspace(0, partition_3.space_divisions_x, partition_3.space_divisions_x)
+        temp_Y_3 = np.linspace(0, partition_3.space_divisions_y, partition_3.space_divisions_y)
+        X_3, Y_3 = np.meshgrid(temp_X_3, temp_Y_3)
+
+        plot_limit_min = np.min(partition_2.pressure_field_results[:])
+        plot_limit_max = np.max(partition_2.pressure_field_results[:])
+
+        for i in range(0, len(partition_1.pressure_field_results), 50):
+            Z_1 = partition_1.pressure_field_results[i]
+            Z_2 = partition_2.pressure_field_results[i]
+            Z_3 = partition_3.pressure_field_results[i]
+
+            ax_1.cla()
+            ax_2.cla()
+            ax_3.cla()
+
+            plt.title(f"t = {(self.sim_params.T * (i / self.sim_params.number_of_samples)):.4f}s")
+
+            ax_1.imshow(Z_1)
+            ax_2.imshow(Z_2)
+            ax_3.imshow(Z_3)
+
+            plt.pause(0.005)
+
+        plot_step = 100
+
+    def plot_3D(self):
+        # TODO Implement
+        pass
+
+
+    def plot(self):
+        # TODO Check which dimension it is and call corresponding plot function
+        dimension = len(self.partitions[0].dimensions)
+        if self.verbose: 
+            print(f"Data is {dimension}-D.")
+        if dimension == 1: 
+            self.plot_1D()
+        if dimension == 2: 
+            self.plot_2D()
+        if dimension == 3: 
+            self.plot_3D()

common/serializer.py

@@ -0,0 +1,30 @@
+import pickle
+import lzma
+from datetime import date
+
+class Serializer():
+    def __init__(self, compressed=False):
+        self.compressed = compressed
+
+    def create_filename(self):
+        # TODO: put reference to rooms, sizes etc.
+        return f"pytard_{date.today()}"
+
+    def dump(self, sim_params, partitions):
+        file_path = self.create_filename() + ".xz"
+        if self.compressed: 
+            with lzma.open(file_path, 'wb') as fh:
+                pickle.dump((sim_params, partitions), fh)
+                fh.close()
+        else:
+            with pickle.open(file_path, 'wb') as fh:
+                pickle.dump((sim_params, partitions), fh)
+                fh.close()
+
+    def read(self, file_path):
+        # TODO: Idea -> See which suffix the file has. If xz, use lzma
+        if self.compressed:
+            raw_bytes = lzma.open(file_path, 'rb')
+        else:
+            raw_bytes = pickle.open(file_path, 'rb')
+        return pickle.load(raw_bytes)

example_2D.py

@@ -3,6 +3,8 @@
 from pytARD_2D.ard import ARDSimulator as ARDS
 from pytARD_2D.partition_data import PartitionData as PARTD
 from common.impulse import Gaussian, WaveFile
+from common.serializer import Serializer
+from common.plotter import Plotter
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -18,6 +20,7 @@
 auralize = False
 verbose = True
 visualize = False
+write_to_file = False
 
 # Compilation of room parameters into parameter class
 sim_params = SIMP(
@@ -44,13 +47,25 @@
 
 part_data = [partition_1, partition_2, partition_3]
 
+# Instantiation serializer for reading and writing simulation state data
+serializer = Serializer(compressed=True)
+
 # Instantiating and executing simulation
 sim = ARDS(sim_params, part_data)
 sim.preprocessing()
 sim.simulation()
 
+# Write partitions and state data to disk
+if write_to_file:
+    if verbose: print("Writing state data to disk. Please wait...")
+    serializer.dump(sim_params, part_data)
+
 # Plotting waveform
-if visualize:
+if True: # if visualize:
+    plotter = Plotter()
+    plotter.set_data_from_simulation(sim_params, part_data)
+    plotter.plot_2D()
+    '''
     room_dims = np.linspace(0., partition_1.dimensions[0], len(partition_1.pressure_field_results[0]))
     ytop = np.max(partition_1.pressure_field_results)
     ybtm = np.min(partition_1.pressure_field_results)
@@ -95,4 +110,5 @@
         plt.pause(0.005)
 
     plot_step = 100
+    '''
 

pytARD_2D/ard.py

@@ -47,8 +47,18 @@ def __init__(self, sim_parameters, part_data):
         self.FDTD_KERNEL_SIZE = int((len(fdtd_coeffs_not_normalized[0])) / 2) 
 
         # Initialize & position mics. 
-        self.mic1 = Mic([int(part_data[0].dimensions[0] / 2), int(part_data[0].dimensions[1] / 2)], sim_parameters, "left")
-        self.mic2 = Mic([int(part_data[2].dimensions[0] / 2), int(part_data[2].dimensions[1] / 2)], sim_parameters, "bottom")
+        self.mic1 = Mic(
+            0, 
+            [int(part_data[0].dimensions[0] / 2), 
+            int(part_data[0].dimensions[1] / 2)], 
+            sim_parameters, "left"
+        )
+        self.mic2 = Mic(
+            2, 
+            [int(part_data[2].dimensions[0] / 2), 
+            int(part_data[2].dimensions[1] / 2)], 
+            sim_parameters, "bottom"
+        )
 
 
     def preprocessing(self):

read_file_2D.py

@@ -0,0 +1,11 @@
+import sys
+from common.plotter import Plotter
+
+plotter = Plotter(verbose=True)
+
+if len(sys.argv) < 2:
+    sys.exit("File name not given. Please specify the file to plot")
+
+file_name = sys.argv[1]
+plotter.set_data_from_file(sys.argv[1])
+plotter.plot()