pyckster 26.2.1__py3-none-any.whl → 26.2.2__py3-none-any.whl

pyckster/obspy_utils.py

@@ -594,4 +594,340 @@ def assisted_picking(trace_data, time_array, y_pick, smoothing_window_size, devi
     for j in range(pick_index, min(pick_index + picking_window_size, len(smoothed_trace_data))):
         if np.abs(smoothed_trace_data[j] - mean_window) > threshold:
             return time_array[j]
-    return y_pick
+    return y_pick
+
+
+def export_shot_to_ascii(stream, shot_index, output_dir, archive=True):
+    """
+    Export a single shot gather to ASCII files.
+    
+    Creates separate ASCII files for:
+    - Trace data matrix (time x traces)
+    - Trace positions (receiver coordinates)
+    - Time array
+    - Shot metadata (source position, parameters)
+    
+    Optionally bundles files into a tar.gz archive.
+    
+    Parameters
+    ----------
+    stream : obspy.Stream
+        Stream containing all traces for the shot
+    shot_index : int
+        Shot/FFID number for naming
+    output_dir : str
+        Directory where files will be saved
+    archive : bool, optional
+        If True, bundle all files into a .tar.gz archive. Default is True.
+        
+    Returns
+    -------
+    str
+        Path to the created archive (if archive=True) or directory (if archive=False)
+    """
+    import os
+    import tarfile
+    from datetime import datetime
+    
+    # Create output directory if needed
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Base name for all files
+    base_name = f"shot_{shot_index:04d}"
+    
+    # Extract data from stream
+    n_traces = len(stream)
+    if n_traces == 0:
+        raise ValueError("Stream is empty")
+    
+    # Get time array from first trace
+    tr = stream[0]
+    n_samples = tr.stats.npts
+    dt = tr.stats.delta
+    time_array = np.arange(n_samples) * dt
+    
+    # Initialize arrays
+    data_matrix = np.zeros((n_samples, n_traces))
+    trace_positions = np.zeros(n_traces)
+    trace_elevations = np.zeros(n_traces)
+    
+    # Extract source position from first trace
+    source_x = 0.0
+    source_y = 0.0
+    source_z = 0.0
+    
+    # Determine format
+    input_format = check_format(stream)
+    
+    for i, tr in enumerate(stream):
+        # Fill data matrix
+        data_matrix[:, i] = tr.data
+        
+        # Get coordinate scalar to properly interpret positions
+        try:
+            coord_scalar = tr.stats[input_format].trace_header.scalar_to_be_applied_to_all_coordinates
+            if coord_scalar < 0:
+                coord_scalar = -1.0 / coord_scalar
+            elif coord_scalar == 0:
+                coord_scalar = 1.0
+        except (AttributeError, KeyError):
+            coord_scalar = 1.0
+        
+        # Get elevation scalar
+        try:
+            elev_scalar = tr.stats[input_format].trace_header.scalar_to_be_applied_to_all_elevations_and_depths
+            if elev_scalar < 0:
+                elev_scalar = -1.0 / elev_scalar
+            elif elev_scalar == 0:
+                elev_scalar = 1.0
+        except (AttributeError, KeyError):
+            elev_scalar = coord_scalar
+        
+        # Get trace position and elevation
+        try:
+            trace_positions[i] = tr.stats[input_format].trace_header.group_coordinate_x * coord_scalar
+        except (AttributeError, KeyError):
+            trace_positions[i] = float(i)
+        
+        try:
+            trace_elevations[i] = tr.stats[input_format].trace_header.receiver_group_elevation * elev_scalar
+        except (AttributeError, KeyError):
+            trace_elevations[i] = 0.0
+        
+        # Extract source info from first trace
+        if i == 0:
+            try:
+                source_x = tr.stats[input_format].trace_header.source_coordinate_x * coord_scalar
+            except (AttributeError, KeyError):
+                source_x = 0.0
+            
+            try:
+                source_y = tr.stats[input_format].trace_header.source_coordinate_y * coord_scalar
+            except (AttributeError, KeyError):
+                source_y = 0.0
+            
+            try:
+                source_z = tr.stats[input_format].trace_header.surface_elevation_at_source * elev_scalar
+            except (AttributeError, KeyError):
+                source_z = 0.0
+    
+    # File paths
+    data_file = os.path.join(output_dir, f"{base_name}_data.txt")
+    time_file = os.path.join(output_dir, f"{base_name}_time.txt")
+    positions_file = os.path.join(output_dir, f"{base_name}_receivers.txt")
+    metadata_file = os.path.join(output_dir, f"{base_name}_metadata.txt")
+    
+    # Save data matrix (one column per trace)
+    np.savetxt(data_file, data_matrix, fmt='%.6e', delimiter='\t',
+               header=f'Trace data for shot {shot_index}\nRows: time samples, Columns: traces\n' +
+                      f'Sampling interval: {dt} s, Number of samples: {n_samples}, Number of traces: {n_traces}',
+               comments='# ')
+    
+    # Save time array
+    np.savetxt(time_file, time_array, fmt='%.6f',
+               header=f'Time array (s) for shot {shot_index}\nSampling interval: {dt} s',
+               comments='# ')
+    
+    # Save receiver positions
+    receiver_data = np.column_stack((trace_positions, trace_elevations))
+    np.savetxt(positions_file, receiver_data, fmt='%.6f', delimiter='\t',
+               header='Receiver positions\nColumn 1: X coordinate (m)\nColumn 2: Elevation (m)',
+               comments='# ')
+    
+    # Save metadata
+    with open(metadata_file, 'w') as f:
+        f.write(f"# Shot metadata for shot {shot_index}\n")
+        f.write(f"# Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+        f.write(f"shot_number = {shot_index}\n")
+        f.write(f"source_x = {source_x:.6f}  # m\n")
+        f.write(f"source_y = {source_y:.6f}  # m\n")
+        f.write(f"source_z = {source_z:.6f}  # m (elevation)\n")
+        f.write(f"n_traces = {n_traces}\n")
+        f.write(f"n_samples = {n_samples}\n")
+        f.write(f"sampling_rate = {1.0/dt:.1f}  # Hz\n")
+        f.write(f"sampling_interval = {dt:.6f}  # s\n")
+        f.write(f"record_length = {time_array[-1]:.6f}  # s\n")
+        f.write(f"\n# Data files:\n")
+        f.write(f"# - {base_name}_data.txt: Trace amplitudes (time x traces matrix)\n")
+        f.write(f"# - {base_name}_time.txt: Time array (s)\n")
+        f.write(f"# - {base_name}_receivers.txt: Receiver positions (x, elevation)\n")
+    
+    # Create archive if requested
+    if archive:
+        archive_path = os.path.join(output_dir, f"{base_name}.tar.gz")
+        with tarfile.open(archive_path, "w:gz") as tar:
+            tar.add(data_file, arcname=f"{base_name}_data.txt")
+            tar.add(time_file, arcname=f"{base_name}_time.txt")
+            tar.add(positions_file, arcname=f"{base_name}_receivers.txt")
+            tar.add(metadata_file, arcname=f"{base_name}_metadata.txt")
+        
+        # Remove individual files
+        os.remove(data_file)
+        os.remove(time_file)
+        os.remove(positions_file)
+        os.remove(metadata_file)
+        
+        return archive_path
+    else:
+        return output_dir
+
+
+def import_shot_from_ascii(archive_path):
+    """
+    Import a shot gather from an ASCII archive.
+    
+    Reads an ASCII archive created by export_shot_to_ascii and converts it
+    back to an obspy Stream object.
+    
+    Parameters
+    ----------
+    archive_path : str
+        Path to the .tar.gz or .zip archive
+        
+    Returns
+    -------
+    obspy.Stream
+        Stream containing the reconstructed shot gather
+    dict
+        Metadata dictionary containing shot information
+    """
+    import os
+    import tarfile
+    import zipfile
+    import tempfile
+    import shutil
+    
+    # Create temporary directory
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # Extract archive
+        if archive_path.endswith('.tar.gz') or archive_path.endswith('.tgz'):
+            with tarfile.open(archive_path, 'r:gz') as tar:
+                tar.extractall(temp_dir)
+        elif archive_path.endswith('.zip'):
+            with zipfile.ZipFile(archive_path, 'r') as zipf:
+                zipf.extractall(temp_dir)
+        else:
+            raise ValueError("Archive must be .tar.gz or .zip format")
+        
+        # Find the files (they should all have the same base name)
+        files = os.listdir(temp_dir)
+        data_file = None
+        time_file = None
+        receivers_file = None
+        metadata_file = None
+        
+        for f in files:
+            if f.endswith('_data.txt'):
+                data_file = os.path.join(temp_dir, f)
+            elif f.endswith('_time.txt'):
+                time_file = os.path.join(temp_dir, f)
+            elif f.endswith('_receivers.txt'):
+                receivers_file = os.path.join(temp_dir, f)
+            elif f.endswith('_metadata.txt'):
+                metadata_file = os.path.join(temp_dir, f)
+        
+        if not all([data_file, time_file, receivers_file, metadata_file]):
+            raise ValueError("Archive is missing required files")
+        
+        # Read data with explicit dtype and comment handling
+        data_matrix = np.loadtxt(data_file, dtype=np.float64, comments='#')
+        time_array = np.loadtxt(time_file, dtype=np.float64, comments='#')
+        receivers = np.loadtxt(receivers_file, dtype=np.float64, comments='#')
+        
+        # Ensure receivers is 2D (handles single trace case)
+        if receivers.ndim == 1:
+            receivers = receivers.reshape(1, -1)
+        
+        # Ensure data_matrix is 2D (handles single trace case)
+        if data_matrix.ndim == 1:
+            data_matrix = data_matrix.reshape(-1, 1)
+        
+        # Read metadata
+        metadata = {}
+        with open(metadata_file, 'r') as f:
+            for line in f:
+                if '=' in line and not line.startswith('#'):
+                    key, value = line.split('=', 1)
+                    value = value.split('#')[0].strip()
+                    try:
+                        metadata[key.strip()] = float(value)
+                    except ValueError:
+                        metadata[key.strip()] = value
+        
+        # Create obspy stream
+        stream = obspy.Stream()
+        
+        n_samples, n_traces = data_matrix.shape
+        dt = float(metadata.get('sampling_interval', time_array[1] - time_array[0]))
+        shot_number = int(metadata.get('shot_number', 1))
+        
+        for i in range(n_traces):
+            # Create trace with float32 dtype for SEGY compatibility
+            trace = obspy.Trace(data=data_matrix[:, i].astype(np.float32))
+            
+            # Set basic stats
+            trace.stats.delta = dt
+            trace.stats.npts = n_samples
+            trace.stats.sampling_rate = 1.0 / dt
+            
+            # Add SU headers (default format)
+            trace.stats.su = obspy.core.util.AttribDict()
+            trace.stats.su.trace_header = obspy.core.util.AttribDict()
+            
+            # Set trace headers
+            trace.stats.su.trace_header.trace_sequence_number_within_line = i + 1
+            trace.stats.su.trace_header.trace_sequence_number_within_segy_file = i + 1
+            trace.stats.su.trace_header.original_field_record_number = shot_number
+            trace.stats.su.trace_header.trace_number_within_the_original_field_record = i + 1
+            
+            # Set coordinates - use appropriate scalar to keep values within int16 range (-32768 to 32767)
+            # Calculate scalar based on max coordinate value
+            receiver_x = receivers[i, 0]
+            receiver_z = receivers[i, 1] if receivers.shape[1] > 1 else 0.0
+            source_x = metadata.get('source_x', 0.0)
+            source_y = metadata.get('source_y', 0.0)
+            source_z = metadata.get('source_z', 0.0)
+            
+            # Determine appropriate scalar to fit values in int16 range
+            max_coord = max(abs(receiver_x), abs(receiver_z), abs(source_x), abs(source_y), abs(source_z))
+            if max_coord > 0:
+                # Find scalar that keeps max_coord * scalar < 32000 (leave some margin)
+                if max_coord * 1000 < 32000:
+                    coord_scalar = -1000  # mm precision
+                elif max_coord * 100 < 32000:
+                    coord_scalar = -100   # cm precision
+                elif max_coord * 10 < 32000:
+                    coord_scalar = -10    # dm precision
+                else:
+                    coord_scalar = -1     # m precision
+            else:
+                coord_scalar = -1000
+            
+            trace.stats.su.trace_header.group_coordinate_x = int(receiver_x * abs(coord_scalar))
+            trace.stats.su.trace_header.group_coordinate_y = 0
+            trace.stats.su.trace_header.receiver_group_elevation = int(receiver_z * abs(coord_scalar))
+            
+            trace.stats.su.trace_header.source_coordinate_x = int(source_x * abs(coord_scalar))
+            trace.stats.su.trace_header.source_coordinate_y = int(source_y * abs(coord_scalar))
+            trace.stats.su.trace_header.surface_elevation_at_source = int(source_z * abs(coord_scalar))
+            
+            trace.stats.su.trace_header.scalar_to_be_applied_to_all_coordinates = coord_scalar
+            trace.stats.su.trace_header.scalar_to_be_applied_to_all_elevations_and_depths = coord_scalar
+            
+            # Calculate offset (apply scalar)
+            offset = receiver_x - source_x
+            trace.stats.su.trace_header.distance_from_center_of_the_source_point_to_the_center_of_the_receiver_group = int(offset * abs(coord_scalar))
+            
+            # Set sampling info
+            trace.stats.su.trace_header.number_of_samples_in_this_trace = n_samples
+            trace.stats.su.trace_header.sample_interval_in_microseconds = int(dt * 1e6)
+            
+            stream.append(trace)
+        
+        return stream, metadata
+        
+    finally:
+        # Clean up temp directory
+        shutil.rmtree(temp_dir)

pyckster/pick_io.py

@@ -544,8 +544,6 @@ def read_vs_file(vs_file, verbose=False):
         parts = lines[1].strip().split()
         n_shots = int(parts[1])
         spacing = float(parts[2])
-        if verbose:
-            print(f"Header: {n_shots} shots, spacing {spacing}m")
     except (ValueError, IndexError) as e:
         if verbose:
             print(f"Error parsing header line 2: {e}")
@@ -556,15 +554,6 @@ def read_vs_file(vs_file, verbose=False):
     line_idx = 2
     shot_count = 0
     
-    if verbose:
-        print(f"\n=== VS FILE PARSING DEBUG ===")
-        print(f"Starting to parse shots from line {line_idx}")
-        print(f"Expected {n_shots} shots")
-        print(f"First 15 lines from file:")
-        for i in range(min(15, len(lines))):
-            print(f"  Line {i}: {lines[i].strip()}")
-        print(f"=== END DEBUG ===\n")
-    
     while line_idx < len(lines) and shot_count < n_shots:
         line = lines[line_idx].strip()
         
@@ -683,21 +672,6 @@ def match_vs_picks_to_geometry(vs_picks_data, trace_positions, source_positions,
     unmatched_shots = set()
     unmatched_details = {}
     
-    if verbose:
-        print(f"\nMatching {n_total} VS picks to geometry...")
-        print(f"Dataset has {n_sources} sources")
-        print(f"VS file has {len(vs_picks_data['shots'])} shots")
-        print(f"Position scale factor: {position_scale}")
-        print(f"Offset tolerance: {offset_tolerance}m")
-        
-        # Show first few source positions
-        print(f"\nFirst 5 source positions: {source_positions[:5]}")
-        print(f"First 5 VS shot positions (scaled): {[s*position_scale for s in vs_picks_data['shots'][:5]]}")
-        
-        # Show first trace positions for first source
-        if trace_positions[0] is not None:
-            print(f"First source trace positions (first 5): {trace_positions[0][:5]}")
-    
     for shot_position, geophone_position, time in vs_picks_data['picks']:
         # Apply position scaling
         scaled_shot_position = shot_position * position_scale
@@ -831,14 +805,8 @@ def read_lst_file(lst_file, verbose=False):
                     
                 except (ValueError, IndexError):
                     # Not a data line, skip
-                    if verbose and 'First breaks' not in line and 'shot no' not in line:
-                        print(f"Skipping non-data line: {line}")
                     continue
     
-    if verbose:
-        print(f"Read {len(picks)} valid picks from {len(shots)} shots")
-        print(f"Shot numbers: {sorted(shots)}")
-    
     return {
         'picks': picks,
         'n_picks': len(picks),
@@ -899,14 +867,6 @@ def match_lst_picks_to_geometry(lst_picks_data, trace_positions, source_position
     unmatched_positions = []
     unmatched_shot_details = {}
     
-    if verbose:
-        print(f"\nMatching {n_total} LST picks to geometry...")
-        print(f"Dataset has {n_sources} sources")
-        print(f"LST file has {len(lst_picks_data['shots'])} unique shots")
-        print(f"Shot number offset: {shot_number_offset}")
-        print(f"Position scale factor: {position_scale}")
-        print(f"Position tolerance: {position_tolerance}m")
-    
     for shot_no, trace_no, position, time in lst_picks_data['picks']:
         # Convert shot number to source index (0-based)
         source_idx = shot_no - 1 + shot_number_offset
@@ -954,22 +914,6 @@ def match_lst_picks_to_geometry(lst_picks_data, trace_positions, source_position
                 else:
                     unmatched_shot_details[shot_no] = "no traces available"
     
-    if verbose:
-        print(f"\nMatched {n_matched}/{n_total} picks ({n_matched*100.0/n_total:.1f}%)")
-        if unmatched_shots:
-            print(f"\nUnmatched shots: {len(unmatched_shots)}")
-            for shot in sorted(unmatched_shots)[:10]:
-                reason = unmatched_shot_details.get(shot, "unknown")
-                print(f"  Shot {shot}: {reason}")
-            if len(unmatched_shots) > 10:
-                print(f"  ... and {len(unmatched_shots)-10} more")
-        
-        if unmatched_positions[:20]:
-            print(f"\nSample unmatched positions (first 20):")
-            for shot_no, position in unmatched_positions[:20]:
-                reason = unmatched_shot_details.get(shot_no, "unknown")
-                print(f"  Shot {shot_no}, pos {position:.2f}m: {reason}")
-    
     return {
         'picks': matched_picks,
         'errors': matched_errors,

{pyckster-26.2.1.dist-info → pyckster-26.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyckster
-Version: 26.2.1
+Version: 26.2.2
 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.1.dist-info → pyckster-26.2.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
-pyckster/__init__.py,sha256=pRpWyxN9aZ3Nc5qVhA9bc8VURQUWwwBmecGxfD_wVws,905
+pyckster/__init__.py,sha256=LO70RUeDFgSj8VdFhawOny6CVOPFksmbZ18sxkVpTBg,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=Sxyw0_ZtaDKgkGw6SarNM5_wgUgda4ishril3x0UlRA,1208902
+pyckster/core.py,sha256=0D3vDbpaToJ-RuNvpL7C4uGPLlrQaPvxb2xBuOTFxsI,1240456
 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=Me8j6FHIEQgx2GH0phEcg1t7TOpGKpyLl_AwmCRnDak,21943
-pyckster/pick_io.py,sha256=-oDMR054tBep8STi9pYTIxc7qJEIPbnbTkhiWFK5Ems,38666
+pyckster/obspy_utils.py,sha256=wm74oyLvvQmF97_ySXPZD95ya-8Aer-pLyVYlA3QWoM,35420
+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
 pyckster/surface_wave_profiling.py,sha256=L9KidhKmfGvVoPZjf6us3c49VB7VPB_VcsDqRx45OYI,315401
 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.1.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
-pyckster-26.2.1.dist-info/METADATA,sha256=DIHwW6-f0WWApHwzeErKYov8sJmcAloeJQjodcp0ids,4567
-pyckster-26.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyckster-26.2.1.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
-pyckster-26.2.1.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
-pyckster-26.2.1.dist-info/RECORD,,
+pyckster-26.2.2.dist-info/licenses/LICENCE,sha256=-uaAIm20JrJKoMdCdn2GlFQfNU4fbsHWK3eh4kIQ_Ec,35143
+pyckster-26.2.2.dist-info/METADATA,sha256=mxaCepOXltujMuxOYLLnG-n4nehgEGZDfd38G8h-O8c,4567
+pyckster-26.2.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyckster-26.2.2.dist-info/entry_points.txt,sha256=yrOQx1wHi84rbxX_ZYtYaVcK3EeuRhHRQDZRc8mB0NI,100
+pyckster-26.2.2.dist-info/top_level.txt,sha256=eaihhwhEmlysgdZE4HmELFdSUwlXcMv90YorkjOXujQ,9
+pyckster-26.2.2.dist-info/RECORD,,