solarviewer 1.0.2__py3-none-any.whl

solar_radio_image_viewer/from_simpl/dynamic_spectra_dialog.py

@@ -0,0 +1,332 @@
+"""
+Dynamic Spectra Dialog
+
+GUI dialog for creating dynamic spectra from MS files.
+Uses the make_dynamic_spectra.py processing functions.
+"""
+
+import os
+import sys
+from PyQt5.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QGridLayout, QLabel, QLineEdit,
+    QPushButton, QFileDialog, QSpinBox, QDoubleSpinBox, QGroupBox,
+    QProgressBar, QTextEdit, QCheckBox, QMessageBox, QApplication
+)
+from PyQt5.QtCore import Qt, QThread, pyqtSignal
+from PyQt5.QtGui import QFont
+
+from .simpl_theme import apply_theme, get_theme_from_args
+
+
+class ProcessingThread(QThread):
+    """Thread for running dynamic spectra processing in isolated subprocess."""
+    progress = pyqtSignal(str)
+    finished = pyqtSignal(bool, str)
+    
+    def __init__(self, params):
+        super().__init__()
+        self.params = params
+    
+    def run(self):
+        """Run make_dynamic_spectra in a separate subprocess to avoid casacore/Qt conflicts."""
+        import subprocess
+        import json
+        
+        try:
+            # Build command line arguments for make_dynamic_spectra.py
+            script_path = os.path.join(os.path.dirname(__file__), 'make_dynamic_spectra.py')
+            
+            cmd = [
+                sys.executable, script_path,
+                '--indir', self.params['indir'],
+                '--outfits', self.params['outfits'],
+                '--binwidth', str(self.params['binwidth']),
+                '--ncpu', str(self.params['ncpu']),
+                '--uvmin', str(self.params['uvmin']),
+                '--uvmax', str(self.params['uvmax']),
+            ]
+            
+            # Add optional frequency range
+            if self.params.get('startfreq') and self.params.get('endfreq'):
+                cmd.extend(['--startfreq', str(self.params['startfreq'])])
+                cmd.extend(['--endfreq', str(self.params['endfreq'])])
+            
+            # Add plot options
+            if self.params.get('saveplot'):
+                cmd.append('--saveplot')
+                if self.params.get('plot_filename'):
+                    cmd.extend(['--plotfile', self.params['plot_filename']])
+            
+            self.progress.emit(f"Running: {os.path.basename(script_path)}")
+            self.progress.emit(f"Input: {self.params['indir']}")
+            self.progress.emit(f"Output: {self.params['outfits']}")
+            self.progress.emit("")
+            
+            # Run in subprocess (completely isolates casacore from Qt)
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+            
+            # Stream output in real-time
+            for line in iter(process.stdout.readline, ''):
+                if line:
+                    self.progress.emit(line.rstrip())
+            
+            process.wait()
+            
+            if process.returncode == 0:
+                self.finished.emit(True, f"Success! Created: {self.params['outfits']}")
+            else:
+                self.finished.emit(False, f"Processing failed with exit code {process.returncode}")
+                
+        except Exception as e:
+            self.finished.emit(False, f"Error: {str(e)}")
+
+
+class DynamicSpectraDialog(QDialog):
+    """Dialog for creating dynamic spectra from MS files."""
+    
+    def __init__(self, parent=None, theme="dark"):
+        super().__init__(parent)
+        self.theme = theme
+        self.processing_thread = None
+        self._setup_ui()
+        
+    def _setup_ui(self):
+        self.setWindowTitle("Create Dynamic Spectra")
+        self.setMinimumSize(600, 500)
+        
+        layout = QVBoxLayout(self)
+        layout.setSpacing(12)
+        
+        # Input/Output Group
+        io_group = QGroupBox("Input / Output")
+        io_layout = QGridLayout(io_group)
+        
+        # Input directory
+        io_layout.addWidget(QLabel("MS Directory:"), 0, 0)
+        self.input_edit = QLineEdit()
+        self.input_edit.setPlaceholderText("Directory containing MS files...")
+        io_layout.addWidget(self.input_edit, 0, 1)
+        self.input_browse_btn = QPushButton("Browse...")
+        self.input_browse_btn.clicked.connect(self._browse_input)
+        io_layout.addWidget(self.input_browse_btn, 0, 2)
+        
+        # Output FITS file
+        io_layout.addWidget(QLabel("Output FITS:"), 1, 0)
+        self.output_edit = QLineEdit()
+        self.output_edit.setPlaceholderText("Output FITS file path...")
+        self.output_edit.setText("dynamic_spectrum.fits")
+        io_layout.addWidget(self.output_edit, 1, 1)
+        self.output_browse_btn = QPushButton("Browse...")
+        self.output_browse_btn.clicked.connect(self._browse_output)
+        io_layout.addWidget(self.output_browse_btn, 1, 2)
+        
+        layout.addWidget(io_group)
+        
+        # Parameters Group
+        params_group = QGroupBox("Processing Parameters")
+        params_layout = QGridLayout(params_group)
+        
+        # Time binwidth
+        params_layout.addWidget(QLabel("Time Bin Width (s):"), 0, 0)
+        self.binwidth_spin = QDoubleSpinBox()
+        self.binwidth_spin.setRange(0.1, 60.0)
+        self.binwidth_spin.setValue(1.0)
+        self.binwidth_spin.setDecimals(1)
+        params_layout.addWidget(self.binwidth_spin, 0, 1)
+        
+        # Number of CPUs
+        params_layout.addWidget(QLabel("CPU Cores:"), 0, 2)
+        self.ncpu_spin = QSpinBox()
+        self.ncpu_spin.setRange(1, os.cpu_count() or 8)
+        self.ncpu_spin.setValue(min(10, os.cpu_count() or 8))
+        params_layout.addWidget(self.ncpu_spin, 0, 3)
+        
+        # UV range
+        params_layout.addWidget(QLabel("UV Min (λ):"), 1, 0)
+        self.uvmin_spin = QDoubleSpinBox()
+        self.uvmin_spin.setRange(0, 10000)
+        self.uvmin_spin.setValue(130.0)
+        params_layout.addWidget(self.uvmin_spin, 1, 1)
+        
+        params_layout.addWidget(QLabel("UV Max (λ):"), 1, 2)
+        self.uvmax_spin = QDoubleSpinBox()
+        self.uvmax_spin.setRange(0, 10000)
+        self.uvmax_spin.setValue(500.0)
+        params_layout.addWidget(self.uvmax_spin, 1, 3)
+        
+        # Frequency range (optional)
+        params_layout.addWidget(QLabel("Start Freq (MHz):"), 2, 0)
+        self.startfreq_spin = QDoubleSpinBox()
+        self.startfreq_spin.setRange(0, 1000)
+        self.startfreq_spin.setValue(0)
+        self.startfreq_spin.setSpecialValueText("Auto")
+        params_layout.addWidget(self.startfreq_spin, 2, 1)
+        
+        params_layout.addWidget(QLabel("End Freq (MHz):"), 2, 2)
+        self.endfreq_spin = QDoubleSpinBox()
+        self.endfreq_spin.setRange(0, 1000)
+        self.endfreq_spin.setValue(0)
+        self.endfreq_spin.setSpecialValueText("Auto")
+        params_layout.addWidget(self.endfreq_spin, 2, 3)
+        
+        layout.addWidget(params_group)
+        
+        # Options Group
+        options_group = QGroupBox("Options")
+        options_layout = QHBoxLayout(options_group)
+        
+        self.save_plot_check = QCheckBox("Save Plot")
+        self.save_plot_check.setChecked(True)
+        options_layout.addWidget(self.save_plot_check)
+        
+        options_layout.addStretch()
+        
+        layout.addWidget(options_group)
+        
+        # Progress section
+        progress_group = QGroupBox("Progress")
+        progress_layout = QVBoxLayout(progress_group)
+        
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 0)  # Indeterminate
+        self.progress_bar.setVisible(False)
+        progress_layout.addWidget(self.progress_bar)
+        
+        self.log_text = QTextEdit()
+        self.log_text.setReadOnly(True)
+        self.log_text.setMaximumHeight(120)
+        self.log_text.setFont(QFont("Consolas", 9))
+        progress_layout.addWidget(self.log_text)
+        
+        layout.addWidget(progress_group)
+        
+        # Buttons
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        
+        self.run_btn = QPushButton("Create Dynamic Spectra")
+        self.run_btn.setMinimumWidth(180)
+        self.run_btn.clicked.connect(self._run_processing)
+        button_layout.addWidget(self.run_btn)
+        
+        self.close_btn = QPushButton("Close")
+        self.close_btn.clicked.connect(self.close)
+        button_layout.addWidget(self.close_btn)
+        
+        layout.addLayout(button_layout)
+    
+    def _browse_input(self):
+        dir_path = QFileDialog.getExistingDirectory(
+            self, "Select MS Directory", 
+            self.input_edit.text() or os.path.expanduser("~")
+        )
+        if dir_path:
+            self.input_edit.setText(dir_path)
+            # Auto-set output path
+            if not self.output_edit.text() or self.output_edit.text() == "dynamic_spectrum.fits":
+                self.output_edit.setText(os.path.join(dir_path, "dynamic_spectrum.fits"))
+    
+    def _browse_output(self):
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Save FITS File",
+            self.output_edit.text() or "dynamic_spectrum.fits",
+            "FITS Files (*.fits);;All Files (*)"
+        )
+        if file_path:
+            self.output_edit.setText(file_path)
+    
+    def _run_processing(self):
+        # Validate input
+        if not self.input_edit.text():
+            QMessageBox.warning(self, "Missing Input", "Please select an MS directory.")
+            return
+        
+        if not os.path.isdir(self.input_edit.text()):
+            QMessageBox.warning(self, "Invalid Input", "The specified directory does not exist.")
+            return
+        
+        if not self.output_edit.text():
+            QMessageBox.warning(self, "Missing Output", "Please specify an output FITS file path.")
+            return
+        
+        # Check for MS files
+        import glob
+        ms_files = glob.glob(os.path.join(self.input_edit.text(), "*.MS"))
+        if not ms_files:
+            QMessageBox.warning(self, "No MS Files", "No .MS files found in the specified directory.")
+            return
+        
+        # Prepare parameters
+        params = {
+            'indir': self.input_edit.text(),
+            'outfits': self.output_edit.text(),
+            'binwidth': self.binwidth_spin.value(),
+            'ncpu': self.ncpu_spin.value(),
+            'uvmin': self.uvmin_spin.value(),
+            'uvmax': self.uvmax_spin.value(),
+            'startfreq': self.startfreq_spin.value() if self.startfreq_spin.value() > 0 else None,
+            'endfreq': self.endfreq_spin.value() if self.endfreq_spin.value() > 0 else None,
+            'saveplot': self.save_plot_check.isChecked(),
+            'plot_filename': self.output_edit.text().replace('.fits', '.png') if self.save_plot_check.isChecked() else None
+        }
+        
+        # Start processing
+        self.log_text.clear()
+        self.log_text.append(f"Found {len(ms_files)} MS files")
+        self.log_text.append(f"Output: {params['outfits']}")
+        self.log_text.append("Starting processing...")
+        
+        self.progress_bar.setVisible(True)
+        self.run_btn.setEnabled(False)
+        
+        self.processing_thread = ProcessingThread(params)
+        self.processing_thread.progress.connect(self._on_progress)
+        self.processing_thread.finished.connect(self._on_finished)
+        self.processing_thread.start()
+    
+    def _on_progress(self, message):
+        self.log_text.append(message)
+        # Auto-scroll to bottom
+        scrollbar = self.log_text.verticalScrollBar()
+        scrollbar.setValue(scrollbar.maximum())
+    
+    def _on_finished(self, success, message):
+        self.progress_bar.setVisible(False)
+        self.run_btn.setEnabled(True)
+        
+        self.log_text.append("")
+        self.log_text.append(f"{'✓' if success else '✗'} {message}")
+        
+        if success:
+            QMessageBox.information(self, "Success", message)
+        else:
+            QMessageBox.warning(self, "Processing Failed", message)
+
+
+def main():
+    """Main entry point for standalone dialog."""
+    # Clear Qt environment variables to avoid opencv conflicts
+    for key in ['QT_PLUGIN_PATH', 'QT_QPA_PLATFORM_PLUGIN_PATH']:
+        if key in os.environ:
+            del os.environ[key]
+    
+    app = QApplication(sys.argv)
+    
+    # Get theme from command line
+    theme = get_theme_from_args()
+    apply_theme(app, theme)
+    
+    dialog = DynamicSpectraDialog(theme=theme)
+    dialog.show()
+    
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()

solar_radio_image_viewer/from_simpl/make_dynamic_spectra.py

@@ -0,0 +1,351 @@
+"""
+Create Dynamic Spectra from MS Files
+
+This script:
+  1. Accepts a directory (--indir) containing MS files (each representing one subband).
+  2. Processes each MS file in parallel (using --ncpu processes) to:
+       - Read TIME, DATA, FLAG, and UVW columns using casacore.
+       - Filter rows with uv distance (in wavelengths) outside the range [130, 500].
+       - Bin data in time with a specified bin width (in seconds) and compute the mean amplitude.
+  3. Combines the results into a dynamic spectrum (2D array: time x subband).
+  4. Reads each MS file's frequency (median from the SPECTRAL_WINDOW table) and converts it to MHz.
+  5. Saves the dynamic spectrum to a FITS file. In the FITS file:
+       - The primary HDU contains the dynamic spectrum.
+       - A BinTableHDU contains the time axis in MJD and a second column with UTC strings.
+       - A second BinTableHDU contains the subband frequencies in MHz.
+  6. Optionally saves and/or displays a plot. The plot's x-axis is in UTC.
+  
+Usage:
+  python create_dynamic_spectra.py --indir /path/to/msfiles --outfits dynamic_spectra.fits --binwidth 1.0 --ncpu 10 --saveplot False --showplot False
+"""
+
+import os
+import sys
+import glob
+import argparse
+import re
+import numpy as np
+import matplotlib.pyplot as plt
+from casacore.tables import table
+from astropy.io import fits
+from astropy.time import Time
+import concurrent.futures
+from matplotlib.dates import DateFormatter, date2num
+import logging
+
+try:
+    from pipeline.tasks.basic_functions import MS_inquiry
+    pipeline_run = True
+except ImportError:
+    pipeline_run = False
+
+# ------------------ Helper Functions ------------------
+def extract_sb_number(filename):
+    """Extract integer following '_SB' from the filename for sorting."""
+    m = re.search(r'_SB(\d+)_', filename)
+    return int(m.group(1)) if m else -1
+
+def read_frequency(ms_file):
+    """Read the median channel frequency (Hz) from the SPECTRAL_WINDOW subtable."""
+    sp_tab = table(os.path.join(ms_file, "SPECTRAL_WINDOW"), ack=False, readonly=True)
+    chan_freq = sp_tab.getcol("CHAN_FREQ")
+    median_freq = np.median(chan_freq)
+    sp_tab.close()
+    return median_freq
+
+def read_ms(ms_file, binwidth=1.0, uv_min=130.0, uv_max=500.0):
+    """
+    Read one MS file and produce binned mean amplitude values.
+    
+    - Reads TIME, DATA, FLAG, and UVW columns.
+    - Computes uv distance (in wavelengths) using wavelength = 299792458/freq.
+    - Filters rows with uv distance outside [uv_min, uv_max] lambda.
+    - Bins the data in time bins of width binwidth (seconds) and computes the mean amplitude.
+    
+    Returns:
+      bin_centers (np.array): Array of bin center times (in seconds).
+      mean_amp (np.array): Mean amplitude for each bin.
+    """
+    try:
+        sp_tab = table(os.path.join(ms_file, "SPECTRAL_WINDOW"), ack=False, readonly=True)
+        chan_freq = sp_tab.getcol("CHAN_FREQ")
+        freq = np.median(chan_freq)
+        sp_tab.close()
+    except Exception as e:
+        print(f"Error reading frequency from {ms_file}: {e}")
+        raise
+
+    wavelength = 299792458.0 / freq  # in meters
+    print(f"Processing {os.path.basename(ms_file)}: freq = {freq/1e6:.2f} MHz, λ = {wavelength*1e2:.2f} cm")
+
+    try:
+        tb = table(ms_file, ack=False, readonly=True)
+        times = tb.getcol("TIME")       # seconds (assumed absolute)
+        # For simplicity, take the first correlation from DATA.
+        data = tb.getcol("DATA")[:,:,0]  # shape: (nrow, nchan)
+        flags = tb.getcol("FLAG")
+        uvw = tb.getcol("UVW")          # shape: (nrow, 3)
+        tb.close()
+    except Exception as e:
+        print(f"Error reading MS columns from {ms_file}: {e}")
+        raise
+
+    uv_dist = np.sqrt(uvw[:,0]**2 + uvw[:,1]**2)
+    uv_lambda = uv_dist / wavelength
+    valid_mask = (uv_lambda >= uv_min) & (uv_lambda <= uv_max)
+    if np.sum(valid_mask) == 0:
+        print(f"Warning: No valid data in uv-lambda range for {ms_file}.")
+        return np.array([]), np.array([])
+
+    times = times[valid_mask]
+    data = data[valid_mask]
+    flags = flags[valid_mask]
+    #times = np.unique(times)
+
+    min_time = np.min(times)
+    max_time = np.max(times)
+    edges = np.arange(min_time, max_time + binwidth, binwidth)
+    
+    # Use vectorized binning.
+    # Compute mean amplitude per row (averaged over channels).
+    row_mean = np.mean(np.abs(data), axis=1)
+    # Digitize times into bins.
+    bin_idx = np.digitize(times, edges) - 1  # 0-indexed
+    nbins = len(edges) - 1
+    sum_per_bin = np.bincount(bin_idx, weights=row_mean, minlength=nbins)
+    count_per_bin = np.bincount(bin_idx, minlength=nbins)
+    mean_amp = np.full(nbins, np.nan)
+    valid = count_per_bin > 0
+    mean_amp[valid] = sum_per_bin[valid] / count_per_bin[valid]
+    bin_centers = (edges[:-1] + edges[1:]) / 2.0
+    
+    return bin_centers, mean_amp
+
+def create_dynamic_spectra(indir, binwidth=1.0, ncpu=10, uv_min=130.0, uv_max=500.0, startfreq=None, endfreq=None):
+    """
+    Process all MS files in 'indir' in parallel to create a dynamic spectrum.
+    
+    Each MS file (each representing one subband) is processed to extract its
+    time bin centers and mean amplitude (filtered for uv-lambda between uv_min and uv_max).
+    
+    Returns:
+      all_times (np.array): Sorted array of unique time bin centers (in seconds).
+      dynamic_spectra (2D np.array): Array of shape (Ntime, Nsub) with mean amplitudes.
+         Missing values are filled with NaN.
+      subband_indices (list): List of subband numbers corresponding to each column.
+      subband_freqs (list): List of frequencies (in MHz) for each subband.
+    """
+    if (startfreq is None and endfreq is None) or (startfreq == 0.0 and endfreq == 0.0):
+        msfiles = sorted(glob.glob(os.path.join(indir, "*.MS")), key=lambda x: extract_sb_number(os.path.basename(x)))
+    elif startfreq<0.0 or endfreq<0.0:
+        raise RuntimeError(f"Invalid frequency range: {startfreq} to {endfreq}. Exiting...")
+    else:
+        from pipeline.tasks.basic_functions import get_filtered_MSs_for_given_freq_range
+        msfiles = get_filtered_MSs_for_given_freq_range(indir, startfreq, endfreq)
+    if len(msfiles) == 0:
+        raise RuntimeError(f"No MS files found in {indir}")
+    
+    results = {}
+    subband_freqs = []
+    with concurrent.futures.ProcessPoolExecutor(max_workers=ncpu) as executor:
+        futures = {executor.submit(read_ms, msfile, binwidth, uv_min=uv_min, uv_max=uv_max): msfile for msfile in msfiles}
+        for future in concurrent.futures.as_completed(futures):
+            msfile = futures[future]
+            try:
+                t, amp = future.result()
+                results[msfile] = (t, amp)
+            except Exception as e:
+                print(f"Error processing {msfile}: {e}")
+        for msfile in msfiles:
+            try:
+                freq = read_frequency(msfile)
+                subband_freqs.append(freq/1e6)
+            except Exception as e:
+                print(f"Error reading frequency from {msfile}: {e}")
+                subband_freqs.append(np.nan)
+    
+    all_times_set = set()
+    subband_indices = []
+    for msfile in msfiles:
+        if msfile in results:
+            t, amp = results[msfile]
+            all_times_set.update(t)
+            subband_indices.append(extract_sb_number(os.path.basename(msfile)))
+        else:
+            subband_indices.append(extract_sb_number(os.path.basename(msfile)))
+    all_times = np.array(sorted(list(all_times_set)))
+    Ntime = len(all_times)
+    Nsub = len(msfiles)
+    dynamic_spectra = np.full((Ntime, Nsub), np.nan, dtype=np.float32)
+    for s, msfile in enumerate(msfiles):
+        if msfile not in results:
+            continue
+        t, amp = results[msfile]
+        time_amp = {t[i]: amp[i] for i in range(len(t))}
+        for i, gt in enumerate(all_times):
+            if gt in time_amp:
+                dynamic_spectra[i, s] = time_amp[gt]
+    return all_times, dynamic_spectra, subband_indices, subband_freqs
+
+def write_fits(all_times, dynamic_spectra, subband_freqs, outfits):
+    """
+    Write the dynamic spectrum to a FITS file.
+    
+    The primary HDU holds the dynamic spectrum (axes: TIME x Subband).
+    Two BinTable HDUs are added:
+      - One for the time axis (TIME_MJD and UTC columns).
+      - One for the subband frequencies (FREQ_MHz column).
+    """
+    # Convert global time (in seconds) to MJD and UTC.
+    time_mjd = all_times / 86400.0
+    utc_times = Time(time_mjd, format='mjd', scale='utc').iso
+    
+    # Primary HDU with dynamic spectrum.
+    hdu = fits.PrimaryHDU(dynamic_spectra)
+    hdr = hdu.header
+    hdr["EXTNAME"] = "DYNAMIC_SPECTRUM"
+    hdr["BUNIT"] = "Amplitude"
+    hdr["COMMENT"] = "Axis0 = time (s), Axis1 = subband (sorted by _SBxxx_ in filename)"
+    
+    # BinTable HDU for time axis.
+    col_time = fits.Column(name="TIME_MJD", format="E", array=time_mjd)
+    col_utc = fits.Column(name="UTC", format="20A", array=np.array(utc_times))
+    time_hdu = fits.BinTableHDU.from_columns([col_time, col_utc])
+    time_hdu.name = "TIME_AXIS"
+    
+    # BinTable HDU for frequency axis.
+    col_freq = fits.Column(name="FREQ_MHz", format="E", array=np.array(subband_freqs))
+    freq_hdu = fits.BinTableHDU.from_columns([col_freq])
+    freq_hdu.name = "FREQ_AXIS"
+    
+    hdul = fits.HDUList([hdu, time_hdu, freq_hdu])
+    hdul.writeto(outfits, overwrite=True)
+    print(f"Dynamic spectra saved to {outfits}")
+
+def run_dynamic_spectra(indir, outfits, binwidth=1.0, ncpu=10, uvmin=130.0, uvmax=500.0, startfreq=None, endfreq=None, saveplot=False, showplot=False, logger=None, plot_filename=None):
+    """
+    Process all MS files in 'indir' to create a dynamic spectrum and save to a FITS file.
+    
+    Parameters
+    ----------
+    indir : str
+        Directory containing MS files.
+    outfits : str
+        Output FITS file path.
+    binwidth : float, optional
+        Time bin width in seconds, by default 1.0
+    ncpu : int, optional
+        Number of CPU cores to use, by default 10
+    uvmin : float, optional
+        Minimum UV baseline in lambda, by default 130.0
+    uvmax : float, optional
+        Maximum UV baseline in lambda, by default 500.0
+    startfreq : float, optional
+        Start frequency in MHz, by default None
+    endfreq : float, optional
+        End frequency in MHz, by default None
+    saveplot : bool, optional
+        Whether to save the plot, by default False
+    showplot : bool, optional
+        Whether to show the plot, by default False
+    logger : logging.Logger, optional
+        Logger instance, by default None
+    plot_filename : str, optional
+        Path where the plot should be saved, by default None
+        If None but saveplot is True, "dynamic_spectrum.png" will be used
+    
+    Returns
+    -------
+    str
+        Path to the output FITS file.
+    """
+    if logger is None:
+        logger = logging.getLogger("create_dynamic_spectra")
+    
+    try:
+        all_times, dynamic_spectra, subband_indices, subband_freqs = create_dynamic_spectra(
+            indir, binwidth=binwidth, ncpu=ncpu, uv_min=uvmin, uv_max=uvmax, startfreq=startfreq, endfreq=endfreq)
+    except Exception as e:
+        if logger:
+            logger.exception(f"Error creating dynamic spectra: {e}")
+        else:
+            print(f"Error creating dynamic spectra: {e}")
+        return None
+    
+    # For plotting, convert time (in seconds) to UTC datetime numbers.
+    time_mjd = all_times / 86400.0
+    utc_dt = Time(time_mjd, format='mjd', scale='utc').to_datetime()
+    utc_num = [date2num(dt) for dt in utc_dt]
+    
+    # Plot dynamic spectrum with x-axis in UTC.
+    if saveplot or showplot:
+        from matplotlib.dates import DateFormatter
+        plt.figure(figsize=(10, 6))
+        extent = [utc_num[0], utc_num[-1], min(subband_freqs), max(subband_freqs)]
+        plt.imshow(dynamic_spectra.T, aspect='auto', origin='lower', extent=extent, cmap='viridis')
+        plt.xlabel("Time (UTC)")
+        plt.ylabel("Frequency (MHz)")
+        plt.title("Dynamic Spectrum")
+        plt.colorbar(label="Amplitude")
+        ax = plt.gca()
+        date_formatter = DateFormatter('%Y-%m-%d\n%H:%M:%S')
+        ax.xaxis.set_major_formatter(date_formatter)
+        plt.gcf().autofmt_xdate()
+        
+        if saveplot:
+            # Use the provided plot_filename or default to "dynamic_spectrum.png"
+            save_path = plot_filename if plot_filename else "dynamic_spectrum.png"
+            plt.savefig(save_path, dpi=150, bbox_inches='tight')
+            if logger:
+                logger.info(f"Dynamic spectrum plot saved as {save_path}")
+            else:
+                print(f"Dynamic spectrum plot saved as {save_path}")
+                
+        if showplot:
+            plt.show()
+        else:
+            plt.close()
+    
+    write_fits(all_times, dynamic_spectra, subband_freqs, outfits)
+    return outfits
+
+def main():
+    parser = argparse.ArgumentParser(description="Create Dynamic Spectra from MS files in a directory.")
+    parser.add_argument("--indir", type=str, required=True, help="Directory containing MS files")
+    parser.add_argument("--outfits", type=str, default="dynamic_spectra.fits", help="Output FITS file name")
+    parser.add_argument("--binwidth", type=float, default=1.0, help="Time bin width in seconds (default 1 s)")
+    parser.add_argument("--ncpu", type=int, default=10, help="Number of CPU threads to use (default 10)")
+    parser.add_argument("--uvmin", type=float, default=130.0, help="Minimum UV baseline (lambda)")
+    parser.add_argument("--uvmax", type=float, default=500.0, help="Maximum UV baseline (lambda)")
+    parser.add_argument("--startfreq", type=float, default=None, help="Start frequency in MHz (optional)")
+    parser.add_argument("--endfreq", type=float, default=None, help="End frequency in MHz (optional)")
+    parser.add_argument("--saveplot", action="store_true", help="Save plot to file")
+    parser.add_argument("--showplot", action="store_true", help="Show plot in window")
+    parser.add_argument("--plotfile", type=str, default=None, help="Filename to save the plot")
+    args = parser.parse_args()
+    
+    # Setup a logger
+    logger = logging.getLogger("create_dynamic_spectra")
+    logger.setLevel(logging.INFO)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+    logger.addHandler(handler)
+    
+    run_dynamic_spectra(
+        args.indir, 
+        outfits=args.outfits, 
+        binwidth=args.binwidth, 
+        ncpu=args.ncpu,
+        uvmin=args.uvmin, 
+        uvmax=args.uvmax,
+        startfreq=args.startfreq,
+        endfreq=args.endfreq,
+        saveplot=args.saveplot, 
+        showplot=args.showplot,
+        logger=logger,
+        plot_filename=args.plotfile
+    )
+
+if __name__ == "__main__":
+    from matplotlib.dates import date2num  # imported here for plotting conversion
+    main()