alpss 1.3.0.dev2__py3-none-any.whl

alpss/alpss_auto_run.py

@@ -0,0 +1,102 @@
+"""
+Credit to Michael Cho
+https://michaelcho.me/article/using-pythons-watchdog-to-monitor-changes-to-a-directory
+"""
+
+import time
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+from alpss_main import *
+import os
+
+
+class Watcher:
+
+    # this is the directory where you will add the files to
+    DIRECTORY_TO_WATCH = (os.getcwd() + '/input_data')
+
+    def __init__(self):
+        self.observer = Observer()
+
+    def run(self):
+        event_handler = Handler()
+        self.observer.schedule(event_handler, self.DIRECTORY_TO_WATCH, recursive=True)
+        self.observer.start()
+        try:
+            while True:
+                time.sleep(5)
+        except:
+            self.observer.stop()
+            print("Error")
+
+        self.observer.join()
+
+
+class Handler(FileSystemEventHandler):
+
+    @staticmethod
+    def on_any_event(event):
+        if event.is_directory:
+            return None
+
+        elif event.event_type == 'created':
+
+            # Take any action here when a file is first created.
+            print("Received created event - %s." % event.src_path)
+
+            fname = os.path.split(event.src_path)[1]
+            print(f"File Created:  {fname}")
+
+            # use these function inputs the same as for the non-automated function alpss_run.py
+            alpss_main(filename=fname,
+                       save_data='yes',
+                       start_time_user='none',
+                       header_lines=1,
+                       time_to_skip=2e-6,
+                       time_to_take=2e-6,
+                       t_before=10e-9,
+                       t_after=100e-9,
+                       start_time_correction=0e-9,
+                       freq_min=1.5e9,
+                       freq_max=4e9,
+                       smoothing_window=401,
+                       smoothing_wid=3,
+                       smoothing_amp=1,
+                       smoothing_sigma=1,
+                       smoothing_mu=0,
+                       pb_neighbors=400,
+                       pb_idx_correction=0,
+                       rc_neighbors=400,
+                       rc_idx_correction=0,
+                       sample_rate=80e9,
+                       nperseg=512,
+                       noverlap=435,
+                       nfft=5120,
+                       window='hann',
+                       blur_kernel=(5, 5),
+                       blur_sigx=0,
+                       blur_sigy=0,
+                       carrier_band_time=250e-9,
+                       cmap='viridis',
+                       uncert_mult=100,
+                       order=6,
+                       wid=5e7,
+                       lam=1547.461e-9,
+                       C0=4540,
+                       density=1730,
+                       delta_rho=9,
+                       delta_C0=23,
+                       delta_lam=8e-18,
+                       theta=0,
+                       delta_theta=5,
+                       exp_data_dir=(os.getcwd() + '/input_data'),
+                       out_files_dir=(os.getcwd() + '/output_data'),
+                       display_plots='yes',
+                       spall_calculation='yes',
+                       plot_figsize=(30, 10),
+                       plot_dpi=300)
+
+
+if __name__ == '__main__':
+    w = Watcher()
+    w.run()

alpss/alpss_main.py

@@ -0,0 +1,121 @@
+import os
+from alpss.spall_doi_finder import spall_doi_finder
+from alpss.plotting import plot_results, plot_voltage
+from alpss.carrier_frequency import carrier_frequency
+from alpss.carrier_filter import carrier_filter
+from alpss.velocity_calculation import velocity_calculation
+from alpss.spall_analysis import spall_analysis
+from alpss.full_uncertainty_analysis import full_uncertainty_analysis
+from alpss.instantaneous_uncertainty_analysis import instantaneous_uncertainty_analysis
+from alpss.saving import save
+from datetime import datetime
+import traceback
+import logging
+
+logging.basicConfig(
+    level=logging.ERROR,  # Minimum level of messages to log (can be DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    format="%(asctime)s - %(levelname)s - %(message)s",  # Log format (include timestamp, level, message)
+    handlers=[
+        logging.FileHandler("error_log.txt"),  # Log to a file
+        logging.StreamHandler(),  # Also log to console
+    ],
+)
+
+
+def validate_inputs(inputs):
+    if inputs["t_after"] > inputs["time_to_take"]:
+        raise ValueError("'t_after' must be less than 'time_to_take'. ")
+
+
+# main function to link together all the sub-functions
+def alpss_main(**inputs):
+    # validate the inputs for the run
+    validate_inputs(inputs)
+
+    # attempt to run the program in full
+    try:
+        # begin the program timer
+
+        start_time = datetime.now()
+
+        # function to find the spall signal domain of interest
+        sdf_out = spall_doi_finder(**inputs)
+
+        # function to find the carrier frequency
+        cen = carrier_frequency(sdf_out, **inputs)
+
+        # function to filter out the carrier frequency after the signal has started
+        cf_out = carrier_filter(sdf_out, cen, **inputs)
+
+        # function to calculate the velocity from the filtered voltage signal
+        vc_out = velocity_calculation(sdf_out, cen, cf_out, **inputs)
+
+        # function to estimate the instantaneous uncertainty for all points in time
+        iua_out = instantaneous_uncertainty_analysis(sdf_out, vc_out, cen, **inputs)
+
+        # function to find points of interest on the velocity trace
+        sa_out = spall_analysis(vc_out, iua_out, **inputs)
+
+        # function to calculate uncertainties in the spall strength and strain rate due to external uncertainties
+        fua_out = full_uncertainty_analysis(cen, sa_out, iua_out, **inputs)
+
+        # end the program timer
+        end_time = datetime.now()
+
+        # function to generate the final figure
+        fig = plot_results(
+            sdf_out,
+            cen,
+            cf_out,
+            vc_out,
+            sa_out,
+            iua_out,
+            fua_out,
+            start_time,
+            end_time,
+            **inputs,
+        )
+
+        # function to save the output files if desired
+        # MOVED to plotting
+        # end final timer and display full runtime
+        end_time2 = datetime.now()
+        logging.info(
+            f"\nFull program runtime (including plotting and saving):\n{end_time2 - start_time}\n"
+        )
+
+        # return the figure so it can be saved if desired
+        # function to save the output files if desired
+        if inputs["save_data"] == "yes":
+            df = save(
+                sdf_out,
+                cen,
+                vc_out,
+                sa_out,
+                iua_out,
+                fua_out,
+                start_time,
+                end_time,
+                fig,
+                **inputs,
+            )
+            return fig, df
+
+        return (fig,)
+
+    # in case the program throws an error
+    except Exception as e:
+        logging.error("Error in the execution of the main program:: %s", str(e))
+        logging.error("Traceback: %s", traceback.format_exc())
+
+        # attempt to plot the voltage signal from the imported data
+        try:
+            logging.info("Attempting a fallback visualization of the voltage signal...")
+            plot_voltage(**inputs)
+
+        # if that also fails then log the traceback and stop running the program
+        except Exception as e:
+            logging.error(
+                "Error in the fallback visualization of the voltage signal: %s", str(e)
+            )
+            logging.error("Traceback: %s", traceback.format_exc())