pyckster 26.2.3__py3-none-any.whl → 26.2.4__py3-none-any.whl

pyckster/__init__.py

@@ -15,7 +15,7 @@ except ImportError:
     pass  # matplotlib not available, that's fine
 
 # Define version and metadata in one place
-__version__ = "26.2.3"
+__version__ = "26.2.4"
 __author__ = "Sylvain Pasquet"
 __email__ = "sylvain.pasquet@sorbonne-universite.fr"
 __license__ = "GPLv3"

pyckster/core.py

@@ -1714,6 +1714,7 @@ class MainWindow(QMainWindow):
 
         # Create a QListWidget for file names and add it to the left
         self.fileListWidget = QListWidget()
+        self.fileListWidget.setSelectionMode(QListWidget.ExtendedSelection)  # Enable multi-selection
         self.fileListWidget.itemSelectionChanged.connect(self.onFileSelectionChanged)
         self.fileListWidget.setMinimumWidth(50)  # Set minimum width
         leftLayout.addWidget(self.fileListWidget)
@@ -2262,28 +2263,36 @@ class MainWindow(QMainWindow):
         self.openFileAction.triggered.connect(self.openFile)
 
         # Create QAction for importing ASCII matrix
-        self.importAsciiAction = QAction('Import ASCII matrix...', self)
+        self.importAsciiAction = QAction('Import ASCII matrix', self)
         self.fileMenu.addAction(self.importAsciiAction)
         self.importAsciiAction.triggered.connect(self.importAsciiMatrix)
 
         # Create QAction for importing ASCII archive
-        self.importAsciiArchiveAction = QAction('Import ASCII archive...', self)
+        self.importAsciiArchiveAction = QAction('Import ASCII archive', self)
         self.fileMenu.addAction(self.importAsciiArchiveAction)
         self.importAsciiArchiveAction.triggered.connect(self.importAsciiArchive)
         
         # Add separator
         self.fileMenu.addSeparator()
 
-        # Create QAction for stacking shots
-        self.stackShotsAction = QAction('Stack shots', self)
-        self.fileMenu.addAction(self.stackShotsAction)
+        # Create a submenu for stacking shots
+        self.stackSubMenu = self.fileMenu.addMenu('Stack...')
+
+        # Create QAction for stacking shots with same source position
+        self.stackShotsAction = QAction('shots at same position', self)
+        self.stackSubMenu.addAction(self.stackShotsAction)
         self.stackShotsAction.triggered.connect(self.stackShots)
 
+        # Create QAction for stacking selected shots
+        self.stackSelectedShotsAction = QAction('selected shots', self)
+        self.stackSubMenu.addAction(self.stackSelectedShotsAction)
+        self.stackSelectedShotsAction.triggered.connect(self.stackSelectedShots)
+
         # Add separator
         self.fileMenu.addSeparator()
 
         # Create a submenu for saving single files
-        self.saveSingleFileSubMenu = self.fileMenu.addMenu('Save current shot')
+        self.saveSingleFileSubMenu = self.fileMenu.addMenu('Save current shot...')
 
         # Create QAction for saving current file in SEGY
         self.saveSingleFileSegyAction = QAction('in a SEGY file', self)
@@ -2301,7 +2310,7 @@ class MainWindow(QMainWindow):
         self.saveSingleFileAsciiAction.triggered.connect(self.saveSingleFileASCII)
 
         # Create a submenu for saving all files
-        self.saveFileSubMenu = self.fileMenu.addMenu('Save all shots')
+        self.saveFileSubMenu = self.fileMenu.addMenu('Save all shots...')
 
         # Create QAction for saving all files in SEGY
         self.saveAllFilesSegyAction = QAction('in separate SEGY files', self)
@@ -2331,10 +2340,10 @@ class MainWindow(QMainWindow):
         # Add separator
         self.fileMenu.addSeparator()
 
-        # Create QAction for removing current file
-        self.removeShotAction = QAction('Remove current shot', self)
+        # Create QAction for removing selected files
+        self.removeShotAction = QAction('Remove selected shot(s)', self)
         self.fileMenu.addAction(self.removeShotAction)
-        self.removeShotAction.triggered.connect(self.removeShot)
+        self.removeShotAction.triggered.connect(self.removeSelectedShots)
 
         # Create QAction for clearing the memory
         self.clearMemoryAction = QAction('Clear memory', self)
@@ -12876,7 +12885,17 @@ class MainWindow(QMainWindow):
             if show_cursor:
                 QApplication.restoreOverrideCursor()
 
+    def getSelectedShotIndices(self):
+        """Helper function to get indices of selected shots in the file list.
+        Returns a sorted list of indices (0-based)."""
+        selected_items = self.fileListWidget.selectedItems()
+        if not selected_items:
+            return []
+        selected_indices = [self.fileListWidget.row(item) for item in selected_items]
+        return sorted(selected_indices)
+    
     def removeShot(self):
+        """Legacy function - kept for backward compatibility. Use removeSelectedShots instead."""
         if self.currentIndex is not None:
             # Remove the current file from the lists
             for attr in self.attributes_to_initialize:
@@ -12900,6 +12919,59 @@ class MainWindow(QMainWindow):
             else:
                 QMessageBox.information(self, "No Shots Remaining", "No shots remaining. Memory will be cleared.")
                 self.initMemory()
+    
+    def removeSelectedShots(self):
+        """Remove all selected shots from the file list."""
+        # Get selected row indices
+        selected_items = self.fileListWidget.selectedItems()
+        if not selected_items:
+            QMessageBox.warning(self, "No Selection", "No shots selected. Please select one or more shots to remove.")
+            return
+        
+        # Get the indices of selected items
+        selected_indices = [self.fileListWidget.row(item) for item in selected_items]
+        selected_indices.sort(reverse=True)  # Sort in reverse to remove from end first
+        
+        # Confirm removal if multiple shots selected
+        if len(selected_indices) > 1:
+            reply = QMessageBox.question(self, "Confirm Removal",
+                f"Are you sure you want to remove {len(selected_indices)} selected shot(s)?",
+                QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+            if reply == QMessageBox.No:
+                return
+        
+        # Remove selected shots (from end to beginning to maintain indices)
+        for idx in selected_indices:
+            for attr in self.attributes_to_initialize:
+                getattr(self, attr).pop(idx)
+        
+        # Update current index to the first remaining shot or 0
+        if self.streams:
+            # Set to the first valid index that's not removed
+            remaining_count = len(self.fileNames)
+            if remaining_count > 0:
+                # Try to select the shot after the last removed one, or the last available
+                new_index = min(selected_indices) if selected_indices else 0
+                self.currentIndex = min(new_index, remaining_count - 1)
+            else:
+                self.currentIndex = 0
+        else:
+            self.currentIndex = 0
+        
+        # Update the plot type dictionary
+        self.updatePlotTypeDict()
+        
+        # Update the file list display
+        self.updateFileListDisplay()
+        
+        # Update selected file in the list display
+        if self.streams:
+            self.fileListWidget.setCurrentRow(self.currentIndex)
+            # Update the plot
+            self.updatePlots()
+        else:
+            QMessageBox.information(self, "No Shots Remaining", "No shots remaining. Memory will be cleared.")
+            self.initMemory()
 
     #######################################
     # Saving shot functions
@@ -16806,9 +16878,18 @@ class MainWindow(QMainWindow):
 
     def batchEditFFID(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First FFID', 'initial_value': self.ffid[0], 'type': 'int'},
             {'label': 'Increment', 'initial_value': 1, 'type': 'int'}
             ]
@@ -16845,9 +16926,18 @@ class MainWindow(QMainWindow):
     
     def batchEditDelay(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'Delay (in s)', 'initial_value': self.delay[self.currentIndex], 'type': 'float'},
             ]
 
@@ -16925,9 +17015,18 @@ class MainWindow(QMainWindow):
 
     def batchEditSourcePosition(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'Skip every N sources', 'initial_value': 0, 'type': 'int'},
             {'label': 'First Source Position (in m)', 'initial_value': self.source_position[0], 'type': 'float'},
             {'label': 'Last Source Position (in m)', 'initial_value': '', 'type': 'float_or_empty'},
@@ -17033,9 +17132,18 @@ class MainWindow(QMainWindow):
 
     def batchEditTracePosition(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace #', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'},
             {'label': 'First Trace Position (in m)', 'initial_value': self.trace_position[self.currentIndex][0], 'type': 'float'},
@@ -17095,9 +17203,18 @@ class MainWindow(QMainWindow):
 
     def batchSwapTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to swap', 'initial_value': 1, 'type': 'int'},
             {'label': 'Second Trace # to swap', 'initial_value': 2, 'type': 'int'}
             ]
@@ -17163,9 +17280,18 @@ class MainWindow(QMainWindow):
 
     def batchRemoveTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to remove', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to remove', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'}
             ]
@@ -17229,9 +17355,18 @@ class MainWindow(QMainWindow):
 
     def batchMoveTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to move', 'initial_value': 1, 'type': 'int'},
             {'label': 'New Position', 'initial_value': 1, 'type': 'int'}
@@ -17298,9 +17433,18 @@ class MainWindow(QMainWindow):
 
     def batchMuteTraces(self):
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-            {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-            {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+            {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+            {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
             {'label': 'First Trace # to mute', 'initial_value': 1, 'type': 'int'},
             {'label': 'Last Trace # to mute', 'initial_value': len(self.trace_position[self.currentIndex]), 'type': 'int'}
             ]
@@ -17350,11 +17494,20 @@ class MainWindow(QMainWindow):
     def batchInsertMutedTraces(self):
         """Batch insert zero traces for a range of shots."""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
             
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'Insert after Trace # (0 for beginning)', 'initial_value': n_traces, 'type': 'int'},
                 {'label': 'Number of traces to insert', 'initial_value': 1, 'type': 'int'}
             ]
@@ -17407,9 +17560,18 @@ class MainWindow(QMainWindow):
     def batchZeroPadTraces(self):
         """Batch zero pad all traces for a range of shots."""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
             ]
             
@@ -17470,11 +17632,20 @@ class MainWindow(QMainWindow):
     def batchReverseTraces(self):
         """Batch reverse trace data (flip data matrix left-to-right) while keeping headers in place"""
         if self.streams:
+            # Get selected shot indices for default values (only if 2+ shots selected)
+            selected_indices = self.getSelectedShotIndices()
+            if len(selected_indices) >= 2:
+                first_source_default = selected_indices[0] + 1
+                last_source_default = selected_indices[-1] + 1
+            else:
+                first_source_default = 1
+                last_source_default = len(self.streams)
+            
             n_traces = len(self.trace_position[self.currentIndex]) if self.currentIndex < len(self.trace_position) else 1
             
             parameters = [
-                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
-                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'First Source #', 'initial_value': first_source_default, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': last_source_default, 'type': 'int'},
                 {'label': 'First Trace #', 'initial_value': 1, 'type': 'int'},
                 {'label': 'Last Trace #', 'initial_value': n_traces, 'type': 'int'}
             ]
@@ -17838,6 +18009,203 @@ class MainWindow(QMainWindow):
         QMessageBox.information(self, "Stacking Complete", 
             f"Successfully created {stacked_shot_count} stacked shot(s).")
 
+    def stackSelectedShots(self):
+        """
+        Stack selected shots regardless of their source position.
+        Creates a new stacked shot with traces summed at identical receiver positions.
+        Uses the source position from the first selected shot.
+        """
+        import obspy
+        from obspy import Stream
+        
+        if not self.streams:
+            QMessageBox.information(self, "No Data", "No shots loaded. Please load shot data first.")
+            return
+        
+        # Get selected shot indices
+        selected_indices = self.getSelectedShotIndices()
+        
+        if len(selected_indices) < 2:
+            QMessageBox.warning(self, "Insufficient Selection", 
+                "Please select at least 2 shots to stack. Use Ctrl+Click to select multiple shots.")
+            return
+        
+        # Build a dictionary of receiver positions across all selected shots
+        # Key: receiver position, Value: list of (shot_idx, trace_idx) tuples
+        receiver_traces = {}
+        
+        for shot_idx in selected_indices:
+            for trace_idx, receiver_pos in enumerate(self.trace_position[shot_idx]):
+                if receiver_pos not in receiver_traces:
+                    receiver_traces[receiver_pos] = []
+                receiver_traces[receiver_pos].append((shot_idx, trace_idx))
+        
+        # Get unique receiver positions (sorted)
+        receiver_positions = sorted(receiver_traces.keys())
+        
+        if not receiver_positions:
+            QMessageBox.warning(self, "No Receiver Positions", 
+                "Could not find any receiver positions in selected shots.")
+            return
+        
+        # Use source position from first selected shot
+        first_shot_idx = selected_indices[0]
+        source_pos = self.source_position[first_shot_idx]
+        
+        # Show confirmation dialog
+        shot_indices_str = ', '.join(str(i + 1) for i in selected_indices)
+        reply = QMessageBox.question(self, "Confirm Stacking",
+            f"Stack {len(selected_indices)} selected shot(s) ({shot_indices_str})?\n\n"
+            f"Source position: {source_pos}m\n"
+            f"Number of unique receiver positions: {len(receiver_positions)}\n\n"
+            f"Traces at the same receiver position will be summed.",
+            QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
+        
+        if reply == QMessageBox.No:
+            return
+        
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        try:
+            # Create stacked stream
+            stacked_stream = obspy.Stream()
+            
+            # For each receiver position, sum all traces at that position
+            for receiver_pos in receiver_positions:
+                trace_list = receiver_traces[receiver_pos]
+                
+                # Get all traces at this receiver position
+                traces_to_sum = []
+                for shot_idx, trace_idx in trace_list:
+                    traces_to_sum.append(self.streams[shot_idx][trace_idx])
+                
+                # Sum the traces
+                if traces_to_sum:
+                    summed_trace = traces_to_sum[0].copy()
+                    for trace in traces_to_sum[1:]:
+                        summed_trace.data += trace.data
+                    stacked_stream.append(summed_trace)
+            
+            if len(stacked_stream) == 0:
+                QMessageBox.warning(self, "No Traces", "Could not create stacked traces.")
+                return
+            
+            # Find the maximum existing FFID and increment
+            max_ffid = max(self.ffid) if self.ffid else 0
+            new_ffid = max_ffid + 1
+            
+            # Get format from first shot
+            format_to_use = self.input_format[first_shot_idx]
+            
+            # Update FFID in headers for stacked stream
+            for trace in stacked_stream:
+                trace.stats[format_to_use].trace_header.original_field_record_number = new_ffid
+            
+            # Append to parallel arrays
+            stacked_shot_name = f"stacked_selected_{new_ffid}"
+            self.fileNames.append(stacked_shot_name)
+            self.streams.append(stacked_stream)
+            self.input_format.append(format_to_use)
+            
+            # Extract data from the stacked stream
+            n_sample_stacked = len(stacked_stream[0].data)
+            self.n_sample.append(n_sample_stacked)
+            
+            # Get sample interval from first shot
+            sample_interval_stacked = self.sample_interval[first_shot_idx]
+            self.sample_interval.append(sample_interval_stacked)
+            
+            # Get delay from first shot
+            delay_stacked = self.delay[first_shot_idx]
+            self.delay.append(delay_stacked)
+            
+            # Generate time array
+            time_stacked = np.arange(n_sample_stacked) * sample_interval_stacked + delay_stacked
+            self.time.append(time_stacked)
+            
+            # Get record length
+            record_length_stacked = self.record_length[first_shot_idx]
+            self.record_length.append(record_length_stacked)
+            
+            # FFID
+            self.ffid.append(new_ffid)
+            
+            # Source position (from first selected shot)
+            self.source_position.append(source_pos)
+            
+            # Trace numbering
+            shot_trace_numbers = [i + 1 for i in range(len(stacked_stream))]
+            self.shot_trace_number.append(shot_trace_numbers)
+            
+            # Trace positions (receiver positions, sorted)
+            self.trace_position.append(receiver_positions)
+            
+            # File trace numbers (sequential)
+            file_trace_numbers = list(range(1, len(stacked_stream) + 1))
+            self.file_trace_number.append(file_trace_numbers)
+            
+            # Initialize unique_trace_number (will be computed later)
+            self.unique_trace_number.append(None)
+            
+            # Trace elevations (from first occurrence of each position)
+            trace_elevations_stacked = []
+            for receiver_pos in receiver_positions:
+                # Find first occurrence of this position
+                for shot_idx, trace_idx in receiver_traces[receiver_pos]:
+                    trace_elevations_stacked.append(self.trace_elevation[shot_idx][trace_idx])
+                    break
+            self.trace_elevation.append(trace_elevations_stacked)
+            
+            # Source elevation (from first shot)
+            self.source_elevation.append(self.source_elevation[first_shot_idx])
+            
+            # Offset (distance from source to each receiver)
+            offsets_stacked = [abs(rp - source_pos) for rp in receiver_positions]
+            self.offset.append(offsets_stacked)
+            
+            # Initialize picks, errors, and UI items as None
+            self.picks.append(None)
+            self.error.append(None)
+            self.pickSeismoItems.append(None)
+            self.pickLayoutItems.append(None)
+            self.airWaveItems.append(None)
+            
+            # Update global trace numbering
+            self._updateAllUniqueTraceNumbers()
+            
+            # Sync headers
+            self.syncHeadersToStreams(len(self.streams) - 1)
+            self.headers_modified = True
+            
+            # Update display
+            self.updateFileListDisplay()
+            self.updatePlots()
+            
+            # Ask if user wants to remove the selected shots
+            reply = QMessageBox.question(self, "Remove Selected Shots",
+                "Remove the selected shots that were used in stacking?",
+                QMessageBox.Yes | QMessageBox.No)
+            
+            if reply == QMessageBox.Yes:
+                # Remove shots in reverse order to preserve indices
+                for idx in reversed(selected_indices):
+                    for attr in self.attributes_to_initialize:
+                        getattr(self, attr).pop(idx)
+                
+                # Update display
+                self.updateFileListDisplay()
+                if self.streams:
+                    self.currentIndex = min(self.currentIndex, len(self.streams) - 1)
+                    self.fileListWidget.setCurrentRow(self.currentIndex)
+                    self.updatePlots()
+            
+            QMessageBox.information(self, "Stacking Complete", 
+                f"Successfully stacked {len(selected_indices)} shot(s) into FFID {new_ffid}.\n"
+                f"Source position: {source_pos}m\n"
+                f"Number of traces: {len(receiver_positions)}")
+        
+        finally:
+            QApplication.restoreOverrideCursor()
+
     #######################################
     # Set parameters functions
     #######################################

pyckster/obspy_utils.py

@@ -2,6 +2,7 @@ import os
 import re
 import numpy as np
 import obspy
+import warnings
 
 #######################################
 # Obspy functions
@@ -63,39 +64,49 @@ def read_seismic_file(seismic_file, separate_sources=False):
     stream : obspy.Stream
         The stream object containing the seismic data.
     '''
-    # Validate .dat files are actually binary, not ASCII
-    file_ext = os.path.splitext(seismic_file)[1].lower()
-    if file_ext == '.dat':
-        if not is_valid_binary_seismic_file(seismic_file):
-            raise ValueError(
-                f"File '{os.path.basename(seismic_file)}' appears to be an ASCII text file, "
-                f"not a binary Seg2 seismic file. Please verify the file format."
-            )
-    
-    # Determine format based on file extension
-    format_map = {
-        '.sgy': 'SEGY',
-        '.seg': 'SEGY',
-        '.segy': 'SEGY',
-        '.su': 'SU',
-        '.seg2': 'SEG2',
-        '.sg2': 'SEG2',
-        '.dat': 'SEG2',  # .dat files are typically SEG2
-    }
-    
-    # Get format from extension, default to None (let obspy auto-detect)
-    file_format = format_map.get(file_ext, None)
-    
-    # Read the seismic file with explicit format if known
-    if file_format:
-        stream = obspy.read(seismic_file, format=file_format, unpack_trace_headers=True)
-    else:
-        stream = obspy.read(seismic_file, unpack_trace_headers=True)
+    # Suppress expected warnings from ObsPy's SEG2 reader
+    # These warnings are expected and handled by our code:
+    # 1. DELAY field warning - we manually extract and apply the delay
+    # 2. Custom header warning - we handle custom SEG2 headers appropriately
+    # 3. Creating trace header - expected during SEG2 to SEGY conversion
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', message='.*DELAY.*', category=UserWarning)
+        warnings.filterwarnings('ignore', message='.*custom defined SEG2 header.*', category=UserWarning)
+        warnings.filterwarnings('ignore', message='CREATING TRACE HEADER', category=UserWarning)
+        
+        # Validate .dat files are actually binary, not ASCII
+        file_ext = os.path.splitext(seismic_file)[1].lower()
+        if file_ext == '.dat':
+            if not is_valid_binary_seismic_file(seismic_file):
+                raise ValueError(
+                    f"File '{os.path.basename(seismic_file)}' appears to be an ASCII text file, "
+                    f"not a binary Seg2 seismic file. Please verify the file format."
+                )
+        
+        # Determine format based on file extension
+        format_map = {
+            '.sgy': 'SEGY',
+            '.seg': 'SEGY',
+            '.segy': 'SEGY',
+            '.su': 'SU',
+            '.seg2': 'SEG2',
+            '.sg2': 'SEG2',
+            '.dat': 'SEG2',  # .dat files are typically SEG2
+        }
+        
+        # Get format from extension, default to None (let obspy auto-detect)
+        file_format = format_map.get(file_ext, None)
+        
+        # Read the seismic file with explicit format if known
+        if file_format:
+            stream = obspy.read(seismic_file, format=file_format, unpack_trace_headers=True)
+        else:
+            stream = obspy.read(seismic_file, unpack_trace_headers=True)
 
     input_format = check_format(stream)
 
     if input_format == 'seg2':
-        # Preserve original SEG2 coordinate information before conversion
+        # Preserve original SEG2 coordinate information and delay before conversion
         original_seg2_coords = []
         for trace_index, trace in enumerate(stream):
             coord_info = {
@@ -105,13 +116,24 @@ def read_seismic_file(seismic_file, separate_sources=False):
                 'source_x': 0.0,
                 'source_y': 0.0,
                 'source_z': 0.0,
+                'delay': 0.0,
                 'trace_index': trace_index
             }
             
-            # Extract coordinates from SEG2 headers with multiple field name variations
+            # Extract coordinates and delay from SEG2 headers with multiple field name variations
             if hasattr(trace.stats, 'seg2'):
                 seg2 = trace.stats.seg2
                 
+                # Extract DELAY from SEG2 headers
+                delay_fields = ['DELAY', 'DELAY_TIME', 'RECORDING_DELAY']
+                for field in delay_fields:
+                    if hasattr(seg2, field):
+                        try:
+                            coord_info['delay'] = float(getattr(seg2, field))
+                            break
+                        except (ValueError, TypeError):
+                            continue
+                
                 # Try different field names for receiver location
                 receiver_location_fields = ['RECEIVER_LOCATION', 'RECEIVER_LOCATION_X', 'RECEIVER_X', 'REC_X']
                 for field in receiver_location_fields:
@@ -170,8 +192,11 @@ def read_seismic_file(seismic_file, separate_sources=False):
         else:
             ffid = 1
 
-        stream.write('tmp.sgy',format='SEGY',data_encoding=5, byteorder='>')
-        stream = obspy.read('tmp.sgy',unpack_trace_headers=True)
+        # Suppress warnings during SEG2 to SEGY conversion
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', message='CREATING TRACE HEADER', category=UserWarning)
+            stream.write('tmp.sgy',format='SEGY',data_encoding=5, byteorder='>')
+            stream = obspy.read('tmp.sgy',unpack_trace_headers=True)
         os.remove('tmp.sgy')
         
         # Calculate coordinate scalar for preserved coordinates
@@ -204,6 +229,8 @@ def read_seismic_file(seismic_file, separate_sources=False):
                 trace.stats[input_format].trace_header.source_coordinate_x = int(coord_info['source_x'] * coordinate_scalar)
                 trace.stats[input_format].trace_header.source_coordinate_y = int(coord_info['source_y'] * coordinate_scalar)
                 trace.stats[input_format].trace_header.surface_elevation_at_source = int(coord_info['source_z'] * coordinate_scalar)
+                # Apply delay from SEG2 header (convert to milliseconds for SEGY)
+                trace.stats[input_format].trace_header.delay_recording_time = int(coord_info['delay'] * 1000)
     
     if separate_sources:
         stream = separate_streams(stream)

{pyckster-26.2.3.dist-info → pyckster-26.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyckster
-Version: 26.2.3
+Version: 26.2.4
 Summary: A PyQt5-based GUI for the processing and analysis of active near-surface seismic data
 Home-page: https://gitlab.in2p3.fr/metis-geophysics/pyckster
 Author: Sylvain Pasquet

{pyckster-26.2.3.dist-info → pyckster-26.2.4.dist-info}/RECORD

@@ -1,15 +1,15 @@
-pyckster/__init__.py,sha256=qESM7e1M2mtkZ_qclsH4wVv39yjHCQrkPg1gO0xze7E,905
+pyckster/__init__.py,sha256=hyEyaD3gWhebOlI1NcoMePXDldgUNNoe7mZ-l0lIm-Y,905
 pyckster/__main__.py,sha256=zv3AGVKorKo2tgWOEIcVnkDbp15eepSqka3IoWH_adU,406
 pyckster/auto_picking.py,sha256=fyZiOj0Ib-SB_oxsKnUszECHbOjo4JE23JVQILGYZco,12754
 pyckster/bayesian_inversion.py,sha256=kdnKOlAZ0JlYLipuFDHlwS7dU8LtI-0aMb90bYpEHhE,163523
-pyckster/core.py,sha256=fcrnR7L18Gwc5AiXj5aWpdqRnjPDZbyWOFSyg0FIsa8,1250792
+pyckster/core.py,sha256=HDJz6UB2TaGM-i68BRgb9X2poM3CJQDiOE3Is_IwG7w,1268015
 pyckster/dispersion_stack_viewer.py,sha256=7Dh2e1tSct062D7Qh6nNrMdJcqKWcJvDIv84V8sC6C8,12645
 pyckster/inversion_app.py,sha256=ovM44oYBFsvfKxO7rjjThUhkJnLDLZZ0R6ZVp-5r66E,60676
 pyckster/inversion_manager.py,sha256=P8i1fqUJKMWkd-9PoDmNtmQuKglGKTeSuptUUA57D-8,15393
 pyckster/inversion_visualizer.py,sha256=vfKZIoJzKawbaEv29NsYYIGnWLDQCGef5bM2vY1aCBo,22135
 pyckster/ipython_console.py,sha256=tZyyoiXCjCl7ozxOj_h-YR4eGjoC4kpKe7nZ48eUAJc,9313
 pyckster/mpl_export.py,sha256=_WqPo9l9ABiSoU0ukLfm4caGV1-FKKbXjt8SoBHTR30,12346
-pyckster/obspy_utils.py,sha256=wm74oyLvvQmF97_ySXPZD95ya-8Aer-pLyVYlA3QWoM,35420
+pyckster/obspy_utils.py,sha256=Rb0-HAZpil7LxDOMtoKqxlSYL71LVe9rAMrT0PRHXbU,37132
 pyckster/pick_io.py,sha256=r7QoRCA2zaGeZlFKuAJ86KnAH_mh_l4qGvP02Q0mwVA,36001
 pyckster/pyqtgraph_utils.py,sha256=PAeE3n_wz7skHOC5eLnkFczbie7diVH1xvuL8jtJ4T8,6049
 pyckster/surface_wave_analysis.py,sha256=97BrDA-n5AZp89NdxQ2ekZPaCErMc7v8C6GmD5KTi-4,102695
@@ -17,9 +17,9 @@ pyckster/surface_wave_profiling.py,sha256=L9KidhKmfGvVoPZjf6us3c49VB7VPB_VcsDqRx
 pyckster/sw_utils.py,sha256=-2CpQ9BkmUHaMBrNy2qXx1R-g9qPX8D9igKi_G-iRHE,13213
 pyckster/tab_factory.py,sha256=NlCIC6F8BrEu7a8BYOJJdWy5ftpX_zKDLj7SbcwBbh8,14519
 pyckster/visualization_utils.py,sha256=bgODn21NAQx1FOMPj91kdDd0szKOgUyfZ3cQlyu2PF8,47947
-pyckster-26.2.3.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
-pyckster-26.2.3.dist-info/METADATA,sha256=lUsnI0wr-TluggRLaC0MF5rUyFfm-VMhZ0H0YK5uZk0,4567
-pyckster-26.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyckster-26.2.3.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
-pyckster-26.2.3.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
-pyckster-26.2.3.dist-info/RECORD,,
+pyckster-26.2.4.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
+pyckster-26.2.4.dist-info/METADATA,sha256=TKeHttAjV2XDga_kdw2glW3b3c6GMP2GczZCK2L0tVk,4567
+pyckster-26.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyckster-26.2.4.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
+pyckster-26.2.4.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
+pyckster-26.2.4.dist-info/RECORD,,